diff --git a/lib/handlers/db-ops-handler.react.js b/lib/handlers/db-ops-handler.react.js
index 32e9023b6..a0ba20b4d 100644
--- a/lib/handlers/db-ops-handler.react.js
+++ b/lib/handlers/db-ops-handler.react.js
@@ -1,88 +1,88 @@
 // @flow
 
 import * as React from 'react';
 
 import { opsProcessingFinishedActionType } from '../actions/db-ops-actions.js';
 import { usePeerToPeerCommunication } from '../tunnelbroker/peer-to-peer-context.js';
 import { useTunnelbroker } from '../tunnelbroker/tunnelbroker-context.js';
 import type { DBOpsEntry } from '../types/db-ops-types.js';
 import type { StoreOperations } from '../types/store-ops-types.js';
 import {
   type MessageProcessed,
   peerToPeerMessageTypes,
 } from '../types/tunnelbroker/peer-to-peer-message-types.js';
 import { getConfig } from '../utils/config.js';
 import { getContentSigningKey } from '../utils/crypto-utils.js';
 import { getMessageForException } from '../utils/errors.js';
 import { useDispatch, useSelector } from '../utils/redux-utils.js';
 
 type Props = {
   +processDBStoreOperations: StoreOperations => Promise<mixed>,
 };
 
 function DBOpsHandler(props: Props): React.Node {
   const { sqliteAPI } = getConfig();
   const { processDBStoreOperations } = props;
   const queueFront = useSelector(state => state.dbOpsStore.queuedOps[0]);
   const prevQueueFront = React.useRef<?DBOpsEntry>(null);
   const { sendMessageToDevice } = useTunnelbroker();
   const { processOutboundMessages } = usePeerToPeerCommunication();
 
   const dispatch = useDispatch();
 
   React.useEffect(() => {
     if (!queueFront || prevQueueFront.current === queueFront) {
       return;
     }
     prevQueueFront.current = queueFront;
 
-    const { ops, messageSourceMetadata } = queueFront;
+    const { ops, messageSourceMetadata, dmOpID } = queueFront;
     void (async () => {
       if (ops) {
         await processDBStoreOperations(ops);
         if (ops.outboundP2PMessages && ops.outboundP2PMessages.length > 0) {
           const messageIDs = ops.outboundP2PMessages.map(
             message => message.messageID,
           );
-          processOutboundMessages(messageIDs);
+          processOutboundMessages(messageIDs, dmOpID);
         }
       }
       dispatch({
         type: opsProcessingFinishedActionType,
       });
       if (messageSourceMetadata) {
         try {
           const { messageID, senderDeviceID } = messageSourceMetadata;
           const deviceID = await getContentSigningKey();
           const message: MessageProcessed = {
             type: peerToPeerMessageTypes.MESSAGE_PROCESSED,
             messageID,
             deviceID,
           };
           await sendMessageToDevice({
             deviceID: senderDeviceID,
             payload: JSON.stringify(message),
           });
           await sqliteAPI.removeInboundP2PMessages([messageID]);
         } catch (e) {
           console.log(
             `Error while sending confirmation: ${
               getMessageForException(e) ?? 'unknown error'
             }`,
           );
         }
       }
     })();
   }, [
     queueFront,
     dispatch,
     processDBStoreOperations,
     sendMessageToDevice,
     sqliteAPI,
     processOutboundMessages,
   ]);
 
   return null;
 }
 
 export { DBOpsHandler };
diff --git a/lib/reducers/db-ops-reducer.js b/lib/reducers/db-ops-reducer.js
index 206fbad66..96d87454e 100644
--- a/lib/reducers/db-ops-reducer.js
+++ b/lib/reducers/db-ops-reducer.js
@@ -1,116 +1,128 @@
 // @flow
 
 import { opsProcessingFinishedActionType } from '../actions/db-ops-actions.js';
 import { extractKeyserverIDFromIDOptional } from '../keyserver-conn/keyserver-call-utils.js';
 import type { MessageSearchStoreOperation } from '../message-search-types.js';
 import type { MessageStoreOperation } from '../ops/message-store-ops.js';
 import type {
   MessageSourceMetadata,
   DBOpsStore,
 } from '../types/db-ops-types.js';
+import { scheduleP2PMessagesActionType } from '../types/dm-ops.js';
 import { messageTypes } from '../types/message-types-enum.js';
 import type { BaseAction } from '../types/redux-types.js';
 import type { StoreOperations } from '../types/store-ops-types.js';
 import { values } from '../utils/objects.js';
 
 function reduceDBOpsStore(store: DBOpsStore, action: BaseAction): DBOpsStore {
   if (action.type === opsProcessingFinishedActionType) {
     const [, ...rest] = store.queuedOps;
     return {
       ...store,
       queuedOps: rest,
     };
+  } else if (action.type === scheduleP2PMessagesActionType) {
+    const newEntry = {
+      ops: {
+        outboundP2PMessages: action.payload.messages,
+      },
+      dmOpID: action.payload.dmOpID,
+    };
+    return {
+      ...store,
+      queuedOps: [...store.queuedOps, newEntry],
+    };
   }
 
   return store;
 }
 
 function getMessageSearchStoreOps(
   messageStoreOps: ?$ReadOnlyArray<MessageStoreOperation>,
 ): $ReadOnlyArray<MessageSearchStoreOperation> {
   if (!messageStoreOps) {
     return [];
   }
   const messageSearchStoreOps: MessageSearchStoreOperation[] = [];
   for (const messageOp of messageStoreOps) {
     if (messageOp.type === 'replace') {
       // We only create search index for thick threads,
       // and for non-local messages
       const { messageInfo } = messageOp.payload;
       if (
         extractKeyserverIDFromIDOptional(messageInfo.threadID) ||
         !messageInfo.id
       ) {
         continue;
       }
 
       if (messageInfo.type === messageTypes.TEXT) {
         messageSearchStoreOps.push({
           type: 'update_search_messages',
           payload: {
             originalMessageID: messageInfo.id,
             messageID: messageInfo.id,
             content: messageInfo.text,
           },
         });
       } else if (messageInfo.type === messageTypes.EDIT_MESSAGE) {
         messageSearchStoreOps.push({
           type: 'update_search_messages',
           payload: {
             originalMessageID: messageInfo.targetMessageID,
             messageID: messageInfo.id,
             content: messageInfo.text,
           },
         });
       }
     }
   }
   return messageSearchStoreOps;
 }
 
 function queueDBOps(
   store: DBOpsStore,
   messageSourceMetadata: ?MessageSourceMetadata,
   inputOps: StoreOperations,
 ): DBOpsStore {
   const areNewOpsPresent = values(inputOps).some(
     opsArray => opsArray.length > 0,
   );
   let newEntry = null;
 
   const { messageStoreOperations } = inputOps;
   const messageSearchStoreOperations = getMessageSearchStoreOps(
     messageStoreOperations,
   );
 
   const ops = {
     ...inputOps,
     messageSearchStoreOperations,
   };
 
   if (messageSourceMetadata && areNewOpsPresent) {
     newEntry = {
       messageSourceMetadata,
       ops,
     };
   } else if (areNewOpsPresent) {
     newEntry = {
       ops,
     };
   } else if (messageSourceMetadata) {
     newEntry = {
       messageSourceMetadata,
     };
   }
 
   if (!newEntry) {
     return store;
   }
 
   return {
     ...store,
     queuedOps: [...store.queuedOps, newEntry],
   };
 }
 
 export { reduceDBOpsStore, queueDBOps, getMessageSearchStoreOps };
diff --git a/lib/tunnelbroker/peer-to-peer-context.js b/lib/tunnelbroker/peer-to-peer-context.js
index ca700b984..2e625568b 100644
--- a/lib/tunnelbroker/peer-to-peer-context.js
+++ b/lib/tunnelbroker/peer-to-peer-context.js
@@ -1,217 +1,280 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
+import uuid from 'uuid';
 
 import {
   type TunnelbrokerClientMessageToDevice,
   useTunnelbroker,
 } from './tunnelbroker-context.js';
+import {
+  createMessagesToPeersFromDMOp,
+  type DMOperationSpecification,
+} from '../shared/dm-ops/dm-op-utils.js';
 import {
   IdentityClientContext,
   type IdentityClientContextType,
 } from '../shared/identity-client-context.js';
+import { scheduleP2PMessagesActionType } from '../types/dm-ops.js';
 import {
   type OutboundP2PMessage,
   outboundP2PMessageStatuses,
 } from '../types/sqlite-types.js';
 import {
   type EncryptedMessage,
   peerToPeerMessageTypes,
 } from '../types/tunnelbroker/peer-to-peer-message-types.js';
 import { getConfig } from '../utils/config.js';
 import { createOlmSessionWithPeer } from '../utils/crypto-utils.js';
 import { getMessageForException } from '../utils/errors.js';
+import { useDispatch, useSelector } from '../utils/redux-utils.js';
 
 type PeerToPeerContextType = {
-  +processOutboundMessages: (messageIDs?: $ReadOnlyArray<string>) => void,
+  +processOutboundMessages: (
+    outboundMessageIDs: ?$ReadOnlyArray<string>,
+    dmOpID: ?string,
+  ) => void,
+  +sendDMOperation: (op: DMOperationSpecification) => Promise<void>,
 };
 
 const PeerToPeerContext: React.Context<?PeerToPeerContextType> =
   React.createContext<?PeerToPeerContextType>();
 
 type Props = {
   +children: React.Node,
 };
 
 async function processOutboundP2PMessages(
   sendMessage: (
     message: TunnelbrokerClientMessageToDevice,
     messageID: ?string,
   ) => Promise<void>,
   identityContext: IdentityClientContextType,
   messageIDs: ?$ReadOnlyArray<string>,
 ): Promise<void> {
   const authMetadata = await identityContext.getAuthMetadata();
   if (
     !authMetadata.deviceID ||
     !authMetadata.userID ||
     !authMetadata.accessToken
   ) {
     return;
   }
 
   const { olmAPI, sqliteAPI } = getConfig();
   await olmAPI.initializeCryptoAccount();
   let messages;
   if (messageIDs) {
     messages = await sqliteAPI.getOutboundP2PMessagesByID(messageIDs);
   } else {
     const allMessages = await sqliteAPI.getAllOutboundP2PMessages();
     messages = allMessages.filter(message => message.supportsAutoRetry);
   }
 
   const devicesMap: { [deviceID: string]: OutboundP2PMessage[] } = {};
   for (const message: OutboundP2PMessage of messages) {
     if (!devicesMap[message.deviceID]) {
       devicesMap[message.deviceID] = [message];
     } else {
       devicesMap[message.deviceID].push(message);
     }
   }
 
   const sendMessageToPeer = async (
     message: OutboundP2PMessage,
   ): Promise<void> => {
     if (!authMetadata.deviceID || !authMetadata.userID) {
       return;
     }
     const encryptedMessage: EncryptedMessage = {
       type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
       senderInfo: {
         deviceID: authMetadata.deviceID,
         userID: authMetadata.userID,
       },
       encryptedData: JSON.parse(message.ciphertext),
     };
     await sendMessage(
       {
         deviceID: message.deviceID,
         payload: JSON.stringify(encryptedMessage),
       },
       message.messageID,
     );
     await sqliteAPI.markOutboundP2PMessageAsSent(
       message.messageID,
       message.deviceID,
     );
   };
 
   for (const peerDeviceID in devicesMap) {
     for (const message of devicesMap[peerDeviceID]) {
       if (message.status === outboundP2PMessageStatuses.persisted) {
         try {
           const result = await olmAPI.encryptAndPersist(
             message.plaintext,
             message.deviceID,
             message.messageID,
           );
 
           const encryptedMessage: OutboundP2PMessage = {
             ...message,
             ciphertext: JSON.stringify(result),
           };
           await sendMessageToPeer(encryptedMessage);
         } catch (e) {
           try {
             await createOlmSessionWithPeer(
               authMetadata,
               identityContext.identityClient,
               sendMessage,
               message.userID,
               peerDeviceID,
             );
             const result = await olmAPI.encryptAndPersist(
               message.plaintext,
               message.deviceID,
               message.messageID,
             );
             const encryptedMessage: OutboundP2PMessage = {
               ...message,
               ciphertext: JSON.stringify(result),
             };
 
             await sendMessageToPeer(encryptedMessage);
           } catch (err) {
             console.log(`Error sending messages to peer ${peerDeviceID}`, err);
             break;
           }
         }
       } else if (message.status === outboundP2PMessageStatuses.encrypted) {
         await sendMessageToPeer(message);
       }
     }
   }
 }
 
 const AUTOMATIC_RETRY_FREQUENCY = 30 * 1000;
 
 function PeerToPeerProvider(props: Props): React.Node {
   const { children } = props;
 
-  const processingQueue = React.useRef<Array<?$ReadOnlyArray<string>>>([]);
-  const promiseRunning = React.useRef<boolean>(false);
-
   const { sendMessageToDevice } = useTunnelbroker();
   const identityContext = React.useContext(IdentityClientContext);
   invariant(identityContext, 'Identity context should be set');
 
+  const dispatch = useDispatch();
+  const dmOpsSendingPromiseResolvers = React.useRef<
+    Map<string, { +resolve: () => mixed, +reject: Error => mixed }>,
+  >(new Map());
+  const auxUserStore = useSelector(state => state.auxUserStore);
+  const currentUserInfo = useSelector(state => state.currentUserInfo);
+
+  const sendDMOperation = React.useCallback(
+    async (op: DMOperationSpecification) => {
+      const dmOpID = uuid.v4();
+      const promise = new Promise<void>((resolve, reject) => {
+        dmOpsSendingPromiseResolvers.current.set(dmOpID, { resolve, reject });
+      });
+
+      const messages = await createMessagesToPeersFromDMOp(
+        op,
+        auxUserStore,
+        currentUserInfo,
+      );
+      dispatch({
+        type: scheduleP2PMessagesActionType,
+        payload: {
+          dmOpID,
+          messages,
+        },
+      });
+
+      return promise;
+    },
+    [auxUserStore, currentUserInfo, dispatch],
+  );
+
+  const processingQueue = React.useRef<
+    Array<{
+      +outboundMessageIDs: ?$ReadOnlyArray<string>,
+      +dmOpID: ?string,
+    }>,
+  >([]);
+  const promiseRunning = React.useRef<boolean>(false);
+
   const processOutboundMessages = React.useCallback(
-    (messageIDs?: $ReadOnlyArray<string>) => {
-      processingQueue.current.push(messageIDs);
+    (outboundMessageIDs: ?$ReadOnlyArray<string>, dmOpID: ?string) => {
+      processingQueue.current.push({ outboundMessageIDs, dmOpID });
       if (!promiseRunning.current) {
         promiseRunning.current = true;
         void (async () => {
           do {
-            const nextMessageIDs = processingQueue.current.shift();
+            const queueFront = processingQueue.current.shift();
             try {
               await processOutboundP2PMessages(
                 sendMessageToDevice,
                 identityContext,
-                nextMessageIDs,
+                queueFront?.outboundMessageIDs,
               );
+              if (queueFront.dmOpID) {
+                dmOpsSendingPromiseResolvers.current
+                  .get(queueFront.dmOpID)
+                  ?.resolve?.();
+              }
             } catch (e) {
               console.log(
                 `Error processing outbound P2P messages: ${
                   getMessageForException(e) ?? 'unknown'
                 }`,
               );
+              if (queueFront.dmOpID) {
+                dmOpsSendingPromiseResolvers.current
+                  .get(queueFront.dmOpID)
+                  ?.reject?.(e);
+              }
+            } finally {
+              if (queueFront.dmOpID) {
+                dmOpsSendingPromiseResolvers.current.delete(queueFront.dmOpID);
+              }
             }
           } while (processingQueue.current.length > 0);
           promiseRunning.current = false;
         })();
       }
     },
     [identityContext, sendMessageToDevice],
   );
 
   React.useEffect(() => {
     const intervalID = setInterval(
       processOutboundMessages,
       AUTOMATIC_RETRY_FREQUENCY,
     );
     return () => clearInterval(intervalID);
   }, [processOutboundMessages]);
 
   const value: PeerToPeerContextType = React.useMemo(
     () => ({
       processOutboundMessages,
+      sendDMOperation,
     }),
-    [processOutboundMessages],
+    [processOutboundMessages, sendDMOperation],
   );
 
   return (
     <PeerToPeerContext.Provider value={value}>
       {children}
     </PeerToPeerContext.Provider>
   );
 }
 
 function usePeerToPeerCommunication(): PeerToPeerContextType {
   const context = React.useContext(PeerToPeerContext);
   invariant(context, 'PeerToPeerContext not found');
 
   return context;
 }
 
 export { PeerToPeerProvider, usePeerToPeerCommunication };
diff --git a/lib/types/db-ops-types.js b/lib/types/db-ops-types.js
index 3576bee97..acead3265 100644
--- a/lib/types/db-ops-types.js
+++ b/lib/types/db-ops-types.js
@@ -1,21 +1,22 @@
 // @flow
 
 import type { StoreOperations } from './store-ops-types.js';
 
 export type MessageSourceMetadata = {
   +messageID: string,
   +senderDeviceID: string,
 };
 
 export type DBOpsEntry =
   | {
       +messageSourceMetadata: MessageSourceMetadata,
       +ops?: ?StoreOperations,
     }
   | {
       +ops: StoreOperations,
+      +dmOpID?: string,
     };
 
 export type DBOpsStore = {
   +queuedOps: $ReadOnlyArray<DBOpsEntry>,
 };
diff --git a/lib/types/dm-ops.js b/lib/types/dm-ops.js
index 97b7ef6f5..92f1646a0 100644
--- a/lib/types/dm-ops.js
+++ b/lib/types/dm-ops.js
@@ -1,156 +1,163 @@
 // @flow
 
 import type { TInterface, TUnion } from 'tcomb';
 import t from 'tcomb';
 
 import type { RawMessageInfo } from './message-types.js';
+import type { OutboundP2PMessage } from './sqlite-types.js';
 import {
   type NonSidebarThickThreadType,
   nonSidebarThickThreadTypes,
 } from './thread-types-enum.js';
 import type { ClientUpdateInfo } from './update-types.js';
 import { values } from '../utils/objects.js';
 import { tShape, tString, tUserID } from '../utils/validation-utils.js';
 
 export const dmOperationTypes = Object.freeze({
   CREATE_THREAD: 'create_thread',
   CREATE_SIDEBAR: 'create_sidebar',
   SEND_TEXT_MESSAGE: 'send_text_message',
   SEND_REACTION_MESSAGE: 'send_reaction_message',
   SEND_EDIT_MESSAGE: 'send_edit_message',
 });
 export type DMOperationType = $Values<typeof dmOperationTypes>;
 
 export type DMCreateThreadOperation = {
   +type: 'create_thread',
   +threadID: string,
   +creatorID: string,
   +time: number,
   +threadType: NonSidebarThickThreadType,
   +memberIDs: $ReadOnlyArray<string>,
   +roleID: string,
   +newMessageID: string,
 };
 export const dmCreateThreadOperationValidator: TInterface<DMCreateThreadOperation> =
   tShape<DMCreateThreadOperation>({
     type: tString(dmOperationTypes.CREATE_THREAD),
     threadID: t.String,
     creatorID: tUserID,
     time: t.Number,
     threadType: t.enums.of(values(nonSidebarThickThreadTypes)),
     memberIDs: t.list(tUserID),
     roleID: t.String,
     newMessageID: t.String,
   });
 
 export type DMCreateSidebarOperation = {
   +type: 'create_sidebar',
   +threadID: string,
   +creatorID: string,
   +time: number,
   +parentThreadID: string,
   +memberIDs: $ReadOnlyArray<string>,
   +sourceMessageID: string,
   +roleID: string,
   +newSidebarSourceMessageID: string,
   +newCreateSidebarMessageID: string,
 };
 export const dmCreateSidebarOperationValidator: TInterface<DMCreateSidebarOperation> =
   tShape<DMCreateSidebarOperation>({
     type: tString(dmOperationTypes.CREATE_SIDEBAR),
     threadID: t.String,
     creatorID: tUserID,
     time: t.Number,
     parentThreadID: t.String,
     memberIDs: t.list(tUserID),
     sourceMessageID: t.String,
     roleID: t.String,
     newSidebarSourceMessageID: t.String,
     newCreateSidebarMessageID: t.String,
   });
 
 export type DMSendTextMessageOperation = {
   +type: 'send_text_message',
   +threadID: string,
   +creatorID: string,
   +time: number,
   +messageID: string,
   +text: string,
 };
 export const dmSendTextMessageOperationValidator: TInterface<DMSendTextMessageOperation> =
   tShape<DMSendTextMessageOperation>({
     type: tString(dmOperationTypes.SEND_TEXT_MESSAGE),
     threadID: t.String,
     creatorID: tUserID,
     time: t.Number,
     messageID: t.String,
     text: t.String,
   });
 
 export type DMSendReactionMessageOperation = {
   +type: 'send_reaction_message',
   +threadID: string,
   +creatorID: string,
   +time: number,
   +messageID: string,
   +targetMessageID: string,
   +reaction: string,
   +action: 'add_reaction' | 'remove_reaction',
 };
 export const dmSendReactionMessageOperationValidator: TInterface<DMSendReactionMessageOperation> =
   tShape<DMSendReactionMessageOperation>({
     type: tString(dmOperationTypes.SEND_REACTION_MESSAGE),
     threadID: t.String,
     creatorID: tUserID,
     time: t.Number,
     messageID: t.String,
     targetMessageID: t.String,
     reaction: t.String,
     action: t.enums.of(['add_reaction', 'remove_reaction']),
   });
 
 export type DMSendEditMessageOperation = {
   +type: 'send_edit_message',
   +threadID: string,
   +creatorID: string,
   +time: number,
   +messageID: string,
   +targetMessageID: string,
   +text: string,
 };
 export const dmSendEditMessageOperationValidator: TInterface<DMSendEditMessageOperation> =
   tShape<DMSendEditMessageOperation>({
     type: tString(dmOperationTypes.SEND_EDIT_MESSAGE),
     threadID: t.String,
     creatorID: tUserID,
     time: t.Number,
     messageID: t.String,
     targetMessageID: t.String,
     text: t.String,
   });
 
 export type DMOperation =
   | DMCreateThreadOperation
   | DMCreateSidebarOperation
   | DMSendTextMessageOperation
   | DMSendReactionMessageOperation
   | DMSendEditMessageOperation;
 export const dmOperationValidator: TUnion<DMOperation> = t.union([
   dmCreateThreadOperationValidator,
   dmCreateSidebarOperationValidator,
   dmSendTextMessageOperationValidator,
   dmSendReactionMessageOperationValidator,
   dmSendEditMessageOperationValidator,
 ]);
 
 export type DMOperationResult = {
   rawMessageInfos: Array<RawMessageInfo>,
   updateInfos: Array<ClientUpdateInfo>,
 };
 
 export const processDMOpsActionType = 'PROCESS_DM_OPS';
 
 export type ProcessDMOpsPayload = {
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +updateInfos: $ReadOnlyArray<ClientUpdateInfo>,
 };
+
+export const scheduleP2PMessagesActionType = 'SCHEDULE_P2P_MESSAGES';
+export type ScheduleP2PMessagesPayload = {
+  +dmOpID: string,
+  +messages: $ReadOnlyArray<OutboundP2PMessage>,
+};
diff --git a/lib/types/redux-types.js b/lib/types/redux-types.js
index be9369b3e..f1fcdec89 100644
--- a/lib/types/redux-types.js
+++ b/lib/types/redux-types.js
@@ -1,1591 +1,1595 @@
 // @flow
 
 import type { PersistState } from 'redux-persist/es/types';
 
 import type {
   LogOutResult,
   KeyserverLogOutResult,
   LegacyLogInStartingPayload,
   LegacyLogInResult,
   LegacyRegisterResult,
   DefaultNotificationPayload,
   ClaimUsernameResponse,
   KeyserverAuthResult,
 } from './account-types.js';
 import type {
   ActivityUpdateSuccessPayload,
   QueueActivityUpdatesPayload,
   SetThreadUnreadStatusPayload,
 } from './activity-types.js';
 import type { AlertStore, RecordAlertActionPayload } from './alert-types.js';
 import type {
   AuxUserStore,
   SetAuxUserFIDsPayload,
   AddAuxUserFIDsPayload,
   SetPeerDeviceListsPayload,
 } from './aux-user-types.js';
 import type {
   UpdateUserAvatarRequest,
   UpdateUserAvatarResponse,
 } from './avatar-types.js';
 import type {
   CommunityStore,
   AddCommunityPayload,
   FetchCommunityInfosResponse,
   CreateOrUpdateFarcasterChannelTagResponse,
   DeleteFarcasterChannelTagPayload,
 } from './community-types.js';
 import type { MessageSourceMetadata, DBOpsStore } from './db-ops-types.js';
 import type {
   GetVersionActionPayload,
   LastCommunicatedPlatformDetails,
 } from './device-types.js';
-import type { ProcessDMOpsPayload } from './dm-ops.js';
+import type {
+  ScheduleP2PMessagesPayload,
+  ProcessDMOpsPayload,
+} from './dm-ops.js';
 import type { DraftStore } from './draft-types.js';
 import type { EnabledApps, SupportedApps } from './enabled-apps.js';
 import type {
   RawEntryInfo,
   EntryStore,
   SaveEntryPayload,
   CreateEntryPayload,
   DeleteEntryResult,
   RestoreEntryPayload,
   FetchEntryInfosResult,
   CalendarQueryUpdateResult,
   CalendarQueryUpdateStartingPayload,
   FetchRevisionsForEntryPayload,
 } from './entry-types.js';
 import type {
   CalendarFilter,
   CalendarThreadFilter,
   SetCalendarDeletedFilterPayload,
 } from './filter-types.js';
 import type { IdentityAuthResult } from './identity-service-types';
 import type { IntegrityStore } from './integrity-types.js';
 import type {
   KeyserverStore,
   AddKeyserverPayload,
   RemoveKeyserverPayload,
 } from './keyserver-types.js';
 import type { LifecycleState } from './lifecycle-state-types.js';
 import type {
   FetchInviteLinksResponse,
   InviteLink,
   InviteLinksStore,
   InviteLinkVerificationResponse,
   DisableInviteLinkPayload,
 } from './link-types.js';
 import type { LoadingStatus, LoadingInfo } from './loading-types.js';
 import type { UpdateMultimediaMessageMediaPayload } from './media-types.js';
 import type { MessageReportCreationResult } from './message-report-types.js';
 import type {
   MessageStore,
   RawMultimediaMessageInfo,
   FetchMessageInfosPayload,
   SendMessagePayload,
   EditMessagePayload,
   SaveMessagesPayload,
   NewMessagesPayload,
   MessageStorePrunePayload,
   LocallyComposedMessageInfo,
   SimpleMessagesPayload,
   FetchPinnedMessagesResult,
   SearchMessagesResponse,
 } from './message-types.js';
 import type { RawReactionMessageInfo } from './messages/reaction.js';
 import type { RawTextMessageInfo } from './messages/text.js';
 import type { BaseNavInfo, WebNavInfo } from './nav-types.js';
 import {
   type ForcePolicyAcknowledgmentPayload,
   type PolicyAcknowledgmentPayload,
   type UserPolicies,
 } from './policy-types.js';
 import type { RelationshipErrors } from './relationship-types.js';
 import type {
   EnabledReports,
   ClearDeliveredReportsPayload,
   QueueReportsPayload,
   ReportStore,
 } from './report-types.js';
 import type {
   ProcessServerRequestAction,
   GetOlmSessionInitializationDataResponse,
 } from './request-types.js';
 import type {
   UserSearchResult,
   ExactUserSearchResult,
 } from './search-types.js';
 import type { SetSessionPayload } from './session-types.js';
 import type {
   ConnectionIssue,
   StateSyncFullActionPayload,
   StateSyncIncrementalActionPayload,
   SetActiveSessionRecoveryPayload,
   ClientStateSyncSocketResult,
 } from './socket-types.js';
 import { type ClientStore } from './store-ops-types.js';
 import type { SubscriptionUpdateResult } from './subscription-types.js';
 import type {
   SyncedMetadataStore,
   SetSyncedMetadataEntryPayload,
   ClearSyncedMetadataEntryPayload,
 } from './synced-metadata-types.js';
 import type { GlobalThemeInfo } from './theme-types.js';
 import type { ThreadActivityStore } from './thread-activity-types.js';
 import type {
   ThreadStore,
   ChangeThreadSettingsPayload,
   LeaveThreadPayload,
   NewThreadResult,
   ThreadJoinPayload,
   ToggleMessagePinResult,
   LegacyThreadStore,
   RoleModificationPayload,
   RoleDeletionPayload,
 } from './thread-types.js';
 import type { TunnelbrokerDeviceToken } from './tunnelbroker-device-token-types.js';
 import type { ClientUpdatesResultWithUserInfos } from './update-types.js';
 import type {
   CurrentUserInfo,
   UserInfos,
   UserStore,
   UserInfo,
 } from './user-types.js';
 import type { SetDeviceTokenActionPayload } from '../actions/device-actions.js';
 import type {
   UpdateConnectionStatusPayload,
   SetLateResponsePayload,
   UpdateKeyserverReachabilityPayload,
 } from '../keyserver-conn/keyserver-conn-types.js';
 
 export type BaseAppState<NavInfo: BaseNavInfo = BaseNavInfo> = {
   +navInfo: NavInfo,
   +currentUserInfo: ?CurrentUserInfo,
   +draftStore: DraftStore,
   +entryStore: EntryStore,
   +threadStore: ThreadStore,
   +userStore: UserStore,
   +messageStore: MessageStore,
   +loadingStatuses: { [key: string]: { [idx: number]: LoadingStatus } },
   +calendarFilters: $ReadOnlyArray<CalendarFilter>,
   +alertStore: AlertStore,
   +watchedThreadIDs: $ReadOnlyArray<string>,
   +lifecycleState: LifecycleState,
   +enabledApps: EnabledApps,
   +reportStore: ReportStore,
   +dataLoaded: boolean,
   +userPolicies: UserPolicies,
   +commServicesAccessToken: ?string,
   +inviteLinksStore: InviteLinksStore,
   +keyserverStore: KeyserverStore,
   +threadActivityStore: ThreadActivityStore,
   +integrityStore: IntegrityStore,
   +globalThemeInfo: GlobalThemeInfo,
   +customServer: ?string,
   +communityStore: CommunityStore,
   +dbOpsStore: DBOpsStore,
   +syncedMetadataStore: SyncedMetadataStore,
   +auxUserStore: AuxUserStore,
   +tunnelbrokerDeviceToken: TunnelbrokerDeviceToken,
   +_persist: ?PersistState,
   ...
 };
 
 export type NativeAppState = BaseAppState<>;
 export type WebAppState = BaseAppState<> & {
   +pushApiPublicKey: ?string,
   ...
 };
 export type AppState = NativeAppState | WebAppState;
 
 export type ClientWebInitialReduxStateResponse = {
   +navInfo: WebNavInfo,
   +currentUserInfo: CurrentUserInfo,
   +entryStore: EntryStore,
   +threadStore: ThreadStore,
   +userInfos: UserInfos,
   +messageStore: MessageStore,
   +pushApiPublicKey: ?string,
   +inviteLinksStore: InviteLinksStore,
   +keyserverInfo: WebInitialKeyserverInfo,
 };
 export type ServerWebInitialReduxStateResponse = {
   +navInfo: WebNavInfo,
   +currentUserInfo: CurrentUserInfo,
   +entryStore: EntryStore,
   +threadStore: LegacyThreadStore,
   +userInfos: UserInfos,
   +messageStore: MessageStore,
   +pushApiPublicKey: ?string,
   +inviteLinksStore: InviteLinksStore,
   +keyserverInfo: WebInitialKeyserverInfo,
 };
 export type WebInitialKeyserverInfo = {
   +sessionID: ?string,
   +updatesCurrentAsOf: number,
 };
 
 export type BaseAction = $ReadOnly<{
   +messageSourceMetadata?: MessageSourceMetadata,
   ...
     | {
         +type: '@@redux/INIT',
         +payload?: void,
       }
     | {
         +type: 'FETCH_ENTRIES_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_ENTRIES_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_ENTRIES_SUCCESS',
         +payload: FetchEntryInfosResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LOG_OUT_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LOG_OUT_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LOG_OUT_SUCCESS',
         +payload: LogOutResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CLAIM_USERNAME_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CLAIM_USERNAME_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CLAIM_USERNAME_SUCCESS',
         +payload: ClaimUsernameResponse,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_KEYSERVER_ACCOUNT_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_KEYSERVER_ACCOUNT_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_KEYSERVER_ACCOUNT_SUCCESS',
         +payload: KeyserverLogOutResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_ACCOUNT_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_ACCOUNT_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_ACCOUNT_SUCCESS',
         +payload: LogOutResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CREATE_LOCAL_ENTRY',
         +payload: RawEntryInfo,
       }
     | {
         +type: 'CREATE_ENTRY_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CREATE_ENTRY_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CREATE_ENTRY_SUCCESS',
         +payload: CreateEntryPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SAVE_ENTRY_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SAVE_ENTRY_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SAVE_ENTRY_SUCCESS',
         +payload: SaveEntryPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CONCURRENT_MODIFICATION_RESET',
         +payload: {
           +id: string,
           +dbText: string,
         },
       }
     | {
         +type: 'DELETE_ENTRY_STARTED',
         +loadingInfo: LoadingInfo,
         +payload: {
           +localID: ?string,
           +serverID: ?string,
         },
       }
     | {
         +type: 'DELETE_ENTRY_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_ENTRY_SUCCESS',
         +payload: ?DeleteEntryResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_LOG_IN_STARTED',
         +loadingInfo: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'IDENTITY_LOG_IN_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_LOG_IN_SUCCESS',
         +payload: IdentityAuthResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'KEYSERVER_AUTH_STARTED',
         +loadingInfo: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'KEYSERVER_AUTH_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'KEYSERVER_AUTH_SUCCESS',
         +payload: KeyserverAuthResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEGACY_LOG_IN_STARTED',
         +loadingInfo: LoadingInfo,
         +payload: LegacyLogInStartingPayload,
       }
     | {
         +type: 'LEGACY_LOG_IN_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEGACY_LOG_IN_SUCCESS',
         +payload: LegacyLogInResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEGACY_KEYSERVER_REGISTER_STARTED',
         +loadingInfo: LoadingInfo,
         +payload: LegacyLogInStartingPayload,
       }
     | {
         +type: 'LEGACY_KEYSERVER_REGISTER_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEGACY_KEYSERVER_REGISTER_SUCCESS',
         +payload: LegacyRegisterResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_REGISTER_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_REGISTER_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_REGISTER_SUCCESS',
         +payload: IdentityAuthResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_GENERATE_NONCE_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_GENERATE_NONCE_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_GENERATE_NONCE_SUCCESS',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_KEYSERVER_USER_PASSWORD_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_KEYSERVER_USER_PASSWORD_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_KEYSERVER_USER_PASSWORD_SUCCESS',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_IDENTITY_USER_PASSWORD_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_IDENTITY_USER_PASSWORD_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_IDENTITY_USER_PASSWORD_SUCCESS',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_THREAD_SETTINGS_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_THREAD_SETTINGS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_THREAD_SETTINGS_SUCCESS',
         +payload: ChangeThreadSettingsPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_THREAD_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_THREAD_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_THREAD_SUCCESS',
         +payload: LeaveThreadPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'NEW_THREAD_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'NEW_THREAD_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'NEW_THREAD_SUCCESS',
         +payload: NewThreadResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'REMOVE_USERS_FROM_THREAD_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'REMOVE_USERS_FROM_THREAD_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'REMOVE_USERS_FROM_THREAD_SUCCESS',
         +payload: ChangeThreadSettingsPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_THREAD_MEMBER_ROLES_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_THREAD_MEMBER_ROLES_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_THREAD_MEMBER_ROLES_SUCCESS',
         +payload: ChangeThreadSettingsPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_REVISIONS_FOR_ENTRY_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_REVISIONS_FOR_ENTRY_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_REVISIONS_FOR_ENTRY_SUCCESS',
         +payload: FetchRevisionsForEntryPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'RESTORE_ENTRY_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'RESTORE_ENTRY_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'RESTORE_ENTRY_SUCCESS',
         +payload: RestoreEntryPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'JOIN_THREAD_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'JOIN_THREAD_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'JOIN_THREAD_SUCCESS',
         +payload: ThreadJoinPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEAVE_THREAD_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEAVE_THREAD_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEAVE_THREAD_SUCCESS',
         +payload: LeaveThreadPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_NEW_SESSION',
         +payload: SetSessionPayload,
       }
     | {
         +type: 'persist/REHYDRATE',
         +payload: ?BaseAppState<>,
       }
     | {
         +type: 'FETCH_MESSAGES_BEFORE_CURSOR_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_MESSAGES_BEFORE_CURSOR_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_MESSAGES_BEFORE_CURSOR_SUCCESS',
         +payload: FetchMessageInfosPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_MOST_RECENT_MESSAGES_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_MOST_RECENT_MESSAGES_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_MOST_RECENT_MESSAGES_SUCCESS',
         +payload: FetchMessageInfosPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_SUCCESS',
         +payload: SimpleMessagesPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_TEXT_MESSAGE_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload: RawTextMessageInfo,
       }
     | {
         +type: 'SEND_TEXT_MESSAGE_FAILED',
         +error: true,
         +payload: Error & {
           +localID: string,
           +threadID: string,
         },
         +loadingInfo?: LoadingInfo,
       }
     | {
         +type: 'SEND_TEXT_MESSAGE_SUCCESS',
         +payload: SendMessagePayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_MULTIMEDIA_MESSAGE_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload: RawMultimediaMessageInfo,
       }
     | {
         +type: 'SEND_MULTIMEDIA_MESSAGE_FAILED',
         +error: true,
         +payload: Error & {
           +localID: string,
           +threadID: string,
         },
         +loadingInfo?: LoadingInfo,
       }
     | {
         +type: 'SEND_MULTIMEDIA_MESSAGE_SUCCESS',
         +payload: SendMessagePayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_REACTION_MESSAGE_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload: RawReactionMessageInfo,
       }
     | {
         +type: 'SEND_REACTION_MESSAGE_FAILED',
         +error: true,
         +payload: Error & {
           +localID: string,
           +threadID: string,
           +targetMessageID: string,
           +reaction: string,
           +action: string,
         },
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_REACTION_MESSAGE_SUCCESS',
         +payload: SendMessagePayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEARCH_USERS_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEARCH_USERS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEARCH_USERS_SUCCESS',
         +payload: UserSearchResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'EXACT_SEARCH_USER_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'EXACT_SEARCH_USER_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'EXACT_SEARCH_USER_SUCCESS',
         +payload: ExactUserSearchResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_DRAFT',
         +payload: {
           +key: string,
           +text: string,
         },
       }
     | {
         +type: 'MOVE_DRAFT',
         +payload: {
           +oldKey: string,
           +newKey: string,
         },
       }
     | {
         +type: 'SET_CLIENT_DB_STORE',
         +payload: ClientStore,
       }
     | {
         +type: 'UPDATE_ACTIVITY_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_ACTIVITY_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_ACTIVITY_SUCCESS',
         +payload: ActivityUpdateSuccessPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_DEVICE_TOKEN_STARTED',
         +payload: ?{
           +deviceToken: ?string,
         },
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_DEVICE_TOKEN_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_DEVICE_TOKEN_SUCCESS',
         +payload: SetDeviceTokenActionPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_REPORT_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_REPORT_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_REPORT_SUCCESS',
         +payload?: ClearDeliveredReportsPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_REPORTS_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_REPORTS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_REPORTS_SUCCESS',
         +payload?: ClearDeliveredReportsPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'QUEUE_REPORTS',
         +payload: QueueReportsPayload,
       }
     | {
         +type: 'SET_URL_PREFIX',
         +payload: string,
       }
     | {
         +type: 'SAVE_MESSAGES',
         +payload: SaveMessagesPayload,
       }
     | {
         +type: 'UPDATE_CALENDAR_THREAD_FILTER',
         +payload: CalendarThreadFilter,
       }
     | {
         +type: 'CLEAR_CALENDAR_THREAD_FILTER',
         +payload?: void,
       }
     | {
         +type: 'SET_CALENDAR_DELETED_FILTER',
         +payload: SetCalendarDeletedFilterPayload,
       }
     | {
         +type: 'UPDATE_SUBSCRIPTION_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_SUBSCRIPTION_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_SUBSCRIPTION_SUCCESS',
         +payload: SubscriptionUpdateResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_CALENDAR_QUERY_STARTED',
         +loadingInfo: LoadingInfo,
         +payload?: CalendarQueryUpdateStartingPayload,
       }
     | {
         +type: 'UPDATE_CALENDAR_QUERY_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_CALENDAR_QUERY_SUCCESS',
         +payload: CalendarQueryUpdateResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FULL_STATE_SYNC',
         +payload: StateSyncFullActionPayload,
       }
     | {
         +type: 'INCREMENTAL_STATE_SYNC',
         +payload: StateSyncIncrementalActionPayload,
       }
     | ProcessServerRequestAction
     | {
         +type: 'UPDATE_CONNECTION_STATUS',
         +payload: UpdateConnectionStatusPayload,
       }
     | {
         +type: 'QUEUE_ACTIVITY_UPDATES',
         +payload: QueueActivityUpdatesPayload,
       }
     | {
         +type: 'UNSUPERVISED_BACKGROUND',
         +payload: { +keyserverID: string },
       }
     | {
         +type: 'UPDATE_LIFECYCLE_STATE',
         +payload: LifecycleState,
       }
     | {
         +type: 'ENABLE_APP',
         +payload: SupportedApps,
       }
     | {
         +type: 'DISABLE_APP',
         +payload: SupportedApps,
       }
     | {
         +type: 'UPDATE_REPORTS_ENABLED',
         +payload: Partial<EnabledReports>,
       }
     | {
         +type: 'PROCESS_UPDATES',
         +payload: ClientUpdatesResultWithUserInfos,
       }
     | {
         +type: 'PROCESS_MESSAGES',
         +payload: NewMessagesPayload,
       }
     | {
         +type: 'MESSAGE_STORE_PRUNE',
         +payload: MessageStorePrunePayload,
       }
     | {
         +type: 'SET_LATE_RESPONSE',
         +payload: SetLateResponsePayload,
       }
     | {
         +type: 'UPDATE_KEYSERVER_REACHABILITY',
         +payload: UpdateKeyserverReachabilityPayload,
       }
     | {
         +type: 'REQUEST_ACCESS_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'REQUEST_ACCESS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'REQUEST_ACCESS_SUCCESS',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_MULTIMEDIA_MESSAGE_MEDIA',
         +payload: UpdateMultimediaMessageMediaPayload,
       }
     | {
         +type: 'CREATE_LOCAL_MESSAGE',
         +payload: LocallyComposedMessageInfo,
       }
     | {
         +type: 'UPDATE_RELATIONSHIPS_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_RELATIONSHIPS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_RELATIONSHIPS_SUCCESS',
         +payload: RelationshipErrors,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_THREAD_UNREAD_STATUS_STARTED',
         +payload: {
           +threadID: string,
           +unread: boolean,
         },
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_THREAD_UNREAD_STATUS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_THREAD_UNREAD_STATUS_SUCCESS',
         +payload: SetThreadUnreadStatusPayload,
       }
     | {
         +type: 'SET_USER_SETTINGS_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_USER_SETTINGS_SUCCESS',
         +payload: DefaultNotificationPayload,
       }
     | {
         +type: 'SET_USER_SETTINGS_FAILED',
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_MESSAGE_REPORT_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_MESSAGE_REPORT_SUCCESS',
         +payload: MessageReportCreationResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_MESSAGE_REPORT_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FORCE_POLICY_ACKNOWLEDGMENT',
         +payload: ForcePolicyAcknowledgmentPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'POLICY_ACKNOWLEDGMENT_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'POLICY_ACKNOWLEDGMENT_SUCCESS',
         +payload: PolicyAcknowledgmentPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'POLICY_ACKNOWLEDGMENT_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'GET_SIWE_NONCE_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'GET_SIWE_NONCE_SUCCESS',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'GET_SIWE_NONCE_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEGACY_SIWE_AUTH_STARTED',
         +payload: LegacyLogInStartingPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEGACY_SIWE_AUTH_SUCCESS',
         +payload: LegacyLogInResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEGACY_SIWE_AUTH_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'RECORD_ALERT',
         +payload: RecordAlertActionPayload,
       }
     | {
         +type: 'UPDATE_USER_AVATAR_STARTED',
         +payload: UpdateUserAvatarRequest,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_USER_AVATAR_SUCCESS',
         +payload: UpdateUserAvatarResponse,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_USER_AVATAR_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_EDIT_MESSAGE_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'SEND_EDIT_MESSAGE_SUCCESS',
         +payload: EditMessagePayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_EDIT_MESSAGE_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'TOGGLE_MESSAGE_PIN_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'TOGGLE_MESSAGE_PIN_SUCCESS',
         +payload: ToggleMessagePinResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'TOGGLE_MESSAGE_PIN_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_PINNED_MESSAGES_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'FETCH_PINNED_MESSAGES_SUCCESS',
         +payload: FetchPinnedMessagesResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_PINNED_MESSAGES_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'VERIFY_INVITE_LINK_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'VERIFY_INVITE_LINK_SUCCESS',
         +payload: InviteLinkVerificationResponse,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'VERIFY_INVITE_LINK_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_PRIMARY_INVITE_LINKS_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'FETCH_PRIMARY_INVITE_LINKS_SUCCESS',
         +payload: FetchInviteLinksResponse,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_PRIMARY_INVITE_LINKS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_CALENDAR_COMMUNITY_FILTER',
         +payload: string,
       }
     | {
         +type: 'CLEAR_CALENDAR_COMMUNITY_FILTER',
         +payload: void,
       }
     | {
         +type: 'UPDATE_CHAT_COMMUNITY_FILTER',
         +payload: string,
       }
     | {
         +type: 'CLEAR_CHAT_COMMUNITY_FILTER',
         +payload: void,
       }
     | {
         +type: 'SEARCH_MESSAGES_STARTED',
         +payload: void,
         +loadingInfo?: LoadingInfo,
       }
     | {
         +type: 'SEARCH_MESSAGES_SUCCESS',
         +payload: SearchMessagesResponse,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEARCH_MESSAGES_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CREATE_OR_UPDATE_PUBLIC_LINK_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'CREATE_OR_UPDATE_PUBLIC_LINK_SUCCESS',
         +payload: InviteLink,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CREATE_OR_UPDATE_PUBLIC_LINK_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DISABLE_INVITE_LINK_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'DISABLE_INVITE_LINK_SUCCESS',
         +payload: DisableInviteLinkPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DISABLE_INVITE_LINK_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'GET_OLM_SESSION_INITIALIZATION_DATA_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'GET_OLM_SESSION_INITIALIZATION_DATA_SUCCESS',
         +payload: GetOlmSessionInitializationDataResponse,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'GET_OLM_SESSION_INITIALIZATION_DATA_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_DATA_LOADED',
         +payload: {
           +dataLoaded: boolean,
         },
       }
     | {
         +type: 'GET_VERSION_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'GET_VERSION_SUCCESS',
         +payload: GetVersionActionPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'GET_VERSION_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_LAST_COMMUNICATED_PLATFORM_DETAILS',
         +payload: LastCommunicatedPlatformDetails,
       }
     | { +type: 'RESET_USER_STATE', +payload?: void }
     | {
         +type: 'MODIFY_COMMUNITY_ROLE_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'MODIFY_COMMUNITY_ROLE_SUCCESS',
         +payload: RoleModificationPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'MODIFY_COMMUNITY_ROLE_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_COMMUNITY_ROLE_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'DELETE_COMMUNITY_ROLE_SUCCESS',
         +payload: RoleDeletionPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_COMMUNITY_ROLE_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_THREAD_LAST_NAVIGATED',
         +payload: { +threadID: string, +time: number },
       }
     | {
         +type: 'UPDATE_INTEGRITY_STORE',
         +payload: {
           +threadIDsToHash?: $ReadOnlyArray<string>,
           +threadHashingStatus?: 'starting' | 'running' | 'completed',
         },
       }
     | {
         +type: 'UPDATE_THEME_INFO',
         +payload: Partial<GlobalThemeInfo>,
       }
     | {
         +type: 'ADD_KEYSERVER',
         +payload: AddKeyserverPayload,
       }
     | {
         +type: 'REMOVE_KEYSERVER',
         +payload: RemoveKeyserverPayload,
       }
     | {
         +type: 'SET_CUSTOM_SERVER',
         +payload: string,
       }
     | {
         +type: 'SET_CONNECTION_ISSUE',
         +payload: { +connectionIssue: ?ConnectionIssue, +keyserverID: string },
       }
     | {
         +type: 'ADD_COMMUNITY',
         +payload: AddCommunityPayload,
       }
     | {
         +type: 'SET_SYNCED_METADATA_ENTRY',
         +payload: SetSyncedMetadataEntryPayload,
       }
     | {
         +type: 'CLEAR_SYNCED_METADATA_ENTRY',
         +payload: ClearSyncedMetadataEntryPayload,
       }
     | {
         +type: 'SET_ACTIVE_SESSION_RECOVERY',
         +payload: SetActiveSessionRecoveryPayload,
       }
     | {
         +type: 'SET_AUX_USER_FIDS',
         +payload: SetAuxUserFIDsPayload,
       }
     | {
         +type: 'ADD_AUX_USER_FIDS',
         +payload: AddAuxUserFIDsPayload,
       }
     | {
         +type: 'CLEAR_AUX_USER_FIDS',
         +payload?: void,
       }
     | {
         +type: 'SET_PEER_DEVICE_LISTS',
         +payload: SetPeerDeviceListsPayload,
       }
     | {
         +type: 'OPS_PROCESSING_FINISHED_ACTION_TYPE',
         +payload?: void,
       }
     | {
         +type: 'FETCH_COMMUNITY_INFOS_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'FETCH_COMMUNITY_INFOS_SUCCESS',
         +payload: FetchCommunityInfosResponse,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_COMMUNITY_INFOS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CREATE_OR_UPDATE_FARCASTER_CHANNEL_TAG_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'CREATE_OR_UPDATE_FARCASTER_CHANNEL_TAG_SUCCESS',
         +payload: CreateOrUpdateFarcasterChannelTagResponse,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CREATE_OR_UPDATE_FARCASTER_CHANNEL_TAG_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_FARCASTER_CHANNEL_TAG_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'DELETE_FARCASTER_CHANNEL_TAG_SUCCESS',
         +payload: DeleteFarcasterChannelTagPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_FARCASTER_CHANNEL_TAG_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'PROCESS_NEW_USER_IDS',
         +payload: {
           +userIDs: $ReadOnlyArray<string>,
         },
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FIND_USER_IDENTITIES_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'FIND_USER_IDENTITIES_SUCCESS',
         +payload: {
           +userInfos: $ReadOnlyArray<UserInfo>,
         },
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FIND_USER_IDENTITIES_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'VERSION_SUPPORTED_BY_IDENTITY_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'VERSION_SUPPORTED_BY_IDENTITY_SUCCESS',
         +payload: {
           +supported: boolean,
         },
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'VERSION_SUPPORTED_BY_IDENTITY_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_PENDING_UPDATES_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'FETCH_PENDING_UPDATES_SUCCESS',
         +payload: ClientStateSyncSocketResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_PENDING_UPDATES_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_TB_DEVICE_TOKEN_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'SET_TB_DEVICE_TOKEN_SUCCESS',
         +payload: {
           +deviceToken: string,
         },
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_TB_DEVICE_TOKEN_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'PROCESS_DM_OPS',
         +payload: ProcessDMOpsPayload,
-      },
+      }
+    | { +type: 'SCHEDULE_P2P_MESSAGES', +payload: ScheduleP2PMessagesPayload },
 }>;
 
 export type ActionPayload = ?(Object | Array<*> | $ReadOnlyArray<*> | string);
 export type DispatchSource = 'tunnelbroker' | 'tab-sync';
 export type SuperAction = {
   +type: string,
   +payload?: ActionPayload,
   +loadingInfo?: LoadingInfo,
   +error?: boolean,
   +dispatchSource?: DispatchSource,
   +messageSourceMetadata?: MessageSourceMetadata,
 };
 type ThunkedAction = (dispatch: Dispatch) => void;
 export type PromisedAction = (dispatch: Dispatch) => Promise<void>;
 export type Dispatch = ((promisedAction: PromisedAction) => Promise<void>) &
   ((thunkedAction: ThunkedAction) => void) &
   ((action: SuperAction) => boolean);
 
 // This is lifted from redux-persist/lib/constants.js
 // I don't want to add redux-persist to the web/server bundles...
 // import { REHYDRATE } from 'redux-persist';
 export const rehydrateActionType = 'persist/REHYDRATE';
diff --git a/web/shared-worker/utils/store.js b/web/shared-worker/utils/store.js
index fa2f1d72f..6ad474064 100644
--- a/web/shared-worker/utils/store.js
+++ b/web/shared-worker/utils/store.js
@@ -1,276 +1,277 @@
 // @flow
 
 import { auxUserStoreOpsHandlers } from 'lib/ops/aux-user-store-ops.js';
 import { communityStoreOpsHandlers } from 'lib/ops/community-store-ops.js';
 import { entryStoreOpsHandlers } from 'lib/ops/entries-store-ops.js';
 import { integrityStoreOpsHandlers } from 'lib/ops/integrity-store-ops.js';
 import { keyserverStoreOpsHandlers } from 'lib/ops/keyserver-store-ops.js';
 import { messageStoreOpsHandlers } from 'lib/ops/message-store-ops.js';
 import { reportStoreOpsHandlers } from 'lib/ops/report-store-ops.js';
 import { syncedMetadataStoreOpsHandlers } from 'lib/ops/synced-metadata-store-ops.js';
 import { threadActivityStoreOpsHandlers } from 'lib/ops/thread-activity-store-ops.js';
 import { threadStoreOpsHandlers } from 'lib/ops/thread-store-ops.js';
 import { userStoreOpsHandlers } from 'lib/ops/user-store-ops.js';
 import { canUseDatabaseOnWeb } from 'lib/shared/web-database.js';
 import type {
   ClientStore,
   StoreOperations,
 } from 'lib/types/store-ops-types.js';
 import { translateClientDBLocalMessageInfos } from 'lib/utils/message-ops-utils.js';
 import { entries } from 'lib/utils/objects.js';
 
 import { defaultWebState } from '../../redux/default-state.js';
 import { workerRequestMessageTypes } from '../../types/worker-types.js';
 import { getCommSharedWorker } from '../shared-worker-provider.js';
 
 async function getClientDBStore(): Promise<ClientStore> {
   const sharedWorker = await getCommSharedWorker();
   let result: ClientStore = {
     currentUserID: null,
     drafts: [],
     messages: null,
     threadStore: null,
     messageStoreThreads: null,
     reports: null,
     users: null,
     keyserverInfos: defaultWebState.keyserverStore.keyserverInfos,
     communityInfos: null,
     threadHashes: null,
     syncedMetadata: null,
     auxUserInfos: null,
     threadActivityStore: null,
     entries: null,
     messageStoreLocalMessageInfos: null,
   };
   const data = await sharedWorker.schedule({
     type: workerRequestMessageTypes.GET_CLIENT_STORE,
   });
   if (data?.store?.drafts) {
     result = {
       ...result,
       drafts: data.store.drafts,
     };
   }
   if (data?.store?.reports) {
     result = {
       ...result,
       reports: reportStoreOpsHandlers.translateClientDBData(data.store.reports),
     };
   }
   if (data?.store?.threads && data.store.threads.length > 0) {
     result = {
       ...result,
       threadStore: {
         threadInfos: threadStoreOpsHandlers.translateClientDBData(
           data.store.threads,
         ),
       },
     };
   }
   if (data?.store?.keyservers?.length) {
     result = {
       ...result,
       keyserverInfos: keyserverStoreOpsHandlers.translateClientDBData(
         data.store.keyservers,
       ),
     };
   }
   if (data?.store?.communities) {
     result = {
       ...result,
       communityInfos: communityStoreOpsHandlers.translateClientDBData(
         data.store.communities,
       ),
     };
   }
   if (data?.store?.integrityThreadHashes) {
     result = {
       ...result,
       threadHashes: integrityStoreOpsHandlers.translateClientDBData(
         data.store.integrityThreadHashes,
       ),
     };
   }
   if (data?.store?.syncedMetadata) {
     result = {
       ...result,
       syncedMetadata: syncedMetadataStoreOpsHandlers.translateClientDBData(
         data.store.syncedMetadata,
       ),
     };
   }
   if (data?.store?.auxUserInfos) {
     result = {
       ...result,
       auxUserInfos: auxUserStoreOpsHandlers.translateClientDBData(
         data.store.auxUserInfos,
       ),
     };
   }
   if (data?.store?.users && data.store.users.length > 0) {
     result = {
       ...result,
       users: userStoreOpsHandlers.translateClientDBData(data.store.users),
     };
   }
   if (data?.store?.messages && data.store.messages.length > 0) {
     result = {
       ...result,
       messages: data.store.messages,
     };
   }
   if (
     data?.store?.messageStoreThreads &&
     data.store.messageStoreThreads.length > 0
   ) {
     result = {
       ...result,
       messageStoreThreads: data.store.messageStoreThreads,
     };
   }
   if (
     data?.store?.threadActivityEntries &&
     data.store.threadActivityEntries.length > 0
   ) {
     result = {
       ...result,
       threadActivityStore: threadActivityStoreOpsHandlers.translateClientDBData(
         data.store.threadActivityEntries,
       ),
     };
   }
 
   if (data?.store?.entries && data.store.entries.length > 0) {
     result = {
       ...result,
       entries: entryStoreOpsHandlers.translateClientDBData(data.store.entries),
     };
   }
 
   if (
     data?.store?.messageStoreLocalMessageInfos &&
     data.store.messageStoreLocalMessageInfos.length > 0
   ) {
     result = {
       ...result,
       messageStoreLocalMessageInfos: translateClientDBLocalMessageInfos(
         data.store.messageStoreLocalMessageInfos,
       ),
     };
   }
   return result;
 }
 
 async function processDBStoreOperations(
   storeOperations: StoreOperations,
   userID?: ?string,
 ): Promise<void> {
   const {
     draftStoreOperations,
     threadStoreOperations,
     reportStoreOperations,
     keyserverStoreOperations,
     communityStoreOperations,
     integrityStoreOperations,
     syncedMetadataStoreOperations,
     auxUserStoreOperations,
     userStoreOperations,
     messageStoreOperations,
     threadActivityStoreOperations,
     outboundP2PMessages,
     entryStoreOperations,
     messageSearchStoreOperations,
   } = storeOperations;
 
   const canUseDatabase = canUseDatabaseOnWeb(userID);
 
   const convertedThreadStoreOperations = canUseDatabase
     ? threadStoreOpsHandlers.convertOpsToClientDBOps(threadStoreOperations)
     : [];
   const convertedReportStoreOperations =
     reportStoreOpsHandlers.convertOpsToClientDBOps(reportStoreOperations);
   const convertedKeyserverStoreOperations =
     keyserverStoreOpsHandlers.convertOpsToClientDBOps(keyserverStoreOperations);
   const convertedCommunityStoreOperations =
     communityStoreOpsHandlers.convertOpsToClientDBOps(communityStoreOperations);
   const convertedIntegrityStoreOperations =
     integrityStoreOpsHandlers.convertOpsToClientDBOps(integrityStoreOperations);
   const convertedSyncedMetadataStoreOperations =
     syncedMetadataStoreOpsHandlers.convertOpsToClientDBOps(
       syncedMetadataStoreOperations,
     );
   const convertedAuxUserStoreOperations =
     auxUserStoreOpsHandlers.convertOpsToClientDBOps(auxUserStoreOperations);
   const convertedUserStoreOperations =
     userStoreOpsHandlers.convertOpsToClientDBOps(userStoreOperations);
   const convertedMessageStoreOperations =
     messageStoreOpsHandlers.convertOpsToClientDBOps(messageStoreOperations);
   const convertedThreadActivityStoreOperations =
     threadActivityStoreOpsHandlers.convertOpsToClientDBOps(
       threadActivityStoreOperations,
     );
   const convertedEntryStoreOperations =
     entryStoreOpsHandlers.convertOpsToClientDBOps(entryStoreOperations);
 
   if (
     convertedThreadStoreOperations.length === 0 &&
     convertedReportStoreOperations.length === 0 &&
     (!draftStoreOperations || draftStoreOperations.length === 0) &&
     convertedKeyserverStoreOperations.length === 0 &&
     convertedCommunityStoreOperations.length === 0 &&
     convertedIntegrityStoreOperations.length === 0 &&
     convertedSyncedMetadataStoreOperations.length === 0 &&
     convertedAuxUserStoreOperations.length === 0 &&
     convertedUserStoreOperations.length === 0 &&
     convertedMessageStoreOperations.length === 0 &&
     convertedThreadActivityStoreOperations.length === 0 &&
-    convertedEntryStoreOperations.length === 0
+    convertedEntryStoreOperations.length === 0 &&
+    outboundP2PMessages?.length === 0
   ) {
     return;
   }
 
   const sharedWorker = await getCommSharedWorker();
   const isSupported = await sharedWorker.isSupported();
   if (!isSupported) {
     return;
   }
   try {
     await sharedWorker.schedule({
       type: workerRequestMessageTypes.PROCESS_STORE_OPERATIONS,
       storeOperations: {
         draftStoreOperations,
         reportStoreOperations: convertedReportStoreOperations,
         threadStoreOperations: convertedThreadStoreOperations,
         keyserverStoreOperations: convertedKeyserverStoreOperations,
         communityStoreOperations: convertedCommunityStoreOperations,
         integrityStoreOperations: convertedIntegrityStoreOperations,
         syncedMetadataStoreOperations: convertedSyncedMetadataStoreOperations,
         auxUserStoreOperations: convertedAuxUserStoreOperations,
         userStoreOperations: convertedUserStoreOperations,
         messageStoreOperations: convertedMessageStoreOperations,
         threadActivityStoreOperations: convertedThreadActivityStoreOperations,
         outboundP2PMessages,
         entryStoreOperations: convertedEntryStoreOperations,
         messageSearchStoreOperations,
       },
     });
   } catch (e) {
     console.log(e);
     if (canUseDatabase) {
       window.alert(e.message);
       if (
         entries(storeOperations).some(
           ([key, ops]) =>
             key !== 'draftStoreOperations' &&
             key !== 'reportStoreOperations' &&
             ops.length > 0,
         )
       ) {
         await sharedWorker.init({ clearDatabase: true, markAsCorrupted: true });
         location.reload();
       }
     }
   }
 }
 
 export { getClientDBStore, processDBStoreOperations };