diff --git a/keyserver/src/responders/message-responders.js b/keyserver/src/responders/message-responders.js
index 51dfad1a7..e5d206da0 100644
--- a/keyserver/src/responders/message-responders.js
+++ b/keyserver/src/responders/message-responders.js
@@ -1,272 +1,272 @@
 // @flow
 
 import invariant from 'invariant';
 import t from 'tcomb';
 
 import { onlyOneEmojiRegex } from 'lib/shared/emojis.js';
 import {
   createMediaMessageData,
   trimMessage,
 } from 'lib/shared/message-utils.js';
 import { relationshipBlockedInEitherDirection } from 'lib/shared/relationship-utils.js';
 import type { Media } from 'lib/types/media-types.js';
 import {
   messageTypes,
   type SendTextMessageRequest,
   type SendMultimediaMessageRequest,
   type SendReactionMessageRequest,
   type FetchMessageInfosResponse,
   type FetchMessageInfosRequest,
   defaultNumberPerThread,
   type SendMessageResponse,
 } from 'lib/types/message-types.js';
 import type { ReactionMessageData } from 'lib/types/messages/reaction.js';
 import type { TextMessageData } from 'lib/types/messages/text.js';
 import { threadPermissions } from 'lib/types/thread-types.js';
 import { ServerError } from 'lib/utils/errors.js';
 import {
   tRegex,
   tShape,
   tMediaMessageMedia,
 } from 'lib/utils/validation-utils.js';
 
 import createMessages from '../creators/message-creator.js';
 import { SQL } from '../database/database.js';
 import {
   fetchMessageInfos,
   fetchMessageInfoForLocalID,
   fetchMessageInfoByID,
 } from '../fetchers/message-fetchers.js';
 import { fetchServerThreadInfos } from '../fetchers/thread-fetchers.js';
 import { checkThreadPermission } from '../fetchers/thread-permission-fetchers.js';
 import {
   fetchMedia,
   fetchMediaFromMediaMessageContent,
 } from '../fetchers/upload-fetchers.js';
 import { fetchKnownUserInfos } from '../fetchers/user-fetchers.js';
 import type { Viewer } from '../session/viewer.js';
 import {
   assignMedia,
   assignMessageContainerToMedia,
 } from '../updaters/upload-updaters.js';
 import { validateInput } from '../utils/validation-utils.js';
 
 const sendTextMessageRequestInputValidator = tShape({
   threadID: t.String,
   localID: t.maybe(t.String),
   text: t.String,
 });
 async function textMessageCreationResponder(
   viewer: Viewer,
   input: any,
 ): Promise<SendMessageResponse> {
   const request: SendTextMessageRequest = input;
   await validateInput(viewer, sendTextMessageRequestInputValidator, request);
 
   const { threadID, localID, text: rawText } = request;
   const text = trimMessage(rawText);
   if (!text) {
     throw new ServerError('invalid_parameters');
   }
 
   const hasPermission = await checkThreadPermission(
     viewer,
     threadID,
     threadPermissions.VOICED,
   );
   if (!hasPermission) {
     throw new ServerError('invalid_parameters');
   }
 
-  const messageData: TextMessageData = {
+  let messageData: TextMessageData = {
     type: messageTypes.TEXT,
     threadID,
     creatorID: viewer.id,
     time: Date.now(),
     text,
   };
   if (localID) {
-    messageData.localID = localID;
+    messageData = { ...messageData, localID };
   }
   const rawMessageInfos = await createMessages(viewer, [messageData]);
 
   return { newMessageInfo: rawMessageInfos[0] };
 }
 
 const fetchMessageInfosRequestInputValidator = tShape({
   cursors: t.dict(t.String, t.maybe(t.String)),
   numberPerThread: t.maybe(t.Number),
 });
 async function messageFetchResponder(
   viewer: Viewer,
   input: any,
 ): Promise<FetchMessageInfosResponse> {
   const request: FetchMessageInfosRequest = input;
   await validateInput(viewer, fetchMessageInfosRequestInputValidator, request);
   const response = await fetchMessageInfos(
     viewer,
     { threadCursors: request.cursors },
     request.numberPerThread ? request.numberPerThread : defaultNumberPerThread,
   );
   return { ...response, userInfos: {} };
 }
 
 const sendMultimediaMessageRequestInputValidator = t.union([
   tShape({
     threadID: t.String,
     localID: t.String,
     mediaIDs: t.list(t.String),
   }),
   tShape({
     threadID: t.String,
     localID: t.String,
     mediaMessageContents: t.list(tMediaMessageMedia),
   }),
 ]);
 async function multimediaMessageCreationResponder(
   viewer: Viewer,
   input: any,
 ): Promise<SendMessageResponse> {
   const request: SendMultimediaMessageRequest = input;
   await validateInput(
     viewer,
     sendMultimediaMessageRequestInputValidator,
     request,
   );
 
   if (
     (request.mediaIDs && request.mediaIDs.length === 0) ||
     (request.mediaMessageContents && request.mediaMessageContents.length === 0)
   ) {
     throw new ServerError('invalid_parameters');
   }
 
   const { threadID, localID } = request;
   const hasPermission = await checkThreadPermission(
     viewer,
     threadID,
     threadPermissions.VOICED,
   );
   if (!hasPermission) {
     throw new ServerError('invalid_parameters');
   }
 
   const existingMessageInfoPromise = fetchMessageInfoForLocalID(
     viewer,
     localID,
   );
   const mediaPromise: Promise<$ReadOnlyArray<Media>> = request.mediaIDs
     ? fetchMedia(viewer, request.mediaIDs)
     : fetchMediaFromMediaMessageContent(viewer, request.mediaMessageContents);
 
   const [existingMessageInfo, media] = await Promise.all([
     existingMessageInfoPromise,
     mediaPromise,
   ]);
 
   if (media.length === 0 && !existingMessageInfo) {
     throw new ServerError('invalid_parameters');
   }
 
   const messageData = createMediaMessageData({
     localID,
     threadID,
     creatorID: viewer.id,
     media,
   });
   const [newMessageInfo] = await createMessages(viewer, [messageData]);
   const { id } = newMessageInfo;
   invariant(
     id !== null && id !== undefined,
     'serverID should be set in createMessages result',
   );
 
   if (request.mediaIDs) {
     await assignMedia(viewer, request.mediaIDs, id);
   } else {
     await assignMessageContainerToMedia(
       viewer,
       request.mediaMessageContents,
       id,
     );
   }
 
   return { newMessageInfo };
 }
 
 const sendReactionMessageRequestInputValidator = tShape({
   threadID: t.String,
   localID: t.maybe(t.String),
   targetMessageID: t.String,
   reaction: tRegex(onlyOneEmojiRegex),
   action: t.enums.of(['add_reaction', 'remove_reaction']),
 });
 async function reactionMessageCreationResponder(
   viewer: Viewer,
   input: any,
 ): Promise<SendMessageResponse> {
   const request: SendReactionMessageRequest = input;
   await validateInput(viewer, sendReactionMessageRequestInputValidator, input);
 
   const { threadID, localID, targetMessageID, reaction, action } = request;
 
   if (!targetMessageID || !reaction) {
     throw new ServerError('invalid_parameters');
   }
 
   const targetMessageInfo = await fetchMessageInfoByID(viewer, targetMessageID);
 
   if (!targetMessageInfo || !targetMessageInfo.id) {
     throw new ServerError('invalid_parameters');
   }
 
   const [serverThreadInfos, hasPermission, targetMessageUserInfos] =
     await Promise.all([
       fetchServerThreadInfos(SQL`t.id = ${threadID}`),
       checkThreadPermission(viewer, threadID, threadPermissions.VOICED),
       fetchKnownUserInfos(viewer, [targetMessageInfo.creatorID]),
     ]);
 
   const targetMessageThreadInfo = serverThreadInfos.threadInfos[threadID];
   if (targetMessageThreadInfo.sourceMessageID === targetMessageID) {
     throw new ServerError('invalid_parameters');
   }
 
   const targetMessageCreator =
     targetMessageUserInfos[targetMessageInfo.creatorID];
 
   const targetMessageCreatorRelationship =
     targetMessageCreator?.relationshipStatus;
 
   const creatorRelationshipHasBlock =
     targetMessageCreatorRelationship &&
     relationshipBlockedInEitherDirection(targetMessageCreatorRelationship);
 
   if (!hasPermission || creatorRelationshipHasBlock) {
     throw new ServerError('invalid_parameters');
   }
 
   let messageData: ReactionMessageData = {
     type: messageTypes.REACTION,
     threadID,
     creatorID: viewer.id,
     time: Date.now(),
     targetMessageID,
     reaction,
     action,
   };
   if (localID) {
     messageData = { ...messageData, localID };
   }
 
   const rawMessageInfos = await createMessages(viewer, [messageData]);
 
   return { newMessageInfo: rawMessageInfos[0] };
 }
 
 export {
   textMessageCreationResponder,
   messageFetchResponder,
   multimediaMessageCreationResponder,
   reactionMessageCreationResponder,
 };
diff --git a/lib/shared/message-utils.js b/lib/shared/message-utils.js
index a1ac3457f..97f168801 100644
--- a/lib/shared/message-utils.js
+++ b/lib/shared/message-utils.js
@@ -1,554 +1,557 @@
 // @flow
 
 import invariant from 'invariant';
 import _maxBy from 'lodash/fp/maxBy.js';
 import _orderBy from 'lodash/fp/orderBy.js';
 import * as React from 'react';
 
 import { codeBlockRegex, type ParserRules } from './markdown.js';
 import { messageSpecs } from './messages/message-specs.js';
 import { threadIsGroupChat } from './thread-utils.js';
 import { useStringForUser } from '../hooks/ens-cache.js';
 import { userIDsToRelativeUserInfos } from '../selectors/user-selectors.js';
 import type { PlatformDetails } from '../types/device-types.js';
 import type { Media } from '../types/media-types.js';
 import {
   type MessageInfo,
   type RawMessageInfo,
   type RobotextMessageInfo,
   type RawMultimediaMessageInfo,
   type MessageData,
   type MessageTruncationStatus,
   type MultimediaMessageData,
   type MessageStore,
   type ComposableMessageInfo,
   messageTypes,
   messageTruncationStatus,
   type RawComposableMessageInfo,
   type ThreadMessageInfo,
 } from '../types/message-types.js';
 import type { ImagesMessageData } from '../types/messages/images.js';
 import type { MediaMessageData } from '../types/messages/media.js';
 import type {
   RawReactionMessageInfo,
   ReactionMessageInfo,
 } from '../types/messages/reaction.js';
 import { type ThreadInfo } from '../types/thread-types.js';
 import type { UserInfos } from '../types/user-types.js';
 import {
   type EntityText,
   useEntityTextAsString,
 } from '../utils/entity-text.js';
 
 const localIDPrefix = 'local';
 
 // Prefers localID
 function messageKey(messageInfo: MessageInfo | RawMessageInfo): string {
   if (messageInfo.localID) {
     return messageInfo.localID;
   }
   invariant(messageInfo.id, 'localID should exist if ID does not');
   return messageInfo.id;
 }
 
 // Prefers serverID
 function messageID(messageInfo: MessageInfo | RawMessageInfo): string {
   if (messageInfo.id) {
     return messageInfo.id;
   }
   invariant(messageInfo.localID, 'localID should exist if ID does not');
   return messageInfo.localID;
 }
 
 function robotextForMessageInfo(
   messageInfo: RobotextMessageInfo,
   threadInfo: ?ThreadInfo,
 ): EntityText {
   const messageSpec = messageSpecs[messageInfo.type];
   invariant(
     messageSpec.robotext,
     `we're not aware of messageType ${messageInfo.type}`,
   );
   return messageSpec.robotext(messageInfo, { threadInfo });
 }
 
 function createMessageInfo(
   rawMessageInfo: RawMessageInfo,
   viewerID: ?string,
   userInfos: UserInfos,
   threadInfos: { +[id: string]: ThreadInfo },
 ): ?MessageInfo {
   const creatorInfo = userInfos[rawMessageInfo.creatorID];
   const creator = {
     id: rawMessageInfo.creatorID,
     username: creatorInfo ? creatorInfo.username : 'anonymous',
     isViewer: rawMessageInfo.creatorID === viewerID,
   };
 
   const createRelativeUserInfos = (userIDs: $ReadOnlyArray<string>) =>
     userIDsToRelativeUserInfos(userIDs, viewerID, userInfos);
   const createMessageInfoFromRaw = (rawInfo: RawMessageInfo) =>
     createMessageInfo(rawInfo, viewerID, userInfos, threadInfos);
 
   const messageSpec = messageSpecs[rawMessageInfo.type];
 
   return messageSpec.createMessageInfo(rawMessageInfo, creator, {
     threadInfos,
     createMessageInfoFromRaw,
     createRelativeUserInfos,
   });
 }
 
 type LengthResult = {
   +local: number,
   +realized: number,
 };
 function findMessageIDMaxLengths(
   messageIDs: $ReadOnlyArray<?string>,
 ): LengthResult {
   const result = {
     local: 0,
     realized: 0,
   };
   for (const id of messageIDs) {
     if (!id) {
       continue;
     }
     if (id.startsWith(localIDPrefix)) {
       result.local = Math.max(result.local, id.length - localIDPrefix.length);
     } else {
       result.realized = Math.max(result.realized, id.length);
     }
   }
   return result;
 }
 
 function extendMessageID(id: ?string, lengths: LengthResult): ?string {
   if (!id) {
     return id;
   }
   if (id.startsWith(localIDPrefix)) {
     const zeroPaddedID = id
       .substr(localIDPrefix.length)
       .padStart(lengths.local, '0');
     return `${localIDPrefix}${zeroPaddedID}`;
   }
   return id.padStart(lengths.realized, '0');
 }
 
 function sortMessageInfoList<T: MessageInfo | RawMessageInfo>(
   messageInfos: $ReadOnlyArray<T>,
 ): T[] {
   const lengths = findMessageIDMaxLengths(
     messageInfos.map(message => message?.id),
   );
   return _orderBy([
     'time',
     (message: T) => extendMessageID(message?.id, lengths),
   ])(['desc', 'desc'])(messageInfos);
 }
 
 const sortMessageIDs: (messages: { +[id: string]: RawMessageInfo }) => (
   messageIDs: $ReadOnlyArray<string>,
 ) => string[] = messages => messageIDs => {
   const lengths = findMessageIDMaxLengths(messageIDs);
   return _orderBy([
     (id: string) => messages[id].time,
     (id: string) => extendMessageID(id, lengths),
   ])(['desc', 'desc'])(messageIDs);
 };
 
 function rawMessageInfoFromMessageData(
   messageData: MessageData,
   id: ?string,
 ): RawMessageInfo {
   const messageSpec = messageSpecs[messageData.type];
   invariant(
     messageSpec.rawMessageInfoFromMessageData,
     `we're not aware of messageType ${messageData.type}`,
   );
   return messageSpec.rawMessageInfoFromMessageData(messageData, id);
 }
 
 function mostRecentMessageTimestamp(
   messageInfos: $ReadOnlyArray<RawMessageInfo>,
   previousTimestamp: number,
 ): number {
   if (messageInfos.length === 0) {
     return previousTimestamp;
   }
   return _maxBy('time')(messageInfos).time;
 }
 
 function usersInMessageInfos(
   messageInfos: $ReadOnlyArray<MessageInfo | RawMessageInfo>,
 ): string[] {
   const userIDs = new Set();
   for (const messageInfo of messageInfos) {
     if (messageInfo.creatorID) {
       userIDs.add(messageInfo.creatorID);
     } else if (messageInfo.creator) {
       userIDs.add(messageInfo.creator.id);
     }
   }
   return [...userIDs];
 }
 
 function combineTruncationStatuses(
   first: MessageTruncationStatus,
   second: ?MessageTruncationStatus,
 ): MessageTruncationStatus {
   if (
     first === messageTruncationStatus.EXHAUSTIVE ||
     second === messageTruncationStatus.EXHAUSTIVE
   ) {
     return messageTruncationStatus.EXHAUSTIVE;
   } else if (
     first === messageTruncationStatus.UNCHANGED &&
     second !== null &&
     second !== undefined
   ) {
     return second;
   } else {
     return first;
   }
 }
 
 function shimUnsupportedRawMessageInfos(
   rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   platformDetails: ?PlatformDetails,
 ): RawMessageInfo[] {
   if (platformDetails && platformDetails.platform === 'web') {
     return [...rawMessageInfos];
   }
   return rawMessageInfos.map(rawMessageInfo => {
     const { shimUnsupportedMessageInfo } = messageSpecs[rawMessageInfo.type];
     if (shimUnsupportedMessageInfo) {
       return shimUnsupportedMessageInfo(rawMessageInfo, platformDetails);
     }
     return rawMessageInfo;
   });
 }
 
 type MediaMessageDataCreationInput = $ReadOnly<{
   threadID: string,
   creatorID: string,
   media: $ReadOnlyArray<Media>,
   localID?: ?string,
   time?: ?number,
   ...
 }>;
 function createMediaMessageData(
   input: MediaMessageDataCreationInput,
 ): MultimediaMessageData {
   let allMediaArePhotos = true;
   const photoMedia = [];
   for (const singleMedia of input.media) {
     if (singleMedia.type === 'video') {
       allMediaArePhotos = false;
       break;
     } else {
       photoMedia.push(singleMedia);
     }
   }
 
   const { localID, threadID, creatorID } = input;
   const time = input.time ? input.time : Date.now();
   let messageData;
   if (allMediaArePhotos) {
     messageData = ({
       type: messageTypes.IMAGES,
       threadID,
       creatorID,
       time,
       media: photoMedia,
     }: ImagesMessageData);
+    if (localID) {
+      messageData = { ...messageData, localID };
+    }
   } else {
     messageData = ({
       type: messageTypes.MULTIMEDIA,
       threadID,
       creatorID,
       time,
       media: input.media,
     }: MediaMessageData);
-  }
-  if (localID) {
-    messageData.localID = localID;
+    if (localID) {
+      messageData = { ...messageData, localID };
+    }
   }
   return messageData;
 }
 
 type MediaMessageInfoCreationInput = $ReadOnly<{
   ...$Exact<MediaMessageDataCreationInput>,
   id?: ?string,
 }>;
 function createMediaMessageInfo(
   input: MediaMessageInfoCreationInput,
 ): RawMultimediaMessageInfo {
   const messageData = createMediaMessageData(input);
   const createRawMessageInfo =
     messageSpecs[messageData.type].rawMessageInfoFromMessageData;
   invariant(
     createRawMessageInfo,
     'multimedia message spec should have rawMessageInfoFromMessageData',
   );
   const result = createRawMessageInfo(messageData, input.id);
   invariant(
     result.type === messageTypes.MULTIMEDIA ||
       result.type === messageTypes.IMAGES,
     `media messageSpec returned MessageType ${result.type}`,
   );
   return result;
 }
 
 function stripLocalID(
   rawMessageInfo: RawComposableMessageInfo | RawReactionMessageInfo,
 ) {
   const { localID, ...rest } = rawMessageInfo;
   return rest;
 }
 
 function stripLocalIDs(
   input: $ReadOnlyArray<RawMessageInfo>,
 ): RawMessageInfo[] {
   const output = [];
   for (const rawMessageInfo of input) {
     if (rawMessageInfo.localID) {
       invariant(
         rawMessageInfo.id,
         'serverID should be set if localID is being stripped',
       );
       output.push(stripLocalID(rawMessageInfo));
     } else {
       output.push(rawMessageInfo);
     }
   }
   return output;
 }
 
 // Normally we call trim() to remove whitespace at the beginning and end of each
 // message. However, our Markdown parser supports a "codeBlock" format where the
 // user can indent each line to indicate a code block. If we match the
 // corresponding RegEx, we'll only trim whitespace off the end.
 function trimMessage(message: string): string {
   message = message.replace(/^\n*/, '');
   return codeBlockRegex.exec(message) ? message.trimEnd() : message.trim();
 }
 
 function createMessageQuote(message: string): string {
   // add `>` to each line to include empty lines in the quote
   return message.replace(/^/gm, '> ');
 }
 
 function createMessageReply(message: string): string {
   return createMessageQuote(message) + '\n\n';
 }
 
 function getMostRecentNonLocalMessageID(
   threadID: string,
   messageStore: MessageStore,
 ): ?string {
   const thread = messageStore.threads[threadID];
   return thread?.messageIDs.find(id => !id.startsWith(localIDPrefix));
 }
 
 function getMessageTitle(
   messageInfo:
     | ComposableMessageInfo
     | RobotextMessageInfo
     | ReactionMessageInfo,
   threadInfo: ThreadInfo,
   markdownRules: ParserRules,
 ): EntityText {
   const { messageTitle } = messageSpecs[messageInfo.type];
   if (messageTitle) {
     return messageTitle({ messageInfo, threadInfo, markdownRules });
   }
 
   invariant(
     messageInfo.type !== messageTypes.TEXT &&
       messageInfo.type !== messageTypes.IMAGES &&
       messageInfo.type !== messageTypes.MULTIMEDIA &&
       messageInfo.type !== messageTypes.REACTION,
     'messageTitle can only be auto-generated for RobotextMessageInfo',
   );
   return robotextForMessageInfo(messageInfo, threadInfo);
 }
 
 function mergeThreadMessageInfos(
   first: ThreadMessageInfo,
   second: ThreadMessageInfo,
   messages: { +[id: string]: RawMessageInfo },
 ): ThreadMessageInfo {
   let firstPointer = 0;
   let secondPointer = 0;
   const mergedMessageIDs = [];
   let firstCandidate = first.messageIDs[firstPointer];
   let secondCandidate = second.messageIDs[secondPointer];
   while (firstCandidate !== undefined || secondCandidate !== undefined) {
     if (firstCandidate === undefined) {
       mergedMessageIDs.push(secondCandidate);
       secondPointer++;
     } else if (secondCandidate === undefined) {
       mergedMessageIDs.push(firstCandidate);
       firstPointer++;
     } else if (firstCandidate === secondCandidate) {
       mergedMessageIDs.push(firstCandidate);
       firstPointer++;
       secondPointer++;
     } else {
       const firstMessage = messages[firstCandidate];
       const secondMessage = messages[secondCandidate];
       invariant(
         firstMessage && secondMessage,
         'message in messageIDs not present in MessageStore',
       );
       if (
         (firstMessage.id &&
           secondMessage.id &&
           firstMessage.id === secondMessage.id) ||
         (firstMessage.localID &&
           secondMessage.localID &&
           firstMessage.localID === secondMessage.localID)
       ) {
         mergedMessageIDs.push(firstCandidate);
         firstPointer++;
         secondPointer++;
       } else if (firstMessage.time < secondMessage.time) {
         mergedMessageIDs.push(secondCandidate);
         secondPointer++;
       } else {
         mergedMessageIDs.push(firstCandidate);
         firstPointer++;
       }
     }
     firstCandidate = first.messageIDs[firstPointer];
     secondCandidate = second.messageIDs[secondPointer];
   }
   return {
     messageIDs: mergedMessageIDs,
     startReached: first.startReached && second.startReached,
     lastNavigatedTo: Math.max(first.lastNavigatedTo, second.lastNavigatedTo),
     lastPruned: Math.max(first.lastPruned, second.lastPruned),
   };
 }
 
 type MessagePreviewPart = {
   +text: string,
   // unread has highest contrast, followed by primary, followed by secondary
   +style: 'unread' | 'primary' | 'secondary',
 };
 type MessagePreviewResult = {
   +message: MessagePreviewPart,
   +username: ?MessagePreviewPart,
 };
 function useMessagePreview(
   originalMessageInfo: ?MessageInfo,
   threadInfo: ThreadInfo,
   markdownRules: ParserRules,
 ): ?MessagePreviewResult {
   let messageInfo;
   if (
     originalMessageInfo &&
     originalMessageInfo.type === messageTypes.SIDEBAR_SOURCE
   ) {
     messageInfo = originalMessageInfo.sourceMessage;
   } else {
     messageInfo = originalMessageInfo;
   }
 
   const hasUsername =
     threadIsGroupChat(threadInfo) ||
     threadInfo.name !== '' ||
     messageInfo?.creator.isViewer;
   const shouldDisplayUser =
     messageInfo?.type === messageTypes.TEXT && hasUsername;
 
   const stringForUser = useStringForUser(
     shouldDisplayUser ? messageInfo?.creator : null,
   );
 
   const { unread } = threadInfo.currentUser;
   const username = React.useMemo(() => {
     if (!shouldDisplayUser) {
       return null;
     }
     invariant(
       stringForUser,
       'useStringForUser should only return falsey if pass null or undefined',
     );
     return {
       text: stringForUser,
       style: unread ? 'unread' : 'secondary',
     };
   }, [shouldDisplayUser, stringForUser, unread]);
 
   const messageTitleEntityText = React.useMemo(() => {
     if (!messageInfo) {
       return messageInfo;
     }
     return getMessageTitle(messageInfo, threadInfo, markdownRules);
   }, [messageInfo, threadInfo, markdownRules]);
 
   const threadID = threadInfo.id;
   const entityTextToStringParams = React.useMemo(
     () => ({
       threadID,
     }),
     [threadID],
   );
   const messageTitle = useEntityTextAsString(
     messageTitleEntityText,
     entityTextToStringParams,
   );
 
   const isTextMessage = messageInfo?.type === messageTypes.TEXT;
   const message = React.useMemo(() => {
     if (messageTitle === null || messageTitle === undefined) {
       return messageTitle;
     }
 
     let style;
     if (unread) {
       style = 'unread';
     } else if (isTextMessage) {
       style = 'primary';
     } else {
       style = 'secondary';
     }
 
     return { text: messageTitle, style };
   }, [messageTitle, unread, isTextMessage]);
 
   return React.useMemo(() => {
     if (!message) {
       return message;
     }
     return { message, username };
   }, [message, username]);
 }
 
 export {
   localIDPrefix,
   messageKey,
   messageID,
   robotextForMessageInfo,
   createMessageInfo,
   sortMessageInfoList,
   sortMessageIDs,
   rawMessageInfoFromMessageData,
   mostRecentMessageTimestamp,
   usersInMessageInfos,
   combineTruncationStatuses,
   shimUnsupportedRawMessageInfos,
   createMediaMessageData,
   createMediaMessageInfo,
   stripLocalIDs,
   trimMessage,
   createMessageQuote,
   createMessageReply,
   getMostRecentNonLocalMessageID,
   getMessageTitle,
   mergeThreadMessageInfos,
   useMessagePreview,
 };
diff --git a/lib/shared/messages/multimedia-message-spec.js b/lib/shared/messages/multimedia-message-spec.js
index 15cd35967..fc04237ac 100644
--- a/lib/shared/messages/multimedia-message-spec.js
+++ b/lib/shared/messages/multimedia-message-spec.js
@@ -1,371 +1,377 @@
 // @flow
 
 import invariant from 'invariant';
 
 import {
   pushTypes,
   type MessageSpec,
   type MessageTitleParam,
   type RawMessageInfoFromServerDBRowParams,
 } from './message-spec.js';
 import { joinResult } from './utils.js';
 import {
   contentStringForMediaArray,
   multimediaMessagePreview,
   shimUploadURI,
 } from '../../media/media-utils.js';
 import type { PlatformDetails } from '../../types/device-types.js';
 import type { Media, Video, Image } from '../../types/media-types.js';
 import {
   messageTypes,
   assertMessageType,
   isMediaMessageType,
 } from '../../types/message-types.js';
 import type {
   MessageInfo,
   RawMessageInfo,
   RawMultimediaMessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types.js';
 import type {
   ImagesMessageData,
   RawImagesMessageInfo,
   ImagesMessageInfo,
 } from '../../types/messages/images.js';
 import type {
   MediaMessageData,
   MediaMessageInfo,
   RawMediaMessageInfo,
 } from '../../types/messages/media.js';
 import { getMediaMessageServerDBContentsFromMedia } from '../../types/messages/media.js';
 import type { RawUnsupportedMessageInfo } from '../../types/messages/unsupported.js';
 import type { NotifTexts } from '../../types/notif-types.js';
 import type { ThreadInfo } from '../../types/thread-types.js';
 import type { RelativeUserInfo } from '../../types/user-types.js';
 import { ET } from '../../utils/entity-text.js';
 import {
   translateClientDBMediaInfosToMedia,
   translateClientDBMediaInfoToImage,
 } from '../../utils/message-ops-utils.js';
 import { createMediaMessageInfo } from '../message-utils.js';
 import { threadIsGroupChat } from '../thread-utils.js';
 import { hasMinCodeVersion } from '../version-utils.js';
 
 export const multimediaMessageSpec: MessageSpec<
   MediaMessageData | ImagesMessageData,
   RawMediaMessageInfo | RawImagesMessageInfo,
   MediaMessageInfo | ImagesMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data:
       | MediaMessageData
       | ImagesMessageData
       | RawMediaMessageInfo
       | RawImagesMessageInfo,
   ): string {
     if (data.type === messageTypes.MULTIMEDIA) {
       return JSON.stringify(
         getMediaMessageServerDBContentsFromMedia(data.media),
       );
     }
     const mediaIDs = data.media.map(media => parseInt(media.id, 10));
     return JSON.stringify(mediaIDs);
   },
 
   messageContentForClientDB(
     data: RawMediaMessageInfo | RawImagesMessageInfo,
   ): string {
     return this.messageContentForServerDB(data);
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawImagesMessageInfo | RawMediaMessageInfo {
     const messageType = assertMessageType(parseInt(clientDBMessageInfo.type));
     invariant(
       isMediaMessageType(messageType),
       'message must be of type IMAGES or MULTIMEDIA',
     );
     invariant(
       clientDBMessageInfo.media_infos !== null &&
         clientDBMessageInfo.media_infos !== undefined,
       `media_infos must be defined`,
     );
 
-    const rawMessageInfo: RawImagesMessageInfo | RawMediaMessageInfo =
+    let rawMessageInfo: RawImagesMessageInfo | RawMediaMessageInfo =
       messageType === messageTypes.IMAGES
         ? {
             type: messageTypes.IMAGES,
             threadID: clientDBMessageInfo.thread,
             creatorID: clientDBMessageInfo.user,
             time: parseInt(clientDBMessageInfo.time),
             media:
               clientDBMessageInfo.media_infos?.map(
                 translateClientDBMediaInfoToImage,
               ) ?? [],
           }
         : {
             type: messageTypes.MULTIMEDIA,
             threadID: clientDBMessageInfo.thread,
             creatorID: clientDBMessageInfo.user,
             time: parseInt(clientDBMessageInfo.time),
             media: translateClientDBMediaInfosToMedia(clientDBMessageInfo),
           };
 
     if (clientDBMessageInfo.local_id) {
-      rawMessageInfo.localID = clientDBMessageInfo.local_id;
+      rawMessageInfo = {
+        ...rawMessageInfo,
+        localID: clientDBMessageInfo.local_id,
+      };
     }
     if (clientDBMessageInfo.id !== clientDBMessageInfo.local_id) {
-      rawMessageInfo.id = clientDBMessageInfo.id;
+      rawMessageInfo = {
+        ...rawMessageInfo,
+        id: clientDBMessageInfo.id,
+      };
     }
     return rawMessageInfo;
   },
 
   messageTitle({
     messageInfo,
   }: MessageTitleParam<MediaMessageInfo | ImagesMessageInfo>) {
     const creator = ET.user({ userInfo: messageInfo.creator });
     const preview = multimediaMessagePreview(messageInfo);
     return ET`${creator} ${preview}`;
   },
 
   rawMessageInfoFromServerDBRow(
     row: Object,
     params: RawMessageInfoFromServerDBRowParams,
   ): RawMediaMessageInfo | RawImagesMessageInfo {
     const { localID, media } = params;
     invariant(media, 'Media should be provided');
     return createMediaMessageInfo({
       threadID: row.threadID.toString(),
       creatorID: row.creatorID.toString(),
       media,
       id: row.id.toString(),
       localID,
       time: row.time,
     });
   },
 
   createMessageInfo(
     rawMessageInfo: RawMediaMessageInfo | RawImagesMessageInfo,
     creator: RelativeUserInfo,
   ): ?(MediaMessageInfo | ImagesMessageInfo) {
     if (rawMessageInfo.type === messageTypes.IMAGES) {
-      const messageInfo: ImagesMessageInfo = {
+      let messageInfo: ImagesMessageInfo = {
         type: messageTypes.IMAGES,
         threadID: rawMessageInfo.threadID,
         creator,
         time: rawMessageInfo.time,
         media: rawMessageInfo.media,
       };
       if (rawMessageInfo.id) {
-        messageInfo.id = rawMessageInfo.id;
+        messageInfo = { ...messageInfo, id: rawMessageInfo.id };
       }
       if (rawMessageInfo.localID) {
-        messageInfo.localID = rawMessageInfo.localID;
+        messageInfo = { ...messageInfo, localID: rawMessageInfo.localID };
       }
       return messageInfo;
     } else if (rawMessageInfo.type === messageTypes.MULTIMEDIA) {
-      const messageInfo: MediaMessageInfo = {
+      let messageInfo: MediaMessageInfo = {
         type: messageTypes.MULTIMEDIA,
         threadID: rawMessageInfo.threadID,
         creator,
         time: rawMessageInfo.time,
         media: rawMessageInfo.media,
       };
       if (rawMessageInfo.id) {
-        messageInfo.id = rawMessageInfo.id;
+        messageInfo = { ...messageInfo, id: rawMessageInfo.id };
       }
       if (rawMessageInfo.localID) {
-        messageInfo.localID = rawMessageInfo.localID;
+        messageInfo = { ...messageInfo, localID: rawMessageInfo.localID };
       }
       return messageInfo;
     }
   },
 
   rawMessageInfoFromMessageData(
     messageData: MediaMessageData | ImagesMessageData,
     id: ?string,
   ): RawMediaMessageInfo | RawImagesMessageInfo {
     if (messageData.type === messageTypes.IMAGES && id) {
       return ({ ...messageData, id }: RawImagesMessageInfo);
     } else if (messageData.type === messageTypes.IMAGES) {
       return ({ ...messageData }: RawImagesMessageInfo);
     } else if (id) {
       return ({ ...messageData, id }: RawMediaMessageInfo);
     } else {
       return ({ ...messageData }: RawMediaMessageInfo);
     }
   },
 
   shimUnsupportedMessageInfo(
     rawMessageInfo: RawMediaMessageInfo | RawImagesMessageInfo,
     platformDetails: ?PlatformDetails,
   ): RawMediaMessageInfo | RawImagesMessageInfo | RawUnsupportedMessageInfo {
     if (rawMessageInfo.type === messageTypes.IMAGES) {
       const shimmedRawMessageInfo = shimMediaMessageInfo(
         rawMessageInfo,
         platformDetails,
       );
       return shimmedRawMessageInfo;
     } else {
       const shimmedRawMessageInfo = shimMediaMessageInfo(
         rawMessageInfo,
         platformDetails,
       );
       // TODO figure out first native codeVersion supporting video playback
       if (hasMinCodeVersion(platformDetails, 158)) {
         return shimmedRawMessageInfo;
       }
       const { id } = shimmedRawMessageInfo;
       invariant(id !== null && id !== undefined, 'id should be set on server');
       return {
         type: messageTypes.UNSUPPORTED,
         id,
         threadID: shimmedRawMessageInfo.threadID,
         creatorID: shimmedRawMessageInfo.creatorID,
         time: shimmedRawMessageInfo.time,
         robotext: multimediaMessagePreview(shimmedRawMessageInfo),
         unsupportedMessageInfo: shimmedRawMessageInfo,
       };
     }
   },
 
   unshimMessageInfo(
     unwrapped: RawMediaMessageInfo | RawImagesMessageInfo,
     messageInfo: RawMessageInfo,
   ): ?RawMessageInfo {
     if (unwrapped.type === messageTypes.IMAGES) {
       return {
         ...unwrapped,
         media: unwrapped.media.map(media => {
           if (media.dimensions) {
             return media;
           }
           const dimensions = preDimensionUploads[media.id];
           invariant(
             dimensions,
             'only four photos were uploaded before dimensions were calculated, ' +
               `and ${media.id} was not one of them`,
           );
           return { ...media, dimensions };
         }),
       };
     } else if (unwrapped.type === messageTypes.MULTIMEDIA) {
       for (const { type } of unwrapped.media) {
         if (type !== 'photo' && type !== 'video') {
           return messageInfo;
         }
       }
     }
     return undefined;
   },
 
   async notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
   ): Promise<NotifTexts> {
     const media = [];
     for (const messageInfo of messageInfos) {
       invariant(
         messageInfo.type === messageTypes.IMAGES ||
           messageInfo.type === messageTypes.MULTIMEDIA,
         'messageInfo should be multimedia type!',
       );
       for (const singleMedia of messageInfo.media) {
         media.push(singleMedia);
       }
     }
     const contentString = contentStringForMediaArray(media);
     const creator = ET.user({ userInfo: messageInfos[0].creator });
 
     let body, merged;
     if (!threadInfo.name && !threadIsGroupChat(threadInfo)) {
       body = `sent you ${contentString}`;
       merged = body;
     } else {
       body = `sent ${contentString}`;
       const thread = ET.thread({ display: 'shortName', threadInfo });
       merged = ET`${body} to ${thread}`;
     }
     merged = ET`${creator} ${merged}`;
 
     return {
       merged,
       body,
       title: threadInfo.uiName,
       prefix: ET`${creator}`,
     };
   },
 
   notificationCollapseKey(
     rawMessageInfo: RawMediaMessageInfo | RawImagesMessageInfo,
   ): string {
     // We use the legacy constant here to collapse both types into one
     return joinResult(
       messageTypes.IMAGES,
       rawMessageInfo.threadID,
       rawMessageInfo.creatorID,
     );
   },
 
   generatesNotifs: async () => pushTypes.NOTIF,
 
   includedInRepliesCount: true,
 });
 
 function shimMediaMessageInfo(
   rawMessageInfo: RawMultimediaMessageInfo,
   platformDetails: ?PlatformDetails,
 ): RawMultimediaMessageInfo {
   if (rawMessageInfo.type === messageTypes.IMAGES) {
     let uriChanged = false;
     const newMedia: Image[] = [];
     for (const singleMedia of rawMessageInfo.media) {
       const shimmedURI = shimUploadURI(singleMedia.uri, platformDetails);
       if (shimmedURI === singleMedia.uri) {
         newMedia.push(singleMedia);
       } else {
         newMedia.push(({ ...singleMedia, uri: shimmedURI }: Image));
         uriChanged = true;
       }
     }
     if (!uriChanged) {
       return rawMessageInfo;
     }
     return ({
       ...rawMessageInfo,
       media: newMedia,
     }: RawImagesMessageInfo);
   } else {
     let uriChanged = false;
     const newMedia: Media[] = [];
     for (const singleMedia of rawMessageInfo.media) {
       const shimmedURI = shimUploadURI(singleMedia.uri, platformDetails);
       if (shimmedURI === singleMedia.uri) {
         newMedia.push(singleMedia);
       } else if (singleMedia.type === 'photo') {
         newMedia.push(({ ...singleMedia, uri: shimmedURI }: Image));
         uriChanged = true;
       } else {
         newMedia.push(({ ...singleMedia, uri: shimmedURI }: Video));
         uriChanged = true;
       }
     }
     if (!uriChanged) {
       return rawMessageInfo;
     }
     return ({
       ...rawMessageInfo,
       media: newMedia,
     }: RawMediaMessageInfo);
   }
 }
 
 // Four photos were uploaded before dimensions were calculated server-side,
 // and delivered to clients without dimensions in the MultimediaMessageInfo.
 const preDimensionUploads = {
   '156642': { width: 1440, height: 1080 },
   '156649': { width: 720, height: 803 },
   '156794': { width: 720, height: 803 },
   '156877': { width: 574, height: 454 },
 };
diff --git a/lib/shared/messages/text-message-spec.js b/lib/shared/messages/text-message-spec.js
index a8e950300..4e4f02d2d 100644
--- a/lib/shared/messages/text-message-spec.js
+++ b/lib/shared/messages/text-message-spec.js
@@ -1,201 +1,207 @@
 // @flow
 
 import invariant from 'invariant';
 import * as SimpleMarkdown from 'simple-markdown';
 
 import {
   pushTypes,
   type MessageSpec,
   type RawMessageInfoFromServerDBRowParams,
 } from './message-spec.js';
 import { assertSingleMessageInfo } from './utils.js';
 import { messageTypes } from '../../types/message-types.js';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types.js';
 import type {
   RawTextMessageInfo,
   TextMessageData,
   TextMessageInfo,
 } from '../../types/messages/text.js';
 import type { NotifTexts } from '../../types/notif-types.js';
 import type { ThreadInfo } from '../../types/thread-types.js';
 import type { RelativeUserInfo } from '../../types/user-types.js';
 import { ET } from '../../utils/entity-text.js';
 import {
   type ASTNode,
   type SingleASTNode,
   stripSpoilersFromNotifications,
   stripSpoilersFromMarkdownAST,
 } from '../markdown.js';
 import { threadIsGroupChat } from '../thread-utils.js';
 
 /**
  * most of the markdown leaves contain `content` field
  * (it is an array or a string) apart from lists,
  * which have `items` field (that holds an array)
  */
 const rawTextFromMarkdownAST = (node: ASTNode): string => {
   if (Array.isArray(node)) {
     return node.map(rawTextFromMarkdownAST).join('');
   }
   const { content, items } = node;
   if (content && typeof content === 'string') {
     return content;
   } else if (items) {
     return rawTextFromMarkdownAST(items);
   } else if (content) {
     return rawTextFromMarkdownAST(content);
   }
   return '';
 };
 
 const getFirstNonQuotedRawLine = (
   nodes: $ReadOnlyArray<SingleASTNode>,
 ): string => {
   let result = 'message';
   for (const node of nodes) {
     if (node.type === 'blockQuote') {
       result = 'quoted message';
     } else {
       const rawText = rawTextFromMarkdownAST(node);
       if (!rawText || !rawText.replace(/\s/g, '')) {
         // handles the case of an empty(or containing only white spaces)
         // new line that usually occurs between a quote and the rest
         // of the message(we don't want it as a title, thus continue)
         continue;
       }
       return rawText;
     }
   }
   return result;
 };
 
 export const textMessageSpec: MessageSpec<
   TextMessageData,
   RawTextMessageInfo,
   TextMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: TextMessageData | RawTextMessageInfo,
   ): string {
     return data.text;
   },
 
   messageContentForClientDB(data: RawTextMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({ messageInfo, markdownRules }) {
     const { text } = messageInfo;
     const parser = SimpleMarkdown.parserFor(markdownRules);
     const ast = stripSpoilersFromMarkdownAST(
       parser(text, { disableAutoBlockNewlines: true }),
     );
     return ET`${getFirstNonQuotedRawLine(ast).trim()}`;
   },
 
   rawMessageInfoFromServerDBRow(
     row: Object,
     params: RawMessageInfoFromServerDBRowParams,
   ): RawTextMessageInfo {
-    const rawTextMessageInfo: RawTextMessageInfo = {
+    let rawTextMessageInfo: RawTextMessageInfo = {
       type: messageTypes.TEXT,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       text: row.content,
     };
     if (params.localID) {
-      rawTextMessageInfo.localID = params.localID;
+      rawTextMessageInfo = { ...rawTextMessageInfo, localID: params.localID };
     }
     return rawTextMessageInfo;
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawTextMessageInfo {
-    const rawTextMessageInfo: RawTextMessageInfo = {
+    let rawTextMessageInfo: RawTextMessageInfo = {
       type: messageTypes.TEXT,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       text: clientDBMessageInfo.content ?? '',
     };
     if (clientDBMessageInfo.local_id) {
-      rawTextMessageInfo.localID = clientDBMessageInfo.local_id;
+      rawTextMessageInfo = {
+        ...rawTextMessageInfo,
+        localID: clientDBMessageInfo.local_id,
+      };
     }
     if (clientDBMessageInfo.id !== clientDBMessageInfo.local_id) {
-      rawTextMessageInfo.id = clientDBMessageInfo.id;
+      rawTextMessageInfo = {
+        ...rawTextMessageInfo,
+        id: clientDBMessageInfo.id,
+      };
     }
     return rawTextMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawTextMessageInfo,
     creator: RelativeUserInfo,
   ): TextMessageInfo {
-    const messageInfo: TextMessageInfo = {
+    let messageInfo: TextMessageInfo = {
       type: messageTypes.TEXT,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       text: rawMessageInfo.text,
     };
     if (rawMessageInfo.id) {
-      messageInfo.id = rawMessageInfo.id;
+      messageInfo = { ...messageInfo, id: rawMessageInfo.id };
     }
     if (rawMessageInfo.localID) {
-      messageInfo.localID = rawMessageInfo.localID;
+      messageInfo = { ...messageInfo, localID: rawMessageInfo.localID };
     }
     return messageInfo;
   },
 
   rawMessageInfoFromMessageData(
     messageData: TextMessageData,
     id: ?string,
   ): RawTextMessageInfo {
     if (id) {
       return { ...messageData, id };
     } else {
       return { ...messageData };
     }
   },
 
   async notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
   ): Promise<NotifTexts> {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.TEXT,
       'messageInfo should be messageTypes.TEXT!',
     );
     const notificationTextWithoutSpoilers = stripSpoilersFromNotifications(
       messageInfo.text,
     );
     if (!threadInfo.name && !threadIsGroupChat(threadInfo)) {
       const thread = ET.thread({ display: 'uiName', threadInfo });
       return {
         merged: ET`${thread}: ${notificationTextWithoutSpoilers}`,
         body: notificationTextWithoutSpoilers,
         title: threadInfo.uiName,
       };
     } else {
       const creator = ET.user({ userInfo: messageInfo.creator });
       const thread = ET.thread({ display: 'shortName', threadInfo });
       return {
         merged: ET`${creator} to ${thread}: ${notificationTextWithoutSpoilers}`,
         body: notificationTextWithoutSpoilers,
         title: threadInfo.uiName,
         prefix: ET`${creator}:`,
       };
     }
   },
 
   generatesNotifs: async () => pushTypes.NOTIF,
 
   includedInRepliesCount: true,
 });
diff --git a/lib/types/messages/images.js b/lib/types/messages/images.js
index af505071e..360094dcc 100644
--- a/lib/types/messages/images.js
+++ b/lib/types/messages/images.js
@@ -1,28 +1,28 @@
 // @flow
 
 import type { Image } from '../media-types.js';
 import type { RelativeUserInfo } from '../user-types.js';
 
 export type ImagesMessageData = {
-  type: 14,
-  localID?: string, // for optimistic creations. included by new clients
-  threadID: string,
-  creatorID: string,
-  time: number,
-  media: $ReadOnlyArray<Image>,
+  +type: 14,
+  +localID?: string, // for optimistic creations. included by new clients
+  +threadID: string,
+  +creatorID: string,
+  +time: number,
+  +media: $ReadOnlyArray<Image>,
 };
 
 export type RawImagesMessageInfo = {
   ...ImagesMessageData,
-  id?: string, // null if local copy without ID yet
+  +id?: string, // null if local copy without ID yet
 };
 
 export type ImagesMessageInfo = {
-  type: 14,
-  id?: string, // null if local copy without ID yet
-  localID?: string, // for optimistic creations
-  threadID: string,
-  creator: RelativeUserInfo,
-  time: number, // millisecond timestamp
-  media: $ReadOnlyArray<Image>,
+  +type: 14,
+  +id?: string, // null if local copy without ID yet
+  +localID?: string, // for optimistic creations
+  +threadID: string,
+  +creator: RelativeUserInfo,
+  +time: number, // millisecond timestamp
+  +media: $ReadOnlyArray<Image>,
 };
diff --git a/lib/types/messages/media.js b/lib/types/messages/media.js
index 1c3e86825..4b649ddcd 100644
--- a/lib/types/messages/media.js
+++ b/lib/types/messages/media.js
@@ -1,73 +1,73 @@
 // @flow
 
 import type { Media } from '../media-types.js';
 import type { RelativeUserInfo } from '../user-types.js';
 
 export type MediaMessageData = {
-  type: 15,
-  localID?: string, // for optimistic creations. included by new clients
-  threadID: string,
-  creatorID: string,
-  time: number,
-  media: $ReadOnlyArray<Media>,
+  +type: 15,
+  +localID?: string, // for optimistic creations. included by new clients
+  +threadID: string,
+  +creatorID: string,
+  +time: number,
+  +media: $ReadOnlyArray<Media>,
 };
 
 export type RawMediaMessageInfo = {
   ...MediaMessageData,
-  id?: string, // null if local copy without ID yet
+  +id?: string, // null if local copy without ID yet
 };
 
 export type MediaMessageInfo = {
-  type: 15,
-  id?: string, // null if local copy without ID yet
-  localID?: string, // for optimistic creations
-  threadID: string,
-  creator: RelativeUserInfo,
-  time: number, // millisecond timestamp
-  media: $ReadOnlyArray<Media>,
+  +type: 15,
+  +id?: string, // null if local copy without ID yet
+  +localID?: string, // for optimistic creations
+  +threadID: string,
+  +creator: RelativeUserInfo,
+  +time: number, // millisecond timestamp
+  +media: $ReadOnlyArray<Media>,
 };
 
 export type MediaMessageServerDBContent =
   | {
       +type: 'photo',
       +uploadID: string,
     }
   | {
       +type: 'video',
       +uploadID: string,
       +thumbnailUploadID: string,
     };
 
 function getUploadIDsFromMediaMessageServerDBContents(
   mediaMessageContents: $ReadOnlyArray<MediaMessageServerDBContent>,
 ): $ReadOnlyArray<string> {
   const uploadIDs: string[] = [];
   for (const mediaContent of mediaMessageContents) {
     uploadIDs.push(mediaContent.uploadID);
     if (mediaContent.type === 'video') {
       uploadIDs.push(mediaContent.thumbnailUploadID);
     }
   }
   return uploadIDs;
 }
 
 function getMediaMessageServerDBContentsFromMedia(
   media: $ReadOnlyArray<Media>,
 ): $ReadOnlyArray<MediaMessageServerDBContent> {
   return media.map(m => {
     if (m.type === 'photo') {
       return { type: 'photo', uploadID: m.id };
     } else {
       return {
         type: 'video',
         uploadID: m.id,
         thumbnailUploadID: m.thumbnailID,
       };
     }
   });
 }
 
 export {
   getUploadIDsFromMediaMessageServerDBContents,
   getMediaMessageServerDBContentsFromMedia,
 };
diff --git a/lib/types/messages/text.js b/lib/types/messages/text.js
index f148f03e6..932712c4f 100644
--- a/lib/types/messages/text.js
+++ b/lib/types/messages/text.js
@@ -1,27 +1,27 @@
 // @flow
 
 import type { RelativeUserInfo } from '../user-types.js';
 
 export type TextMessageData = {
-  type: 0,
-  localID?: string, // for optimistic creations. included by new clients
-  threadID: string,
-  creatorID: string,
-  time: number,
-  text: string,
+  +type: 0,
+  +localID?: string, // for optimistic creations. included by new clients
+  +threadID: string,
+  +creatorID: string,
+  +time: number,
+  +text: string,
 };
 
 export type RawTextMessageInfo = {
   ...TextMessageData,
-  id?: string, // null if local copy without ID yet
+  +id?: string, // null if local copy without ID yet
 };
 
 export type TextMessageInfo = {
-  type: 0,
-  id?: string, // null if local copy without ID yet
-  localID?: string, // for optimistic creations
-  threadID: string,
-  creator: RelativeUserInfo,
-  time: number, // millisecond timestamp
-  text: string,
+  +type: 0,
+  +id?: string, // null if local copy without ID yet
+  +localID?: string, // for optimistic creations
+  +threadID: string,
+  +creator: RelativeUserInfo,
+  +time: number, // millisecond timestamp
+  +text: string,
 };