diff --git a/lib/reducers/message-reducer.js b/lib/reducers/message-reducer.js
index 7f0df3702..bba2a3caa 100644
--- a/lib/reducers/message-reducer.js
+++ b/lib/reducers/message-reducer.js
@@ -1,1773 +1,1779 @@
 // @flow
 
 import invariant from 'invariant';
 import _difference from 'lodash/fp/difference.js';
 import _flow from 'lodash/fp/flow.js';
 import _isEqual from 'lodash/fp/isEqual.js';
 import _keyBy from 'lodash/fp/keyBy.js';
 import _map from 'lodash/fp/map.js';
 import _mapKeys from 'lodash/fp/mapKeys.js';
 import _mapValues from 'lodash/fp/mapValues.js';
 import _omit from 'lodash/fp/omit.js';
 import _omitBy from 'lodash/fp/omitBy.js';
 import _pick from 'lodash/fp/pick.js';
 import _pickBy from 'lodash/fp/pickBy.js';
 import _uniq from 'lodash/fp/uniq.js';
 
 import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
 import {
   createEntryActionTypes,
   saveEntryActionTypes,
   deleteEntryActionTypes,
   restoreEntryActionTypes,
 } from '../actions/entry-actions.js';
 import {
   fetchMessagesBeforeCursorActionTypes,
   fetchMostRecentMessagesActionTypes,
   sendTextMessageActionTypes,
   sendMultimediaMessageActionTypes,
   sendReactionMessageActionTypes,
   sendEditMessageActionTypes,
   saveMessagesActionType,
   processMessagesActionType,
   messageStorePruneActionType,
   createLocalMessageActionType,
   fetchSingleMostRecentMessagesFromThreadsActionTypes,
 } from '../actions/message-actions.js';
 import { sendMessageReportActionTypes } from '../actions/message-report-actions.js';
 import { siweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   changeThreadSettingsActionTypes,
   deleteThreadActionTypes,
   leaveThreadActionTypes,
   newThreadActionTypes,
   removeUsersFromThreadActionTypes,
   changeThreadMemberRolesActionTypes,
   joinThreadActionTypes,
   toggleMessagePinActionTypes,
 } from '../actions/thread-actions.js';
 import { updateMultimediaMessageMediaActionType } from '../actions/upload-actions.js';
 import {
   logOutActionTypes,
   deleteAccountActionTypes,
   logInActionTypes,
   registerActionTypes,
 } from '../actions/user-actions.js';
 import { pendingToRealizedThreadIDsSelector } from '../selectors/thread-selectors.js';
 import {
   messageID,
   combineTruncationStatuses,
   sortMessageInfoList,
   sortMessageIDs,
   mergeThreadMessageInfos,
 } from '../shared/message-utils.js';
 import {
   threadHasPermission,
   threadInChatList,
   threadIsPending,
 } from '../shared/thread-utils.js';
 import threadWatcher from '../shared/thread-watcher.js';
 import { unshimMessageInfos } from '../shared/unshim-utils.js';
 import type { Media, Image } from '../types/media-types.js';
 import { messageTypes } from '../types/message-types-enum.js';
 import {
   type RawMessageInfo,
   type LocalMessageInfo,
   type MessageStore,
   type ReplaceMessageOperation,
   type MessageStoreOperation,
   type MessageTruncationStatus,
   type MessageTruncationStatuses,
   messageTruncationStatus,
   defaultNumberPerThread,
   type ThreadMessageInfo,
 } from '../types/message-types.js';
 import type { RawImagesMessageInfo } from '../types/messages/images.js';
 import type { RawMediaMessageInfo } from '../types/messages/media.js';
 import { type BaseAction } from '../types/redux-types.js';
 import { processServerRequestsActionType } from '../types/request-types.js';
 import {
   fullStateSyncActionType,
   incrementalStateSyncActionType,
 } from '../types/socket-types.js';
 import {
   type RawThreadInfo,
   threadPermissions,
 } from '../types/thread-types.js';
 import {
   updateTypes,
   type ClientUpdateInfo,
   processUpdatesActionType,
 } from '../types/update-types.js';
 import { setNewSessionActionType } from '../utils/action-utils.js';
 import { isDev } from '../utils/dev-utils.js';
 import {
   translateClientDBMessageInfosToRawMessageInfos,
   translateClientDBThreadMessageInfos,
 } from '../utils/message-ops-utils.js';
 import { assertObjectsAreEqual } from '../utils/objects.js';
 
 const PROCESSED_MSG_STORE_INVARIANTS_DISABLED = !isDev;
 const _mapValuesWithKeys = _mapValues.convert({ cap: false });
 
 // Input must already be ordered!
 function mapThreadsToMessageIDsFromOrderedMessageInfos(
   orderedMessageInfos: $ReadOnlyArray<RawMessageInfo>,
 ): { [threadID: string]: string[] } {
   const threadsToMessageIDs: { [threadID: string]: string[] } = {};
   for (const messageInfo of orderedMessageInfos) {
     const key = messageID(messageInfo);
     if (!threadsToMessageIDs[messageInfo.threadID]) {
       threadsToMessageIDs[messageInfo.threadID] = [key];
     } else {
       threadsToMessageIDs[messageInfo.threadID].push(key);
     }
   }
   return threadsToMessageIDs;
 }
 
 function isThreadWatched(
   threadID: string,
   threadInfo: ?RawThreadInfo,
   watchedIDs: $ReadOnlyArray<string>,
 ) {
   return (
     threadIsPending(threadID) ||
     (threadInfo &&
       threadHasPermission(threadInfo, threadPermissions.VISIBLE) &&
       (threadInChatList(threadInfo) || watchedIDs.includes(threadID)))
   );
 }
 
 function assertMessageStoreThreadsAreEqual(
   processedMessageStore: MessageStore,
   expectedMessageStore: MessageStore,
   location: string,
 ) {
   if (PROCESSED_MSG_STORE_INVARIANTS_DISABLED) {
     return;
   }
 
   assertObjectsAreEqual(
     processedMessageStore.threads,
     expectedMessageStore.threads,
     `MessageStore.threads - ${location}`,
   );
 }
 
 const newThread = () => ({
   messageIDs: [],
   startReached: false,
   lastNavigatedTo: 0,
   lastPruned: Date.now(),
 });
 
 type FreshMessageStoreResult = {
   +messageStoreOperations: $ReadOnlyArray<MessageStoreOperation>,
   +messageStore: MessageStore,
 };
 function freshMessageStore(
   messageInfos: $ReadOnlyArray<RawMessageInfo>,
   truncationStatus: { [threadID: string]: MessageTruncationStatus },
   currentAsOf: number,
   threadInfos: { +[threadID: string]: RawThreadInfo },
 ): FreshMessageStoreResult {
   const unshimmed = unshimMessageInfos(messageInfos);
   const orderedMessageInfos = sortMessageInfoList(unshimmed);
   const messages = _keyBy(messageID)(orderedMessageInfos);
 
   const messageStoreReplaceOperations = orderedMessageInfos.map(
     messageInfo => ({
       type: 'replace',
       payload: { id: messageID(messageInfo), messageInfo },
     }),
   );
 
   const threadsToMessageIDs =
     mapThreadsToMessageIDsFromOrderedMessageInfos(orderedMessageInfos);
   const threads = _mapValuesWithKeys(
     (messageIDs: string[], threadID: string) => ({
       ...newThread(),
       messageIDs,
       startReached:
         truncationStatus[threadID] === messageTruncationStatus.EXHAUSTIVE,
     }),
   )(threadsToMessageIDs);
   const watchedIDs = threadWatcher.getWatchedIDs();
   for (const threadID in threadInfos) {
     const threadInfo = threadInfos[threadID];
     if (
       threads[threadID] ||
       !isThreadWatched(threadID, threadInfo, watchedIDs)
     ) {
       continue;
     }
     threads[threadID] = newThread();
   }
 
   const messageStoreOperations = [
     { type: 'remove_all' },
     {
       type: 'remove_all_threads',
     },
     {
       type: 'replace_threads',
       payload: { threads },
     },
     ...messageStoreReplaceOperations,
   ];
 
   return {
     messageStoreOperations,
     messageStore: { messages, threads, local: {}, currentAsOf },
   };
 }
 
 type ReassignmentResult = {
   +messageStoreOperations: MessageStoreOperation[],
   +messageStore: MessageStore,
   +reassignedThreadIDs: string[],
 };
 
 function reassignMessagesToRealizedThreads(
   messageStore: MessageStore,
   threadInfos: { +[threadID: string]: RawThreadInfo },
 ): ReassignmentResult {
   const pendingToRealizedThreadIDs =
     pendingToRealizedThreadIDsSelector(threadInfos);
 
   const messageStoreOperations: MessageStoreOperation[] = [];
   const messages = {};
   for (const storeMessageID in messageStore.messages) {
     const message = messageStore.messages[storeMessageID];
     const newThreadID = pendingToRealizedThreadIDs.get(message.threadID);
 
     messages[storeMessageID] = newThreadID
       ? {
           ...message,
           threadID: newThreadID,
           time: threadInfos[newThreadID]?.creationTime ?? message.time,
         }
       : message;
 
     if (!newThreadID) {
       continue;
     }
 
     const updateMsgOperation: ReplaceMessageOperation = {
       type: 'replace',
       payload: { id: storeMessageID, messageInfo: messages[storeMessageID] },
     };
 
     messageStoreOperations.push(updateMsgOperation);
   }
 
   const threads = {};
   const reassignedThreadIDs = [];
   const updatedThreads = {};
   const threadsToRemove = [];
   for (const threadID in messageStore.threads) {
     const threadMessageInfo = messageStore.threads[threadID];
     const newThreadID = pendingToRealizedThreadIDs.get(threadID);
     if (!newThreadID) {
       threads[threadID] = threadMessageInfo;
       continue;
     }
     const realizedThread = messageStore.threads[newThreadID];
     if (!realizedThread) {
       reassignedThreadIDs.push(newThreadID);
       threads[newThreadID] = threadMessageInfo;
       updatedThreads[newThreadID] = threadMessageInfo;
       threadsToRemove.push(threadID);
       continue;
     }
     threads[newThreadID] = mergeThreadMessageInfos(
       threadMessageInfo,
       realizedThread,
       messages,
     );
     updatedThreads[newThreadID] = threads[newThreadID];
   }
   if (threadsToRemove.length) {
     messageStoreOperations.push({
       type: 'remove_threads',
       payload: {
         ids: threadsToRemove,
       },
     });
   }
   messageStoreOperations.push({
     type: 'replace_threads',
     payload: {
       threads: updatedThreads,
     },
   });
 
   return {
     messageStoreOperations,
     messageStore: {
       ...messageStore,
       threads,
       messages,
     },
     reassignedThreadIDs,
   };
 }
 
 type MergeNewMessagesResult = {
   +messageStoreOperations: $ReadOnlyArray<MessageStoreOperation>,
   +messageStore: MessageStore,
 };
 // oldMessageStore is from the old state
 // newMessageInfos, truncationStatus come from server
 function mergeNewMessages(
   oldMessageStore: MessageStore,
   newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   truncationStatus: { [threadID: string]: MessageTruncationStatus },
   threadInfos: { +[threadID: string]: RawThreadInfo },
   actionType: string,
 ): MergeNewMessagesResult {
   const {
     messageStoreOperations: updateWithLatestThreadInfosOps,
     messageStore: messageStoreUpdatedWithLatestThreadInfos,
     reassignedThreadIDs,
   } = updateMessageStoreWithLatestThreadInfos(oldMessageStore, threadInfos);
 
   const messageStoreAfterUpdateOps = processMessageStoreOperations(
     oldMessageStore,
     updateWithLatestThreadInfosOps,
   );
 
   assertMessageStoreThreadsAreEqual(
     messageStoreAfterUpdateOps,
     messageStoreUpdatedWithLatestThreadInfos,
     `${actionType} | reassignment and filtering`,
   );
 
   const updatedMessageStore = {
     ...messageStoreUpdatedWithLatestThreadInfos,
     messages: messageStoreAfterUpdateOps.messages,
   };
 
   const localIDsToServerIDs: Map<string, string> = new Map();
 
   const watchedThreadIDs = [
     ...threadWatcher.getWatchedIDs(),
     ...reassignedThreadIDs,
   ];
   const unshimmedNewMessages = unshimMessageInfos(newMessageInfos);
   const unshimmedNewMessagesOfWatchedThreads = unshimmedNewMessages.filter(
     msg =>
       isThreadWatched(
         msg.threadID,
         threadInfos[msg.threadID],
         watchedThreadIDs,
       ),
   );
   const orderedNewMessageInfos = _flow(
     _map((messageInfo: RawMessageInfo) => {
       const { id: inputID } = messageInfo;
       invariant(inputID, 'new messageInfos should have serverID');
       invariant(
         !threadIsPending(messageInfo.threadID),
         'new messageInfos should have realized thread id',
       );
       const currentMessageInfo = updatedMessageStore.messages[inputID];
       if (
         messageInfo.type === messageTypes.TEXT ||
         messageInfo.type === messageTypes.IMAGES ||
         messageInfo.type === messageTypes.MULTIMEDIA
       ) {
         const { localID: inputLocalID } = messageInfo;
         const currentLocalMessageInfo = inputLocalID
           ? updatedMessageStore.messages[inputLocalID]
           : null;
         if (currentMessageInfo && currentMessageInfo.localID) {
           // If the client already has a RawMessageInfo with this serverID, keep
           // any localID associated with the existing one. This is because we
           // use localIDs as React keys and changing React keys leads to loss of
           // component state. (The conditional below is for Flow)
           if (messageInfo.type === messageTypes.TEXT) {
             messageInfo = {
               ...messageInfo,
               localID: currentMessageInfo.localID,
             };
           } else if (messageInfo.type === messageTypes.MULTIMEDIA) {
             messageInfo = ({
               ...messageInfo,
               localID: currentMessageInfo.localID,
             }: RawMediaMessageInfo);
           } else {
             messageInfo = ({
               ...messageInfo,
               localID: currentMessageInfo.localID,
             }: RawImagesMessageInfo);
           }
         } else if (currentLocalMessageInfo && currentLocalMessageInfo.localID) {
           // If the client has a RawMessageInfo with this localID, but not with
           // the serverID, that means the message creation succeeded but the
           // success action never got processed. We set a key in
           // localIDsToServerIDs here to fix the messageIDs for the rest of the
           // MessageStore too. (The conditional below is for Flow)
           invariant(inputLocalID, 'inputLocalID should be set');
           localIDsToServerIDs.set(inputLocalID, inputID);
           if (messageInfo.type === messageTypes.TEXT) {
             messageInfo = {
               ...messageInfo,
               localID: currentLocalMessageInfo.localID,
             };
           } else if (messageInfo.type === messageTypes.MULTIMEDIA) {
             messageInfo = ({
               ...messageInfo,
               localID: currentLocalMessageInfo.localID,
             }: RawMediaMessageInfo);
           } else {
             messageInfo = ({
               ...messageInfo,
               localID: currentLocalMessageInfo.localID,
             }: RawImagesMessageInfo);
           }
         } else {
           // If neither the serverID nor the localID from the delivered
           // RawMessageInfo exists in the client store, then this message is
           // brand new to us. Ignore any localID provided by the server.
           // (The conditional below is for Flow)
           const { localID, ...rest } = messageInfo;
           if (rest.type === messageTypes.TEXT) {
             messageInfo = { ...rest };
           } else if (rest.type === messageTypes.MULTIMEDIA) {
             messageInfo = ({ ...rest }: RawMediaMessageInfo);
           } else {
             messageInfo = ({ ...rest }: RawImagesMessageInfo);
           }
         }
       } else if (
         currentMessageInfo &&
         messageInfo.time > currentMessageInfo.time
       ) {
         // When thick threads will be introduced it will be possible for two
         // clients to create the same message (e.g. when they create the same
         // sidebar at the same time). We're going to use deterministic ids for
         // messages which should be unique within a thread and we have to find
         // a way for clients to agree which message to keep. We can't rely on
         // always choosing incoming messages nor messages from the store,
         // because a message that is in one user's store, will be send to
         // another user. One way to deal with it is to always choose a message
         // which is older, according to its timestamp. We can use this strategy
         // only for messages that can start a thread, because for other types
         // it might break the "contiguous" property of message ids (we can
         // consider selecting younger messages in that case, but for now we use
         // an invariant).
         invariant(
           messageInfo.type === messageTypes.CREATE_SIDEBAR ||
             messageInfo.type === messageTypes.CREATE_THREAD ||
             messageInfo.type === messageTypes.SIDEBAR_SOURCE,
           `Two different messages of type ${messageInfo.type} with the same ` +
             'id found',
         );
         return currentMessageInfo;
       }
       return _isEqual(messageInfo)(currentMessageInfo)
         ? currentMessageInfo
         : messageInfo;
     }),
     sortMessageInfoList,
   )(unshimmedNewMessagesOfWatchedThreads);
 
   const newMessageOps: MessageStoreOperation[] = [];
   const threadsToMessageIDs = mapThreadsToMessageIDsFromOrderedMessageInfos(
     orderedNewMessageInfos,
   );
   const oldMessageInfosToCombine = [];
   const threadsThatNeedMessageIDsResorted = [];
   const local = {};
   const updatedThreads = {};
   const threads = _flow(
     _mapValuesWithKeys((messageIDs: string[], threadID: string) => {
       const oldThread = updatedMessageStore.threads[threadID];
       const truncate = truncationStatus[threadID];
       if (!oldThread) {
         updatedThreads[threadID] = {
           ...newThread(),
           messageIDs,
           startReached: truncate === messageTruncationStatus.EXHAUSTIVE,
         };
         return updatedThreads[threadID];
       }
       let oldMessageIDsUnchanged = true;
       const oldMessageIDs = oldThread.messageIDs.map(oldID => {
         const newID = localIDsToServerIDs.get(oldID);
         if (newID !== null && newID !== undefined) {
           oldMessageIDsUnchanged = false;
           return newID;
         }
         return oldID;
       });
       if (truncate === messageTruncationStatus.TRUNCATED) {
         // If the result set in the payload isn't contiguous with what we have
         // now, that means we need to dump what we have in the state and replace
         // it with the result set. We do this to achieve our two goals for the
         // messageStore: currentness and contiguousness.
         newMessageOps.push({
           type: 'remove_messages_for_threads',
           payload: { threadIDs: [threadID] },
         });
         updatedThreads[threadID] = {
           messageIDs,
           startReached: false,
           lastNavigatedTo: oldThread.lastNavigatedTo,
           lastPruned: oldThread.lastPruned,
         };
         return updatedThreads[threadID];
       }
       const oldNotInNew = _difference(oldMessageIDs)(messageIDs);
       for (const id of oldNotInNew) {
         const oldMessageInfo = updatedMessageStore.messages[id];
         invariant(oldMessageInfo, `could not find ${id} in messageStore`);
         oldMessageInfosToCombine.push(oldMessageInfo);
         const localInfo = updatedMessageStore.local[id];
         if (localInfo) {
           local[id] = localInfo;
         }
       }
       const startReached =
         oldThread.startReached ||
         truncate === messageTruncationStatus.EXHAUSTIVE;
       if (_difference(messageIDs)(oldMessageIDs).length === 0) {
         if (startReached === oldThread.startReached && oldMessageIDsUnchanged) {
           return oldThread;
         }
         updatedThreads[threadID] = {
           messageIDs: oldMessageIDs,
           startReached,
           lastNavigatedTo: oldThread.lastNavigatedTo,
           lastPruned: oldThread.lastPruned,
         };
         return updatedThreads[threadID];
       }
       const mergedMessageIDs = [...messageIDs, ...oldNotInNew];
       threadsThatNeedMessageIDsResorted.push(threadID);
       return {
         messageIDs: mergedMessageIDs,
         startReached,
         lastNavigatedTo: oldThread.lastNavigatedTo,
         lastPruned: oldThread.lastPruned,
       };
     }),
     _pickBy(thread => !!thread),
   )(threadsToMessageIDs);
 
   for (const threadID in updatedMessageStore.threads) {
     if (threads[threadID]) {
       continue;
     }
     let thread = updatedMessageStore.threads[threadID];
     const truncate = truncationStatus[threadID];
     if (truncate === messageTruncationStatus.EXHAUSTIVE) {
       thread = {
         ...thread,
         startReached: true,
       };
     }
     threads[threadID] = thread;
     updatedThreads[threadID] = thread;
 
     for (const id of thread.messageIDs) {
       const messageInfo = updatedMessageStore.messages[id];
       if (messageInfo) {
         oldMessageInfosToCombine.push(messageInfo);
       }
       const localInfo = updatedMessageStore.local[id];
       if (localInfo) {
         local[id] = localInfo;
       }
     }
   }
 
   const messages = _flow(
     sortMessageInfoList,
     _keyBy(messageID),
   )([...orderedNewMessageInfos, ...oldMessageInfosToCombine]);
 
   const newMessages = _keyBy(messageID)(orderedNewMessageInfos);
   for (const id in newMessages) {
     newMessageOps.push({
       type: 'replace',
       payload: { id, messageInfo: newMessages[id] },
     });
   }
 
   if (localIDsToServerIDs.size > 0) {
     newMessageOps.push({
       type: 'remove',
       payload: { ids: [...localIDsToServerIDs.keys()] },
     });
   }
 
   for (const threadID of threadsThatNeedMessageIDsResorted) {
     threads[threadID].messageIDs = sortMessageIDs(messages)(
       threads[threadID].messageIDs,
     );
     updatedThreads[threadID] = threads[threadID];
   }
 
   const currentAsOf = Math.max(
     orderedNewMessageInfos.length > 0 ? orderedNewMessageInfos[0].time : 0,
     updatedMessageStore.currentAsOf,
   );
 
   newMessageOps.push({
     type: 'replace_threads',
     payload: {
       threads: updatedThreads,
     },
   });
 
   const processedMessageStore = processMessageStoreOperations(
     updatedMessageStore,
     newMessageOps,
   );
 
   const messageStore = {
     messages: processedMessageStore.messages,
     threads,
     local,
     currentAsOf,
   };
 
   assertMessageStoreThreadsAreEqual(
     processedMessageStore,
     messageStore,
     `${actionType} | processed`,
   );
 
   return {
     messageStoreOperations: [
       ...updateWithLatestThreadInfosOps,
       ...newMessageOps,
     ],
     messageStore,
   };
 }
 
 type UpdateMessageStoreWithLatestThreadInfosResult = {
   +messageStoreOperations: MessageStoreOperation[],
   +messageStore: MessageStore,
   +reassignedThreadIDs: string[],
 };
 function updateMessageStoreWithLatestThreadInfos(
   messageStore: MessageStore,
   threadInfos: { +[id: string]: RawThreadInfo },
 ): UpdateMessageStoreWithLatestThreadInfosResult {
   const messageStoreOperations: MessageStoreOperation[] = [];
   const {
     messageStore: reassignedMessageStore,
     messageStoreOperations: reassignMessagesOps,
     reassignedThreadIDs,
   } = reassignMessagesToRealizedThreads(messageStore, threadInfos);
   messageStoreOperations.push(...reassignMessagesOps);
   const watchedIDs = [...threadWatcher.getWatchedIDs(), ...reassignedThreadIDs];
   const watchedThreadInfos = _pickBy((threadInfo: RawThreadInfo) =>
     isThreadWatched(threadInfo.id, threadInfo, watchedIDs),
   )(threadInfos);
 
   const filteredThreads = _pick(Object.keys(watchedThreadInfos))(
     reassignedMessageStore.threads,
   );
 
   const messageIDsToRemove = [];
   const threadsToRemoveMessagesFrom = [];
   for (const threadID in reassignedMessageStore.threads) {
     if (watchedThreadInfos[threadID]) {
       continue;
     }
     threadsToRemoveMessagesFrom.push(threadID);
     for (const id of reassignedMessageStore.threads[threadID].messageIDs) {
       messageIDsToRemove.push(id);
     }
   }
 
   const updatedThreads = {};
   for (const threadID in threadInfos) {
     const threadInfo = threadInfos[threadID];
     if (
       isThreadWatched(threadID, threadInfo, watchedIDs) &&
       !filteredThreads[threadID]
     ) {
       filteredThreads[threadID] = newThread();
       updatedThreads[threadID] = filteredThreads[threadID];
     }
   }
 
   messageStoreOperations.push({
     type: 'remove_threads',
     payload: { ids: threadsToRemoveMessagesFrom },
   });
 
   messageStoreOperations.push({
     type: 'replace_threads',
     payload: {
       threads: updatedThreads,
     },
   });
 
   messageStoreOperations.push({
     type: 'remove_messages_for_threads',
     payload: { threadIDs: threadsToRemoveMessagesFrom },
   });
 
   return {
     messageStoreOperations,
     messageStore: {
       messages: _omit(messageIDsToRemove)(reassignedMessageStore.messages),
       threads: filteredThreads,
       local: _omit(messageIDsToRemove)(reassignedMessageStore.local),
       currentAsOf: reassignedMessageStore.currentAsOf,
     },
     reassignedThreadIDs,
   };
 }
 
 function ensureRealizedThreadIDIsUsedWhenPossible<T: RawMessageInfo>(
   payload: T,
   threadInfos: { +[id: string]: RawThreadInfo },
 ): T {
   const pendingToRealizedThreadIDs =
     pendingToRealizedThreadIDsSelector(threadInfos);
   const realizedThreadID = pendingToRealizedThreadIDs.get(payload.threadID);
   return realizedThreadID
     ? { ...payload, threadID: realizedThreadID }
     : payload;
 }
 
 function processMessageStoreOperations(
   messageStore: MessageStore,
   messageStoreOperations: $ReadOnlyArray<MessageStoreOperation>,
 ): MessageStore {
   if (messageStoreOperations.length === 0) {
     return messageStore;
   }
   let processedMessages = { ...messageStore.messages };
   let processedThreads = { ...messageStore.threads };
   for (const operation of messageStoreOperations) {
     if (operation.type === 'replace') {
       processedMessages[operation.payload.id] = operation.payload.messageInfo;
     } else if (operation.type === 'remove') {
       for (const id of operation.payload.ids) {
         delete processedMessages[id];
       }
     } else if (operation.type === 'remove_messages_for_threads') {
       for (const msgID in processedMessages) {
         if (
           operation.payload.threadIDs.includes(
             processedMessages[msgID].threadID,
           )
         ) {
           delete processedMessages[msgID];
         }
       }
     } else if (operation.type === 'rekey') {
       processedMessages[operation.payload.to] =
         processedMessages[operation.payload.from];
       delete processedMessages[operation.payload.from];
     } else if (operation.type === 'remove_all') {
       processedMessages = {};
     } else if (operation.type === 'replace_threads') {
       for (const threadID in operation.payload.threads) {
         processedThreads[threadID] = operation.payload.threads[threadID];
       }
     } else if (operation.type === 'remove_threads') {
       for (const id of operation.payload.ids) {
         delete processedThreads[id];
       }
     } else if (operation.type === 'remove_all_threads') {
       processedThreads = {};
     }
   }
   return {
     ...messageStore,
     threads: processedThreads,
     messages: processedMessages,
   };
 }
 
 type ReduceMessageStoreResult = {
   +messageStoreOperations: $ReadOnlyArray<MessageStoreOperation>,
   +messageStore: MessageStore,
 };
 function reduceMessageStore(
   messageStore: MessageStore,
   action: BaseAction,
   newThreadInfos: { +[id: string]: RawThreadInfo },
 ): ReduceMessageStoreResult {
   if (
     action.type === logInActionTypes.success ||
     action.type === siweAuthActionTypes.success
   ) {
     const messagesResult = action.payload.messagesResult;
     const { messageStoreOperations, messageStore: freshStore } =
       freshMessageStore(
         messagesResult.messageInfos,
         messagesResult.truncationStatus,
         messagesResult.currentAsOf,
         newThreadInfos,
       );
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     assertMessageStoreThreadsAreEqual(
       processedMessageStore,
       freshStore,
       `${action.type} | fresh store`,
     );
 
     return {
       messageStoreOperations,
       messageStore: { ...freshStore, messages: processedMessageStore.messages },
     };
   } else if (action.type === incrementalStateSyncActionType) {
     if (
       action.payload.messagesResult.rawMessageInfos.length === 0 &&
       action.payload.updatesResult.newUpdates.length === 0
     ) {
       return { messageStoreOperations: [], messageStore };
     }
 
     const messagesResult = mergeUpdatesWithMessageInfos(
       action.payload.messagesResult.rawMessageInfos,
       action.payload.updatesResult.newUpdates,
       action.payload.messagesResult.truncationStatuses,
     );
 
     return mergeNewMessages(
       messageStore,
       messagesResult.rawMessageInfos,
       messagesResult.truncationStatuses,
       newThreadInfos,
       action.type,
     );
   } else if (action.type === processUpdatesActionType) {
     if (action.payload.updatesResult.newUpdates.length === 0) {
       return { messageStoreOperations: [], messageStore };
     }
 
     const messagesResult = mergeUpdatesWithMessageInfos(
       [],
       action.payload.updatesResult.newUpdates,
     );
 
     const { messageStoreOperations, messageStore: newMessageStore } =
       mergeNewMessages(
         messageStore,
         messagesResult.rawMessageInfos,
         messagesResult.truncationStatuses,
         newThreadInfos,
         action.type,
       );
     return {
       messageStoreOperations,
       messageStore: {
         messages: newMessageStore.messages,
         threads: newMessageStore.threads,
         local: newMessageStore.local,
         currentAsOf: messageStore.currentAsOf,
       },
     };
   } else if (
     action.type === fullStateSyncActionType ||
     action.type === processMessagesActionType
   ) {
     const { messagesResult } = action.payload;
     return mergeNewMessages(
       messageStore,
       messagesResult.rawMessageInfos,
       messagesResult.truncationStatuses,
       newThreadInfos,
       action.type,
     );
   } else if (
     action.type === fetchSingleMostRecentMessagesFromThreadsActionTypes.success
   ) {
     return mergeNewMessages(
       messageStore,
       action.payload.rawMessageInfos,
       action.payload.truncationStatuses,
       newThreadInfos,
       action.type,
     );
   } else if (
     action.type === fetchMessagesBeforeCursorActionTypes.success ||
     action.type === fetchMostRecentMessagesActionTypes.success
   ) {
     return mergeNewMessages(
       messageStore,
       action.payload.rawMessageInfos,
       { [action.payload.threadID]: action.payload.truncationStatus },
       newThreadInfos,
       action.type,
     );
   } else if (
     action.type === logOutActionTypes.success ||
     action.type === deleteAccountActionTypes.success ||
     action.type === deleteThreadActionTypes.success ||
     action.type === leaveThreadActionTypes.success ||
     action.type === setNewSessionActionType
   ) {
     const { messageStoreOperations, messageStore: filteredMessageStore } =
       updateMessageStoreWithLatestThreadInfos(messageStore, newThreadInfos);
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     assertMessageStoreThreadsAreEqual(
       processedMessageStore,
       filteredMessageStore,
       action.type,
     );
 
     return {
       messageStoreOperations,
       messageStore: {
         ...filteredMessageStore,
         messages: processedMessageStore.messages,
       },
     };
   } else if (action.type === newThreadActionTypes.success) {
     const messagesResult = mergeUpdatesWithMessageInfos(
       action.payload.newMessageInfos,
       action.payload.updatesResult.newUpdates,
     );
     return mergeNewMessages(
       messageStore,
       messagesResult.rawMessageInfos,
       messagesResult.truncationStatuses,
       newThreadInfos,
       action.type,
     );
   } else if (action.type === sendMessageReportActionTypes.success) {
     return mergeNewMessages(
       messageStore,
       [action.payload.messageInfo],
       {
         [action.payload.messageInfo.threadID]:
           messageTruncationStatus.UNCHANGED,
       },
       newThreadInfos,
       action.type,
     );
   } else if (action.type === registerActionTypes.success) {
     const truncationStatuses = {};
     for (const messageInfo of action.payload.rawMessageInfos) {
       truncationStatuses[messageInfo.threadID] =
         messageTruncationStatus.EXHAUSTIVE;
     }
     return mergeNewMessages(
       messageStore,
       action.payload.rawMessageInfos,
       truncationStatuses,
       newThreadInfos,
       action.type,
     );
   } else if (
     action.type === changeThreadSettingsActionTypes.success ||
     action.type === removeUsersFromThreadActionTypes.success ||
     action.type === changeThreadMemberRolesActionTypes.success ||
     action.type === createEntryActionTypes.success ||
     action.type === saveEntryActionTypes.success ||
     action.type === restoreEntryActionTypes.success ||
     action.type === toggleMessagePinActionTypes.success
   ) {
     return mergeNewMessages(
       messageStore,
       action.payload.newMessageInfos,
       { [action.payload.threadID]: messageTruncationStatus.UNCHANGED },
       newThreadInfos,
       action.type,
     );
   } else if (action.type === deleteEntryActionTypes.success) {
     const payload = action.payload;
     if (payload) {
       return mergeNewMessages(
         messageStore,
         payload.newMessageInfos,
         { [payload.threadID]: messageTruncationStatus.UNCHANGED },
         newThreadInfos,
         action.type,
       );
     }
   } else if (action.type === joinThreadActionTypes.success) {
     const messagesResult = mergeUpdatesWithMessageInfos(
       action.payload.rawMessageInfos,
       action.payload.updatesResult.newUpdates,
     );
     return mergeNewMessages(
       messageStore,
       messagesResult.rawMessageInfos,
       messagesResult.truncationStatuses,
       newThreadInfos,
       action.type,
     );
   } else if (action.type === sendEditMessageActionTypes.success) {
     const { newMessageInfos } = action.payload;
     const truncationStatuses = {};
     for (const messageInfo of newMessageInfos) {
       truncationStatuses[messageInfo.threadID] =
         messageTruncationStatus.UNCHANGED;
     }
     return mergeNewMessages(
       messageStore,
       newMessageInfos,
       truncationStatuses,
       newThreadInfos,
       action.type,
     );
   } else if (
     action.type === sendTextMessageActionTypes.started ||
     action.type === sendMultimediaMessageActionTypes.started ||
     action.type === sendReactionMessageActionTypes.started
   ) {
     const payload = ensureRealizedThreadIDIsUsedWhenPossible(
       action.payload,
       newThreadInfos,
     );
     const { localID, threadID } = payload;
     invariant(localID, `localID should be set on ${action.type}`);
 
     const messageIDs = messageStore.threads[threadID]?.messageIDs ?? [];
     if (!messageStore.messages[localID]) {
       for (const existingMessageID of messageIDs) {
         const existingMessageInfo = messageStore.messages[existingMessageID];
         if (existingMessageInfo && existingMessageInfo.localID === localID) {
           return { messageStoreOperations: [], messageStore };
         }
       }
     }
 
     const messageStoreOperations = [
       {
         type: 'replace',
         payload: { id: localID, messageInfo: payload },
       },
     ];
 
     const now = Date.now();
     let updatedThreads;
     let local = { ...messageStore.local };
     if (messageStore.messages[localID]) {
       const messages = { ...messageStore.messages, [localID]: payload };
       local = _pickBy(
         (localInfo: LocalMessageInfo, key: string) => key !== localID,
       )(messageStore.local);
       const thread = messageStore.threads[threadID];
       updatedThreads = {
         [threadID]: {
           messageIDs: sortMessageIDs(messages)(messageIDs),
           startReached: thread?.startReached ?? true,
           lastNavigatedTo: thread?.lastNavigatedTo ?? now,
           lastPruned: thread?.lastPruned ?? now,
         },
       };
     } else {
       updatedThreads = {
         [threadID]: messageStore.threads[threadID]
           ? {
               ...messageStore.threads[threadID],
               messageIDs: [localID, ...messageIDs],
             }
           : {
               messageIDs: [localID],
               startReached: true,
               lastNavigatedTo: now,
               lastPruned: now,
             },
       };
     }
 
     const threads = {
       ...messageStore.threads,
       ...updatedThreads,
     };
     messageStoreOperations.push({
       type: 'replace_threads',
       payload: {
         threads: { ...updatedThreads },
       },
     });
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     const newMessageStore = {
       messages: processedMessageStore.messages,
       threads,
       local,
       currentAsOf: messageStore.currentAsOf,
     };
 
     assertMessageStoreThreadsAreEqual(
       processedMessageStore,
       newMessageStore,
       action.type,
     );
 
     return {
       messageStoreOperations,
       messageStore: newMessageStore,
     };
   } else if (
     action.type === sendTextMessageActionTypes.failed ||
     action.type === sendMultimediaMessageActionTypes.failed
   ) {
     const { localID } = action.payload;
     return {
       messageStoreOperations: [],
       messageStore: {
         messages: messageStore.messages,
         threads: messageStore.threads,
         local: {
           ...messageStore.local,
           [localID]: { sendFailed: true },
         },
         currentAsOf: messageStore.currentAsOf,
       },
     };
   } else if (action.type === sendReactionMessageActionTypes.failed) {
     const { localID, threadID } = action.payload;
     const messageStoreOperations = [];
 
     messageStoreOperations.push({
       type: 'remove',
       payload: { ids: [localID] },
     });
 
     const newMessageIDs = messageStore.threads[threadID].messageIDs.filter(
       id => id !== localID,
     );
     const updatedThreads = {
       [threadID]: {
         ...messageStore.threads[threadID],
         messageIDs: newMessageIDs,
       },
     };
 
     messageStoreOperations.push({
       type: 'replace_threads',
       payload: { threads: updatedThreads },
     });
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     const newMessageStore = {
       ...processedMessageStore,
       threads: {
         ...messageStore.threads,
         ...updatedThreads,
       },
     };
 
     assertMessageStoreThreadsAreEqual(
       processedMessageStore,
       newMessageStore,
       action.type,
     );
 
     return {
       messageStoreOperations,
       messageStore: newMessageStore,
     };
   } else if (
     action.type === sendTextMessageActionTypes.success ||
     action.type === sendMultimediaMessageActionTypes.success ||
     action.type === sendReactionMessageActionTypes.success
   ) {
     const { payload } = action;
     invariant(
       !threadIsPending(payload.threadID),
       'Successful message action should have realized thread id',
     );
     const replaceMessageKey = (messageKey: string) =>
       messageKey === payload.localID ? payload.serverID : messageKey;
     let newMessages;
     const messageStoreOperations = [];
     if (messageStore.messages[payload.serverID]) {
       // If somehow the serverID got in there already, we'll just update the
       // serverID message and scrub the localID one
       newMessages = _omitBy(
         (messageInfo: RawMessageInfo) =>
           messageInfo.type === messageTypes.TEXT &&
           !messageInfo.id &&
           messageInfo.localID === payload.localID,
       )(messageStore.messages);
       messageStoreOperations.push({
         type: 'remove',
         payload: { ids: [payload.localID] },
       });
     } else if (messageStore.messages[payload.localID]) {
       // The normal case, the localID message gets replaced by the serverID one
       newMessages = _mapKeys(replaceMessageKey)(messageStore.messages);
       messageStoreOperations.push({
         type: 'rekey',
         payload: { from: payload.localID, to: payload.serverID },
       });
     } else {
       // Well this is weird, we probably got deauthorized between when the
       // action was dispatched and when we ran this reducer...
       return { messageStoreOperations, messageStore };
     }
 
     const newMessage = {
       ...newMessages[payload.serverID],
       id: payload.serverID,
       localID: payload.localID,
       time: payload.time,
     };
     newMessages[payload.serverID] = newMessage;
     messageStoreOperations.push({
       type: 'replace',
       payload: { id: payload.serverID, messageInfo: newMessage },
     });
     const threadID = payload.threadID;
     const newMessageIDs = _flow(
       _uniq,
       sortMessageIDs(newMessages),
     )(messageStore.threads[threadID].messageIDs.map(replaceMessageKey));
     const local = _pickBy(
       (localInfo: LocalMessageInfo, key: string) => key !== payload.localID,
     )(messageStore.local);
 
     const updatedThreads = {
       [threadID]: {
         ...messageStore.threads[threadID],
         messageIDs: newMessageIDs,
       },
     };
     messageStoreOperations.push({
       type: 'replace_threads',
       payload: { threads: updatedThreads },
     });
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     const newMessageStore = {
       ...messageStore,
       messages: processedMessageStore.messages,
       threads: {
         ...messageStore.threads,
         ...updatedThreads,
       },
       local,
     };
 
     assertMessageStoreThreadsAreEqual(
       processedMessageStore,
       newMessageStore,
       action.type,
     );
 
     return {
       messageStoreOperations,
       messageStore: newMessageStore,
     };
   } else if (action.type === saveMessagesActionType) {
     const truncationStatuses = {};
     for (const messageInfo of action.payload.rawMessageInfos) {
       truncationStatuses[messageInfo.threadID] =
         messageTruncationStatus.UNCHANGED;
     }
     const { messageStoreOperations, messageStore: newMessageStore } =
       mergeNewMessages(
         messageStore,
         action.payload.rawMessageInfos,
         truncationStatuses,
         newThreadInfos,
         action.type,
       );
     return {
       messageStoreOperations,
       messageStore: {
         messages: newMessageStore.messages,
         threads: newMessageStore.threads,
         local: newMessageStore.local,
         // We avoid bumping currentAsOf because notifs may include a contracted
         // RawMessageInfo, so we want to make sure we still fetch it
         currentAsOf: messageStore.currentAsOf,
       },
     };
   } else if (action.type === messageStorePruneActionType) {
     const now = Date.now();
     const messageIDsToPrune = [];
 
     const updatedThreads = {};
     for (const threadID of action.payload.threadIDs) {
       let thread = messageStore.threads[threadID];
       if (!thread) {
         continue;
       }
       thread = { ...thread, lastPruned: now };
 
       const newMessageIDs = [...thread.messageIDs];
       const removed = newMessageIDs.splice(defaultNumberPerThread);
       if (removed.length > 0) {
         thread = {
           ...thread,
           messageIDs: newMessageIDs,
           startReached: false,
         };
       }
       for (const id of removed) {
         messageIDsToPrune.push(id);
       }
 
       updatedThreads[threadID] = thread;
     }
 
     const messageStoreOperations = [
       {
         type: 'remove',
         payload: { ids: messageIDsToPrune },
       },
       {
         type: 'replace_threads',
         payload: {
           threads: updatedThreads,
         },
       },
     ];
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     const newMessageStore = {
       messages: processedMessageStore.messages,
       threads: {
         ...messageStore.threads,
         ...updatedThreads,
       },
       local: _omit(messageIDsToPrune)(messageStore.local),
       currentAsOf: messageStore.currentAsOf,
     };
 
     assertMessageStoreThreadsAreEqual(
       processedMessageStore,
       newMessageStore,
       action.type,
     );
 
     return {
       messageStoreOperations,
       messageStore: newMessageStore,
     };
   } else if (action.type === updateMultimediaMessageMediaActionType) {
     const { messageID: id, currentMediaID, mediaUpdate } = action.payload;
     const message = messageStore.messages[id];
     invariant(message, `message with ID ${id} could not be found`);
     invariant(
       message.type === messageTypes.IMAGES ||
         message.type === messageTypes.MULTIMEDIA,
       `message with ID ${id} is not multimedia`,
     );
 
     let updatedMessage;
     let replaced = false;
     if (message.type === messageTypes.IMAGES) {
       const media: Image[] = [];
       for (const singleMedia of message.media) {
         if (singleMedia.id !== currentMediaID) {
           media.push(singleMedia);
         } else {
           let updatedMedia: Image = {
             id: mediaUpdate.id ?? singleMedia.id,
             type: 'photo',
             uri: mediaUpdate.uri ?? singleMedia.uri,
             dimensions: mediaUpdate.dimensions ?? singleMedia.dimensions,
           };
 
           if (
             'localMediaSelection' in singleMedia &&
             !('localMediaSelection' in mediaUpdate)
           ) {
             updatedMedia = {
               ...updatedMedia,
               localMediaSelection: singleMedia.localMediaSelection,
             };
           } else if (mediaUpdate.localMediaSelection) {
             updatedMedia = {
               ...updatedMedia,
               localMediaSelection: mediaUpdate.localMediaSelection,
             };
           }
 
           media.push(updatedMedia);
           replaced = true;
         }
       }
       updatedMessage = { ...message, media };
     } else {
       const media: Media[] = [];
       for (const singleMedia of message.media) {
         if (singleMedia.id !== currentMediaID) {
           media.push(singleMedia);
         } else if (
           singleMedia.type === 'photo' &&
           mediaUpdate.type === 'photo'
         ) {
           media.push({ ...singleMedia, ...mediaUpdate });
           replaced = true;
         } else if (
           singleMedia.type === 'video' &&
           mediaUpdate.type === 'video'
         ) {
           media.push({ ...singleMedia, ...mediaUpdate });
           replaced = true;
         } else if (
           singleMedia.type === 'encrypted_photo' &&
           mediaUpdate.type === 'encrypted_photo'
         ) {
           media.push({ ...singleMedia, ...mediaUpdate });
           replaced = true;
         } else if (
           singleMedia.type === 'encrypted_video' &&
           mediaUpdate.type === 'encrypted_video'
         ) {
           media.push({ ...singleMedia, ...mediaUpdate });
           replaced = true;
         } else if (
           singleMedia.type === 'photo' &&
           mediaUpdate.type === 'encrypted_photo'
         ) {
           // extract fields that are absent in encrypted_photo type
           const { uri, localMediaSelection, ...original } = singleMedia;
           const { holder, encryptionKey, ...update } = mediaUpdate;
           invariant(
             holder && encryptionKey,
             'holder and encryptionKey are required for encrypted_photo message',
           );
           media.push({
             ...original,
             ...update,
             type: 'encrypted_photo',
             holder,
             encryptionKey,
           });
           replaced = true;
         } else if (
           singleMedia.type === 'video' &&
           mediaUpdate.type === 'encrypted_video'
         ) {
           const { uri, thumbnailURI, localMediaSelection, ...original } =
             singleMedia;
           const {
             holder,
             encryptionKey,
             thumbnailHolder,
             thumbnailEncryptionKey,
             ...update
           } = mediaUpdate;
           invariant(
             holder && encryptionKey,
             'holder and encryptionKey are required for encrypted_video message',
           );
           invariant(
             thumbnailHolder && thumbnailEncryptionKey,
             'thumbnailHolder and thumbnailEncryptionKey are required for ' +
               'encrypted_video message',
           );
           media.push({
             ...original,
             ...update,
             type: 'encrypted_video',
             holder,
             encryptionKey,
             thumbnailHolder,
             thumbnailEncryptionKey,
           });
           replaced = true;
         }
       }
       updatedMessage = { ...message, media };
     }
 
     invariant(
       replaced,
       `message ${id} did not contain media with ID ${currentMediaID}`,
     );
 
     const messageStoreOperations = [
       {
         type: 'replace',
         payload: {
           id,
           messageInfo: updatedMessage,
         },
       },
     ];
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     return {
       messageStoreOperations,
       messageStore: {
         ...messageStore,
         messages: processedMessageStore.messages,
       },
     };
   } else if (action.type === createLocalMessageActionType) {
     const messageInfo = ensureRealizedThreadIDIsUsedWhenPossible(
       action.payload,
       newThreadInfos,
     );
     const { localID, threadID } = messageInfo;
 
     const messageIDs =
       messageStore.threads[messageInfo.threadID]?.messageIDs ?? [];
     const now = Date.now();
     const threadState: ThreadMessageInfo = messageStore.threads[threadID]
       ? {
           ...messageStore.threads[threadID],
           messageIDs: [localID, ...messageIDs],
         }
       : {
           messageIDs: [localID],
           startReached: true,
           lastNavigatedTo: now,
           lastPruned: now,
         };
 
     const messageStoreOperations = [
       {
         type: 'replace',
         payload: { id: localID, messageInfo },
       },
       {
         type: 'replace_threads',
         payload: {
           threads: { [threadID]: threadState },
         },
       },
     ];
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     const newMessageStore = {
       ...messageStore,
       threads: {
         ...messageStore.threads,
         [threadID]: threadState,
       },
       messages: processedMessageStore.messages,
     };
 
     assertMessageStoreThreadsAreEqual(
       processedMessageStore,
       newMessageStore,
       action.type,
     );
 
     return {
       messageStoreOperations,
       messageStore: newMessageStore,
     };
   } else if (action.type === processServerRequestsActionType) {
     const {
       messageStoreOperations,
       messageStore: messageStoreAfterReassignment,
     } = reassignMessagesToRealizedThreads(messageStore, newThreadInfos);
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     assertMessageStoreThreadsAreEqual(
       processedMessageStore,
       messageStoreAfterReassignment,
       action.type,
     );
 
     return {
       messageStoreOperations,
       messageStore: {
         ...messageStoreAfterReassignment,
         messages: processedMessageStore.messages,
       },
     };
   } else if (action.type === setClientDBStoreActionType) {
+    const payloadMessages = action.payload.messages;
+    if (!payloadMessages) {
+      return { messageStoreOperations: [], messageStore };
+    }
     const actionPayloadMessageStoreThreads =
-      translateClientDBThreadMessageInfos(action.payload.messageStoreThreads);
+      translateClientDBThreadMessageInfos(
+        action.payload.messageStoreThreads ?? [],
+      );
 
     const newThreads = {};
     for (const threadID in actionPayloadMessageStoreThreads) {
       newThreads[threadID] = {
         ...actionPayloadMessageStoreThreads[threadID],
         messageIDs: messageStore.threads[threadID]?.messageIDs ?? [],
       };
     }
 
     assertMessageStoreThreadsAreEqual(
       {
         ...messageStore,
         threads: newThreads,
       },
       messageStore,
       `${action.type} | comparing SQLite with redux-persist`,
     );
 
     const { messageStoreOperations, messageStore: updatedMessageStore } =
       updateMessageStoreWithLatestThreadInfos(messageStore, newThreadInfos);
 
     let threads = { ...updatedMessageStore.threads };
     let local = { ...updatedMessageStore.local };
 
     // Store message IDs already contained within threads so that we
     // do not insert duplicates
     const existingMessageIDs = new Set();
     for (const threadID in threads) {
       threads[threadID].messageIDs.forEach(msgID => {
         existingMessageIDs.add(msgID);
       });
     }
     const threadsNeedMsgIDsResorting = new Set();
     const actionPayloadMessages =
-      translateClientDBMessageInfosToRawMessageInfos(action.payload.messages);
+      translateClientDBMessageInfosToRawMessageInfos(payloadMessages);
 
     // When starting the app on native, we filter out any local-only multimedia
     // messages because the relevant context is no longer available
     const messageIDsToBeRemoved = [];
     const threadsToAdd = {};
     for (const id in actionPayloadMessages) {
       const message = actionPayloadMessages[id];
       const { threadID } = message;
       let existingThread = threads[threadID];
       if (!existingThread) {
         existingThread = newThread();
         threadsToAdd[threadID] = existingThread;
       }
       if (
         (message.type === messageTypes.IMAGES ||
           message.type === messageTypes.MULTIMEDIA) &&
         !message.id
       ) {
         messageIDsToBeRemoved.push(id);
         threads = {
           ...threads,
           [threadID]: {
             ...existingThread,
             messageIDs: existingThread.messageIDs.filter(
               curMessageID => curMessageID !== id,
             ),
           },
         };
         local = _pickBy(
           (localInfo: LocalMessageInfo, key: string) => key !== id,
         )(local);
       } else if (!existingMessageIDs.has(id)) {
         threads = {
           ...threads,
           [threadID]: {
             ...existingThread,
             messageIDs: [...existingThread.messageIDs, id],
           },
         };
         threadsNeedMsgIDsResorting.add(threadID);
       } else if (!threads[threadID]) {
         threads = { ...threads, [threadID]: existingThread };
       }
     }
 
     for (const threadID of threadsNeedMsgIDsResorting) {
       threads[threadID].messageIDs = sortMessageIDs(actionPayloadMessages)(
         threads[threadID].messageIDs,
       );
     }
 
     const newMessageStore = {
       ...updatedMessageStore,
       messages: actionPayloadMessages,
       threads: threads,
       local: local,
     };
 
     if (messageIDsToBeRemoved.length > 0) {
       messageStoreOperations.push({
         type: 'remove',
         payload: { ids: messageIDsToBeRemoved },
       });
     }
 
     const processedMessageStore = processMessageStoreOperations(
       newMessageStore,
       messageStoreOperations,
     );
 
     messageStoreOperations.push({
       type: 'replace_threads',
       payload: { threads: threadsToAdd },
     });
 
     return {
       messageStoreOperations,
       messageStore: processedMessageStore,
     };
   }
   return { messageStoreOperations: [], messageStore };
 }
 
 type MergedUpdatesWithMessages = {
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatuses: MessageTruncationStatuses,
 };
 function mergeUpdatesWithMessageInfos(
   messageInfos: $ReadOnlyArray<RawMessageInfo>,
   newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   truncationStatuses?: MessageTruncationStatuses,
 ): MergedUpdatesWithMessages {
   const messageIDs = new Set(messageInfos.map(messageInfo => messageInfo.id));
   const mergedMessageInfos = [...messageInfos];
   const mergedTruncationStatuses = { ...truncationStatuses };
 
   for (const updateInfo of newUpdates) {
     if (updateInfo.type !== updateTypes.JOIN_THREAD) {
       continue;
     }
     for (const messageInfo of updateInfo.rawMessageInfos) {
       if (messageIDs.has(messageInfo.id)) {
         continue;
       }
       mergedMessageInfos.push(messageInfo);
       messageIDs.add(messageInfo.id);
     }
 
     mergedTruncationStatuses[updateInfo.threadInfo.id] =
       combineTruncationStatuses(
         updateInfo.truncationStatus,
         mergedTruncationStatuses[updateInfo.threadInfo.id],
       );
   }
   return {
     rawMessageInfos: mergedMessageInfos,
     truncationStatuses: mergedTruncationStatuses,
   };
 }
 
 export { freshMessageStore, reduceMessageStore };
diff --git a/lib/reducers/thread-reducer.js b/lib/reducers/thread-reducer.js
index 1e6242224..74cf15d4a 100644
--- a/lib/reducers/thread-reducer.js
+++ b/lib/reducers/thread-reducer.js
@@ -1,510 +1,510 @@
 // @flow
 
 import _isEqual from 'lodash/fp/isEqual.js';
 
 import {
   setThreadUnreadStatusActionTypes,
   updateActivityActionTypes,
 } from '../actions/activity-actions.js';
 import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
 import { saveMessagesActionType } from '../actions/message-actions.js';
 import { siweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   changeThreadSettingsActionTypes,
   deleteThreadActionTypes,
   newThreadActionTypes,
   removeUsersFromThreadActionTypes,
   changeThreadMemberRolesActionTypes,
   joinThreadActionTypes,
   leaveThreadActionTypes,
 } from '../actions/thread-actions.js';
 import {
   logOutActionTypes,
   deleteAccountActionTypes,
   logInActionTypes,
   registerActionTypes,
   updateSubscriptionActionTypes,
 } from '../actions/user-actions.js';
 import type { BaseAction } from '../types/redux-types.js';
 import {
   type ClientThreadInconsistencyReportCreationRequest,
   reportTypes,
 } from '../types/report-types.js';
 import {
   serverRequestTypes,
   processServerRequestsActionType,
 } from '../types/request-types.js';
 import {
   fullStateSyncActionType,
   incrementalStateSyncActionType,
 } from '../types/socket-types.js';
 import type {
   RawThreadInfo,
   ThreadStore,
   ThreadStoreOperation,
 } from '../types/thread-types.js';
 import {
   updateTypes,
   type ClientUpdateInfo,
   processUpdatesActionType,
 } from '../types/update-types.js';
 import { actionLogger } from '../utils/action-logger.js';
 import { setNewSessionActionType } from '../utils/action-utils.js';
 import { getConfig } from '../utils/config.js';
 import { sanitizeActionSecrets } from '../utils/sanitization.js';
 
 function generateOpsForThreadUpdates(
   threadInfos: { +[id: string]: RawThreadInfo },
   payload: {
     +updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... },
     ...
   },
 ): $ReadOnlyArray<ThreadStoreOperation> {
   const threadOperations: ThreadStoreOperation[] = [];
   for (const update of payload.updatesResult.newUpdates) {
     if (
       (update.type === updateTypes.UPDATE_THREAD ||
         update.type === updateTypes.JOIN_THREAD) &&
       !_isEqual(threadInfos[update.threadInfo.id])(update.threadInfo)
     ) {
       threadOperations.push({
         type: 'replace',
         payload: {
           id: update.threadInfo.id,
           threadInfo: update.threadInfo,
         },
       });
     } else if (
       update.type === updateTypes.UPDATE_THREAD_READ_STATUS &&
       threadInfos[update.threadID] &&
       threadInfos[update.threadID].currentUser.unread !== update.unread
     ) {
       const updatedThread = {
         ...threadInfos[update.threadID],
         currentUser: {
           ...threadInfos[update.threadID].currentUser,
           unread: update.unread,
         },
       };
       threadOperations.push({
         type: 'replace',
         payload: {
           id: update.threadID,
           threadInfo: updatedThread,
         },
       });
     } else if (
       update.type === updateTypes.DELETE_THREAD &&
       threadInfos[update.threadID]
     ) {
       threadOperations.push({
         type: 'remove',
         payload: {
           ids: [update.threadID],
         },
       });
     } else if (update.type === updateTypes.DELETE_ACCOUNT) {
       for (const threadID in threadInfos) {
         const threadInfo = threadInfos[threadID];
         const newMembers = threadInfo.members.filter(
           member => member.id !== update.deletedUserID,
         );
         if (newMembers.length < threadInfo.members.length) {
           const updatedThread = {
             ...threadInfo,
             members: newMembers,
           };
           threadOperations.push({
             type: 'replace',
             payload: {
               id: threadID,
               threadInfo: updatedThread,
             },
           });
         }
       }
     }
   }
   return threadOperations;
 }
 
 function findInconsistencies(
   action: BaseAction,
   beforeStateCheck: { +[id: string]: RawThreadInfo },
   afterStateCheck: { +[id: string]: RawThreadInfo },
 ): ClientThreadInconsistencyReportCreationRequest[] {
   if (_isEqual(beforeStateCheck)(afterStateCheck)) {
     return [];
   }
   return [
     {
       type: reportTypes.THREAD_INCONSISTENCY,
       platformDetails: getConfig().platformDetails,
       beforeAction: beforeStateCheck,
       action: sanitizeActionSecrets(action),
       pushResult: afterStateCheck,
       lastActions: actionLogger.interestingActionSummaries,
       time: Date.now(),
     },
   ];
 }
 
 function reduceThreadInfos(
   state: ThreadStore,
   action: BaseAction,
 ): {
   threadStore: ThreadStore,
   newThreadInconsistencies: $ReadOnlyArray<ClientThreadInconsistencyReportCreationRequest>,
   threadStoreOperations: $ReadOnlyArray<ThreadStoreOperation>,
 } {
   if (
     action.type === logInActionTypes.success ||
     action.type === siweAuthActionTypes.success ||
     action.type === registerActionTypes.success ||
     action.type === fullStateSyncActionType
   ) {
     const newThreadInfos = action.payload.threadInfos;
     const threadStoreOperations = [
       {
         type: 'remove_all',
       },
       ...Object.keys(newThreadInfos).map((id: string) => ({
         type: 'replace',
         payload: { id, threadInfo: newThreadInfos[id] },
       })),
     ];
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (
     action.type === logOutActionTypes.success ||
     action.type === deleteAccountActionTypes.success ||
     (action.type === setNewSessionActionType &&
       action.payload.sessionChange.cookieInvalidated)
   ) {
     if (Object.keys(state.threadInfos).length === 0) {
       return {
         threadStore: state,
         newThreadInconsistencies: [],
         threadStoreOperations: [],
       };
     }
     const threadStoreOperations = [
       {
         type: 'remove_all',
       },
     ];
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (
     action.type === joinThreadActionTypes.success ||
     action.type === leaveThreadActionTypes.success ||
     action.type === deleteThreadActionTypes.success ||
     action.type === changeThreadSettingsActionTypes.success ||
     action.type === removeUsersFromThreadActionTypes.success ||
     action.type === changeThreadMemberRolesActionTypes.success ||
     action.type === incrementalStateSyncActionType ||
     action.type === processUpdatesActionType ||
     action.type === newThreadActionTypes.success
   ) {
     const { newUpdates } = action.payload.updatesResult;
     if (newUpdates.length === 0) {
       return {
         threadStore: state,
         newThreadInconsistencies: [],
         threadStoreOperations: [],
       };
     }
     const threadStoreOperations = generateOpsForThreadUpdates(
       state.threadInfos,
       action.payload,
     );
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (action.type === updateSubscriptionActionTypes.success) {
     const { threadID, subscription } = action.payload;
     const newThreadInfo = {
       ...state.threadInfos[threadID],
       currentUser: {
         ...state.threadInfos[threadID].currentUser,
         subscription,
       },
     };
     const threadStoreOperations = [
       {
         type: 'replace',
         payload: {
           id: threadID,
           threadInfo: newThreadInfo,
         },
       },
     ];
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (action.type === saveMessagesActionType) {
     const threadIDToMostRecentTime = new Map();
     for (const messageInfo of action.payload.rawMessageInfos) {
       const current = threadIDToMostRecentTime.get(messageInfo.threadID);
       if (!current || current < messageInfo.time) {
         threadIDToMostRecentTime.set(messageInfo.threadID, messageInfo.time);
       }
     }
     const changedThreadInfos = {};
     for (const [threadID, mostRecentTime] of threadIDToMostRecentTime) {
       const threadInfo = state.threadInfos[threadID];
       if (
         !threadInfo ||
         threadInfo.currentUser.unread ||
         action.payload.updatesCurrentAsOf > mostRecentTime
       ) {
         continue;
       }
       changedThreadInfos[threadID] = {
         ...state.threadInfos[threadID],
         currentUser: {
           ...state.threadInfos[threadID].currentUser,
           unread: true,
         },
       };
     }
     if (Object.keys(changedThreadInfos).length !== 0) {
       const threadStoreOperations = Object.keys(changedThreadInfos).map(id => ({
         type: 'replace',
         payload: {
           id,
           threadInfo: changedThreadInfos[id],
         },
       }));
       const updatedThreadStore = processThreadStoreOperations(
         state,
         threadStoreOperations,
       );
       return {
         threadStore: updatedThreadStore,
         newThreadInconsistencies: [],
         threadStoreOperations,
       };
     }
   } else if (action.type === processServerRequestsActionType) {
     const checkStateRequest = action.payload.serverRequests.find(
       candidate => candidate.type === serverRequestTypes.CHECK_STATE,
     );
     if (!checkStateRequest || !checkStateRequest.stateChanges) {
       return {
         threadStore: state,
         newThreadInconsistencies: [],
         threadStoreOperations: [],
       };
     }
     const { rawThreadInfos, deleteThreadIDs } = checkStateRequest.stateChanges;
     if (!rawThreadInfos && !deleteThreadIDs) {
       return {
         threadStore: state,
         newThreadInconsistencies: [],
         threadStoreOperations: [],
       };
     }
 
     const threadStoreOperations: ThreadStoreOperation[] = [];
     if (rawThreadInfos) {
       for (const rawThreadInfo of rawThreadInfos) {
         threadStoreOperations.push({
           type: 'replace',
           payload: {
             id: rawThreadInfo.id,
             threadInfo: rawThreadInfo,
           },
         });
       }
     }
     if (deleteThreadIDs) {
       threadStoreOperations.push({
         type: 'remove',
         payload: {
           ids: deleteThreadIDs,
         },
       });
     }
 
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
 
     const newThreadInconsistencies = findInconsistencies(
       action,
       state.threadInfos,
       updatedThreadStore.threadInfos,
     );
 
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies,
       threadStoreOperations,
     };
   } else if (action.type === updateActivityActionTypes.success) {
     const updatedThreadInfos = {};
     for (const setToUnread of action.payload.result.unfocusedToUnread) {
       const threadInfo = state.threadInfos[setToUnread];
       if (threadInfo && !threadInfo.currentUser.unread) {
         updatedThreadInfos[setToUnread] = {
           ...threadInfo,
           currentUser: {
             ...threadInfo.currentUser,
             unread: true,
           },
         };
       }
     }
     if (Object.keys(updatedThreadInfos).length === 0) {
       return {
         threadStore: state,
         newThreadInconsistencies: [],
         threadStoreOperations: [],
       };
     }
     const threadStoreOperations = Object.keys(updatedThreadInfos).map(id => ({
       type: 'replace',
       payload: {
         id,
         threadInfo: updatedThreadInfos[id],
       },
     }));
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (action.type === setThreadUnreadStatusActionTypes.started) {
     const { threadID, unread } = action.payload;
     const updatedThreadInfo = {
       ...state.threadInfos[threadID],
       currentUser: {
         ...state.threadInfos[threadID].currentUser,
         unread,
       },
     };
     const threadStoreOperations = [
       {
         type: 'replace',
         payload: {
           id: threadID,
           threadInfo: updatedThreadInfo,
         },
       },
     ];
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (action.type === setThreadUnreadStatusActionTypes.success) {
     const { threadID, resetToUnread } = action.payload;
     const currentUser = state.threadInfos[threadID].currentUser;
 
     if (!resetToUnread || currentUser.unread) {
       return {
         threadStore: state,
         newThreadInconsistencies: [],
         threadStoreOperations: [],
       };
     }
 
     const updatedUser = {
       ...currentUser,
       unread: true,
     };
     const updatedThread = {
       ...state.threadInfos[threadID],
       currentUser: updatedUser,
     };
     const threadStoreOperations = [
       {
         type: 'replace',
         payload: {
           id: threadID,
           threadInfo: updatedThread,
         },
       },
     ];
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (action.type === setClientDBStoreActionType) {
     return {
-      threadStore: action.payload.threadStore,
+      threadStore: action.payload.threadStore ?? state,
       newThreadInconsistencies: [],
       threadStoreOperations: [],
     };
   }
   return {
     threadStore: state,
     newThreadInconsistencies: [],
     threadStoreOperations: [],
   };
 }
 
 function processThreadStoreOperations(
   threadStore: ThreadStore,
   threadStoreOperations: $ReadOnlyArray<ThreadStoreOperation>,
 ): ThreadStore {
   if (threadStoreOperations.length === 0) {
     return threadStore;
   }
   let processedThreads = { ...threadStore.threadInfos };
   for (const operation of threadStoreOperations) {
     if (operation.type === 'replace') {
       processedThreads[operation.payload.id] = operation.payload.threadInfo;
     } else if (operation.type === 'remove') {
       for (const id of operation.payload.ids) {
         delete processedThreads[id];
       }
     } else if (operation.type === 'remove_all') {
       processedThreads = {};
     }
   }
   return { ...threadStore, threadInfos: processedThreads };
 }
 
 export { reduceThreadInfos, processThreadStoreOperations };
diff --git a/lib/types/redux-types.js b/lib/types/redux-types.js
index a3892fd7d..7b3f61e7e 100644
--- a/lib/types/redux-types.js
+++ b/lib/types/redux-types.js
@@ -1,1029 +1,1029 @@
 // @flow
 
 import type {
   LogOutResult,
   LogInStartingPayload,
   LogInResult,
   RegisterResult,
   DefaultNotificationPayload,
 } from './account-types.js';
 import type {
   ActivityUpdateSuccessPayload,
   QueueActivityUpdatesPayload,
   SetThreadUnreadStatusPayload,
 } from './activity-types.js';
 import type {
   UpdateUserAvatarRequest,
   UpdateUserAvatarResponse,
 } from './avatar-types.js';
 import type { CryptoStore } from './crypto-types.js';
 import type { ClientDBDraftInfo, DraftStore } from './draft-types.js';
 import type { EnabledApps, SupportedApps } from './enabled-apps.js';
 import type {
   RawEntryInfo,
   EntryStore,
   SaveEntryPayload,
   CreateEntryPayload,
   DeleteEntryResult,
   RestoreEntryPayload,
   FetchEntryInfosResult,
   CalendarQueryUpdateResult,
   CalendarQueryUpdateStartingPayload,
 } from './entry-types.js';
 import type {
   CalendarFilter,
   CalendarThreadFilter,
   SetCalendarDeletedFilterPayload,
 } from './filter-types.js';
 import type { LifecycleState } from './lifecycle-state-types.js';
 import type { InviteLinkVerificationResponse } 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,
   ClientDBMessageInfo,
   SimpleMessagesPayload,
   ClientDBThreadMessageInfo,
   FetchPinnedMessagesResult,
 } from './message-types.js';
 import type { RawReactionMessageInfo } from './messages/reaction.js';
 import type { RawTextMessageInfo } from './messages/text.js';
 import type { BaseNavInfo } 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 { ProcessServerRequestsPayload } from './request-types.js';
 import type { UserSearchResult } from './search-types.js';
 import type { SetSessionPayload } from './session-types.js';
 import type {
   ConnectionInfo,
   StateSyncFullActionPayload,
   StateSyncIncrementalActionPayload,
   UpdateConnectionStatusPayload,
   SetLateResponsePayload,
   UpdateDisconnectedBarPayload,
 } from './socket-types.js';
 import type { SubscriptionUpdateResult } from './subscription-types.js';
 import type {
   ThreadStore,
   ChangeThreadSettingsPayload,
   LeaveThreadPayload,
   NewThreadResult,
   ThreadJoinPayload,
   ToggleMessagePinResult,
 } from './thread-types.js';
 import type { ClientUpdatesResultWithUserInfos } from './update-types.js';
 import type { CurrentUserInfo, UserStore } from './user-types.js';
 import type { Shape } from '../types/core.js';
 import type { NotifPermissionAlertInfo } from '../utils/push-alerts.js';
 
 export type BaseAppState<NavInfo: BaseNavInfo> = {
   navInfo: NavInfo,
   currentUserInfo: ?CurrentUserInfo,
   draftStore: DraftStore,
   entryStore: EntryStore,
   threadStore: ThreadStore,
   userStore: UserStore,
   messageStore: MessageStore,
   updatesCurrentAsOf: number, // millisecond timestamp
   loadingStatuses: { [key: string]: { [idx: number]: LoadingStatus } },
   calendarFilters: $ReadOnlyArray<CalendarFilter>,
   urlPrefix: string,
   notifPermissionAlertInfo: NotifPermissionAlertInfo,
   connection: ConnectionInfo,
   watchedThreadIDs: $ReadOnlyArray<string>,
   lifecycleState: LifecycleState,
   enabledApps: EnabledApps,
   reportStore: ReportStore,
   nextLocalID: number,
   dataLoaded: boolean,
   userPolicies: UserPolicies,
   deviceToken: ?string,
   +commServicesAccessToken: ?string,
   ...
 };
 
 // Web JS runtime doesn't have access to the cookie for security reasons.
 // Native JS doesn't have a sessionID because the cookieID is used instead.
 export type NativeAppState = BaseAppState<*> & {
   sessionID?: void,
   cookie: ?string,
   ...
 };
 export type WebAppState = BaseAppState<*> & {
   sessionID: ?string,
   cookie?: void,
   cryptoStore: CryptoStore,
   pushApiPublicKey: ?string,
   ...
 };
 export type AppState = NativeAppState | WebAppState;
 
 export type BaseAction =
   | {
       +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: '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: 'LOG_IN_STARTED',
       +loadingInfo: LoadingInfo,
       +payload: LogInStartingPayload,
     }
   | {
       +type: 'LOG_IN_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LOG_IN_SUCCESS',
       +payload: LogInResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REGISTER_STARTED',
       +loadingInfo: LoadingInfo,
       +payload: LogInStartingPayload,
     }
   | {
       +type: 'REGISTER_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REGISTER_SUCCESS',
       +payload: RegisterResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_USER_PASSWORD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_USER_PASSWORD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_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: {
         +entryID: string,
         +text: string,
         +deleted: boolean,
       },
       +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: 'UPDATE_DRAFT',
       +payload: {
         +key: string,
         +text: string,
       },
     }
   | {
       +type: 'MOVE_DRAFT',
       +payload: {
         +oldKey: string,
         +newKey: string,
       },
     }
   | {
       +type: 'SET_CLIENT_DB_STORE',
       +payload: {
         +currentUserID: ?string,
         +drafts: $ReadOnlyArray<ClientDBDraftInfo>,
-        +messages: $ReadOnlyArray<ClientDBMessageInfo>,
-        +threadStore: ThreadStore,
-        +messageStoreThreads: $ReadOnlyArray<ClientDBThreadMessageInfo>,
+        +messages: ?$ReadOnlyArray<ClientDBMessageInfo>,
+        +threadStore: ?ThreadStore,
+        +messageStoreThreads: ?$ReadOnlyArray<ClientDBThreadMessageInfo>,
       },
     }
   | {
       +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?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_DEVICE_TOKEN_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_DEVICE_TOKEN_SUCCESS',
       +payload: ?string,
       +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,
     }
   | {
       +type: 'PROCESS_SERVER_REQUESTS',
       +payload: ProcessServerRequestsPayload,
     }
   | {
       +type: 'UPDATE_CONNECTION_STATUS',
       +payload: UpdateConnectionStatusPayload,
     }
   | {
       +type: 'QUEUE_ACTIVITY_UPDATES',
       +payload: QueueActivityUpdatesPayload,
     }
   | {
       +type: 'UNSUPERVISED_BACKGROUND',
       +payload?: void,
     }
   | {
       +type: 'UPDATE_LIFECYCLE_STATE',
       +payload: LifecycleState,
     }
   | {
       +type: 'ENABLE_APP',
       +payload: SupportedApps,
     }
   | {
       +type: 'DISABLE_APP',
       +payload: SupportedApps,
     }
   | {
       +type: 'UPDATE_REPORTS_ENABLED',
       +payload: Shape<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_DISCONNECTED_BAR',
       +payload: UpdateDisconnectedBarPayload,
     }
   | {
       +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: 'SIWE_AUTH_STARTED',
       +payload: LogInStartingPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SIWE_AUTH_SUCCESS',
       +payload: LogInResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SIWE_AUTH_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'RECORD_NOTIF_PERMISSION_ALERT',
       +payload: { +time: number },
     }
   | {
       +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,
     };
 
 export type ActionPayload = ?(Object | Array<*> | $ReadOnlyArray<*> | string);
 export type SuperAction = {
   type: string,
   payload?: ActionPayload,
   loadingInfo?: LoadingInfo,
   error?: boolean,
 };
 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';