diff --git a/keyserver/src/responders/website-responders.js b/keyserver/src/responders/website-responders.js
index 31d9df7ae..f9968a1c5 100644
--- a/keyserver/src/responders/website-responders.js
+++ b/keyserver/src/responders/website-responders.js
@@ -1,815 +1,826 @@
 // @flow
 
 import html from 'common-tags/lib/html/index.js';
 import { detect as detectBrowser } from 'detect-browser';
 import type { $Response, $Request } from 'express';
 import fs from 'fs';
 import _isEqual from 'lodash/fp/isEqual.js';
 import _keyBy from 'lodash/fp/keyBy.js';
 import * as React from 'react';
 // eslint-disable-next-line import/extensions
 import ReactDOMServer from 'react-dom/server';
 import t from 'tcomb';
 import { promisify } from 'util';
 
 import { inviteLinkUrl } from 'lib/facts/links.js';
 import { baseLegalPolicies } from 'lib/facts/policies.js';
 import stores from 'lib/facts/stores.js';
 import { daysToEntriesFromEntryInfos } from 'lib/reducers/entry-reducer.js';
 import { freshMessageStore } from 'lib/reducers/message-reducer.js';
 import { mostRecentlyReadThread } from 'lib/selectors/thread-selectors.js';
 import { mostRecentMessageTimestamp } from 'lib/shared/message-utils.js';
 import {
   threadHasPermission,
   threadIsPending,
   parsePendingThreadID,
   createPendingThread,
 } from 'lib/shared/thread-utils.js';
 import { defaultWebEnabledApps } from 'lib/types/enabled-apps.js';
 import { entryStoreValidator } from 'lib/types/entry-types.js';
 import { defaultCalendarFilters } from 'lib/types/filter-types.js';
 import { inviteLinksStoreValidator } from 'lib/types/link-types.js';
 import {
   defaultNumberPerThread,
   messageStoreValidator,
 } from 'lib/types/message-types.js';
 import { defaultEnabledReports } from 'lib/types/report-types.js';
 import { defaultConnectionInfo } from 'lib/types/socket-types.js';
 import { threadPermissions } from 'lib/types/thread-permission-types.js';
 import { threadTypes } from 'lib/types/thread-types-enum.js';
 import { threadStoreValidator } from 'lib/types/thread-types.js';
 import {
   currentUserInfoValidator,
   userInfosValidator,
 } from 'lib/types/user-types.js';
 import { currentDateInTimeZone } from 'lib/utils/date-utils.js';
 import { ServerError } from 'lib/utils/errors.js';
 import { promiseAll } from 'lib/utils/promises.js';
 import { defaultNotifPermissionAlertInfo } from 'lib/utils/push-alerts.js';
 import { infoFromURL } from 'lib/utils/url-utils.js';
 import { tBool, tNumber, tShape, tString } from 'lib/utils/validation-utils.js';
 import getTitle from 'web/title/getTitle.js';
 import { navInfoValidator } from 'web/types/nav-types.js';
 import { navInfoFromURL } from 'web/url-utils.js';
 
 import { fetchEntryInfos } from '../fetchers/entry-fetchers.js';
 import { fetchPrimaryInviteLinks } from '../fetchers/link-fetchers.js';
 import { fetchMessageInfos } from '../fetchers/message-fetchers.js';
 import { hasAnyNotAcknowledgedPolicies } from '../fetchers/policy-acknowledgment-fetchers.js';
 import { fetchThreadInfos } from '../fetchers/thread-fetchers.js';
 import {
   fetchCurrentUserInfo,
   fetchKnownUserInfos,
   fetchUserInfos,
 } from '../fetchers/user-fetchers.js';
 import { getWebPushConfig } from '../push/providers.js';
 import { setNewSession } from '../session/cookies.js';
 import { Viewer } from '../session/viewer.js';
 import { streamJSON, waitForStream } from '../utils/json-stream.js';
 import {
   getAppURLFactsFromRequestURL,
   getCommAppURLFacts,
 } from '../utils/urls.js';
 import { validateOutput } from '../utils/validation-utils.js';
 
 const { renderToNodeStream } = ReactDOMServer;
 
 const access = promisify(fs.access);
 const readFile = promisify(fs.readFile);
 
 const googleFontsURL =
   'https://fonts.googleapis.com/css2?family=IBM+Plex+Sans:wght@400;500;600&family=Inter:wght@400;500;600&display=swap';
 const localFontsURL = 'fonts/local-fonts.css';
 async function getFontsURL() {
   try {
     await access(localFontsURL);
     return localFontsURL;
   } catch {
     return googleFontsURL;
   }
 }
 
 type AssetInfo = {
   +jsURL: string,
   +fontsURL: string,
   +cssInclude: string,
   +olmFilename: string,
   +sqljsFilename: string,
+  +commQueryExecutorFilename: string,
   +opaqueURL: string,
 };
 let assetInfo: ?AssetInfo = null;
 async function getAssetInfo() {
   if (assetInfo) {
     return assetInfo;
   }
   if (process.env.NODE_ENV === 'development') {
     const fontsURL = await getFontsURL();
     assetInfo = {
       jsURL: 'http://localhost:8080/dev.build.js',
       fontsURL,
       cssInclude: '',
       olmFilename: '',
       sqljsFilename: '',
+      commQueryExecutorFilename: '',
       opaqueURL: 'http://localhost:8080/opaque-ke.wasm',
     };
     return assetInfo;
   }
   try {
     const manifestString = await readFile('../web/dist/manifest.json', 'utf8');
     const manifest = JSON.parse(manifestString);
     const webworkersManifestString = await readFile(
       '../web/dist/webworkers/manifest.json',
       'utf8',
     );
     const webworkersManifest = JSON.parse(webworkersManifestString);
     assetInfo = {
       jsURL: `compiled/${manifest['browser.js']}`,
       fontsURL: googleFontsURL,
       cssInclude: html`
         <link
           rel="stylesheet"
           type="text/css"
           href="compiled/${manifest['browser.css']}"
         />
       `,
       olmFilename: manifest['olm.wasm'],
       sqljsFilename: webworkersManifest['sql-wasm.wasm'],
+      commQueryExecutorFilename: webworkersManifest['comm_query_executor.wasm'],
       opaqueURL: `compiled/${manifest['comm_opaque2_wasm_bg.wasm']}`,
     };
     return assetInfo;
   } catch {
     throw new Error(
       'Could not load manifest.json for web build. ' +
         'Did you forget to run `yarn dev` in the web folder?',
     );
   }
 }
 
 let webpackCompiledRootComponent: ?React.ComponentType<{}> = null;
 async function getWebpackCompiledRootComponentForSSR() {
   if (webpackCompiledRootComponent) {
     return webpackCompiledRootComponent;
   }
   try {
     // $FlowFixMe web/dist doesn't always exist
     const webpackBuild = await import('web/dist/app.build.cjs');
     webpackCompiledRootComponent = webpackBuild.app.default;
     return webpackCompiledRootComponent;
   } catch {
     throw new Error(
       'Could not load app.build.cjs. ' +
         'Did you forget to run `yarn dev` in the web folder?',
     );
   }
 }
 
 const initialReduxStateValidator = tShape({
   navInfo: navInfoValidator,
   deviceID: t.Nil,
   currentUserInfo: currentUserInfoValidator,
   draftStore: t.irreducible('default draftStore', _isEqual({ drafts: {} })),
   sessionID: t.maybe(t.String),
   entryStore: entryStoreValidator,
   threadStore: threadStoreValidator,
   userStore: tShape({
     userInfos: userInfosValidator,
     inconsistencyReports: t.irreducible(
       'default inconsistencyReports',
       _isEqual([]),
     ),
   }),
   messageStore: messageStoreValidator,
   updatesCurrentAsOf: t.Number,
   loadingStatuses: t.irreducible('default loadingStatuses', _isEqual({})),
   calendarFilters: t.irreducible(
     'defaultCalendarFilters',
     _isEqual(defaultCalendarFilters),
   ),
   communityPickerStore: t.irreducible(
     'default communityPickerStore',
     _isEqual({ chat: null, calendar: null }),
   ),
   urlPrefix: tString(''),
   windowDimensions: t.irreducible(
     'default windowDimensions',
     _isEqual({ width: 0, height: 0 }),
   ),
   baseHref: t.String,
   notifPermissionAlertInfo: t.irreducible(
     'default notifPermissionAlertInfo',
     _isEqual(defaultNotifPermissionAlertInfo),
   ),
   connection: tShape({
     status: tString('connecting'),
     queuedActivityUpdates: t.irreducible(
       'default queuedActivityUpdates',
       _isEqual([]),
     ),
     actualizedCalendarQuery: tShape({
       startDate: t.String,
       endDate: t.String,
       filters: t.irreducible(
         'default filters',
         _isEqual(defaultCalendarFilters),
       ),
     }),
     lateResponses: t.irreducible('default lateResponses', _isEqual([])),
     showDisconnectedBar: tBool(false),
   }),
   watchedThreadIDs: t.irreducible('default watchedThreadIDs', _isEqual([])),
   lifecycleState: tString('active'),
   enabledApps: t.irreducible(
     'defaultWebEnabledApps',
     _isEqual(defaultWebEnabledApps),
   ),
   reportStore: t.irreducible(
     'default reportStore',
     _isEqual({
       enabledReports: defaultEnabledReports,
       queuedReports: [],
     }),
   ),
   nextLocalID: tNumber(0),
   cookie: t.Nil,
   deviceToken: t.Nil,
   dataLoaded: t.Boolean,
   windowActive: tBool(true),
   userPolicies: t.irreducible('default userPolicies', _isEqual({})),
   cryptoStore: t.irreducible(
     'default cryptoStore',
     _isEqual({
       primaryIdentityKeys: null,
       notificationIdentityKeys: null,
     }),
   ),
   pushApiPublicKey: t.maybe(t.String),
   _persist: t.Nil,
   commServicesAccessToken: t.Nil,
   inviteLinksStore: inviteLinksStoreValidator,
   lastCommunicatedPlatformDetails: t.irreducible(
     'default lastCommunicatedPlatformDetails',
     _isEqual({}),
   ),
 });
 
 async function websiteResponder(
   viewer: Viewer,
   req: $Request,
   res: $Response,
 ): Promise<void> {
   const appURLFacts = getAppURLFactsFromRequestURL(req.originalUrl);
   const { basePath, baseDomain } = appURLFacts;
   const baseURL = basePath.replace(/\/$/, '');
   const baseHref = baseDomain + baseURL;
 
   const loadingPromise = getWebpackCompiledRootComponentForSSR();
   const hasNotAcknowledgedPoliciesPromise = hasAnyNotAcknowledgedPolicies(
     viewer.id,
     baseLegalPolicies,
   );
 
   const initialNavInfoPromise = (async () => {
     try {
       const urlInfo = infoFromURL(req.url);
 
       let backupInfo = {
         now: currentDateInTimeZone(viewer.timeZone),
       };
       // Some user ids in selectedUserList might not exist in the userStore
       // (e.g. they were included in the results of the user search endpoint)
       // Because of that we keep their userInfos inside the navInfo.
       if (urlInfo.selectedUserList) {
         const fetchedUserInfos = await fetchUserInfos(urlInfo.selectedUserList);
         const userInfos = {};
         for (const userID in fetchedUserInfos) {
           const userInfo = fetchedUserInfos[userID];
           if (userInfo.username) {
             userInfos[userID] = userInfo;
           }
         }
         backupInfo = { userInfos, ...backupInfo };
       }
       return navInfoFromURL(urlInfo, backupInfo);
     } catch (e) {
       throw new ServerError(e.message);
     }
   })();
 
   const calendarQueryPromise = (async () => {
     const initialNavInfo = await initialNavInfoPromise;
     return {
       startDate: initialNavInfo.startDate,
       endDate: initialNavInfo.endDate,
       filters: defaultCalendarFilters,
     };
   })();
   const messageSelectionCriteria = { joinedThreads: true };
   const initialTime = Date.now();
 
   const assetInfoPromise = getAssetInfo();
   const threadInfoPromise = fetchThreadInfos(viewer);
   const messageInfoPromise = fetchMessageInfos(
     viewer,
     messageSelectionCriteria,
     defaultNumberPerThread,
   );
   const entryInfoPromise = (async () => {
     const calendarQuery = await calendarQueryPromise;
     return await fetchEntryInfos(viewer, [calendarQuery]);
   })();
   const currentUserInfoPromise = fetchCurrentUserInfo(viewer);
   const userInfoPromise = fetchKnownUserInfos(viewer);
 
   const sessionIDPromise = (async () => {
     const calendarQuery = await calendarQueryPromise;
     if (viewer.loggedIn) {
       await setNewSession(viewer, calendarQuery, initialTime);
     }
     return viewer.sessionID;
   })();
 
   const threadStorePromise = (async () => {
     const [{ threadInfos }, hasNotAcknowledgedPolicies] = await Promise.all([
       threadInfoPromise,
       hasNotAcknowledgedPoliciesPromise,
     ]);
     return { threadInfos: hasNotAcknowledgedPolicies ? {} : threadInfos };
   })();
   const messageStorePromise = (async () => {
     const [
       { threadInfos },
       { rawMessageInfos, truncationStatuses },
       hasNotAcknowledgedPolicies,
     ] = await Promise.all([
       threadInfoPromise,
       messageInfoPromise,
       hasNotAcknowledgedPoliciesPromise,
     ]);
     if (hasNotAcknowledgedPolicies) {
       return {
         messages: {},
         threads: {},
         local: {},
         currentAsOf: 0,
       };
     }
     const { messageStore: freshStore } = freshMessageStore(
       rawMessageInfos,
       truncationStatuses,
       mostRecentMessageTimestamp(rawMessageInfos, initialTime),
       threadInfos,
     );
     return freshStore;
   })();
   const entryStorePromise = (async () => {
     const [{ rawEntryInfos }, hasNotAcknowledgedPolicies] = await Promise.all([
       entryInfoPromise,
       hasNotAcknowledgedPoliciesPromise,
     ]);
     if (hasNotAcknowledgedPolicies) {
       return {
         entryInfos: {},
         daysToEntries: {},
         lastUserInteractionCalendar: 0,
       };
     }
     return {
       entryInfos: _keyBy('id')(rawEntryInfos),
       daysToEntries: daysToEntriesFromEntryInfos(rawEntryInfos),
       lastUserInteractionCalendar: initialTime,
     };
   })();
   const userStorePromise = (async () => {
     const [userInfos, hasNotAcknowledgedPolicies] = await Promise.all([
       userInfoPromise,
       hasNotAcknowledgedPoliciesPromise,
     ]);
     return {
       userInfos: hasNotAcknowledgedPolicies ? {} : userInfos,
       inconsistencyReports: [],
     };
   })();
 
   const navInfoPromise = (async () => {
     const [
       { threadInfos },
       messageStore,
       currentUserInfo,
       userStore,
       finalNavInfo,
     ] = await Promise.all([
       threadInfoPromise,
       messageStorePromise,
       currentUserInfoPromise,
       userStorePromise,
       initialNavInfoPromise,
     ]);
 
     const requestedActiveChatThreadID = finalNavInfo.activeChatThreadID;
     if (
       requestedActiveChatThreadID &&
       !threadIsPending(requestedActiveChatThreadID) &&
       !threadHasPermission(
         threadInfos[requestedActiveChatThreadID],
         threadPermissions.VISIBLE,
       )
     ) {
       finalNavInfo.activeChatThreadID = null;
     }
 
     if (!finalNavInfo.activeChatThreadID) {
       const mostRecentThread = mostRecentlyReadThread(
         messageStore,
         threadInfos,
       );
       if (mostRecentThread) {
         finalNavInfo.activeChatThreadID = mostRecentThread;
       }
     }
 
     if (
       finalNavInfo.activeChatThreadID &&
       threadIsPending(finalNavInfo.activeChatThreadID) &&
       finalNavInfo.pendingThread?.id !== finalNavInfo.activeChatThreadID
     ) {
       const pendingThreadData = parsePendingThreadID(
         finalNavInfo.activeChatThreadID,
       );
       if (
         pendingThreadData &&
         pendingThreadData.threadType !== threadTypes.SIDEBAR &&
         currentUserInfo.id
       ) {
         const { userInfos } = userStore;
         const members = [...pendingThreadData.memberIDs, currentUserInfo.id]
           .map(id => {
             const userInfo = userInfos[id];
             if (!userInfo || !userInfo.username) {
               return undefined;
             }
             const { username } = userInfo;
             return { id, username };
           })
           .filter(Boolean);
         const newPendingThread = createPendingThread({
           viewerID: currentUserInfo.id,
           threadType: pendingThreadData.threadType,
           members,
         });
         finalNavInfo.activeChatThreadID = newPendingThread.id;
         finalNavInfo.pendingThread = newPendingThread;
       }
     }
 
     return finalNavInfo;
   })();
   const currentAsOfPromise = (async () => {
     const hasNotAcknowledgedPolicies = await hasNotAcknowledgedPoliciesPromise;
     return hasNotAcknowledgedPolicies ? 0 : initialTime;
   })();
 
   const pushApiPublicKeyPromise = (async () => {
     const pushConfig = await getWebPushConfig();
     if (!pushConfig) {
       if (process.env.NODE_ENV !== 'development') {
         console.warn('keyserver/secrets/web_push_config.json should exist');
       }
       return null;
     }
     return pushConfig.publicKey;
   })();
 
   const inviteLinksStorePromise = (async () => {
     const primaryInviteLinks = await fetchPrimaryInviteLinks(viewer);
     const links = {};
     for (const link of primaryInviteLinks) {
       if (link.primary) {
         links[link.communityID] = {
           primaryLink: link,
         };
       }
     }
     return {
       links,
     };
   })();
 
-  const { jsURL, fontsURL, cssInclude, olmFilename, sqljsFilename, opaqueURL } =
-    await assetInfoPromise;
+  const {
+    jsURL,
+    fontsURL,
+    cssInclude,
+    olmFilename,
+    sqljsFilename,
+    opaqueURL,
+    commQueryExecutorFilename,
+  } = await assetInfoPromise;
 
   // prettier-ignore
   res.write(html`
     <!DOCTYPE html>
     <html lang="en">
       <head>
         <meta charset="utf-8" />
         <title>${getTitle(0)}</title>
         <base href="${basePath}" />
         <link rel="stylesheet" type="text/css" href="${fontsURL}" />
         ${cssInclude}
         <link
           rel="apple-touch-icon"
           sizes="180x180"
           href="apple-touch-icon.png"
         />
         <link
           rel="icon"
           type="image/png"
           sizes="32x32"
           href="favicon-32x32.png"
         />
         <link
           rel="icon"
           type="image/png"
           sizes="16x16"
           href="favicon-16x16.png"
         />
         <link rel="manifest" href="site.webmanifest" />
         <meta name="apple-mobile-web-app-title" content="Comm" />
         <meta name="application-name" content="Comm" />
         <meta name="msapplication-TileColor" content="#b91d47" />
         <meta name="theme-color" content="#b91d47" />
       </head>
       <body>
         <div id="react-root">
   `);
 
   const Loading = await loadingPromise;
   const reactStream = renderToNodeStream(<Loading />);
   reactStream.pipe(res, { end: false });
 
   await waitForStream(reactStream);
   res.write(html`
     </div>
     <script>
       var preloadedState =
   `);
 
   const initialReduxState = await promiseAll({
     navInfo: navInfoPromise,
     deviceID: null,
     currentUserInfo: currentUserInfoPromise,
     draftStore: { drafts: {} },
     sessionID: sessionIDPromise,
     entryStore: entryStorePromise,
     threadStore: threadStorePromise,
     userStore: userStorePromise,
     messageStore: messageStorePromise,
     updatesCurrentAsOf: currentAsOfPromise,
     loadingStatuses: {},
     calendarFilters: defaultCalendarFilters,
     communityPickerStore: { chat: null, calendar: null },
     // We can use paths local to the <base href> on web
     urlPrefix: '',
     windowDimensions: { width: 0, height: 0 },
     baseHref,
     notifPermissionAlertInfo: defaultNotifPermissionAlertInfo,
     connection: (async () => ({
       ...defaultConnectionInfo(viewer.platform ?? 'web', viewer.timeZone),
       actualizedCalendarQuery: await calendarQueryPromise,
     }))(),
     watchedThreadIDs: [],
     lifecycleState: 'active',
     enabledApps: defaultWebEnabledApps,
     reportStore: {
       enabledReports: defaultEnabledReports,
       queuedReports: [],
     },
     nextLocalID: 0,
     cookie: undefined,
     deviceToken: null,
     dataLoaded: viewer.loggedIn,
     windowActive: true,
     userPolicies: {},
     cryptoStore: {
       primaryIdentityKeys: null,
       notificationIdentityKeys: null,
     },
     pushApiPublicKey: pushApiPublicKeyPromise,
     _persist: null,
     commServicesAccessToken: null,
     inviteLinksStore: inviteLinksStorePromise,
     lastCommunicatedPlatformDetails: {},
   });
   const validatedInitialReduxState = validateOutput(
     viewer.platformDetails,
     initialReduxStateValidator,
     initialReduxState,
   );
   const jsonStream = streamJSON(res, validatedInitialReduxState);
 
   await waitForStream(jsonStream);
   res.end(html`
     ;
           var baseURL = "${baseURL}";
           var olmFilename = "${olmFilename}";
           var sqljsFilename = "${sqljsFilename}";
+          var commQueryExecutorFilename = "${commQueryExecutorFilename}";
           var opaqueURL = "${opaqueURL}";
         </script>
         <script src="${jsURL}"></script>
       </body>
     </html>
   `);
 }
 
 const inviteSecretRegex = /^[a-z0-9]+$/i;
 
 // On native, if this responder is called, it means that the app isn't
 // installed.
 async function inviteResponder(req: $Request, res: $Response): Promise<void> {
   const { secret } = req.params;
   const userAgent = req.get('User-Agent');
   const detectionResult = detectBrowser(userAgent);
   if (detectionResult.os === 'Android OS') {
     const isSecretValid = inviteSecretRegex.test(secret);
     const referrer = isSecretValid
       ? `&referrer=${encodeURIComponent(`utm_source=invite/${secret}`)}`
       : '';
     const redirectUrl = `${stores.googlePlayUrl}${referrer}`;
     res.writeHead(301, {
       Location: redirectUrl,
     });
     res.end();
     return;
   } else if (detectionResult.os !== 'iOS') {
     const urlFacts = getCommAppURLFacts();
     const baseDomain = urlFacts?.baseDomain ?? '';
     const basePath = urlFacts?.basePath ?? '/';
     const redirectUrl = `${baseDomain}${basePath}handle/invite/${secret}`;
     res.writeHead(301, {
       Location: redirectUrl,
     });
     res.end();
     return;
   }
   const fontsURL = await getFontsURL();
   res.end(html`
     <!DOCTYPE html>
     <html lang="en">
       <head>
         <meta charset="utf-8" />
         <title>Comm</title>
         <link rel="stylesheet" type="text/css" href="/${fontsURL}" />
         <style>
           * {
             -webkit-font-smoothing: antialiased;
             -moz-osx-font-smoothing: grayscale;
             box-sizing: border-box;
             padding: 0;
             margin: 0;
           }
 
           html {
             height: 100%;
             font-size: 112.5%;
           }
 
           body {
             font-family: 'Inter', -apple-system, 'Segoe UI', 'Roboto', 'Oxygen',
               'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
               ui-sans-serif;
             background: #0a0a0a url('/images/invite_link_background.png')
               no-repeat;
             background-size: cover;
             color: #ffffff;
             display: flex;
             flex-direction: column;
             justify-content: space-around;
             align-items: center;
             height: 100%;
             padding: 1.6rem;
             font-size: 1.8rem;
             line-height: 2.4rem;
             font-weight: 500;
           }
 
           section {
             display: flex;
             flex-direction: column;
             align-items: center;
             justify-content: space-between;
             width: 100%;
           }
 
           .card {
             width: 100%;
             padding: 3.2rem 1.6rem;
             gap: 4rem;
             background-color: #1f1f1f;
             border-radius: 1.6rem;
           }
 
           .buttons {
             gap: 1.2rem;
           }
 
           h1 {
             font-size: 3.6rem;
             line-height: 1.5;
             font-weight: 500;
             font-family: 'IBM Plex Sans', sans-serif;
           }
 
           p {
             text-align: center;
           }
 
           .separator {
             border: 1px solid #404040;
             width: 100%;
           }
 
           .button {
             all: unset;
             box-sizing: border-box;
             display: flex;
             justify-content: center;
             align-items: center;
             width: 100%;
             padding: 1.7rem;
             border-radius: 0.4rem;
             border: 1px solid transparent;
             background-color: #6d49ab;
             font-size: 1.6rem;
             line-height: 1.5;
           }
 
           .button.secondary {
             background-color: #1f1f1f;
             border-color: #ffffff;
           }
 
           .link {
             all: unset;
             box-sizing: border-box;
             display: flex;
             align-items: center;
           }
 
           .link-text {
             text-decoration-line: underline;
           }
 
           .logo-container {
             background-color: #0a0a0a;
             width: 4.2rem;
             height: 4.2rem;
             display: flex;
             justify-content: center;
             align-items: center;
             border-radius: 50%;
           }
 
           .logo {
             height: 2.6rem;
           }
 
           .arrow {
             width: 1.8rem;
             height: 1.8rem;
           }
         </style>
       </head>
       <body>
         <div></div>
         <section class="card">
           <section>
             <div class="logo-container">
               <img
                 src="/images/loading_logo.svg"
                 alt="Comm logo"
                 class="logo"
               />
             </div>
             <h1>Comm</h1>
           </section>
           <p>
             To join this community, download the Comm app and reopen this invite
             link
           </p>
           <div class="separator"></div>
           <section class="buttons">
             <a class="button" href="${stores.appStoreUrl}">Download Comm</a>
             <a
               class="button secondary"
               href="${inviteLinkUrl(secret)}"
               target="_blank"
             >
               Invite Link
             </a>
           </section>
         </section>
         <a class="link" href="https://comm.app/">
           <span class="link-text">Visit Comm’s website</span>
           <img
             src="/images/arrow_up_right.svg"
             alt="arrow up right"
             class="arrow"
           />
         </a>
       </body>
     </html>
   `);
 }
 
 export { websiteResponder, inviteResponder };
diff --git a/web/database/database-module-provider.js b/web/database/database-module-provider.js
index 951610e40..c748f57f5 100644
--- a/web/database/database-module-provider.js
+++ b/web/database/database-module-provider.js
@@ -1,123 +1,125 @@
 // @flow
 
 import { DATABASE_WORKER_PATH, SQLJS_FILE_PATH } from './utils/constants.js';
 import { isDesktopSafari, isSQLiteSupported } from './utils/db-utils.js';
 import WorkerConnectionProxy from './utils/WorkerConnectionProxy.js';
 import type { AppState } from '../redux/redux-setup.js';
 import {
   workerRequestMessageTypes,
   type WorkerRequestMessage,
   type WorkerResponseMessage,
 } from '../types/worker-types.js';
 
 declare var sqljsFilename: string;
+declare var commQueryExecutorFilename: string;
 declare var preloadedState: AppState;
 
 const databaseStatuses = Object.freeze({
   notSupported: 'NOT_SUPPORTED',
   initSuccess: 'INIT_SUCCESS',
   initInProgress: 'INIT_IN_PROGRESS',
   initError: 'INIT_ERROR',
 });
 
 type DatabaseStatus = $Values<typeof databaseStatuses>;
 
 class DatabaseModule {
   worker: SharedWorker;
   workerProxy: WorkerConnectionProxy;
   initPromise: Promise<void>;
   status: DatabaseStatus;
 
   constructor() {
     const currentLoggedInUserID = preloadedState.currentUserInfo?.anonymous
       ? undefined
       : preloadedState.currentUserInfo?.id;
     const isSupported = isSQLiteSupported(currentLoggedInUserID);
 
     if (!isSupported || isDesktopSafari) {
       this.status = databaseStatuses.notSupported;
     } else {
       this.init();
     }
   }
 
   init(encryptionKey?: ?SubtleCrypto$JsonWebKey) {
     this.status = databaseStatuses.initInProgress;
     this.worker = new SharedWorker(DATABASE_WORKER_PATH);
     this.worker.onerror = console.error;
     this.workerProxy = new WorkerConnectionProxy(
       this.worker.port,
       console.error,
     );
 
     const origin = window.location.origin;
 
     this.initPromise = (async () => {
       try {
         await this.workerProxy.scheduleOnWorker({
           type: workerRequestMessageTypes.INIT,
           sqljsFilePath: `${origin}${SQLJS_FILE_PATH}`,
           sqljsFilename,
           encryptionKey,
+          commQueryExecutorFilename,
         });
         this.status = databaseStatuses.initSuccess;
         console.info('Database initialization success');
       } catch (error) {
         this.status = databaseStatuses.initError;
         console.error(`Database initialization failure`, error);
       }
     })();
   }
 
   initDBForLoggedInUser(
     currentLoggedInUserID: ?string,
     encryptionKey?: ?SubtleCrypto$JsonWebKey,
   ) {
     if (this.status === databaseStatuses.initSuccess) {
       return;
     }
 
     if (
       this.status === databaseStatuses.notSupported &&
       isSQLiteSupported(currentLoggedInUserID)
     ) {
       this.init(encryptionKey);
     }
   }
 
   async clearSensitiveData(): Promise<void> {
     this.status = databaseStatuses.notSupported;
     await this.workerProxy.scheduleOnWorker({
       type: workerRequestMessageTypes.CLEAR_SENSITIVE_DATA,
     });
   }
 
   async isDatabaseSupported(): Promise<boolean> {
     if (this.status === databaseStatuses.initInProgress) {
       await this.initPromise;
     }
     return this.status === databaseStatuses.initSuccess;
   }
 
   async schedule(
     payload: WorkerRequestMessage,
   ): Promise<?WorkerResponseMessage> {
     if (this.status === databaseStatuses.notSupported) {
       throw new Error('Database not supported');
     }
 
     if (this.status === databaseStatuses.initInProgress) {
       await this.initPromise;
     }
 
     if (this.status === databaseStatuses.initError) {
       throw new Error('Database could not be initialized');
     }
 
     return this.workerProxy.scheduleOnWorker(payload);
   }
 }
 
 const databaseModule: DatabaseModule = new DatabaseModule();
 
 export { databaseModule };
diff --git a/web/database/worker/db-worker.js b/web/database/worker/db-worker.js
index 0fa8c9f2e..be736d567 100644
--- a/web/database/worker/db-worker.js
+++ b/web/database/worker/db-worker.js
@@ -1,315 +1,336 @@
 // @flow
 
 import localforage from 'localforage';
 import initSqlJs, { type SqliteDatabase } from 'sql.js';
 
 import type { ClientDBReportStoreOperation } from 'lib/ops/report-store-ops.js';
 import type {
   ClientDBDraftStoreOperation,
   DraftStoreOperation,
 } from 'lib/types/draft-types.js';
 import type { ClientDBStore } from 'lib/types/store-ops-types.js';
 
 import {
   type SharedWorkerMessageEvent,
   type WorkerRequestMessage,
   type WorkerResponseMessage,
   workerRequestMessageTypes,
   workerResponseMessageTypes,
   type WorkerRequestProxyMessage,
   workerWriteRequests,
 } from '../../types/worker-types.js';
+import Module from '../_generated/comm-query-executor.js';
 import { migrate, setupSQLiteDB } from '../queries/db-queries.js';
 import {
   getAllDrafts,
   moveDraft,
   removeAllDrafts,
   updateDraft,
 } from '../queries/draft-queries.js';
 import { getMetadata, setMetadata } from '../queries/metadata-queries.js';
 import {
   getAllReports,
   removeAllReports,
   removeReports,
   updateReport,
 } from '../queries/report-queries.js';
 import {
   getPersistStorageItem,
   removePersistStorageItem,
   setPersistStorageItem,
 } from '../queries/storage-engine-queries.js';
 import {
   CURRENT_USER_ID_KEY,
   localforageConfig,
   SQLITE_CONTENT,
   SQLITE_ENCRYPTION_KEY,
 } from '../utils/constants.js';
 import {
   decryptDatabaseFile,
   encryptDatabaseFile,
   generateDatabaseCryptoKey,
   importJWKKey,
 } from '../utils/worker-crypto-utils.js';
 
 localforage.config(localforageConfig);
 
 let sqliteDb: ?SqliteDatabase = null;
 let encryptionKey: ?CryptoKey = null;
 
 let persistNeeded: boolean = false;
 let persistInProgress: boolean = false;
 
+const defaultCommQueryExecutorFilename = 'comm_query_executor.wasm';
+
 async function initDatabase(
   sqljsFilePath: string,
   sqljsFilename: ?string,
+  commQueryExecutorFilename: ?string,
   encryptionKeyJWK?: ?SubtleCrypto$JsonWebKey,
 ) {
+  const dbModule = Module({
+    locateFile: function () {
+      if (commQueryExecutorFilename) {
+        return `${sqljsFilePath}/${commQueryExecutorFilename}`;
+      }
+      return `${sqljsFilePath}/${defaultCommQueryExecutorFilename}`;
+    },
+  });
+
+  try {
+    const result = dbModule.CommQueryExecutor.testDBOperation();
+    console.log(result);
+  } catch (e) {
+    console.error(e);
+  }
+
   if (encryptionKeyJWK) {
     encryptionKey = await importJWKKey(encryptionKeyJWK);
   } else {
     encryptionKey = await localforage.getItem(SQLITE_ENCRYPTION_KEY);
     if (!encryptionKey) {
       const cryptoKey = await generateDatabaseCryptoKey({ extractable: false });
       await localforage.setItem(SQLITE_ENCRYPTION_KEY, cryptoKey);
     }
   }
 
   const encryptedContent = await localforage.getItem(SQLITE_CONTENT);
 
   let dbContent = null;
   try {
     if (encryptionKey && encryptedContent) {
       dbContent = await decryptDatabaseFile(encryptedContent, encryptionKey);
     }
   } catch (e) {
     console.error('Error while decrypting content, clearing database content');
     await localforage.removeItem(SQLITE_CONTENT);
   }
 
   const locateFile = defaultFilename => {
     if (sqljsFilename) {
       return `${sqljsFilePath}/${sqljsFilename}`;
     }
     return `${sqljsFilePath}/${defaultFilename}`;
   };
   const SQL = await initSqlJs({
     locateFile,
   });
 
   if (dbContent) {
     sqliteDb = new SQL.Database(dbContent);
     console.info(
       'Database exists and is properly encrypted, using persisted data',
     );
     migrate(sqliteDb);
   } else {
     sqliteDb = new SQL.Database();
     setupSQLiteDB(sqliteDb);
     console.info('Creating fresh database');
   }
 }
 
 function processDraftStoreOperations(
   operations: $ReadOnlyArray<ClientDBDraftStoreOperation>,
 ) {
   if (!sqliteDb) {
     throw new Error('Database not initialized');
   }
   for (const operation: DraftStoreOperation of operations) {
     if (operation.type === 'remove_all') {
       removeAllDrafts(sqliteDb);
     } else if (operation.type === 'update') {
       const { key, text } = operation.payload;
       updateDraft(sqliteDb, key, text);
     } else if (operation.type === 'move') {
       const { oldKey, newKey } = operation.payload;
       moveDraft(sqliteDb, oldKey, newKey);
     } else {
       throw new Error('Unsupported draft operation');
     }
   }
 }
 
 function processReportStoreOperations(
   operations: $ReadOnlyArray<ClientDBReportStoreOperation>,
 ) {
   if (!sqliteDb) {
     throw new Error('Database not initialized');
   }
   for (const operation: ClientDBReportStoreOperation of operations) {
     if (operation.type === 'remove_all_reports') {
       removeAllReports(sqliteDb);
     } else if (operation.type === 'remove_reports') {
       const { ids } = operation.payload;
       removeReports(sqliteDb, ids);
     } else if (operation.type === 'replace_report') {
       const { id, report } = operation.payload;
       updateReport(sqliteDb, id, report);
     } else {
       throw new Error('Unsupported report operation');
     }
   }
 }
 
 function getClientStore(): ClientDBStore {
   if (!sqliteDb) {
     throw new Error('Database not initialized');
   }
   return {
     drafts: getAllDrafts(sqliteDb),
     messages: [],
     threads: [],
     messageStoreThreads: [],
     reports: getAllReports(sqliteDb),
   };
 }
 
 async function persist() {
   persistInProgress = true;
   if (!sqliteDb) {
     persistInProgress = false;
     throw new Error('Database not initialized');
   }
 
   if (!encryptionKey) {
     encryptionKey = await localforage.getItem(SQLITE_ENCRYPTION_KEY);
   }
 
   while (persistNeeded) {
     persistNeeded = false;
     const dbData = sqliteDb.export();
     if (!encryptionKey) {
       persistInProgress = false;
       throw new Error('Encryption key is missing');
     }
     const encryptedData = await encryptDatabaseFile(dbData, encryptionKey);
     await localforage.setItem(SQLITE_CONTENT, encryptedData);
   }
   persistInProgress = false;
 }
 
 async function processAppRequest(
   message: WorkerRequestMessage,
 ): Promise<?WorkerResponseMessage> {
   // non-database operations
   if (message.type === workerRequestMessageTypes.PING) {
     return {
       type: workerResponseMessageTypes.PONG,
       text: 'PONG',
     };
   } else if (
     message.type === workerRequestMessageTypes.GENERATE_DATABASE_ENCRYPTION_KEY
   ) {
     const cryptoKey = await generateDatabaseCryptoKey({ extractable: false });
     await localforage.setItem(SQLITE_ENCRYPTION_KEY, cryptoKey);
     return undefined;
   }
 
   // database operations
   if (message.type === workerRequestMessageTypes.INIT) {
     await initDatabase(
       message.sqljsFilePath,
       message.sqljsFilename,
+      message.commQueryExecutorFilename,
       message.encryptionKey,
     );
     return undefined;
   } else if (message.type === workerRequestMessageTypes.CLEAR_SENSITIVE_DATA) {
     encryptionKey = null;
     if (sqliteDb) {
       sqliteDb.close();
     }
     await localforage.clear();
     return undefined;
   }
 
   if (!sqliteDb) {
     throw new Error('Database not initialized');
   }
 
   // read-only operations
   if (message.type === workerRequestMessageTypes.GET_CLIENT_STORE) {
     return {
       type: workerResponseMessageTypes.CLIENT_STORE,
       store: getClientStore(),
     };
   } else if (message.type === workerRequestMessageTypes.GET_CURRENT_USER_ID) {
     return {
       type: workerResponseMessageTypes.GET_CURRENT_USER_ID,
       userID: getMetadata(sqliteDb, CURRENT_USER_ID_KEY),
     };
   } else if (
     message.type === workerRequestMessageTypes.GET_PERSIST_STORAGE_ITEM
   ) {
     return {
       type: workerResponseMessageTypes.GET_PERSIST_STORAGE_ITEM,
       item: getPersistStorageItem(sqliteDb, message.key),
     };
   }
 
   // write operations
   if (!workerWriteRequests.includes(message.type)) {
     throw new Error('Request type not supported');
   }
 
   if (message.type === workerRequestMessageTypes.PROCESS_STORE_OPERATIONS) {
     const { draftStoreOperations, reportStoreOperations } =
       message.storeOperations;
     if (draftStoreOperations) {
       processDraftStoreOperations(draftStoreOperations);
     }
     if (reportStoreOperations) {
       processReportStoreOperations(reportStoreOperations);
     }
   } else if (message.type === workerRequestMessageTypes.SET_CURRENT_USER_ID) {
     setMetadata(sqliteDb, CURRENT_USER_ID_KEY, message.userID);
   } else if (
     message.type === workerRequestMessageTypes.SET_PERSIST_STORAGE_ITEM
   ) {
     setPersistStorageItem(sqliteDb, message.key, message.item);
   } else if (
     message.type === workerRequestMessageTypes.REMOVE_PERSIST_STORAGE_ITEM
   ) {
     removePersistStorageItem(sqliteDb, message.key);
   }
 
   persistNeeded = true;
   if (!persistInProgress) {
     persist();
   }
 
   return undefined;
 }
 
 function connectHandler(event: SharedWorkerMessageEvent) {
   if (!event.ports.length) {
     return;
   }
   const port: MessagePort = event.ports[0];
   console.log('Web database worker alive!');
 
   port.onmessage = async function (messageEvent: MessageEvent) {
     const data: WorkerRequestProxyMessage = (messageEvent.data: any);
     const { id, message } = data;
 
     if (!id) {
       port.postMessage({
         error: 'Request without identifier',
       });
     }
 
     try {
       const result = await processAppRequest(message);
       port.postMessage({
         id,
         message: result,
       });
     } catch (e) {
       port.postMessage({
         id,
         error: e.message,
       });
     }
   };
 }
 
 self.addEventListener('connect', connectHandler);
diff --git a/web/types/worker-types.js b/web/types/worker-types.js
index 343d8d2d4..7d0973cc8 100644
--- a/web/types/worker-types.js
+++ b/web/types/worker-types.js
@@ -1,146 +1,147 @@
 // @flow
 
 import type {
   ClientDBStore,
   ClientDBStoreOperations,
 } from 'lib/types/store-ops-types.js';
 
 // The types of messages sent from app to worker
 export const workerRequestMessageTypes = Object.freeze({
   PING: 0,
   INIT: 1,
   GENERATE_DATABASE_ENCRYPTION_KEY: 2,
   PROCESS_STORE_OPERATIONS: 3,
   GET_CLIENT_STORE: 4,
   SET_CURRENT_USER_ID: 5,
   GET_CURRENT_USER_ID: 6,
   GET_PERSIST_STORAGE_ITEM: 7,
   SET_PERSIST_STORAGE_ITEM: 8,
   REMOVE_PERSIST_STORAGE_ITEM: 9,
   CLEAR_SENSITIVE_DATA: 10,
 });
 
 export const workerWriteRequests: $ReadOnlyArray<number> = [
   workerRequestMessageTypes.PROCESS_STORE_OPERATIONS,
   workerRequestMessageTypes.SET_CURRENT_USER_ID,
   workerRequestMessageTypes.SET_PERSIST_STORAGE_ITEM,
   workerRequestMessageTypes.REMOVE_PERSIST_STORAGE_ITEM,
 ];
 
 export type PingWorkerRequestMessage = {
   +type: 0,
   +text: string,
 };
 
 export type InitWorkerRequestMessage = {
   +type: 1,
   +sqljsFilePath: string,
   +sqljsFilename: ?string,
+  +commQueryExecutorFilename: ?string,
   +encryptionKey?: ?SubtleCrypto$JsonWebKey,
 };
 
 export type GenerateDatabaseEncryptionKeyRequestMessage = {
   +type: 2,
 };
 
 export type ProcessStoreOperationsRequestMessage = {
   +type: 3,
   +storeOperations: ClientDBStoreOperations,
 };
 
 export type GetClientStoreRequestMessage = {
   +type: 4,
 };
 
 export type SetCurrentUserIDRequestMessage = {
   +type: 5,
   +userID: string,
 };
 
 export type GetCurrentUserIDRequestMessage = {
   +type: 6,
 };
 
 export type GetPersistStorageItemRequestMessage = {
   +type: 7,
   +key: string,
 };
 
 export type SetPersistStorageItemRequestMessage = {
   +type: 8,
   +key: string,
   +item: string,
 };
 
 export type RemovePersistStorageItemRequestMessage = {
   +type: 9,
   +key: string,
 };
 
 export type ClearSensitiveDataRequestMessage = {
   +type: 10,
 };
 
 export type WorkerRequestMessage =
   | PingWorkerRequestMessage
   | InitWorkerRequestMessage
   | GenerateDatabaseEncryptionKeyRequestMessage
   | ProcessStoreOperationsRequestMessage
   | GetClientStoreRequestMessage
   | SetCurrentUserIDRequestMessage
   | GetCurrentUserIDRequestMessage
   | GetPersistStorageItemRequestMessage
   | SetPersistStorageItemRequestMessage
   | RemovePersistStorageItemRequestMessage
   | ClearSensitiveDataRequestMessage;
 
 export type WorkerRequestProxyMessage = {
   +id: number,
   +message: WorkerRequestMessage,
 };
 
 // The types of messages sent from worker to app
 export const workerResponseMessageTypes = Object.freeze({
   PONG: 0,
   CLIENT_STORE: 1,
   GET_CURRENT_USER_ID: 2,
   GET_PERSIST_STORAGE_ITEM: 3,
 });
 
 export type PongWorkerResponseMessage = {
   +type: 0,
   +text: string,
 };
 
 export type ClientStoreResponseMessage = {
   +type: 1,
   +store: ClientDBStore,
 };
 
 export type GetCurrentUserIDResponseMessage = {
   +type: 2,
   +userID: ?string,
 };
 
 export type GetPersistStorageItemResponseMessage = {
   +type: 3,
   +item: string,
 };
 
 export type WorkerResponseMessage =
   | PongWorkerResponseMessage
   | ClientStoreResponseMessage
   | GetCurrentUserIDResponseMessage
   | GetPersistStorageItemResponseMessage;
 
 export type WorkerResponseProxyMessage = {
   +id?: number,
   +message?: WorkerResponseMessage,
   +error?: string,
 };
 
 // SharedWorker types
 export type SharedWorkerMessageEvent = MessageEvent & {
   +ports: $ReadOnlyArray<MessagePort>,
   ...
 };