diff --git a/lib/selectors/chat-selectors.js b/lib/selectors/chat-selectors.js
index 6b3a121e8..537abf17d 100644
--- a/lib/selectors/chat-selectors.js
+++ b/lib/selectors/chat-selectors.js
@@ -1,614 +1,614 @@
 // @flow
 
 import invariant from 'invariant';
 import _filter from 'lodash/fp/filter';
 import _flow from 'lodash/fp/flow';
 import _map from 'lodash/fp/map';
 import _orderBy from 'lodash/fp/orderBy';
 import * as React from 'react';
 import { useSelector } from 'react-redux';
 import { createSelector } from 'reselect';
 import { createObjectSelector } from 'reselect-map';
 
 import {
   messageKey,
   robotextForMessageInfo,
   createMessageInfo,
   getMostRecentNonLocalMessageID,
   sortMessageInfoList,
 } from '../shared/message-utils';
 import {
   threadIsPending,
   threadIsTopLevel,
   threadInChatList,
 } from '../shared/thread-utils';
 import {
   type MessageInfo,
   type MessageStore,
   type ComposableMessageInfo,
   type RobotextMessageInfo,
   type LocalMessageInfo,
   messageTypes,
   isComposableMessageType,
 } from '../types/message-types';
 import type { BaseAppState } from '../types/redux-types';
 import {
   type ThreadInfo,
   type RawThreadInfo,
   type SidebarInfo,
   maxReadSidebars,
   maxUnreadSidebars,
   threadTypes,
 } from '../types/thread-types';
 import type {
   UserInfo,
   AccountUserInfo,
   RelativeUserInfo,
 } from '../types/user-types';
 import { threeDays } from '../utils/date-utils';
 import type { EntityText } from '../utils/entity-text';
 import memoize2 from '../utils/memoize';
 import {
   threadInfoSelector,
   sidebarInfoSelector,
   threadInfoFromSourceMessageIDSelector,
 } from './thread-selectors';
 
 export type SidebarItem =
   | {
       ...SidebarInfo,
       +type: 'sidebar',
     }
   | {
       +type: 'seeMore',
       +unread: boolean,
     }
   | { +type: 'spacer' };
 
 export type ChatThreadItem = {
   +type: 'chatThreadItem',
   +threadInfo: ThreadInfo,
   +mostRecentMessageInfo: ?MessageInfo,
   +mostRecentNonLocalMessage: ?string,
   +lastUpdatedTime: number,
   +lastUpdatedTimeIncludingSidebars: number,
   +sidebars: $ReadOnlyArray<SidebarItem>,
   +pendingPersonalThreadUserInfo?: UserInfo,
 };
 
 const messageInfoSelector: (
   state: BaseAppState<*>,
 ) => { +[id: string]: ?MessageInfo } = createObjectSelector(
   (state: BaseAppState<*>) => state.messageStore.messages,
   (state: BaseAppState<*>) => state.currentUserInfo && state.currentUserInfo.id,
   (state: BaseAppState<*>) => state.userStore.userInfos,
   threadInfoSelector,
   createMessageInfo,
 );
 
 function isEmptyMediaMessage(messageInfo: MessageInfo): boolean {
   return (
     (messageInfo.type === messageTypes.MULTIMEDIA ||
       messageInfo.type === messageTypes.IMAGES) &&
     messageInfo.media.length === 0
   );
 }
 
 function getMostRecentMessageInfo(
   threadInfo: ThreadInfo,
   messageStore: MessageStore,
   messages: { +[id: string]: ?MessageInfo },
 ): ?MessageInfo {
   const thread = messageStore.threads[threadInfo.id];
   if (!thread) {
     return null;
   }
   for (const messageID of thread.messageIDs) {
     const messageInfo = messages[messageID];
     if (!messageInfo || isEmptyMediaMessage(messageInfo)) {
       continue;
     }
     return messageInfo;
   }
   return null;
 }
 
 function getLastUpdatedTime(
   threadInfo: ThreadInfo,
   mostRecentMessageInfo: ?MessageInfo,
 ): number {
   return mostRecentMessageInfo
     ? mostRecentMessageInfo.time
     : threadInfo.creationTime;
 }
 
 function createChatThreadItem(
   threadInfo: ThreadInfo,
   messageStore: MessageStore,
   messages: { +[id: string]: ?MessageInfo },
   sidebarInfos: ?$ReadOnlyArray<SidebarInfo>,
 ): ChatThreadItem {
   const mostRecentMessageInfo = getMostRecentMessageInfo(
     threadInfo,
     messageStore,
     messages,
   );
   const mostRecentNonLocalMessage = getMostRecentNonLocalMessageID(
     threadInfo.id,
     messageStore,
   );
   const lastUpdatedTime = getLastUpdatedTime(threadInfo, mostRecentMessageInfo);
 
   const sidebars = sidebarInfos ?? [];
   const allSidebarItems = sidebars.map(sidebarInfo => ({
     type: 'sidebar',
     ...sidebarInfo,
   }));
   const lastUpdatedTimeIncludingSidebars =
     allSidebarItems.length > 0
       ? Math.max(lastUpdatedTime, allSidebarItems[0].lastUpdatedTime)
       : lastUpdatedTime;
 
   const numUnreadSidebars = allSidebarItems.filter(
     sidebar => sidebar.threadInfo.currentUser.unread,
   ).length;
   let numReadSidebarsToShow = maxReadSidebars - numUnreadSidebars;
   const threeDaysAgo = Date.now() - threeDays;
 
   const sidebarItems = [];
   for (const sidebar of allSidebarItems) {
     if (sidebarItems.length >= maxUnreadSidebars) {
       break;
     } else if (sidebar.threadInfo.currentUser.unread) {
       sidebarItems.push(sidebar);
     } else if (
       sidebar.lastUpdatedTime > threeDaysAgo &&
       numReadSidebarsToShow > 0
     ) {
       sidebarItems.push(sidebar);
       numReadSidebarsToShow--;
     }
   }
 
   const numReadButRecentSidebars = allSidebarItems.filter(
     sidebar =>
       !sidebar.threadInfo.currentUser.unread &&
       sidebar.lastUpdatedTime > threeDaysAgo,
   ).length;
   if (
     sidebarItems.length < numUnreadSidebars + numReadButRecentSidebars ||
     (sidebarItems.length < allSidebarItems.length && sidebarItems.length > 0)
   ) {
     sidebarItems.push({
       type: 'seeMore',
       unread: numUnreadSidebars > maxUnreadSidebars,
     });
   }
   if (sidebarItems.length !== 0) {
     sidebarItems.push({
       type: 'spacer',
     });
   }
 
   return {
     type: 'chatThreadItem',
     threadInfo,
     mostRecentMessageInfo,
     mostRecentNonLocalMessage,
     lastUpdatedTime,
     lastUpdatedTimeIncludingSidebars,
     sidebars: sidebarItems,
   };
 }
 
 const chatListData: (
   state: BaseAppState<*>,
 ) => $ReadOnlyArray<ChatThreadItem> = createSelector(
   threadInfoSelector,
   (state: BaseAppState<*>) => state.messageStore,
   messageInfoSelector,
   sidebarInfoSelector,
   (
     threadInfos: { +[id: string]: ThreadInfo },
     messageStore: MessageStore,
     messageInfos: { +[id: string]: ?MessageInfo },
     sidebarInfos: { +[id: string]: $ReadOnlyArray<SidebarInfo> },
   ): $ReadOnlyArray<ChatThreadItem> =>
     getChatThreadItems(
       threadInfos,
       messageStore,
       messageInfos,
       sidebarInfos,
       threadIsTopLevel,
     ),
 );
 
 function useFlattenedChatListData(): $ReadOnlyArray<ChatThreadItem> {
   return useFilteredChatListData(threadInChatList);
 }
 
 function useFilteredChatListData(
   filterFunction: (threadInfo: ?(ThreadInfo | RawThreadInfo)) => boolean,
 ): $ReadOnlyArray<ChatThreadItem> {
   const threadInfos = useSelector(threadInfoSelector);
   const messageInfos = useSelector(messageInfoSelector);
   const sidebarInfos = useSelector(sidebarInfoSelector);
   const messageStore = useSelector(state => state.messageStore);
 
   return React.useMemo(
     () =>
       getChatThreadItems(
         threadInfos,
         messageStore,
         messageInfos,
         sidebarInfos,
         filterFunction,
       ),
     [messageInfos, messageStore, sidebarInfos, filterFunction, threadInfos],
   );
 }
 
 function getChatThreadItems(
   threadInfos: { +[id: string]: ThreadInfo },
   messageStore: MessageStore,
   messageInfos: { +[id: string]: ?MessageInfo },
   sidebarInfos: { +[id: string]: $ReadOnlyArray<SidebarInfo> },
   filterFunction: (threadInfo: ?(ThreadInfo | RawThreadInfo)) => boolean,
 ): $ReadOnlyArray<ChatThreadItem> {
   return _flow(
     _filter(filterFunction),
     _map((threadInfo: ThreadInfo): ChatThreadItem =>
       createChatThreadItem(
         threadInfo,
         messageStore,
         messageInfos,
         sidebarInfos[threadInfo.id],
       ),
     ),
     _orderBy('lastUpdatedTimeIncludingSidebars')('desc'),
   )(threadInfos);
 }
 
 export type RobotextChatMessageInfoItem = {
   +itemType: 'message',
   +messageInfoType: 'robotext',
   +messageInfo: RobotextMessageInfo,
   +startsConversation: boolean,
   +startsCluster: boolean,
   endsCluster: boolean,
-  +robotext: EntityText | string,
+  +robotext: EntityText,
   +threadCreatedFromMessage: ?ThreadInfo,
   +reactions: $ReadOnlyMap<string, MessageReactionInfo>,
 };
 export type ChatMessageInfoItem =
   | RobotextChatMessageInfoItem
   | {
       +itemType: 'message',
       +messageInfoType: 'composable',
       +messageInfo: ComposableMessageInfo,
       +localMessageInfo: ?LocalMessageInfo,
       +startsConversation: boolean,
       +startsCluster: boolean,
       endsCluster: boolean,
       +threadCreatedFromMessage: ?ThreadInfo,
       +reactions: $ReadOnlyMap<string, MessageReactionInfo>,
     };
 export type ChatMessageItem = { itemType: 'loader' } | ChatMessageInfoItem;
 export type MessageReactionInfo = {
   +viewerReacted: boolean,
   +users: $ReadOnlyArray<RelativeUserInfo>,
 };
 type TargetMessageReactions = Map<string, Map<string, RelativeUserInfo>>;
 
 const msInFiveMinutes = 5 * 60 * 1000;
 function createChatMessageItems(
   threadID: string,
   messageStore: MessageStore,
   messageInfos: { +[id: string]: ?MessageInfo },
   threadInfos: { +[id: string]: ThreadInfo },
   threadInfoFromSourceMessageID: { +[id: string]: ThreadInfo },
   additionalMessages: $ReadOnlyArray<MessageInfo>,
   viewerID: string,
 ): ChatMessageItem[] {
   const thread = messageStore.threads[threadID];
 
   const threadMessageInfos = (thread?.messageIDs ?? [])
     .map((messageID: string) => messageInfos[messageID])
     .filter(Boolean);
   const messages =
     additionalMessages.length > 0
       ? sortMessageInfoList([...threadMessageInfos, ...additionalMessages])
       : threadMessageInfos;
 
   const targetMessageReactionsMap = new Map<string, TargetMessageReactions>();
 
   // We need to iterate backwards to put the order of messages in chronological
   // order, starting with the oldest. This avoids the scenario where the most
   // recent message with the remove_reaction action may try to remove a user
   // that hasn't been added to the messageReactionUsersInfoMap, causing it
   // to be skipped.
   for (let i = messages.length - 1; i >= 0; i--) {
     const messageInfo = messages[i];
     if (messageInfo.type !== messageTypes.REACTION) {
       continue;
     }
 
     if (!targetMessageReactionsMap.has(messageInfo.targetMessageID)) {
       const reactsMap: TargetMessageReactions = new Map();
       targetMessageReactionsMap.set(messageInfo.targetMessageID, reactsMap);
     }
 
     const messageReactsMap = targetMessageReactionsMap.get(
       messageInfo.targetMessageID,
     );
     invariant(messageReactsMap, 'messageReactsInfo should be set');
 
     if (!messageReactsMap.has(messageInfo.reaction)) {
       const usersInfoMap = new Map<string, RelativeUserInfo>();
       messageReactsMap.set(messageInfo.reaction, usersInfoMap);
     }
 
     const messageReactionUsersInfoMap = messageReactsMap.get(
       messageInfo.reaction,
     );
     invariant(
       messageReactionUsersInfoMap,
       'messageReactionUsersInfoMap should be set',
     );
 
     if (messageInfo.action === 'add_reaction') {
       messageReactionUsersInfoMap.set(
         messageInfo.creator.id,
         messageInfo.creator,
       );
     } else {
       messageReactionUsersInfoMap.delete(messageInfo.creator.id);
     }
   }
 
   const chatMessageItems = [];
   let lastMessageInfo = null;
   for (let i = messages.length - 1; i >= 0; i--) {
     const messageInfo = messages[i];
 
     if (messageInfo.type === messageTypes.REACTION) {
       continue;
     }
 
     const originalMessageInfo =
       messageInfo.type === messageTypes.SIDEBAR_SOURCE
         ? messageInfo.sourceMessage
         : messageInfo;
 
     if (isEmptyMediaMessage(originalMessageInfo)) {
       continue;
     }
 
     let startsConversation = true;
     let startsCluster = true;
     if (
       lastMessageInfo &&
       lastMessageInfo.time + msInFiveMinutes > originalMessageInfo.time
     ) {
       startsConversation = false;
       if (
         isComposableMessageType(lastMessageInfo.type) &&
         isComposableMessageType(originalMessageInfo.type) &&
         lastMessageInfo.creator.id === originalMessageInfo.creator.id
       ) {
         startsCluster = false;
       }
     }
     if (startsCluster && chatMessageItems.length > 0) {
       const lastMessageItem = chatMessageItems[chatMessageItems.length - 1];
       invariant(lastMessageItem.itemType === 'message', 'should be message');
       lastMessageItem.endsCluster = true;
     }
     const threadCreatedFromMessage =
       messageInfo.id && threadInfos[threadID]?.type !== threadTypes.SIDEBAR
         ? threadInfoFromSourceMessageID[messageInfo.id]
         : undefined;
 
     const renderedReactions: $ReadOnlyMap<
       string,
       MessageReactionInfo,
     > = (() => {
       const result = new Map<string, MessageReactionInfo>();
 
       let messageReactsMap;
       if (originalMessageInfo.id) {
         messageReactsMap = targetMessageReactionsMap.get(
           originalMessageInfo.id,
         );
       }
 
       if (!messageReactsMap) {
         return result;
       }
 
       for (const reaction of messageReactsMap.keys()) {
         const reactionUsersInfoMap = messageReactsMap.get(reaction);
         invariant(reactionUsersInfoMap, 'reactionUsersInfoMap should be set');
 
         if (reactionUsersInfoMap.size === 0) {
           continue;
         }
 
         const reactionUserInfos = [...reactionUsersInfoMap.values()];
 
         const messageReactionInfo = {
           users: reactionUserInfos,
           viewerReacted: reactionUsersInfoMap.has(viewerID),
         };
 
         result.set(reaction, messageReactionInfo);
       }
 
       return result;
     })();
 
     if (isComposableMessageType(originalMessageInfo.type)) {
       // We use these invariants instead of just checking the messageInfo.type
       // directly in the conditional above so that isComposableMessageType can
       // be the source of truth
       invariant(
         originalMessageInfo.type === messageTypes.TEXT ||
           originalMessageInfo.type === messageTypes.IMAGES ||
           originalMessageInfo.type === messageTypes.MULTIMEDIA,
         "Flow doesn't understand isComposableMessageType above",
       );
       const localMessageInfo =
         messageStore.local[messageKey(originalMessageInfo)];
       chatMessageItems.push({
         itemType: 'message',
         messageInfoType: 'composable',
         messageInfo: originalMessageInfo,
         localMessageInfo,
         startsConversation,
         startsCluster,
         endsCluster: false,
         threadCreatedFromMessage,
         reactions: renderedReactions,
       });
     } else {
       invariant(
         originalMessageInfo.type !== messageTypes.TEXT &&
           originalMessageInfo.type !== messageTypes.IMAGES &&
           originalMessageInfo.type !== messageTypes.MULTIMEDIA,
         "Flow doesn't understand isComposableMessageType above",
       );
       const robotext = robotextForMessageInfo(
         originalMessageInfo,
         threadInfos[threadID],
       );
       chatMessageItems.push({
         itemType: 'message',
         messageInfoType: 'robotext',
         messageInfo: originalMessageInfo,
         startsConversation,
         startsCluster,
         endsCluster: false,
         threadCreatedFromMessage,
         robotext,
         reactions: renderedReactions,
       });
     }
     lastMessageInfo = originalMessageInfo;
   }
   if (chatMessageItems.length > 0) {
     const lastMessageItem = chatMessageItems[chatMessageItems.length - 1];
     invariant(lastMessageItem.itemType === 'message', 'should be message');
     lastMessageItem.endsCluster = true;
   }
   chatMessageItems.reverse();
   const hideSpinner = thread ? thread.startReached : threadIsPending(threadID);
   if (hideSpinner) {
     return chatMessageItems;
   }
   return [...chatMessageItems, ({ itemType: 'loader' }: ChatMessageItem)];
 }
 
 const baseMessageListData = (
   threadID: ?string,
   additionalMessages: $ReadOnlyArray<MessageInfo>,
 ) =>
   createSelector(
     (state: BaseAppState<*>) => state.messageStore,
     messageInfoSelector,
     threadInfoSelector,
     threadInfoFromSourceMessageIDSelector,
     (state: BaseAppState<*>) =>
       state.currentUserInfo && state.currentUserInfo.id,
     (
       messageStore: MessageStore,
       messageInfos: { +[id: string]: ?MessageInfo },
       threadInfos: { +[id: string]: ThreadInfo },
       threadInfoFromSourceMessageID: { +[id: string]: ThreadInfo },
       viewerID: ?string,
     ): ?(ChatMessageItem[]) => {
       if (!threadID || !viewerID) {
         return null;
       }
       return createChatMessageItems(
         threadID,
         messageStore,
         messageInfos,
         threadInfos,
         threadInfoFromSourceMessageID,
         additionalMessages,
         viewerID,
       );
     },
   );
 type MessageListData = ?(ChatMessageItem[]);
 const messageListData: (
   threadID: ?string,
   additionalMessages: $ReadOnlyArray<MessageInfo>,
 ) => (state: BaseAppState<*>) => MessageListData = memoize2(
   baseMessageListData,
 );
 
 type UseMessageListDataArgs = {
   +searching: boolean,
   +userInfoInputArray: $ReadOnlyArray<AccountUserInfo>,
   +threadInfo: ?ThreadInfo,
 };
 
 function useMessageListData({
   searching,
   userInfoInputArray,
   threadInfo,
 }: UseMessageListDataArgs): MessageListData {
   const pendingSidebarSourceMessageInfo = useSelector(state => {
     const sourceMessageID = threadInfo?.sourceMessageID;
     if (
       !threadInfo ||
       threadInfo.type !== threadTypes.SIDEBAR ||
       !sourceMessageID
     ) {
       return null;
     }
     const thread = state.messageStore.threads[threadInfo.id];
     const messageInfos = messageInfoSelector(state);
     const shouldSourceBeAdded =
       !thread ||
       (thread.startReached &&
         thread.messageIDs.every(
           id => messageInfos[id]?.type !== messageTypes.SIDEBAR_SOURCE,
         ));
     return shouldSourceBeAdded ? messageInfos[sourceMessageID] : null;
   });
 
   invariant(
     !pendingSidebarSourceMessageInfo ||
       pendingSidebarSourceMessageInfo.type !== messageTypes.SIDEBAR_SOURCE,
     'sidebars can not be created from sidebar_source message',
   );
 
   const additionalMessages = React.useMemo(
     () =>
       pendingSidebarSourceMessageInfo ? [pendingSidebarSourceMessageInfo] : [],
     [pendingSidebarSourceMessageInfo],
   );
   const boundMessageListData = useSelector(
     messageListData(threadInfo?.id, additionalMessages),
   );
 
   return React.useMemo(() => {
     if (searching && userInfoInputArray.length === 0) {
       return [];
     }
     return boundMessageListData;
   }, [searching, userInfoInputArray.length, boundMessageListData]);
 }
 
 export {
   messageInfoSelector,
   createChatThreadItem,
   chatListData,
   createChatMessageItems,
   messageListData,
   useFlattenedChatListData,
   useFilteredChatListData,
   useMessageListData,
 };
diff --git a/lib/shared/message-utils.js b/lib/shared/message-utils.js
index 6c3a8fdfd..5bcc6a988 100644
--- a/lib/shared/message-utils.js
+++ b/lib/shared/message-utils.js
@@ -1,585 +1,528 @@
 // @flow
 
 import invariant from 'invariant';
 import _maxBy from 'lodash/fp/maxBy';
 import _orderBy from 'lodash/fp/orderBy';
 
 import { useStringForUser } from '../hooks/ens-cache';
 import { userIDsToRelativeUserInfos } from '../selectors/user-selectors';
 import type { PlatformDetails } from '../types/device-types';
 import type { Media } from '../types/media-types';
 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';
 import type { ImagesMessageData } from '../types/messages/images';
 import type { MediaMessageData } from '../types/messages/media';
 import type {
   RawReactionMessageInfo,
   ReactionMessageInfo,
 } from '../types/messages/reaction';
 import { type ThreadInfo } from '../types/thread-types';
-import type { RelativeUserInfo, UserInfos } from '../types/user-types';
-import { type EntityText, entityTextToRawString } from '../utils/entity-text';
-import { pluralize } from '../utils/text-utils';
+import type { UserInfos } from '../types/user-types';
+import type { EntityText } from '../utils/entity-text';
 import { codeBlockRegex, type ParserRules } from './markdown';
 import { messageSpecs } from './messages/message-specs';
 import { threadIsGroupChat } from './thread-utils';
 
 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 robotextForUser(user: RelativeUserInfo): string {
-  if (user.isViewer) {
-    return 'you';
-  } else if (user.username) {
-    return `<${encodeURI(user.username)}|u${user.id}>`;
-  } else {
-    return 'anonymous';
-  }
-}
-
-function robotextForUsers(users: RelativeUserInfo[]): string {
-  return pluralize(users.map(robotextForUser), 3);
-}
-
-function encodedThreadEntity(threadID: string, text: string): string {
-  return `<${text}|t${threadID}>`;
-}
-
 function robotextForMessageInfo(
   messageInfo: RobotextMessageInfo,
   threadInfo: ?ThreadInfo,
-): string | EntityText {
-  const creator = robotextForUser(messageInfo.creator);
+): EntityText {
   const messageSpec = messageSpecs[messageInfo.type];
   invariant(
     messageSpec.robotext,
     `we're not aware of messageType ${messageInfo.type}`,
   );
-  return messageSpec.robotext(messageInfo, creator, {
-    encodedThreadEntity,
-    robotextForUsers,
-    robotextForUser,
-    threadInfo,
-  });
-}
-
-function robotextToRawString(
-  robotext: string | EntityText,
-  threadID?: string,
-): string {
-  if (typeof robotext !== 'string') {
-    return entityTextToRawString(robotext, threadID);
-  }
-  return decodeURI(robotext.replace(/<([^<>|]+)\|[^<>|]+>/g, '$1'));
+  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 splitRobotext(robotext: string): string[] {
-  return robotext.split(/(<[^<>|]+\|[^<>|]+>)/g);
-}
-
-const robotextEntityRegex = /<([^<>|]+)\|([^<>|]+)>/;
-type RobotextEntityInfo = {
-  +rawText: string,
-  +entityType: string,
-  +id: string,
-};
-function parseRobotextEntity(robotextPart: string): RobotextEntityInfo {
-  const entityParts = robotextPart.match(robotextEntityRegex);
-  invariant(entityParts && entityParts[1], 'malformed robotext');
-  const rawText = decodeURI(entityParts[1]);
-  const entityType = entityParts[2].charAt(0);
-  const id = entityParts[2].substr(1);
-  return { rawText, entityType, id };
-}
-
 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);
   } else {
     messageData = ({
       type: messageTypes.MULTIMEDIA,
       threadID,
       creatorID,
       time,
       media: input.media,
     }: MediaMessageData);
   }
   if (localID) {
     messageData.localID = 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));
 }
 
 export type GetMessageTitleViewerContext =
   | 'global_viewer'
   | 'individual_viewer';
 
 function getMessageTitle(
   messageInfo:
     | ComposableMessageInfo
     | RobotextMessageInfo
     | ReactionMessageInfo,
   threadInfo: ThreadInfo,
   markdownRules: ParserRules,
   viewerContext?: GetMessageTitleViewerContext = 'individual_viewer',
 ): string {
   const { messageTitle } = messageSpecs[messageInfo.type];
   return messageTitle({
     messageInfo,
     threadInfo,
     markdownRules,
     viewerContext,
   });
 }
 
 function removeCreatorAsViewer<Info: MessageInfo>(messageInfo: Info): Info {
   return {
     ...messageInfo,
     creator: { ...messageInfo.creator, isViewer: false },
   };
 }
 
 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 stringForUser = useStringForUser(
     messageInfo?.type === messageTypes.TEXT && hasUsername
       ? messageInfo?.creator
       : null,
   );
   if (!messageInfo) {
     return messageInfo;
   }
 
   let username = null;
   if (messageInfo.type === messageTypes.TEXT && hasUsername) {
     invariant(
       stringForUser,
       'useStringForUser should only return falsey if pass null or undefined',
     );
     username = {
       text: stringForUser,
       style: 'secondary',
     };
   }
 
   const messageTitle = getMessageTitle(messageInfo, threadInfo, markdownRules);
   const message = {
     text: messageTitle,
     style: messageInfo.type === messageTypes.TEXT ? 'primary' : 'secondary',
   };
 
   if (threadInfo.currentUser.unread) {
     message.style = 'unread';
     if (username) {
       username.style = 'unread';
     }
   }
 
   return { message, username };
 }
 
 export {
   localIDPrefix,
   messageKey,
   messageID,
   robotextForMessageInfo,
-  robotextToRawString,
   createMessageInfo,
   sortMessageInfoList,
   sortMessageIDs,
   rawMessageInfoFromMessageData,
   mostRecentMessageTimestamp,
-  splitRobotext,
-  parseRobotextEntity,
   usersInMessageInfos,
   combineTruncationStatuses,
   shimUnsupportedRawMessageInfos,
   createMediaMessageData,
   createMediaMessageInfo,
   stripLocalIDs,
   trimMessage,
   createMessageQuote,
   createMessageReply,
   getMostRecentNonLocalMessageID,
   getMessageTitle,
   removeCreatorAsViewer,
   mergeThreadMessageInfos,
   useMessagePreview,
 };
diff --git a/lib/shared/messages/add-members-message-spec.js b/lib/shared/messages/add-members-message-spec.js
index ea2bb6d42..2d2f191a0 100644
--- a/lib/shared/messages/add-members-message-spec.js
+++ b/lib/shared/messages/add-members-message-spec.js
@@ -1,190 +1,190 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   AddMembersMessageData,
   AddMembersMessageInfo,
   RawAddMembersMessageInfo,
 } from '../../types/messages/add-members';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import {
   ET,
   type EntityText,
   pluralizeEntityText,
+  entityTextToRawString,
 } from '../../utils/entity-text';
 import { values } from '../../utils/objects';
 import {
   robotextForMessageInfo,
-  robotextToRawString,
   removeCreatorAsViewer,
 } from '../message-utils';
 import type {
   CreateMessageInfoParams,
   MessageSpec,
   MessageTitleParam,
   NotificationTextsParams,
 } from './message-spec';
 import { joinResult } from './utils';
 
 export const addMembersMessageSpec: MessageSpec<
   AddMembersMessageData,
   RawAddMembersMessageInfo,
   AddMembersMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: AddMembersMessageData | RawAddMembersMessageInfo,
   ): string {
     return JSON.stringify(data.addedUserIDs);
   },
 
   messageContentForClientDB(data: RawAddMembersMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<AddMembersMessageInfo>) {
     let validMessageInfo: AddMembersMessageInfo = (messageInfo: AddMembersMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
       validMessageInfo = {
         ...validMessageInfo,
         addedMembers: validMessageInfo.addedMembers.map(item => ({
           ...item,
           isViewer: false,
         })),
       };
     }
-    return robotextToRawString(
+    return entityTextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawAddMembersMessageInfo {
     return {
       type: messageTypes.ADD_MEMBERS,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       addedUserIDs: JSON.parse(row.content),
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawAddMembersMessageInfo {
     const content = clientDBMessageInfo.content;
     invariant(
       content !== undefined && content !== null,
       'content must be defined',
     );
     const rawAddMembersMessageInfo: RawAddMembersMessageInfo = {
       type: messageTypes.ADD_MEMBERS,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       addedUserIDs: JSON.parse(content),
     };
     return rawAddMembersMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawAddMembersMessageInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ): AddMembersMessageInfo {
     const addedMembers = params.createRelativeUserInfos(
       rawMessageInfo.addedUserIDs,
     );
     return {
       type: messageTypes.ADD_MEMBERS,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       addedMembers,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: AddMembersMessageData,
     id: ?string,
   ): RawAddMembersMessageInfo {
     invariant(id, 'RawAddMembersMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(messageInfo: AddMembersMessageInfo): EntityText {
     const users = messageInfo.addedMembers;
     invariant(users.length !== 0, 'added who??');
 
     const creator = ET.user({ userInfo: messageInfo.creator });
     const addedUsers = pluralizeEntityText(
       users.map(user => ET`${ET.user({ userInfo: user })}`),
     );
 
     return ET`${creator} added ${addedUsers}`;
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const addedMembersObject = {};
     for (const messageInfo of messageInfos) {
       invariant(
         messageInfo.type === messageTypes.ADD_MEMBERS,
         'messageInfo should be messageTypes.ADD_MEMBERS!',
       );
       for (const member of messageInfo.addedMembers) {
         addedMembersObject[member.id] = member;
       }
     }
     const addedMembers = values(addedMembersObject);
 
     const mostRecentMessageInfo = messageInfos[0];
     invariant(
       mostRecentMessageInfo.type === messageTypes.ADD_MEMBERS,
       'messageInfo should be messageTypes.ADD_MEMBERS!',
     );
     const mergedMessageInfo = { ...mostRecentMessageInfo, addedMembers };
 
     const robotext = params.strippedRobotextForMessageInfo(
       mergedMessageInfo,
       threadInfo,
     );
     const merged = `${robotext} to ${params.notifThreadName(threadInfo)}`;
     return {
       merged,
       title: threadInfo.uiName,
       body: robotext,
     };
   },
 
   notificationCollapseKey(rawMessageInfo: RawAddMembersMessageInfo): string {
     return joinResult(
       rawMessageInfo.type,
       rawMessageInfo.threadID,
       rawMessageInfo.creatorID,
     );
   },
 
   generatesNotifs: async () => undefined,
 
   userIDs(rawMessageInfo: RawAddMembersMessageInfo): $ReadOnlyArray<string> {
     return rawMessageInfo.addedUserIDs;
   },
 });
diff --git a/lib/shared/messages/change-role-message-spec.js b/lib/shared/messages/change-role-message-spec.js
index 60383d607..c5e0f1ac0 100644
--- a/lib/shared/messages/change-role-message-spec.js
+++ b/lib/shared/messages/change-role-message-spec.js
@@ -1,206 +1,205 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   ChangeRoleMessageData,
   ChangeRoleMessageInfo,
   RawChangeRoleMessageInfo,
 } from '../../types/messages/change-role';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import {
   ET,
   type EntityText,
   pluralizeEntityText,
+  entityTextToRawString,
 } from '../../utils/entity-text';
 import { values } from '../../utils/objects';
 import {
-  robotextToRawString,
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
 import {
   pushTypes,
   type CreateMessageInfoParams,
   type MessageSpec,
   type MessageTitleParam,
   type NotificationTextsParams,
   type RobotextParams,
 } from './message-spec';
 import { joinResult } from './utils';
 
 export const changeRoleMessageSpec: MessageSpec<
   ChangeRoleMessageData,
   RawChangeRoleMessageInfo,
   ChangeRoleMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: ChangeRoleMessageData | RawChangeRoleMessageInfo,
   ): string {
     return JSON.stringify({
       userIDs: data.userIDs,
       newRole: data.newRole,
     });
   },
 
   messageContentForClientDB(data: RawChangeRoleMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<ChangeRoleMessageInfo>) {
     let validMessageInfo: ChangeRoleMessageInfo = (messageInfo: ChangeRoleMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
       validMessageInfo = {
         ...validMessageInfo,
         members: validMessageInfo.members.map(item => ({
           ...item,
           isViewer: false,
         })),
       };
     }
-    return robotextToRawString(
+    return entityTextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawChangeRoleMessageInfo {
     const content = JSON.parse(row.content);
     return {
       type: messageTypes.CHANGE_ROLE,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       userIDs: content.userIDs,
       newRole: content.newRole,
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawChangeRoleMessageInfo {
     invariant(
       clientDBMessageInfo.content !== undefined &&
         clientDBMessageInfo.content !== null,
       'content must be defined',
     );
     const content = JSON.parse(clientDBMessageInfo.content);
     const rawChangeRoleMessageInfo: RawChangeRoleMessageInfo = {
       type: messageTypes.CHANGE_ROLE,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       userIDs: content.userIDs,
       newRole: content.newRole,
     };
     return rawChangeRoleMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawChangeRoleMessageInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ): ChangeRoleMessageInfo {
     const members = params.createRelativeUserInfos(rawMessageInfo.userIDs);
     return {
       type: messageTypes.CHANGE_ROLE,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       members,
       newRole: rawMessageInfo.newRole,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: ChangeRoleMessageData,
     id: ?string,
   ): RawChangeRoleMessageInfo {
     invariant(id, 'RawChangeRoleMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(
     messageInfo: ChangeRoleMessageInfo,
-    creatorString: string,
     params: RobotextParams,
   ): EntityText {
     const users = messageInfo.members;
     invariant(users.length !== 0, 'changed whose role??');
 
     const creator = ET.user({ userInfo: messageInfo.creator });
     const affectedUsers = pluralizeEntityText(
       users.map(user => ET`${ET.user({ userInfo: user })}`),
     );
 
     const { threadInfo } = params;
     invariant(threadInfo, 'ThreadInfo should be set for CHANGE_ROLE message');
     const verb = threadInfo.roles[messageInfo.newRole].isDefault
       ? 'removed'
       : 'added';
     const noun = users.length === 1 ? 'an admin' : 'admins';
 
     return ET`${creator} ${verb} ${affectedUsers} as ${noun}`;
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const membersObject = {};
     for (const messageInfo of messageInfos) {
       invariant(
         messageInfo.type === messageTypes.CHANGE_ROLE,
         'messageInfo should be messageTypes.CHANGE_ROLE!',
       );
       for (const member of messageInfo.members) {
         membersObject[member.id] = member;
       }
     }
     const members = values(membersObject);
 
     const mostRecentMessageInfo = messageInfos[0];
     invariant(
       mostRecentMessageInfo.type === messageTypes.CHANGE_ROLE,
       'messageInfo should be messageTypes.CHANGE_ROLE!',
     );
     const mergedMessageInfo = { ...mostRecentMessageInfo, members };
 
     const robotext = params.strippedRobotextForMessageInfo(
       mergedMessageInfo,
       threadInfo,
     );
     const merged = `${robotext} from ${params.notifThreadName(threadInfo)}`;
     return {
       merged,
       title: threadInfo.uiName,
       body: robotext,
     };
   },
 
   notificationCollapseKey(rawMessageInfo: RawChangeRoleMessageInfo): string {
     return joinResult(
       rawMessageInfo.type,
       rawMessageInfo.threadID,
       rawMessageInfo.creatorID,
       rawMessageInfo.newRole,
     );
   },
 
   generatesNotifs: async () => pushTypes.NOTIF,
 });
diff --git a/lib/shared/messages/change-settings-message-spec.js b/lib/shared/messages/change-settings-message-spec.js
index 74c6182e6..25e552411 100644
--- a/lib/shared/messages/change-settings-message-spec.js
+++ b/lib/shared/messages/change-settings-message-spec.js
@@ -1,193 +1,196 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   ChangeSettingsMessageData,
   ChangeSettingsMessageInfo,
   RawChangeSettingsMessageInfo,
 } from '../../types/messages/change-settings';
 import type { NotifTexts } from '../../types/notif-types';
 import { assertThreadType } from '../../types/thread-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
-import { ET, type EntityText } from '../../utils/entity-text';
+import {
+  ET,
+  type EntityText,
+  entityTextToRawString,
+} from '../../utils/entity-text';
 import { validHexColorRegex } from '../account-utils';
 import {
-  robotextToRawString,
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
 import { threadLabel } from '../thread-utils';
 import {
   pushTypes,
   type MessageSpec,
   type MessageTitleParam,
   type NotificationTextsParams,
 } from './message-spec';
 import { joinResult } from './utils';
 
 export const changeSettingsMessageSpec: MessageSpec<
   ChangeSettingsMessageData,
   RawChangeSettingsMessageInfo,
   ChangeSettingsMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: ChangeSettingsMessageData | RawChangeSettingsMessageInfo,
   ): string {
     return JSON.stringify({
       [data.field]: data.value,
     });
   },
 
   messageContentForClientDB(data: RawChangeSettingsMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<ChangeSettingsMessageInfo>) {
     let validMessageInfo: ChangeSettingsMessageInfo = (messageInfo: ChangeSettingsMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
     }
-    return robotextToRawString(
+    return entityTextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawChangeSettingsMessageInfo {
     const content = JSON.parse(row.content);
     const field = Object.keys(content)[0];
     return {
       type: messageTypes.CHANGE_SETTINGS,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       field,
       value: content[field],
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawChangeSettingsMessageInfo {
     invariant(
       clientDBMessageInfo.content !== undefined &&
         clientDBMessageInfo.content !== null,
       'content must be defined',
     );
     const content = JSON.parse(clientDBMessageInfo.content);
     const field = Object.keys(content)[0];
     const rawChangeSettingsMessageInfo: RawChangeSettingsMessageInfo = {
       type: messageTypes.CHANGE_SETTINGS,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       field,
       value: content[field],
     };
     return rawChangeSettingsMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawChangeSettingsMessageInfo,
     creator: RelativeUserInfo,
   ): ChangeSettingsMessageInfo {
     return {
       type: messageTypes.CHANGE_SETTINGS,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       field: rawMessageInfo.field,
       value: rawMessageInfo.value,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: ChangeSettingsMessageData,
     id: ?string,
   ): RawChangeSettingsMessageInfo {
     invariant(id, 'RawChangeSettingsMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(messageInfo: ChangeSettingsMessageInfo): EntityText {
     const creator = ET.user({ userInfo: messageInfo.creator });
     if (
       (messageInfo.field === 'name' || messageInfo.field === 'description') &&
       messageInfo.value.toString() === ''
     ) {
       return ET`${creator} cleared ${ET.thread({
         display: 'alwaysDisplayShortName',
         threadID: messageInfo.threadID,
         possessive: true,
       })} ${messageInfo.field}`;
     }
     let value;
     if (
       messageInfo.field === 'color' &&
       messageInfo.value.toString().match(validHexColorRegex)
     ) {
       value = ET.color({ hex: `#${messageInfo.value}` });
     } else if (messageInfo.field === 'type') {
       invariant(
         typeof messageInfo.value === 'number',
         'messageInfo.value should be number for thread type change ',
       );
       const newThreadType = assertThreadType(messageInfo.value);
       value = threadLabel(newThreadType);
     } else {
       value = messageInfo.value.toString();
     }
     return ET`${creator} updated ${ET.thread({
       display: 'alwaysDisplayShortName',
       threadID: messageInfo.threadID,
       possessive: true,
     })} ${messageInfo.field} to "${value}"`;
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const mostRecentMessageInfo = messageInfos[0];
     invariant(
       mostRecentMessageInfo.type === messageTypes.CHANGE_SETTINGS,
       'messageInfo should be messageTypes.CHANGE_SETTINGS!',
     );
     const body = params.strippedRobotextForMessageInfo(
       mostRecentMessageInfo,
       threadInfo,
     );
     return {
       merged: body,
       title: threadInfo.uiName,
       body,
     };
   },
 
   notificationCollapseKey(
     rawMessageInfo: RawChangeSettingsMessageInfo,
   ): string {
     return joinResult(
       rawMessageInfo.type,
       rawMessageInfo.threadID,
       rawMessageInfo.creatorID,
       rawMessageInfo.field,
     );
   },
 
   generatesNotifs: async () => pushTypes.NOTIF,
 });
diff --git a/lib/shared/messages/create-entry-message-spec.js b/lib/shared/messages/create-entry-message-spec.js
index da1659f81..e189e1fd1 100644
--- a/lib/shared/messages/create-entry-message-spec.js
+++ b/lib/shared/messages/create-entry-message-spec.js
@@ -1,184 +1,187 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   CreateEntryMessageData,
   CreateEntryMessageInfo,
   RawCreateEntryMessageInfo,
 } from '../../types/messages/create-entry';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import { prettyDate } from '../../utils/date-utils';
-import { ET, type EntityText } from '../../utils/entity-text';
 import {
-  robotextToRawString,
+  ET,
+  type EntityText,
+  entityTextToRawString,
+} from '../../utils/entity-text';
+import {
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
 import { stringForUser } from '../user-utils';
 import {
   pushTypes,
   type MessageSpec,
   type MessageTitleParam,
   type NotificationTextsParams,
 } from './message-spec';
 import { joinResult } from './utils';
 
 export const createEntryMessageSpec: MessageSpec<
   CreateEntryMessageData,
   RawCreateEntryMessageInfo,
   CreateEntryMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: CreateEntryMessageData | RawCreateEntryMessageInfo,
   ): string {
     return JSON.stringify({
       entryID: data.entryID,
       date: data.date,
       text: data.text,
     });
   },
 
   messageContentForClientDB(data: RawCreateEntryMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<CreateEntryMessageInfo>) {
     let validMessageInfo: CreateEntryMessageInfo = (messageInfo: CreateEntryMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
     }
-    return robotextToRawString(
+    return entityTextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawCreateEntryMessageInfo {
     const content = JSON.parse(row.content);
     return {
       type: messageTypes.CREATE_ENTRY,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       entryID: content.entryID,
       date: content.date,
       text: content.text,
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawCreateEntryMessageInfo {
     invariant(
       clientDBMessageInfo.content !== undefined &&
         clientDBMessageInfo.content !== null,
       'content must be defined',
     );
     const content = JSON.parse(clientDBMessageInfo.content);
     const rawCreateEntryMessageInfo: RawCreateEntryMessageInfo = {
       type: messageTypes.CREATE_ENTRY,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       entryID: content.entryID,
       date: content.date,
       text: content.text,
     };
     return rawCreateEntryMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawCreateEntryMessageInfo,
     creator: RelativeUserInfo,
   ): CreateEntryMessageInfo {
     return {
       type: messageTypes.CREATE_ENTRY,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       entryID: rawMessageInfo.entryID,
       date: rawMessageInfo.date,
       text: rawMessageInfo.text,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: CreateEntryMessageData,
     id: ?string,
   ): RawCreateEntryMessageInfo {
     invariant(id, 'RawCreateEntryMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(messageInfo: CreateEntryMessageInfo): EntityText {
     const date = prettyDate(messageInfo.date);
     const creator = ET.user({ userInfo: messageInfo.creator });
     const { text } = messageInfo;
     return ET`${creator} created an event scheduled for ${date}: "${text}"`;
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const hasCreateEntry = messageInfos.some(
       messageInfo => messageInfo.type === messageTypes.CREATE_ENTRY,
     );
     const messageInfo = messageInfos[0];
     if (!hasCreateEntry) {
       invariant(
         messageInfo.type === messageTypes.EDIT_ENTRY,
         'messageInfo should be messageTypes.EDIT_ENTRY!',
       );
       const body =
         `updated the text of an event in ` +
         `${params.notifThreadName(threadInfo)} scheduled for ` +
         `${prettyDate(messageInfo.date)}: "${messageInfo.text}"`;
       const prefix = stringForUser(messageInfo.creator);
       const merged = `${prefix} ${body}`;
       return {
         merged,
         title: threadInfo.uiName,
         body,
         prefix,
       };
     }
     invariant(
       messageInfo.type === messageTypes.CREATE_ENTRY ||
         messageInfo.type === messageTypes.EDIT_ENTRY,
       'messageInfo should be messageTypes.CREATE_ENTRY/EDIT_ENTRY!',
     );
     const prefix = stringForUser(messageInfo.creator);
     const body =
       `created an event in ${params.notifThreadName(threadInfo)} ` +
       `scheduled for ${prettyDate(messageInfo.date)}: "${messageInfo.text}"`;
     const merged = `${prefix} ${body}`;
     return {
       merged,
       title: threadInfo.uiName,
       body,
       prefix,
     };
   },
 
   notificationCollapseKey(rawMessageInfo: RawCreateEntryMessageInfo): string {
     return joinResult(rawMessageInfo.creatorID, rawMessageInfo.entryID);
   },
 
   generatesNotifs: async () => pushTypes.NOTIF,
 });
diff --git a/lib/shared/messages/create-sidebar-message-spec.js b/lib/shared/messages/create-sidebar-message-spec.js
index 51cad53d7..fad7c8c7b 100644
--- a/lib/shared/messages/create-sidebar-message-spec.js
+++ b/lib/shared/messages/create-sidebar-message-spec.js
@@ -1,255 +1,255 @@
 // @flow
 
 import invariant from 'invariant';
 
 import type { PlatformDetails } from '../../types/device-types';
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   CreateSidebarMessageData,
   CreateSidebarMessageInfo,
   RawCreateSidebarMessageInfo,
 } from '../../types/messages/create-sidebar';
 import type { RawUnsupportedMessageInfo } from '../../types/messages/unsupported';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import {
   ET,
   type EntityText,
   pluralizeEntityText,
+  entityTextToRawString,
 } from '../../utils/entity-text';
 import {
-  robotextToRawString,
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
 import { stringForUser } from '../user-utils';
 import { hasMinCodeVersion } from '../version-utils';
 import {
   pushTypes,
   type CreateMessageInfoParams,
   type MessageSpec,
   type MessageTitleParam,
 } from './message-spec';
 import { assertSingleMessageInfo } from './utils';
 
 export const createSidebarMessageSpec: MessageSpec<
   CreateSidebarMessageData,
   RawCreateSidebarMessageInfo,
   CreateSidebarMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: CreateSidebarMessageData | RawCreateSidebarMessageInfo,
   ): string {
     return JSON.stringify({
       ...data.initialThreadState,
       sourceMessageAuthorID: data.sourceMessageAuthorID,
     });
   },
 
   messageContentForClientDB(data: RawCreateSidebarMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<CreateSidebarMessageInfo>) {
     let validMessageInfo: CreateSidebarMessageInfo = (messageInfo: CreateSidebarMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
       validMessageInfo = {
         ...validMessageInfo,
         sourceMessageAuthor: {
           ...validMessageInfo.sourceMessageAuthor,
           isViewer: false,
         },
         initialThreadState: {
           ...validMessageInfo.initialThreadState,
           otherMembers: validMessageInfo.initialThreadState.otherMembers.map(
             item => ({
               ...item,
               isViewer: false,
             }),
           ),
         },
       };
     }
-    return robotextToRawString(
+    return entityTextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawCreateSidebarMessageInfo {
     const { sourceMessageAuthorID, ...initialThreadState } = JSON.parse(
       row.content,
     );
     return {
       type: messageTypes.CREATE_SIDEBAR,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       sourceMessageAuthorID,
       initialThreadState,
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawCreateSidebarMessageInfo {
     invariant(
       clientDBMessageInfo.content !== undefined &&
         clientDBMessageInfo.content !== null,
       'content must be defined',
     );
 
     const { sourceMessageAuthorID, ...initialThreadState } = JSON.parse(
       clientDBMessageInfo.content,
     );
     const rawCreateSidebarMessageInfo: RawCreateSidebarMessageInfo = {
       type: messageTypes.CREATE_SIDEBAR,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       sourceMessageAuthorID: sourceMessageAuthorID,
       initialThreadState: initialThreadState,
     };
     return rawCreateSidebarMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawCreateSidebarMessageInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ): ?CreateSidebarMessageInfo {
     const { threadInfos } = params;
     const parentThreadInfo =
       threadInfos[rawMessageInfo.initialThreadState.parentThreadID];
 
     const sourceMessageAuthor = params.createRelativeUserInfos([
       rawMessageInfo.sourceMessageAuthorID,
     ])[0];
     if (!sourceMessageAuthor) {
       return null;
     }
 
     return {
       type: messageTypes.CREATE_SIDEBAR,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       sourceMessageAuthor,
       initialThreadState: {
         name: rawMessageInfo.initialThreadState.name,
         parentThreadInfo,
         color: rawMessageInfo.initialThreadState.color,
         otherMembers: params.createRelativeUserInfos(
           rawMessageInfo.initialThreadState.memberIDs.filter(
             (userID: string) => userID !== rawMessageInfo.creatorID,
           ),
         ),
       },
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: CreateSidebarMessageData,
     id: ?string,
   ): RawCreateSidebarMessageInfo {
     invariant(id, 'RawCreateSidebarMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(messageInfo: CreateSidebarMessageInfo): EntityText {
     let text = ET`started ${ET.thread({
       display: 'alwaysDisplayShortName',
       threadID: messageInfo.threadID,
     })}`;
     const users = messageInfo.initialThreadState.otherMembers.filter(
       member => member.id !== messageInfo.sourceMessageAuthor.id,
     );
     if (users.length !== 0) {
       const initialUsers = pluralizeEntityText(
         users.map(user => ET`${ET.user({ userInfo: user })}`),
       );
       text = ET`${text} and added ${initialUsers}`;
     }
     const creator = ET.user({ userInfo: messageInfo.creator });
     return ET`${creator} ${text}`;
   },
 
   shimUnsupportedMessageInfo(
     rawMessageInfo: RawCreateSidebarMessageInfo,
     platformDetails: ?PlatformDetails,
   ): RawCreateSidebarMessageInfo | RawUnsupportedMessageInfo {
     // TODO determine min code version
     if (hasMinCodeVersion(platformDetails, 75)) {
       return rawMessageInfo;
     }
     const { id } = rawMessageInfo;
     invariant(id !== null && id !== undefined, 'id should be set on server');
     return {
       type: messageTypes.UNSUPPORTED,
       id,
       threadID: rawMessageInfo.threadID,
       creatorID: rawMessageInfo.creatorID,
       time: rawMessageInfo.time,
       robotext: 'created a thread',
       unsupportedMessageInfo: rawMessageInfo,
     };
   },
 
   unshimMessageInfo(
     unwrapped: RawCreateSidebarMessageInfo,
   ): RawCreateSidebarMessageInfo {
     return unwrapped;
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
   ): NotifTexts {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.CREATE_SIDEBAR,
       'messageInfo should be messageTypes.CREATE_SIDEBAR!',
     );
     const prefix = stringForUser(messageInfo.creator);
     const title = threadInfo.uiName;
     const sourceMessageAuthorPossessive = messageInfo.sourceMessageAuthor
       .isViewer
       ? 'your'
       : `${stringForUser(messageInfo.sourceMessageAuthor)}'s`;
     const body =
       `started a thread in response to ${sourceMessageAuthorPossessive} ` +
       `message "${messageInfo.initialThreadState.name ?? ''}"`;
     const merged = `${prefix} ${body}`;
     return {
       merged,
       body,
       title,
       prefix,
     };
   },
 
   generatesNotifs: async () => pushTypes.NOTIF,
 
   userIDs(rawMessageInfo: RawCreateSidebarMessageInfo): $ReadOnlyArray<string> {
     return rawMessageInfo.initialThreadState.memberIDs;
   },
 
   threadIDs(
     rawMessageInfo: RawCreateSidebarMessageInfo,
   ): $ReadOnlyArray<string> {
     const { parentThreadID } = rawMessageInfo.initialThreadState;
     return [parentThreadID];
   },
 });
diff --git a/lib/shared/messages/create-sub-thread-message-spec.js b/lib/shared/messages/create-sub-thread-message-spec.js
index bb8a3b910..83bd9702d 100644
--- a/lib/shared/messages/create-sub-thread-message-spec.js
+++ b/lib/shared/messages/create-sub-thread-message-spec.js
@@ -1,183 +1,186 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { permissionLookup } from '../../permissions/thread-permissions';
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   CreateSubthreadMessageData,
   CreateSubthreadMessageInfo,
   RawCreateSubthreadMessageInfo,
 } from '../../types/messages/create-subthread';
 import type { NotifTexts } from '../../types/notif-types';
 import { threadPermissions, threadTypes } from '../../types/thread-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
-import { ET, type EntityText } from '../../utils/entity-text';
 import {
-  robotextToRawString,
+  ET,
+  type EntityText,
+  entityTextToRawString,
+} from '../../utils/entity-text';
+import {
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
 import {
   pushTypes,
   type CreateMessageInfoParams,
   type MessageSpec,
   type MessageTitleParam,
   type NotificationTextsParams,
   type GeneratesNotifsParams,
 } from './message-spec';
 import { assertSingleMessageInfo } from './utils';
 
 export const createSubThreadMessageSpec: MessageSpec<
   CreateSubthreadMessageData,
   RawCreateSubthreadMessageInfo,
   CreateSubthreadMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: CreateSubthreadMessageData | RawCreateSubthreadMessageInfo,
   ): string {
     return data.childThreadID;
   },
 
   messageContentForClientDB(data: RawCreateSubthreadMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<CreateSubthreadMessageInfo>) {
     let validMessageInfo: CreateSubthreadMessageInfo = (messageInfo: CreateSubthreadMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
     }
-    return robotextToRawString(
+    return entityTextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   rawMessageInfoFromServerDBRow(row: Object): ?RawCreateSubthreadMessageInfo {
     const subthreadPermissions = row.subthread_permissions;
     if (!permissionLookup(subthreadPermissions, threadPermissions.KNOW_OF)) {
       return null;
     }
     return {
       type: messageTypes.CREATE_SUB_THREAD,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       childThreadID: row.content,
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawCreateSubthreadMessageInfo {
     const content = clientDBMessageInfo.content;
     invariant(
       content !== undefined && content !== null,
       'content must be defined',
     );
     const rawCreateSubthreadMessageInfo: RawCreateSubthreadMessageInfo = {
       type: messageTypes.CREATE_SUB_THREAD,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       childThreadID: content,
     };
     return rawCreateSubthreadMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawCreateSubthreadMessageInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ): ?CreateSubthreadMessageInfo {
     const { threadInfos } = params;
     const childThreadInfo = threadInfos[rawMessageInfo.childThreadID];
     if (!childThreadInfo) {
       return null;
     }
     return {
       type: messageTypes.CREATE_SUB_THREAD,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       childThreadInfo,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: CreateSubthreadMessageData,
     id: ?string,
   ): RawCreateSubthreadMessageInfo {
     invariant(id, 'RawCreateSubthreadMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(messageInfo: CreateSubthreadMessageInfo): EntityText {
     const threadEntity = ET.thread({
       display: 'shortName',
       threadInfo: messageInfo.childThreadInfo,
       subchannel: true,
     });
 
     let text;
     if (messageInfo.childThreadInfo.name) {
       const childNoun =
         messageInfo.childThreadInfo.type === threadTypes.SIDEBAR
           ? 'thread'
           : 'subchannel';
       text = ET`created a ${childNoun} named "${threadEntity}"`;
     } else {
       text = ET`created a ${threadEntity}`;
     }
 
     const creator = ET.user({ userInfo: messageInfo.creator });
     return ET`${creator} ${text}`;
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.CREATE_SUB_THREAD,
       'messageInfo should be messageTypes.CREATE_SUB_THREAD!',
     );
     return params.notifTextForSubthreadCreation(
       messageInfo.creator,
       messageInfo.childThreadInfo.type,
       threadInfo,
       messageInfo.childThreadInfo.name,
       messageInfo.childThreadInfo.uiName,
     );
   },
 
   generatesNotifs: async (
     rawMessageInfo: RawCreateSubthreadMessageInfo,
     params: GeneratesNotifsParams,
   ) => {
     const { userNotMemberOfSubthreads } = params;
     return userNotMemberOfSubthreads.has(rawMessageInfo.childThreadID)
       ? pushTypes.NOTIF
       : undefined;
   },
 
   threadIDs(
     rawMessageInfo: RawCreateSubthreadMessageInfo,
   ): $ReadOnlyArray<string> {
     return [rawMessageInfo.childThreadID];
   },
 });
diff --git a/lib/shared/messages/create-thread-message-spec.js b/lib/shared/messages/create-thread-message-spec.js
index 106b90262..a577958cb 100644
--- a/lib/shared/messages/create-thread-message-spec.js
+++ b/lib/shared/messages/create-thread-message-spec.js
@@ -1,222 +1,222 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   CreateThreadMessageData,
   CreateThreadMessageInfo,
   RawCreateThreadMessageInfo,
 } from '../../types/messages/create-thread';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import {
   ET,
   type EntityText,
   pluralizeEntityText,
+  entityTextToRawString,
 } from '../../utils/entity-text';
 import {
-  robotextToRawString,
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
 import { stringForUser } from '../user-utils';
 import {
   pushTypes,
   type CreateMessageInfoParams,
   type MessageSpec,
   type MessageTitleParam,
   type NotificationTextsParams,
 } from './message-spec';
 import { assertSingleMessageInfo } from './utils';
 
 export const createThreadMessageSpec: MessageSpec<
   CreateThreadMessageData,
   RawCreateThreadMessageInfo,
   CreateThreadMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: CreateThreadMessageData | RawCreateThreadMessageInfo,
   ): string {
     return JSON.stringify(data.initialThreadState);
   },
 
   messageContentForClientDB(data: RawCreateThreadMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<CreateThreadMessageInfo>) {
     let validMessageInfo: CreateThreadMessageInfo = (messageInfo: CreateThreadMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
       validMessageInfo = {
         ...validMessageInfo,
         initialThreadState: {
           ...validMessageInfo.initialThreadState,
           otherMembers: validMessageInfo.initialThreadState.otherMembers.map(
             item => ({
               ...item,
               isViewer: false,
             }),
           ),
         },
       };
     }
-    return robotextToRawString(
+    return entityTextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawCreateThreadMessageInfo {
     return {
       type: messageTypes.CREATE_THREAD,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       initialThreadState: JSON.parse(row.content),
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawCreateThreadMessageInfo {
     const content = clientDBMessageInfo.content;
     invariant(
       content !== undefined && content !== null,
       'content must be defined',
     );
     const rawCreateThreadMessageInfo: RawCreateThreadMessageInfo = {
       type: messageTypes.CREATE_THREAD,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       initialThreadState: JSON.parse(content),
     };
     return rawCreateThreadMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawCreateThreadMessageInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ): CreateThreadMessageInfo {
     const initialParentThreadID =
       rawMessageInfo.initialThreadState.parentThreadID;
     const parentThreadInfo = initialParentThreadID
       ? params.threadInfos[initialParentThreadID]
       : null;
 
     return {
       type: messageTypes.CREATE_THREAD,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       initialThreadState: {
         name: rawMessageInfo.initialThreadState.name,
         parentThreadInfo,
         type: rawMessageInfo.initialThreadState.type,
         color: rawMessageInfo.initialThreadState.color,
         otherMembers: params.createRelativeUserInfos(
           rawMessageInfo.initialThreadState.memberIDs.filter(
             (userID: string) => userID !== rawMessageInfo.creatorID,
           ),
         ),
       },
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: CreateThreadMessageData,
     id: ?string,
   ): RawCreateThreadMessageInfo {
     invariant(id, 'RawCreateThreadMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(messageInfo: CreateThreadMessageInfo): EntityText {
     let text = ET`created ${ET.thread({
       display: 'alwaysDisplayShortName',
       threadID: messageInfo.threadID,
     })}`;
     const parentThread = messageInfo.initialThreadState.parentThreadInfo;
     if (parentThread) {
       text = ET`${text} as a child of ${ET.thread({
         display: 'uiName',
         threadInfo: parentThread,
       })}`;
     }
     if (messageInfo.initialThreadState.name) {
       text = ET`${text} with the name "${messageInfo.initialThreadState.name}"`;
     }
     const users = messageInfo.initialThreadState.otherMembers;
     if (users.length !== 0) {
       const initialUsers = pluralizeEntityText(
         users.map(user => ET`${ET.user({ userInfo: user })}`),
       );
       text = ET`${text} and added ${initialUsers}`;
     }
     const creator = ET.user({ userInfo: messageInfo.creator });
     return ET`${creator} ${text}`;
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.CREATE_THREAD,
       'messageInfo should be messageTypes.CREATE_THREAD!',
     );
     const parentThreadInfo = messageInfo.initialThreadState.parentThreadInfo;
     if (parentThreadInfo) {
       return params.notifTextForSubthreadCreation(
         messageInfo.creator,
         messageInfo.initialThreadState.type,
         parentThreadInfo,
         messageInfo.initialThreadState.name,
         threadInfo.uiName,
       );
     }
     const prefix = stringForUser(messageInfo.creator);
     const body = 'created a new chat';
     let merged = `${prefix} ${body}`;
     if (messageInfo.initialThreadState.name) {
       merged += ` called "${messageInfo.initialThreadState.name}"`;
     }
     return {
       merged,
       body,
       title: threadInfo.uiName,
       prefix,
     };
   },
 
   generatesNotifs: async () => pushTypes.NOTIF,
 
   userIDs(rawMessageInfo: RawCreateThreadMessageInfo): $ReadOnlyArray<string> {
     return rawMessageInfo.initialThreadState.memberIDs;
   },
 
   startsThread: true,
 
   threadIDs(
     rawMessageInfo: RawCreateThreadMessageInfo,
   ): $ReadOnlyArray<string> {
     const { parentThreadID } = rawMessageInfo.initialThreadState;
     return parentThreadID ? [parentThreadID] : [];
   },
 });
diff --git a/lib/shared/messages/delete-entry-message-spec.js b/lib/shared/messages/delete-entry-message-spec.js
index b569c3dd1..cfa3ef818 100644
--- a/lib/shared/messages/delete-entry-message-spec.js
+++ b/lib/shared/messages/delete-entry-message-spec.js
@@ -1,158 +1,161 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   DeleteEntryMessageData,
   DeleteEntryMessageInfo,
   RawDeleteEntryMessageInfo,
 } from '../../types/messages/delete-entry';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import { prettyDate } from '../../utils/date-utils';
-import { ET, type EntityText } from '../../utils/entity-text';
 import {
-  robotextToRawString,
+  ET,
+  type EntityText,
+  entityTextToRawString,
+} from '../../utils/entity-text';
+import {
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
 import { stringForUser } from '../user-utils';
 import {
   pushTypes,
   type MessageSpec,
   type MessageTitleParam,
   type NotificationTextsParams,
 } from './message-spec';
 import { assertSingleMessageInfo } from './utils';
 
 export const deleteEntryMessageSpec: MessageSpec<
   DeleteEntryMessageData,
   RawDeleteEntryMessageInfo,
   DeleteEntryMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: DeleteEntryMessageData | RawDeleteEntryMessageInfo,
   ): string {
     return JSON.stringify({
       entryID: data.entryID,
       date: data.date,
       text: data.text,
     });
   },
 
   messageContentForClientDB(data: RawDeleteEntryMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<DeleteEntryMessageInfo>) {
     let validMessageInfo: DeleteEntryMessageInfo = (messageInfo: DeleteEntryMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
     }
-    return robotextToRawString(
+    return entityTextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawDeleteEntryMessageInfo {
     const content = JSON.parse(row.content);
     return {
       type: messageTypes.DELETE_ENTRY,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       entryID: content.entryID,
       date: content.date,
       text: content.text,
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawDeleteEntryMessageInfo {
     invariant(
       clientDBMessageInfo.content !== undefined &&
         clientDBMessageInfo.content !== null,
       'content must be defined',
     );
     const content = JSON.parse(clientDBMessageInfo.content);
     const rawDeleteEntryMessageInfo: RawDeleteEntryMessageInfo = {
       type: messageTypes.DELETE_ENTRY,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       entryID: content.entryID,
       date: content.date,
       text: content.text,
     };
     return rawDeleteEntryMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawDeleteEntryMessageInfo,
     creator: RelativeUserInfo,
   ): DeleteEntryMessageInfo {
     return {
       type: messageTypes.DELETE_ENTRY,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       entryID: rawMessageInfo.entryID,
       date: rawMessageInfo.date,
       text: rawMessageInfo.text,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: DeleteEntryMessageData,
     id: ?string,
   ): RawDeleteEntryMessageInfo {
     invariant(id, 'RawDeleteEntryMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(messageInfo: DeleteEntryMessageInfo): EntityText {
     const date = prettyDate(messageInfo.date);
     const creator = ET.user({ userInfo: messageInfo.creator });
     const { text } = messageInfo;
     return ET`${creator} deleted an event scheduled for ${date}: "${text}"`;
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.DELETE_ENTRY,
       'messageInfo should be messageTypes.DELETE_ENTRY!',
     );
     const prefix = stringForUser(messageInfo.creator);
     const body =
       `deleted an event in ${params.notifThreadName(threadInfo)} ` +
       `scheduled for ${prettyDate(messageInfo.date)}: "${messageInfo.text}"`;
     const merged = `${prefix} ${body}`;
     return {
       merged,
       title: threadInfo.uiName,
       body,
       prefix,
     };
   },
 
   generatesNotifs: async () => pushTypes.NOTIF,
 });
diff --git a/lib/shared/messages/edit-entry-message-spec.js b/lib/shared/messages/edit-entry-message-spec.js
index ec4806c1f..7d33526ba 100644
--- a/lib/shared/messages/edit-entry-message-spec.js
+++ b/lib/shared/messages/edit-entry-message-spec.js
@@ -1,184 +1,187 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   EditEntryMessageData,
   EditEntryMessageInfo,
   RawEditEntryMessageInfo,
 } from '../../types/messages/edit-entry';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import { prettyDate } from '../../utils/date-utils';
-import { ET, type EntityText } from '../../utils/entity-text';
 import {
-  robotextToRawString,
+  ET,
+  type EntityText,
+  entityTextToRawString,
+} from '../../utils/entity-text';
+import {
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
 import { stringForUser } from '../user-utils';
 import {
   pushTypes,
   type MessageSpec,
   type MessageTitleParam,
   type NotificationTextsParams,
 } from './message-spec';
 import { joinResult } from './utils';
 
 export const editEntryMessageSpec: MessageSpec<
   EditEntryMessageData,
   RawEditEntryMessageInfo,
   EditEntryMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: EditEntryMessageData | RawEditEntryMessageInfo,
   ): string {
     return JSON.stringify({
       entryID: data.entryID,
       date: data.date,
       text: data.text,
     });
   },
 
   messageContentForClientDB(data: RawEditEntryMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<EditEntryMessageInfo>) {
     let validMessageInfo: EditEntryMessageInfo = (messageInfo: EditEntryMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
     }
-    return robotextToRawString(
+    return entityTextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawEditEntryMessageInfo {
     const content = JSON.parse(row.content);
     return {
       type: messageTypes.EDIT_ENTRY,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       entryID: content.entryID,
       date: content.date,
       text: content.text,
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawEditEntryMessageInfo {
     invariant(
       clientDBMessageInfo.content !== null &&
         clientDBMessageInfo.content !== undefined,
       'content must be defined',
     );
     const content = JSON.parse(clientDBMessageInfo.content);
     const rawEditEntryMessageInfo: RawEditEntryMessageInfo = {
       type: messageTypes.EDIT_ENTRY,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       entryID: content.entryID,
       date: content.date,
       text: content.text,
     };
     return rawEditEntryMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawEditEntryMessageInfo,
     creator: RelativeUserInfo,
   ): EditEntryMessageInfo {
     return {
       type: messageTypes.EDIT_ENTRY,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       entryID: rawMessageInfo.entryID,
       date: rawMessageInfo.date,
       text: rawMessageInfo.text,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: EditEntryMessageData,
     id: ?string,
   ): RawEditEntryMessageInfo {
     invariant(id, 'RawEditEntryMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(messageInfo: EditEntryMessageInfo): EntityText {
     const date = prettyDate(messageInfo.date);
     const creator = ET.user({ userInfo: messageInfo.creator });
     const { text } = messageInfo;
     return ET`${creator} updated the text of an event scheduled for ${date}: "${text}"`;
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const hasCreateEntry = messageInfos.some(
       messageInfo => messageInfo.type === messageTypes.CREATE_ENTRY,
     );
     const messageInfo = messageInfos[0];
     if (!hasCreateEntry) {
       invariant(
         messageInfo.type === messageTypes.EDIT_ENTRY,
         'messageInfo should be messageTypes.EDIT_ENTRY!',
       );
       const body =
         `updated the text of an event in ` +
         `${params.notifThreadName(threadInfo)} scheduled for ` +
         `${prettyDate(messageInfo.date)}: "${messageInfo.text}"`;
       const prefix = stringForUser(messageInfo.creator);
       const merged = `${prefix} ${body}`;
       return {
         merged,
         title: threadInfo.uiName,
         body,
         prefix,
       };
     }
     invariant(
       messageInfo.type === messageTypes.CREATE_ENTRY ||
         messageInfo.type === messageTypes.EDIT_ENTRY,
       'messageInfo should be messageTypes.CREATE_ENTRY/EDIT_ENTRY!',
     );
     const prefix = stringForUser(messageInfo.creator);
     const body =
       `created an event in ${params.notifThreadName(threadInfo)} ` +
       `scheduled for ${prettyDate(messageInfo.date)}: "${messageInfo.text}"`;
     const merged = `${prefix} ${body}`;
     return {
       merged,
       title: threadInfo.uiName,
       body,
       prefix,
     };
   },
 
   notificationCollapseKey(rawMessageInfo: RawEditEntryMessageInfo): string {
     return joinResult(rawMessageInfo.creatorID, rawMessageInfo.entryID);
   },
 
   generatesNotifs: async () => pushTypes.NOTIF,
 });
diff --git a/lib/shared/messages/join-thread-message-spec.js b/lib/shared/messages/join-thread-message-spec.js
index 876cbc4e8..2696997fe 100644
--- a/lib/shared/messages/join-thread-message-spec.js
+++ b/lib/shared/messages/join-thread-message-spec.js
@@ -1,135 +1,138 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   JoinThreadMessageData,
   JoinThreadMessageInfo,
   RawJoinThreadMessageInfo,
 } from '../../types/messages/join-thread';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
-import { ET, type EntityText } from '../../utils/entity-text';
+import {
+  ET,
+  type EntityText,
+  entityTextToRawString,
+} from '../../utils/entity-text';
 import { values } from '../../utils/objects';
 import { pluralize } from '../../utils/text-utils';
 import {
-  robotextToRawString,
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
 import { stringForUser } from '../user-utils';
 import type {
   MessageSpec,
   MessageTitleParam,
   NotificationTextsParams,
 } from './message-spec';
 import { joinResult } from './utils';
 
 export const joinThreadMessageSpec: MessageSpec<
   JoinThreadMessageData,
   RawJoinThreadMessageInfo,
   JoinThreadMessageInfo,
 > = Object.freeze({
   rawMessageInfoFromServerDBRow(row: Object): RawJoinThreadMessageInfo {
     return {
       type: messageTypes.JOIN_THREAD,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawJoinThreadMessageInfo {
     const rawJoinThreadMessageInfo: RawJoinThreadMessageInfo = {
       type: messageTypes.JOIN_THREAD,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
     };
     return rawJoinThreadMessageInfo;
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<JoinThreadMessageInfo>) {
     let validMessageInfo: JoinThreadMessageInfo = (messageInfo: JoinThreadMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
     }
-    return robotextToRawString(
+    return entityTextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   createMessageInfo(
     rawMessageInfo: RawJoinThreadMessageInfo,
     creator: RelativeUserInfo,
   ): JoinThreadMessageInfo {
     return {
       type: messageTypes.JOIN_THREAD,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: JoinThreadMessageData,
     id: ?string,
   ): RawJoinThreadMessageInfo {
     invariant(id, 'RawJoinThreadMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(messageInfo: JoinThreadMessageInfo): EntityText {
     const creator = ET.user({ userInfo: messageInfo.creator });
     return ET`${creator} joined ${ET.thread({
       display: 'alwaysDisplayShortName',
       threadID: messageInfo.threadID,
     })}`;
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const joinerArray = {};
     for (const messageInfo of messageInfos) {
       invariant(
         messageInfo.type === messageTypes.JOIN_THREAD,
         'messageInfo should be messageTypes.JOIN_THREAD!',
       );
       joinerArray[messageInfo.creator.id] = messageInfo.creator;
     }
     const joiners = values(joinerArray);
     const joinersString = pluralize(joiners.map(stringForUser));
 
     const body = `${joinersString} joined`;
     const merged = `${body} ${params.notifThreadName(threadInfo)}`;
     return {
       merged,
       title: threadInfo.uiName,
       body,
     };
   },
 
   notificationCollapseKey(rawMessageInfo: RawJoinThreadMessageInfo): string {
     return joinResult(rawMessageInfo.type, rawMessageInfo.threadID);
   },
 
   generatesNotifs: async () => undefined,
 });
diff --git a/lib/shared/messages/leave-thread-message-spec.js b/lib/shared/messages/leave-thread-message-spec.js
index a4447dca1..575be8bac 100644
--- a/lib/shared/messages/leave-thread-message-spec.js
+++ b/lib/shared/messages/leave-thread-message-spec.js
@@ -1,135 +1,138 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   LeaveThreadMessageData,
   LeaveThreadMessageInfo,
   RawLeaveThreadMessageInfo,
 } from '../../types/messages/leave-thread';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
-import { ET, type EntityText } from '../../utils/entity-text';
+import {
+  ET,
+  type EntityText,
+  entityTextToRawString,
+} from '../../utils/entity-text';
 import { values } from '../../utils/objects';
 import { pluralize } from '../../utils/text-utils';
 import {
-  robotextToRawString,
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
 import { stringForUser } from '../user-utils';
 import type {
   MessageSpec,
   MessageTitleParam,
   NotificationTextsParams,
 } from './message-spec';
 import { joinResult } from './utils';
 
 export const leaveThreadMessageSpec: MessageSpec<
   LeaveThreadMessageData,
   RawLeaveThreadMessageInfo,
   LeaveThreadMessageInfo,
 > = Object.freeze({
   rawMessageInfoFromServerDBRow(row: Object): RawLeaveThreadMessageInfo {
     return {
       type: messageTypes.LEAVE_THREAD,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawLeaveThreadMessageInfo {
     const rawLeaveThreadMessageInfo: RawLeaveThreadMessageInfo = {
       type: messageTypes.LEAVE_THREAD,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
     };
     return rawLeaveThreadMessageInfo;
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<LeaveThreadMessageInfo>) {
     let validMessageInfo: LeaveThreadMessageInfo = (messageInfo: LeaveThreadMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
     }
-    return robotextToRawString(
+    return entityTextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   createMessageInfo(
     rawMessageInfo: RawLeaveThreadMessageInfo,
     creator: RelativeUserInfo,
   ): LeaveThreadMessageInfo {
     return {
       type: messageTypes.LEAVE_THREAD,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: LeaveThreadMessageData,
     id: ?string,
   ): RawLeaveThreadMessageInfo {
     invariant(id, 'RawLeaveThreadMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(messageInfo: LeaveThreadMessageInfo): EntityText {
     const creator = ET.user({ userInfo: messageInfo.creator });
     return ET`${creator} left ${ET.thread({
       display: 'alwaysDisplayShortName',
       threadID: messageInfo.threadID,
     })}`;
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const leaverBeavers = {};
     for (const messageInfo of messageInfos) {
       invariant(
         messageInfo.type === messageTypes.LEAVE_THREAD,
         'messageInfo should be messageTypes.LEAVE_THREAD!',
       );
       leaverBeavers[messageInfo.creator.id] = messageInfo.creator;
     }
     const leavers = values(leaverBeavers);
     const leaversString = pluralize(leavers.map(stringForUser));
 
     const body = `${leaversString} left`;
     const merged = `${body} ${params.notifThreadName(threadInfo)}`;
     return {
       merged,
       title: threadInfo.uiName,
       body,
     };
   },
 
   notificationCollapseKey(rawMessageInfo: RawLeaveThreadMessageInfo): string {
     return joinResult(rawMessageInfo.type, rawMessageInfo.threadID);
   },
 
   generatesNotifs: async () => undefined,
 });
diff --git a/lib/shared/messages/message-spec.js b/lib/shared/messages/message-spec.js
index e5f425efc..7bfb2a7c7 100644
--- a/lib/shared/messages/message-spec.js
+++ b/lib/shared/messages/message-spec.js
@@ -1,127 +1,120 @@
 // @flow
 
 import type { PlatformDetails } from '../../types/device-types';
 import type { Media } from '../../types/media-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
   RawComposableMessageInfo,
   RawMessageInfo,
   RawRobotextMessageInfo,
   RobotextMessageInfo,
 } from '../../types/message-types';
 import type { RawUnsupportedMessageInfo } from '../../types/messages/unsupported';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo, ThreadType } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import type { EntityText } from '../../utils/entity-text';
 import { type ParserRules } from '../markdown';
 import type { GetMessageTitleViewerContext } from '../message-utils';
 
 export type MessageTitleParam<Info> = {
   +messageInfo: Info,
   +threadInfo: ThreadInfo,
   +markdownRules: ParserRules,
   +viewerContext?: GetMessageTitleViewerContext,
 };
 
 export type RawMessageInfoFromServerDBRowParams = {
   +localID: ?string,
   +media?: $ReadOnlyArray<Media>,
   +derivedMessages: $ReadOnlyMap<
     string,
     RawComposableMessageInfo | RawRobotextMessageInfo,
   >,
 };
 
 export type CreateMessageInfoParams = {
   +threadInfos: { +[id: string]: ThreadInfo },
   +createMessageInfoFromRaw: (rawInfo: RawMessageInfo) => ?MessageInfo,
   +createRelativeUserInfos: (
     userIDs: $ReadOnlyArray<string>,
   ) => RelativeUserInfo[],
 };
 
 export type RobotextParams = {
-  +encodedThreadEntity: (threadID: string, text: string) => string,
-  +robotextForUsers: (users: RelativeUserInfo[]) => string,
-  +robotextForUser: (user: RelativeUserInfo) => string,
   +threadInfo: ?ThreadInfo,
 };
 
 export type NotificationTextsParams = {
   +notifThreadName: (threadInfo: ThreadInfo) => string,
   +notifTextForSubthreadCreation: (
     creator: RelativeUserInfo,
     threadType: ThreadType,
     parentThreadInfo: ThreadInfo,
     childThreadName: ?string,
     childThreadUIName: string,
   ) => NotifTexts,
   +strippedRobotextForMessageInfo: (
     messageInfo: RobotextMessageInfo,
     threadInfo: ThreadInfo,
   ) => string,
   +notificationTexts: (
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
   ) => NotifTexts,
 };
 
 export type GeneratesNotifsParams = {
   +notifTargetUserID: string,
   +userNotMemberOfSubthreads: Set<string>,
   +fetchMessageInfoByID: (messageID: string) => Promise<?RawMessageInfo>,
 };
 
 export const pushTypes = Object.freeze({
   NOTIF: 'notif',
   RESCIND: 'rescind',
 });
 export type PushType = $Values<typeof pushTypes>;
 
 export type MessageSpec<Data, RawInfo, Info> = {
   +messageContentForServerDB?: (data: Data | RawInfo) => string,
   +messageContentForClientDB?: (data: RawInfo) => string,
   +messageTitle: (param: MessageTitleParam<Info>) => string,
   +rawMessageInfoFromServerDBRow?: (
     row: Object,
     params: RawMessageInfoFromServerDBRowParams,
   ) => ?RawInfo,
   +rawMessageInfoFromClientDB: (
     clientDBMessageInfo: ClientDBMessageInfo,
   ) => RawInfo,
   +createMessageInfo: (
     rawMessageInfo: RawInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ) => ?Info,
   +rawMessageInfoFromMessageData?: (messageData: Data, id: ?string) => RawInfo,
-  +robotext?: (
-    messageInfo: Info,
-    creator: string,
-    params: RobotextParams,
-  ) => string | EntityText,
+  +robotext?: (messageInfo: Info, params: RobotextParams) => EntityText,
   +shimUnsupportedMessageInfo?: (
     rawMessageInfo: RawInfo,
     platformDetails: ?PlatformDetails,
   ) => RawInfo | RawUnsupportedMessageInfo,
   +unshimMessageInfo?: (
     unwrapped: RawInfo,
     messageInfo: RawMessageInfo,
   ) => ?RawMessageInfo,
   +notificationTexts?: (
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ) => NotifTexts,
   +notificationCollapseKey?: (rawMessageInfo: RawInfo) => string,
   +generatesNotifs: (
     rawMessageInfo: RawInfo,
     params: GeneratesNotifsParams,
   ) => Promise<?PushType>,
   +userIDs?: (rawMessageInfo: RawInfo) => $ReadOnlyArray<string>,
   +startsThread?: boolean,
   +threadIDs?: (rawMessageInfo: RawInfo) => $ReadOnlyArray<string>,
   +includedInRepliesCount?: boolean,
 };
diff --git a/lib/shared/messages/remove-members-message-spec.js b/lib/shared/messages/remove-members-message-spec.js
index 94b1d9e14..79e50f020 100644
--- a/lib/shared/messages/remove-members-message-spec.js
+++ b/lib/shared/messages/remove-members-message-spec.js
@@ -1,190 +1,190 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   RawRemoveMembersMessageInfo,
   RemoveMembersMessageData,
   RemoveMembersMessageInfo,
 } from '../../types/messages/remove-members';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import {
   ET,
   type EntityText,
   pluralizeEntityText,
+  entityTextToRawString,
 } from '../../utils/entity-text';
 import { values } from '../../utils/objects';
 import {
   robotextForMessageInfo,
-  robotextToRawString,
   removeCreatorAsViewer,
 } from '../message-utils';
 import type {
   CreateMessageInfoParams,
   MessageSpec,
   MessageTitleParam,
   NotificationTextsParams,
 } from './message-spec';
 import { joinResult } from './utils';
 
 export const removeMembersMessageSpec: MessageSpec<
   RemoveMembersMessageData,
   RawRemoveMembersMessageInfo,
   RemoveMembersMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: RemoveMembersMessageData | RawRemoveMembersMessageInfo,
   ): string {
     return JSON.stringify(data.removedUserIDs);
   },
 
   messageContentForClientDB(data: RawRemoveMembersMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<RemoveMembersMessageInfo>) {
     let validMessageInfo: RemoveMembersMessageInfo = (messageInfo: RemoveMembersMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
       validMessageInfo = {
         ...validMessageInfo,
         removedMembers: validMessageInfo.removedMembers.map(item => ({
           ...item,
           isViewer: false,
         })),
       };
     }
-    return robotextToRawString(
+    return entityTextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawRemoveMembersMessageInfo {
     return {
       type: messageTypes.REMOVE_MEMBERS,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       removedUserIDs: JSON.parse(row.content),
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawRemoveMembersMessageInfo {
     const content = clientDBMessageInfo.content;
     invariant(
       content !== undefined && content !== null,
       'content must be defined',
     );
     const rawRemoveMembersMessageInfo: RawRemoveMembersMessageInfo = {
       type: messageTypes.REMOVE_MEMBERS,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       removedUserIDs: JSON.parse(content),
     };
     return rawRemoveMembersMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawRemoveMembersMessageInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ): RemoveMembersMessageInfo {
     const removedMembers = params.createRelativeUserInfos(
       rawMessageInfo.removedUserIDs,
     );
     return {
       type: messageTypes.REMOVE_MEMBERS,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       removedMembers,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: RemoveMembersMessageData,
     id: ?string,
   ): RawRemoveMembersMessageInfo {
     invariant(id, 'RawRemoveMembersMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(messageInfo: RemoveMembersMessageInfo): EntityText {
     const users = messageInfo.removedMembers;
     invariant(users.length !== 0, 'added who??');
 
     const creator = ET.user({ userInfo: messageInfo.creator });
     const removedUsers = pluralizeEntityText(
       users.map(user => ET`${ET.user({ userInfo: user })}`),
     );
 
     return ET`${creator} removed ${removedUsers}`;
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const removedMembersObject = {};
     for (const messageInfo of messageInfos) {
       invariant(
         messageInfo.type === messageTypes.REMOVE_MEMBERS,
         'messageInfo should be messageTypes.REMOVE_MEMBERS!',
       );
       for (const member of messageInfo.removedMembers) {
         removedMembersObject[member.id] = member;
       }
     }
     const removedMembers = values(removedMembersObject);
 
     const mostRecentMessageInfo = messageInfos[0];
     invariant(
       mostRecentMessageInfo.type === messageTypes.REMOVE_MEMBERS,
       'messageInfo should be messageTypes.REMOVE_MEMBERS!',
     );
     const mergedMessageInfo = { ...mostRecentMessageInfo, removedMembers };
 
     const robotext = params.strippedRobotextForMessageInfo(
       mergedMessageInfo,
       threadInfo,
     );
     const merged = `${robotext} from ${params.notifThreadName(threadInfo)}`;
     return {
       merged,
       title: threadInfo.uiName,
       body: robotext,
     };
   },
 
   notificationCollapseKey(rawMessageInfo: RawRemoveMembersMessageInfo): string {
     return joinResult(
       rawMessageInfo.type,
       rawMessageInfo.threadID,
       rawMessageInfo.creatorID,
     );
   },
 
   generatesNotifs: async () => undefined,
 
   userIDs(rawMessageInfo: RawRemoveMembersMessageInfo): $ReadOnlyArray<string> {
     return rawMessageInfo.removedUserIDs;
   },
 });
diff --git a/lib/shared/messages/restore-entry-message-spec.js b/lib/shared/messages/restore-entry-message-spec.js
index db8c8dcf8..873bea751 100644
--- a/lib/shared/messages/restore-entry-message-spec.js
+++ b/lib/shared/messages/restore-entry-message-spec.js
@@ -1,158 +1,161 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   RawRestoreEntryMessageInfo,
   RestoreEntryMessageData,
   RestoreEntryMessageInfo,
 } from '../../types/messages/restore-entry';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import { prettyDate } from '../../utils/date-utils';
-import { ET, type EntityText } from '../../utils/entity-text';
 import {
-  robotextToRawString,
+  ET,
+  type EntityText,
+  entityTextToRawString,
+} from '../../utils/entity-text';
+import {
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
 import { stringForUser } from '../user-utils';
 import {
   pushTypes,
   type MessageSpec,
   type MessageTitleParam,
   type NotificationTextsParams,
 } from './message-spec';
 import { assertSingleMessageInfo } from './utils';
 
 export const restoreEntryMessageSpec: MessageSpec<
   RestoreEntryMessageData,
   RawRestoreEntryMessageInfo,
   RestoreEntryMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: RestoreEntryMessageData | RawRestoreEntryMessageInfo,
   ): string {
     return JSON.stringify({
       entryID: data.entryID,
       date: data.date,
       text: data.text,
     });
   },
 
   messageContentForClientDB(data: RawRestoreEntryMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<RestoreEntryMessageInfo>) {
     let validMessageInfo: RestoreEntryMessageInfo = (messageInfo: RestoreEntryMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
     }
-    return robotextToRawString(
+    return entityTextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawRestoreEntryMessageInfo {
     const content = JSON.parse(row.content);
     return {
       type: messageTypes.RESTORE_ENTRY,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       entryID: content.entryID,
       date: content.date,
       text: content.text,
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawRestoreEntryMessageInfo {
     invariant(
       clientDBMessageInfo.content !== undefined &&
         clientDBMessageInfo.content !== null,
       'content must be defined',
     );
     const content = JSON.parse(clientDBMessageInfo.content);
     const rawRestoreEntryMessageInfo: RawRestoreEntryMessageInfo = {
       type: messageTypes.RESTORE_ENTRY,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       entryID: content.entryID,
       date: content.date,
       text: content.text,
     };
     return rawRestoreEntryMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawRestoreEntryMessageInfo,
     creator: RelativeUserInfo,
   ): RestoreEntryMessageInfo {
     return {
       type: messageTypes.RESTORE_ENTRY,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       entryID: rawMessageInfo.entryID,
       date: rawMessageInfo.date,
       text: rawMessageInfo.text,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: RestoreEntryMessageData,
     id: ?string,
   ): RawRestoreEntryMessageInfo {
     invariant(id, 'RawRestoreEntryMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(messageInfo: RestoreEntryMessageInfo): EntityText {
     const date = prettyDate(messageInfo.date);
     const creator = ET.user({ userInfo: messageInfo.creator });
     const { text } = messageInfo;
     return ET`${creator} restored an event scheduled for ${date}: "${text}"`;
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): NotifTexts {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.RESTORE_ENTRY,
       'messageInfo should be messageTypes.RESTORE_ENTRY!',
     );
     const prefix = stringForUser(messageInfo.creator);
     const body =
       `restored an event in ${params.notifThreadName(threadInfo)} ` +
       `scheduled for ${prettyDate(messageInfo.date)}: "${messageInfo.text}"`;
     const merged = `${prefix} ${body}`;
     return {
       merged,
       title: threadInfo.uiName,
       body,
       prefix,
     };
   },
 
   generatesNotifs: async () => pushTypes.NOTIF,
 });
diff --git a/lib/shared/messages/unsupported-message-spec.js b/lib/shared/messages/unsupported-message-spec.js
index 63f1bc08b..dc007f021 100644
--- a/lib/shared/messages/unsupported-message-spec.js
+++ b/lib/shared/messages/unsupported-message-spec.js
@@ -1,100 +1,103 @@
 // @flow
 
 import invariant from 'invariant';
 
 import {
   messageTypes,
   type ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   RawUnsupportedMessageInfo,
   UnsupportedMessageInfo,
 } from '../../types/messages/unsupported';
 import type { RelativeUserInfo } from '../../types/user-types';
-import { ET, type EntityText } from '../../utils/entity-text';
 import {
-  robotextToRawString,
+  ET,
+  type EntityText,
+  entityTextToRawString,
+} from '../../utils/entity-text';
+import {
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
 import {
   pushTypes,
   type MessageSpec,
   type MessageTitleParam,
 } from './message-spec';
 
 export const unsupportedMessageSpec: MessageSpec<
   null,
   RawUnsupportedMessageInfo,
   UnsupportedMessageInfo,
 > = Object.freeze({
   messageContentForClientDB(data: RawUnsupportedMessageInfo): string {
     return JSON.stringify({
       robotext: data.robotext,
       dontPrefixCreator: data.dontPrefixCreator,
       unsupportedMessageInfo: data.unsupportedMessageInfo,
     });
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawUnsupportedMessageInfo {
     invariant(
       clientDBMessageInfo.content !== undefined &&
         clientDBMessageInfo.content !== null,
       'content must be defined',
     );
     const content = JSON.parse(clientDBMessageInfo.content);
     const rawUnsupportedMessageInfo: RawUnsupportedMessageInfo = {
       type: messageTypes.UNSUPPORTED,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       robotext: content.robotext,
       dontPrefixCreator: content.dontPrefixCreator,
       unsupportedMessageInfo: content.unsupportedMessageInfo,
     };
     return rawUnsupportedMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawUnsupportedMessageInfo,
     creator: RelativeUserInfo,
   ): UnsupportedMessageInfo {
     return {
       type: messageTypes.UNSUPPORTED,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       robotext: rawMessageInfo.robotext,
       dontPrefixCreator: rawMessageInfo.dontPrefixCreator,
       unsupportedMessageInfo: rawMessageInfo.unsupportedMessageInfo,
     };
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<UnsupportedMessageInfo>) {
     let validMessageInfo: UnsupportedMessageInfo = (messageInfo: UnsupportedMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
     }
-    return robotextToRawString(
+    return entityTextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   robotext(messageInfo: UnsupportedMessageInfo): EntityText {
     if (messageInfo.dontPrefixCreator) {
       return ET`${messageInfo.robotext}`;
     }
     const creator = ET.user({ userInfo: messageInfo.creator });
     return ET`${creator} ${messageInfo.robotext}`;
   },
 
   generatesNotifs: async () => pushTypes.NOTIF,
 });
diff --git a/lib/shared/messages/update-relationship-message-spec.js b/lib/shared/messages/update-relationship-message-spec.js
index 5e3a9748b..a73e25870 100644
--- a/lib/shared/messages/update-relationship-message-spec.js
+++ b/lib/shared/messages/update-relationship-message-spec.js
@@ -1,200 +1,203 @@
 // @flow
 
 import invariant from 'invariant';
 
 import type { PlatformDetails } from '../../types/device-types';
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type { RawUnsupportedMessageInfo } from '../../types/messages/unsupported';
 import type {
   RawUpdateRelationshipMessageInfo,
   UpdateRelationshipMessageData,
   UpdateRelationshipMessageInfo,
 } from '../../types/messages/update-relationship';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
-import { ET, type EntityText } from '../../utils/entity-text';
 import {
-  robotextToRawString,
+  ET,
+  type EntityText,
+  entityTextToRawString,
+} from '../../utils/entity-text';
+import {
   robotextForMessageInfo,
   removeCreatorAsViewer,
 } from '../message-utils';
 import { stringForUser } from '../user-utils';
 import { hasMinCodeVersion } from '../version-utils';
 import {
   pushTypes,
   type CreateMessageInfoParams,
   type MessageSpec,
   type MessageTitleParam,
 } from './message-spec';
 import { assertSingleMessageInfo } from './utils';
 
 export const updateRelationshipMessageSpec: MessageSpec<
   UpdateRelationshipMessageData,
   RawUpdateRelationshipMessageInfo,
   UpdateRelationshipMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: UpdateRelationshipMessageData | RawUpdateRelationshipMessageInfo,
   ): string {
     return JSON.stringify({
       operation: data.operation,
       targetID: data.targetID,
     });
   },
 
   messageContentForClientDB(data: RawUpdateRelationshipMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({
     messageInfo,
     threadInfo,
     viewerContext,
   }: MessageTitleParam<UpdateRelationshipMessageInfo>) {
     let validMessageInfo: UpdateRelationshipMessageInfo = (messageInfo: UpdateRelationshipMessageInfo);
     if (viewerContext === 'global_viewer') {
       validMessageInfo = removeCreatorAsViewer(validMessageInfo);
       validMessageInfo = {
         ...validMessageInfo,
         target: { ...validMessageInfo.target, isViewer: false },
       };
     }
-    return robotextToRawString(
+    return entityTextToRawString(
       robotextForMessageInfo(validMessageInfo, threadInfo),
     );
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawUpdateRelationshipMessageInfo {
     const content = JSON.parse(row.content);
     return {
       type: messageTypes.UPDATE_RELATIONSHIP,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       targetID: content.targetID,
       operation: content.operation,
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawUpdateRelationshipMessageInfo {
     invariant(
       clientDBMessageInfo.content !== undefined &&
         clientDBMessageInfo.content !== null,
       'content must be defined',
     );
     const content = JSON.parse(clientDBMessageInfo.content);
     const rawUpdateRelationshipMessageInfo: RawUpdateRelationshipMessageInfo = {
       type: messageTypes.UPDATE_RELATIONSHIP,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       targetID: content.targetID,
       operation: content.operation,
     };
     return rawUpdateRelationshipMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawUpdateRelationshipMessageInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ): ?UpdateRelationshipMessageInfo {
     const target = params.createRelativeUserInfos([rawMessageInfo.targetID])[0];
     if (!target) {
       return null;
     }
     return {
       type: messageTypes.UPDATE_RELATIONSHIP,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       target,
       time: rawMessageInfo.time,
       operation: rawMessageInfo.operation,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: UpdateRelationshipMessageData,
     id: ?string,
   ): RawUpdateRelationshipMessageInfo {
     invariant(id, 'RawUpdateRelationshipMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(messageInfo: UpdateRelationshipMessageInfo): EntityText {
     const creator = ET.user({ userInfo: messageInfo.creator });
     if (messageInfo.operation === 'request_sent') {
       const target = ET.user({ userInfo: messageInfo.target });
       return ET`${creator} sent ${target} a friend request`;
     } else if (messageInfo.operation === 'request_accepted') {
       const targetPossessive = ET.user({
         userInfo: messageInfo.target,
         possessive: true,
       });
       return ET`${creator} accepted ${targetPossessive} friend request`;
     }
     invariant(
       false,
       `Invalid operation ${messageInfo.operation} ` +
         `of message with type ${messageInfo.type}`,
     );
   },
 
   shimUnsupportedMessageInfo(
     rawMessageInfo: RawUpdateRelationshipMessageInfo,
     platformDetails: ?PlatformDetails,
   ): RawUpdateRelationshipMessageInfo | RawUnsupportedMessageInfo {
     if (hasMinCodeVersion(platformDetails, 71)) {
       return rawMessageInfo;
     }
     const { id } = rawMessageInfo;
     invariant(id !== null && id !== undefined, 'id should be set on server');
     return {
       type: messageTypes.UNSUPPORTED,
       id,
       threadID: rawMessageInfo.threadID,
       creatorID: rawMessageInfo.creatorID,
       time: rawMessageInfo.time,
       robotext: 'performed a relationship action',
       unsupportedMessageInfo: rawMessageInfo,
     };
   },
 
   unshimMessageInfo(
     unwrapped: RawUpdateRelationshipMessageInfo,
   ): RawUpdateRelationshipMessageInfo {
     return unwrapped;
   },
 
   notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
   ): NotifTexts {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     const prefix = stringForUser(messageInfo.creator);
     const title = threadInfo.uiName;
     const body =
       messageInfo.operation === 'request_sent'
         ? 'sent you a friend request'
         : 'accepted your friend request';
     const merged = `${prefix} ${body}`;
     return {
       merged,
       body,
       title,
       prefix,
     };
   },
 
   generatesNotifs: async () => pushTypes.NOTIF,
 });
diff --git a/lib/shared/notif-utils.js b/lib/shared/notif-utils.js
index bc3cc0973..2b1837e8b 100644
--- a/lib/shared/notif-utils.js
+++ b/lib/shared/notif-utils.js
@@ -1,146 +1,141 @@
 // @flow
 
 import invariant from 'invariant';
 
 import {
   type MessageInfo,
   type RawMessageInfo,
   type RobotextMessageInfo,
   type MessageType,
 } from '../types/message-types';
 import type { NotifTexts } from '../types/notif-types';
 import type { ThreadInfo, ThreadType } from '../types/thread-types';
 import type { RelativeUserInfo } from '../types/user-types';
+import { entityTextToRawString } from '../utils/entity-text';
 import { trimText } from '../utils/text-utils';
-import { robotextForMessageInfo, robotextToRawString } from './message-utils';
+import { robotextForMessageInfo } from './message-utils';
 import { messageSpecs } from './messages/message-specs';
 import { threadNoun } from './thread-utils';
 import { stringForUser } from './user-utils';
 
 function notifTextsForMessageInfo(
   messageInfos: MessageInfo[],
   threadInfo: ThreadInfo,
 ): NotifTexts {
   const fullNotifTexts = fullNotifTextsForMessageInfo(messageInfos, threadInfo);
   const merged = trimText(fullNotifTexts.merged, 300);
   const body = trimText(fullNotifTexts.body, 300);
   const title = trimText(fullNotifTexts.title, 100);
   if (!fullNotifTexts.prefix) {
     return { merged, body, title };
   }
   const prefix = trimText(fullNotifTexts.prefix, 50);
   return { merged, body, title, prefix };
 }
 
 const notifTextForSubthreadCreation = (
   creator: RelativeUserInfo,
   threadType: ThreadType,
   parentThreadInfo: ThreadInfo,
   childThreadName: ?string,
   childThreadUIName: string,
 ) => {
   const prefix = stringForUser(creator);
   let body = `created a new ${threadNoun(threadType)}`;
   if (parentThreadInfo.name) {
     body += ` in ${parentThreadInfo.name}`;
   }
   let merged = `${prefix} ${body}`;
   if (childThreadName) {
     merged += ` called "${childThreadName}"`;
   }
   return {
     merged,
     body,
     title: childThreadUIName,
     prefix,
   };
 };
 
 function notifThreadName(threadInfo: ThreadInfo): string {
   if (threadInfo.name) {
     return threadInfo.name;
   } else {
     return 'your chat';
   }
 }
 
 function mostRecentMessageInfoType(
   messageInfos: $ReadOnlyArray<MessageInfo>,
 ): MessageType {
   if (messageInfos.length === 0) {
     throw new Error('expected MessageInfo, but none present!');
   }
   return messageInfos[0].type;
 }
 
 function fullNotifTextsForMessageInfo(
   messageInfos: $ReadOnlyArray<MessageInfo>,
   threadInfo: ThreadInfo,
 ): NotifTexts {
   const mostRecentType = mostRecentMessageInfoType(messageInfos);
   const messageSpec = messageSpecs[mostRecentType];
   invariant(
     messageSpec.notificationTexts,
     `we're not aware of messageType ${mostRecentType}`,
   );
   return messageSpec.notificationTexts(messageInfos, threadInfo, {
     notifThreadName,
     notifTextForSubthreadCreation,
     strippedRobotextForMessageInfo,
     notificationTexts: fullNotifTextsForMessageInfo,
   });
 }
 
 function strippedRobotextForMessageInfo(
   messageInfo: RobotextMessageInfo,
   threadInfo: ThreadInfo,
 ): string {
   const robotext = robotextForMessageInfo(messageInfo, threadInfo);
   const threadName = notifThreadName(threadInfo);
-  if (typeof robotext === 'string') {
-    const threadEntityRegex = new RegExp(`<[^<>\\|]+\\|t${threadInfo.id}>`);
-    const threadMadeExplicit = robotext.replace(threadEntityRegex, threadName);
-    return robotextToRawString(threadMadeExplicit);
-  } else {
-    const threadMadeExplicit = robotext.map(entity => {
-      if (
-        typeof entity !== 'string' &&
-        entity.type === 'thread' &&
-        entity.id === threadInfo.id
-      ) {
-        return threadName;
-      }
-      return entity;
-    });
-    return robotextToRawString(threadMadeExplicit);
-  }
+  const threadMadeExplicit = robotext.map(entity => {
+    if (
+      typeof entity !== 'string' &&
+      entity.type === 'thread' &&
+      entity.id === threadInfo.id
+    ) {
+      return threadName;
+    }
+    return entity;
+  });
+  return entityTextToRawString(threadMadeExplicit);
 }
 
 function notifCollapseKeyForRawMessageInfo(
   rawMessageInfo: RawMessageInfo,
 ): ?string {
   const messageSpec = messageSpecs[rawMessageInfo.type];
   return messageSpec.notificationCollapseKey?.(rawMessageInfo) ?? null;
 }
 
 type Unmerged = $ReadOnly<{
   body: string,
   title: string,
   prefix?: string,
   ...
 }>;
 type Merged = {
   body: string,
   title: string,
 };
 function mergePrefixIntoBody(unmerged: Unmerged): Merged {
   const { body, title, prefix } = unmerged;
   const merged = prefix ? `${prefix} ${body}` : body;
   return { body: merged, title };
 }
 
 export {
   notifTextsForMessageInfo,
   notifCollapseKeyForRawMessageInfo,
   mergePrefixIntoBody,
 };
diff --git a/native/chat/chat-item-height-measurer.react.js b/native/chat/chat-item-height-measurer.react.js
index d5eab2840..eaabbad73 100644
--- a/native/chat/chat-item-height-measurer.react.js
+++ b/native/chat/chat-item-height-measurer.react.js
@@ -1,178 +1,179 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import type { ChatMessageItem } from 'lib/selectors/chat-selectors';
-import { messageID, robotextToRawString } from 'lib/shared/message-utils';
+import { messageID } from 'lib/shared/message-utils';
 import { messageTypes, type MessageType } from 'lib/types/message-types';
+import { entityTextToRawString } from 'lib/utils/entity-text';
 
 import NodeHeightMeasurer from '../components/node-height-measurer.react';
 import { InputStateContext } from '../input/input-state';
 import type { MeasurementTask } from './chat-context-provider.react';
 import { useComposedMessageMaxWidth } from './composed-message-width';
 import { dummyNodeForRobotextMessageHeightMeasurement } from './inner-robotext-message.react';
 import { dummyNodeForTextMessageHeightMeasurement } from './inner-text-message.react';
 import { MessageListContextProvider } from './message-list-types';
 import { multimediaMessageContentSizes } from './multimedia-message-utils';
 import { chatMessageItemKey } from './utils';
 
 type Props = {
   +measurement: MeasurementTask,
 };
 
 const heightMeasurerKey = (item: ChatMessageItem) => {
   if (item.itemType !== 'message') {
     return null;
   }
   const { messageInfo } = item;
   if (messageInfo.type === messageTypes.TEXT) {
     return messageInfo.text;
   } else if (item.robotext) {
-    return robotextToRawString(item.robotext, item.messageInfo.threadID);
+    return entityTextToRawString(item.robotext, item.messageInfo.threadID);
   }
   return null;
 };
 
 const heightMeasurerDummy = (item: ChatMessageItem) => {
   invariant(
     item.itemType === 'message',
     'NodeHeightMeasurer asked for dummy for non-message item',
   );
   const { messageInfo } = item;
   if (messageInfo.type === messageTypes.TEXT) {
     return dummyNodeForTextMessageHeightMeasurement(messageInfo.text);
   } else if (item.robotext) {
     return dummyNodeForRobotextMessageHeightMeasurement(
       item.robotext,
       item.messageInfo.threadID,
     );
   }
   invariant(false, 'NodeHeightMeasurer asked for dummy for non-text message');
 };
 
 function ChatItemHeightMeasurer(props: Props) {
   const composedMessageMaxWidth = useComposedMessageMaxWidth();
   const inputState = React.useContext(InputStateContext);
   const inputStatePendingUploads = inputState?.pendingUploads;
 
   const { measurement } = props;
   const { threadInfo } = measurement;
   const heightMeasurerMergeItem = React.useCallback(
     (item: ChatMessageItem, height: ?number) => {
       if (item.itemType !== 'message') {
         return item;
       }
 
       const { messageInfo } = item;
       const messageType: MessageType = messageInfo.type;
       invariant(
         messageType !== messageTypes.SIDEBAR_SOURCE,
         'Sidebar source messages should be replaced by sourceMessage before being measured',
       );
 
       if (
         messageInfo.type === messageTypes.IMAGES ||
         messageInfo.type === messageTypes.MULTIMEDIA
       ) {
         // Conditional due to Flow...
         const localMessageInfo = item.localMessageInfo
           ? item.localMessageInfo
           : null;
         const id = messageID(messageInfo);
         const pendingUploads = inputStatePendingUploads?.[id];
         const sizes = multimediaMessageContentSizes(
           messageInfo,
           composedMessageMaxWidth,
         );
         return {
           itemType: 'message',
           messageShapeType: 'multimedia',
           messageInfo,
           localMessageInfo,
           threadInfo,
           startsConversation: item.startsConversation,
           startsCluster: item.startsCluster,
           endsCluster: item.endsCluster,
           threadCreatedFromMessage: item.threadCreatedFromMessage,
           pendingUploads,
           reactions: item.reactions,
           ...sizes,
         };
       }
 
       invariant(
         height !== null && height !== undefined,
         'height should be set',
       );
       if (messageInfo.type === messageTypes.TEXT) {
         // Conditional due to Flow...
         const localMessageInfo = item.localMessageInfo
           ? item.localMessageInfo
           : null;
         return {
           itemType: 'message',
           messageShapeType: 'text',
           messageInfo,
           localMessageInfo,
           threadInfo,
           startsConversation: item.startsConversation,
           startsCluster: item.startsCluster,
           endsCluster: item.endsCluster,
           threadCreatedFromMessage: item.threadCreatedFromMessage,
           contentHeight: height,
           reactions: item.reactions,
         };
       }
       invariant(
         item.messageInfoType !== 'composable',
         'ChatItemHeightMeasurer was handed a messageInfoType=composable, but ' +
           `does not know how to handle MessageType ${messageInfo.type}`,
       );
       invariant(
         item.messageInfoType === 'robotext',
         'ChatItemHeightMeasurer was handed a messageInfoType that it does ' +
           `not recognize: ${item.messageInfoType}`,
       );
       return {
         itemType: 'message',
         messageShapeType: 'robotext',
         messageInfo,
         threadInfo,
         startsConversation: item.startsConversation,
         startsCluster: item.startsCluster,
         endsCluster: item.endsCluster,
         threadCreatedFromMessage: item.threadCreatedFromMessage,
         robotext: item.robotext,
         contentHeight: height,
         reactions: item.reactions,
       };
     },
     [composedMessageMaxWidth, inputStatePendingUploads, threadInfo],
   );
 
   return (
     <MessageListContextProvider
       threadID={threadInfo.id}
       key={measurement.measurerID}
     >
       <NodeHeightMeasurer
         listData={measurement.messages}
         itemToID={chatMessageItemKey}
         itemToMeasureKey={heightMeasurerKey}
         itemToDummy={heightMeasurerDummy}
         mergeItemWithHeight={heightMeasurerMergeItem}
         allHeightsMeasured={measurement.onMessagesMeasured}
         inputState={inputState}
         composedMessageMaxWidth={composedMessageMaxWidth}
         initialMeasuredHeights={measurement.initialMeasuredHeights}
       />
     </MessageListContextProvider>
   );
 }
 
 const MemoizedChatItemHeightMeasurer: React.ComponentType<Props> = React.memo<Props>(
   ChatItemHeightMeasurer,
 );
 
 export default MemoizedChatItemHeightMeasurer;
diff --git a/native/chat/inner-robotext-message.react.js b/native/chat/inner-robotext-message.react.js
index 99d28ba5e..0178a1a0f 100644
--- a/native/chat/inner-robotext-message.react.js
+++ b/native/chat/inner-robotext-message.react.js
@@ -1,180 +1,141 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { Text, TouchableWithoutFeedback, View } from 'react-native';
 
 import { threadInfoSelector } from 'lib/selectors/thread-selectors';
 import {
-  splitRobotext,
-  parseRobotextEntity,
-  robotextToRawString,
-} from 'lib/shared/message-utils';
-import { entityTextToReact, type EntityText } from 'lib/utils/entity-text';
+  entityTextToReact,
+  entityTextToRawString,
+  type EntityText,
+} from 'lib/utils/entity-text';
 
 import Markdown from '../markdown/markdown.react';
 import { inlineMarkdownRules } from '../markdown/rules.react';
 import { useSelector } from '../redux/redux-utils';
 import { useOverlayStyles } from '../themes/colors';
 import type { ChatRobotextMessageInfoItemWithHeight } from '../types/chat-types';
 import { useNavigateToThread } from './message-list-types';
 
 function dummyNodeForRobotextMessageHeightMeasurement(
-  robotext: string | EntityText,
+  robotext: EntityText,
   threadID: string,
 ): React.Element<typeof View> {
   return (
     <View style={unboundStyles.robotextContainer}>
       <Text style={unboundStyles.dummyRobotext}>
-        {robotextToRawString(robotext, threadID)}
+        {entityTextToRawString(robotext, threadID)}
       </Text>
     </View>
   );
 }
 
 type InnerRobotextMessageProps = {
   +item: ChatRobotextMessageInfoItemWithHeight,
   +onPress: () => void,
   +onLongPress?: () => void,
 };
 function InnerRobotextMessage(props: InnerRobotextMessageProps): React.Node {
   const { item, onLongPress, onPress } = props;
   const activeTheme = useSelector(state => state.globalThemeInfo.activeTheme);
   const styles = useOverlayStyles(unboundStyles);
 
   const { messageInfo, robotext } = item;
   const { threadID } = messageInfo;
   const textParts = React.useMemo(() => {
     const darkColor = activeTheme === 'dark';
-
-    if (typeof robotext !== 'string') {
-      return entityTextToReact(robotext, threadID, {
-        // eslint-disable-next-line react/display-name
-        renderText: ({ text }) => (
-          <Markdown
-            style={styles.robotext}
-            rules={inlineMarkdownRules(darkColor)}
-          >
-            {text}
-          </Markdown>
-        ),
-        // eslint-disable-next-line react/display-name
-        renderThread: ({ id, name }) => <ThreadEntity id={id} name={name} />,
-        // eslint-disable-next-line react/display-name
-        renderColor: ({ hex }) => <ColorEntity color={hex} />,
-      });
-    }
-
-    const robotextParts = splitRobotext(robotext);
-    const result = [];
-    let keyIndex = 0;
-
-    for (const splitPart of robotextParts) {
-      if (splitPart === '') {
-        continue;
-      }
-      const key = `text${keyIndex++}`;
-      if (splitPart.charAt(0) !== '<') {
-        result.push(
-          <Markdown
-            style={styles.robotext}
-            key={key}
-            rules={inlineMarkdownRules(darkColor)}
-          >
-            {decodeURI(splitPart)}
-          </Markdown>,
-        );
-        continue;
-      }
-
-      const { rawText, entityType, id } = parseRobotextEntity(splitPart);
-
-      if (entityType === 't' && id !== threadID) {
-        result.push(<ThreadEntity key={key} id={id} name={rawText} />);
-      } else if (entityType === 'c') {
-        result.push(<ColorEntity key={key} color={rawText} />);
-      } else {
-        result.push(rawText);
-      }
-    }
-
-    return result;
+    return entityTextToReact(robotext, threadID, {
+      // eslint-disable-next-line react/display-name
+      renderText: ({ text }) => (
+        <Markdown
+          style={styles.robotext}
+          rules={inlineMarkdownRules(darkColor)}
+        >
+          {text}
+        </Markdown>
+      ),
+      // eslint-disable-next-line react/display-name
+      renderThread: ({ id, name }) => <ThreadEntity id={id} name={name} />,
+      // eslint-disable-next-line react/display-name
+      renderColor: ({ hex }) => <ColorEntity color={hex} />,
+    });
   }, [robotext, activeTheme, threadID, styles.robotext]);
 
   const viewStyle = [styles.robotextContainer];
   if (!__DEV__) {
     // We don't force view height in dev mode because we
     // want to measure it in Message to see if it's correct
     viewStyle.push({ height: item.contentHeight });
   }
 
   return (
     <TouchableWithoutFeedback onPress={onPress} onLongPress={onLongPress}>
       <View style={viewStyle}>
         <Text style={styles.robotext}>{textParts}</Text>
       </View>
     </TouchableWithoutFeedback>
   );
 }
 
 type ThreadEntityProps = {
   +id: string,
   +name: string,
 };
 function ThreadEntity(props: ThreadEntityProps) {
   const threadID = props.id;
   const threadInfo = useSelector(state => threadInfoSelector(state)[threadID]);
 
   const styles = useOverlayStyles(unboundStyles);
 
   const navigateToThread = useNavigateToThread();
   const onPressThread = React.useCallback(() => {
     invariant(threadInfo, 'onPressThread should have threadInfo');
     navigateToThread({ threadInfo });
   }, [threadInfo, navigateToThread]);
 
   if (!threadInfo) {
     return <Text>{props.name}</Text>;
   }
   return (
     <Text style={styles.link} onPress={onPressThread}>
       {props.name}
     </Text>
   );
 }
 
 function ColorEntity(props: { +color: string }) {
   const colorStyle = { color: props.color };
   return <Text style={colorStyle}>{props.color}</Text>;
 }
 
 const unboundStyles = {
   link: {
     color: 'link',
   },
   robotextContainer: {
     paddingTop: 6,
     paddingBottom: 11,
     paddingHorizontal: 24,
   },
   robotext: {
     color: 'listForegroundSecondaryLabel',
     fontFamily: 'Arial',
     fontSize: 15,
     textAlign: 'center',
   },
   dummyRobotext: {
     fontFamily: 'Arial',
     fontSize: 15,
     textAlign: 'center',
   },
 };
 
 const MemoizedInnerRobotextMessage: React.ComponentType<InnerRobotextMessageProps> = React.memo<InnerRobotextMessageProps>(
   InnerRobotextMessage,
 );
 
 export {
   dummyNodeForRobotextMessageHeightMeasurement,
   MemoizedInnerRobotextMessage as InnerRobotextMessage,
 };
diff --git a/native/types/chat-types.js b/native/types/chat-types.js
index df3876711..18590d710 100644
--- a/native/types/chat-types.js
+++ b/native/types/chat-types.js
@@ -1,70 +1,70 @@
 // @flow
 
 import type { MessageReactionInfo } from 'lib/selectors/chat-selectors';
 import type {
   LocalMessageInfo,
   MultimediaMessageInfo,
   RobotextMessageInfo,
 } from 'lib/types/message-types';
 import type { TextMessageInfo } from 'lib/types/messages/text';
 import type { ThreadInfo } from 'lib/types/thread-types';
 import type { EntityText } from 'lib/utils/entity-text';
 
 import type { MessagePendingUploads } from '../input/input-state';
 
 export type ChatRobotextMessageInfoItemWithHeight = {
   +itemType: 'message',
   +messageShapeType: 'robotext',
   +messageInfo: RobotextMessageInfo,
   +threadInfo: ThreadInfo,
   +startsConversation: boolean,
   +startsCluster: boolean,
   +endsCluster: boolean,
-  +robotext: string | EntityText,
+  +robotext: EntityText,
   +threadCreatedFromMessage: ?ThreadInfo,
   +contentHeight: number,
   +reactions: $ReadOnlyMap<string, MessageReactionInfo>,
 };
 
 export type ChatTextMessageInfoItemWithHeight = {
   +itemType: 'message',
   +messageShapeType: 'text',
   +messageInfo: TextMessageInfo,
   +localMessageInfo: ?LocalMessageInfo,
   +threadInfo: ThreadInfo,
   +startsConversation: boolean,
   +startsCluster: boolean,
   +endsCluster: boolean,
   +contentHeight: number,
   +threadCreatedFromMessage: ?ThreadInfo,
   +reactions: $ReadOnlyMap<string, MessageReactionInfo>,
 };
 
 export type MultimediaContentSizes = {
   +imageHeight: number,
   +contentHeight: number,
   +contentWidth: number,
 };
 export type ChatMultimediaMessageInfoItem = {
   ...MultimediaContentSizes,
   +itemType: 'message',
   +messageShapeType: 'multimedia',
   +messageInfo: MultimediaMessageInfo,
   +localMessageInfo: ?LocalMessageInfo,
   +threadInfo: ThreadInfo,
   +startsConversation: boolean,
   +startsCluster: boolean,
   +endsCluster: boolean,
   +threadCreatedFromMessage: ?ThreadInfo,
   +pendingUploads: ?MessagePendingUploads,
   +reactions: $ReadOnlyMap<string, MessageReactionInfo>,
 };
 
 export type ChatMessageInfoItemWithHeight =
   | ChatRobotextMessageInfoItemWithHeight
   | ChatTextMessageInfoItemWithHeight
   | ChatMultimediaMessageInfoItem;
 
 export type ChatMessageItemWithHeight =
   | { itemType: 'loader' }
   | ChatMessageInfoItemWithHeight;
diff --git a/web/chat/robotext-message.react.js b/web/chat/robotext-message.react.js
index eb2164f92..0c35e9529 100644
--- a/web/chat/robotext-message.react.js
+++ b/web/chat/robotext-message.react.js
@@ -1,190 +1,149 @@
 // @flow
 
 import * as React from 'react';
 import { useDispatch } from 'react-redux';
 
 import { type RobotextChatMessageInfoItem } from 'lib/selectors/chat-selectors';
 import { threadInfoSelector } from 'lib/selectors/thread-selectors';
-import { splitRobotext, parseRobotextEntity } from 'lib/shared/message-utils';
 import type { Dispatch } from 'lib/types/redux-types';
 import { type ThreadInfo } from 'lib/types/thread-types';
-import { type EntityText, entityTextToReact } from 'lib/utils/entity-text';
+import { entityTextToReact } from 'lib/utils/entity-text';
 
 import Markdown from '../markdown/markdown.react';
 import { linkRules } from '../markdown/rules.react';
 import { updateNavInfoActionType } from '../redux/action-types';
 import { useSelector } from '../redux/redux-utils';
 import { tooltipPositions, useMessageTooltip } from '../utils/tooltip-utils';
 import InlineEngagement from './inline-engagement.react';
 import css from './robotext-message.css';
 
 const availableTooltipPositionsForRobotext = [
   tooltipPositions.LEFT,
   tooltipPositions.LEFT_TOP,
   tooltipPositions.LEFT_BOTTOM,
   tooltipPositions.RIGHT,
   tooltipPositions.RIGHT_TOP,
   tooltipPositions.RIGHT_BOTTOM,
 ];
 
 type BaseProps = {
   +item: RobotextChatMessageInfoItem,
   +threadInfo: ThreadInfo,
 };
 type Props = {
   ...BaseProps,
   +onMouseLeave: ?() => mixed,
   +onMouseEnter: (event: SyntheticEvent<HTMLDivElement>) => mixed,
 };
 class RobotextMessage extends React.PureComponent<Props> {
   render() {
     let inlineEngagement;
     if (
       this.props.item.threadCreatedFromMessage ||
       this.props.item.reactions.size > 0
     ) {
       inlineEngagement = (
         <div className={css.sidebarMarginTop}>
           <InlineEngagement
             threadInfo={this.props.item.threadCreatedFromMessage}
             reactions={this.props.item.reactions}
             positioning="center"
           />
         </div>
       );
     }
 
     return (
       <div className={css.robotextContainer}>
         <div
           className={css.innerRobotextContainer}
           onMouseEnter={this.props.onMouseEnter}
           onMouseLeave={this.props.onMouseLeave}
         >
           <span>{this.linkedRobotext()}</span>
         </div>
         {inlineEngagement}
       </div>
     );
   }
 
   linkedRobotext() {
     const { item } = this.props;
     const { robotext } = item;
     const { threadID } = item.messageInfo;
-    if (typeof robotext === 'string') {
-      return this.renderStringRobotext(robotext, threadID);
-    } else {
-      return this.renderEntityText(robotext, threadID);
-    }
-  }
-
-  renderStringRobotext(robotext: string, threadID: string): React.Node {
-    const robotextParts = splitRobotext(robotext);
-    const textParts = [];
-    let keyIndex = 0;
-    for (const splitPart of robotextParts) {
-      if (splitPart === '') {
-        continue;
-      }
-      const key = `text${keyIndex++}`;
-      if (splitPart.charAt(0) !== '<') {
-        textParts.push(
-          <Markdown key={key} rules={linkRules(false)}>
-            {decodeURI(splitPart)}
-          </Markdown>,
-        );
-        continue;
-      }
-
-      const { rawText, entityType, id } = parseRobotextEntity(splitPart);
-
-      if (entityType === 't' && id !== threadID) {
-        textParts.push(<ThreadEntity key={key} id={id} name={rawText} />);
-      } else if (entityType === 'c') {
-        textParts.push(<ColorEntity key={key} color={rawText} />);
-      } else {
-        textParts.push(rawText);
-      }
-    }
-
-    return textParts;
-  }
-
-  renderEntityText(entityText: EntityText, threadID: string): React.Node {
-    return entityTextToReact(entityText, threadID, {
+    return entityTextToReact(robotext, threadID, {
       renderText: ({ text }) => (
         <Markdown rules={linkRules(false)}>{text}</Markdown>
       ),
       renderThread: ({ id, name }) => <ThreadEntity id={id} name={name} />,
       renderColor: ({ hex }) => <ColorEntity color={hex} />,
     });
   }
 }
 type BaseInnerThreadEntityProps = {
   +id: string,
   +name: string,
 };
 type InnerThreadEntityProps = {
   ...BaseInnerThreadEntityProps,
   +threadInfo: ThreadInfo,
   +dispatch: Dispatch,
 };
 class InnerThreadEntity extends React.PureComponent<InnerThreadEntityProps> {
   render() {
     return <a onClick={this.onClickThread}>{this.props.name}</a>;
   }
 
   onClickThread = (event: SyntheticEvent<HTMLAnchorElement>) => {
     event.preventDefault();
     const id = this.props.id;
     this.props.dispatch({
       type: updateNavInfoActionType,
       payload: {
         activeChatThreadID: id,
       },
     });
   };
 }
 const ThreadEntity = React.memo<BaseInnerThreadEntityProps>(
   function ConnectedInnerThreadEntity(props: BaseInnerThreadEntityProps) {
     const { id } = props;
     const threadInfo = useSelector(state => threadInfoSelector(state)[id]);
     const dispatch = useDispatch();
 
     return (
       <InnerThreadEntity
         {...props}
         threadInfo={threadInfo}
         dispatch={dispatch}
       />
     );
   },
 );
 
 function ColorEntity(props: { color: string }) {
   const colorStyle = { color: props.color };
   return <span style={colorStyle}>{props.color}</span>;
 }
 
 const ConnectedRobotextMessage: React.ComponentType<BaseProps> = React.memo<BaseProps>(
   function ConnectedRobotextMessage(props) {
     const { item, threadInfo } = props;
 
     const { onMouseLeave, onMouseEnter } = useMessageTooltip({
       item,
       threadInfo,
       availablePositions: availableTooltipPositionsForRobotext,
     });
 
     return (
       <RobotextMessage
         {...props}
         onMouseLeave={onMouseLeave}
         onMouseEnter={onMouseEnter}
       />
     );
   },
 );
 
 export default ConnectedRobotextMessage;