diff --git a/lib/shared/notif-utils.js b/lib/shared/notif-utils.js
index d59bf539d..3c43c35fd 100644
--- a/lib/shared/notif-utils.js
+++ b/lib/shared/notif-utils.js
@@ -1,531 +1,534 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { contentStringForMediaArray } from '../media/media-utils';
 import {
   type MessageInfo,
   type RawMessageInfo,
   type RobotextMessageInfo,
   type MessageType,
   messageTypes,
 } from '../types/message-types';
-import type { ThreadInfo } from '../types/thread-types';
+import type { ThreadInfo, ThreadType } from '../types/thread-types';
 import type { RelativeUserInfo } from '../types/user-types';
 import { prettyDate } from '../utils/date-utils';
 import { values } from '../utils/objects';
 import { pluralize } from '../utils/text-utils';
 import { robotextForMessageInfo, robotextToRawString } from './message-utils';
-import { threadIsGroupChat } from './thread-utils';
+import { threadIsGroupChat, threadNoun } from './thread-utils';
 import { stringForUser } from './user-utils';
 
 type NotifTexts = {|
   merged: string,
   body: string,
   title: string,
   prefix?: string,
 |};
 function notifTextsForMessageInfo(
   messageInfos: MessageInfo[],
   threadInfo: ThreadInfo,
 ): NotifTexts {
   const fullNotifTexts = fullNotifTextsForMessageInfo(messageInfos, threadInfo);
   const result: NotifTexts = {
     merged: trimNotifText(fullNotifTexts.merged, 300),
     body: trimNotifText(fullNotifTexts.body, 300),
     title: trimNotifText(fullNotifTexts.title, 100),
   };
   if (fullNotifTexts.prefix) {
     result.prefix = trimNotifText(fullNotifTexts.prefix, 50);
   }
   return result;
 }
 
 function trimNotifText(text: string, maxLength: number): string {
   if (text.length <= maxLength) {
     return text;
   }
   return text.substr(0, maxLength - 3) + '...';
 }
 
 const notifTextForSubthreadCreation = (
   creator: RelativeUserInfo,
+  threadType: ThreadType,
   parentThreadInfo: ThreadInfo,
   childThreadName: ?string,
   childThreadUIName: string,
 ) => {
   const prefix = stringForUser(creator);
-  let body = `created a new thread`;
+  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 thread';
   }
 }
 
 function assertSingleMessageInfo(
   messageInfos: $ReadOnlyArray<MessageInfo>,
 ): MessageInfo {
   if (messageInfos.length === 0) {
     throw new Error('expected single MessageInfo, but none present!');
   } else if (messageInfos.length !== 1) {
     const messageIDs = messageInfos.map((messageInfo) => messageInfo.id);
     console.log(
       'expected single MessageInfo, but there are multiple! ' +
         messageIDs.join(', '),
     );
   }
   return messageInfos[0];
 }
 
 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: MessageInfo[],
   threadInfo: ThreadInfo,
 ): NotifTexts {
   const mostRecentType = mostRecentMessageInfoType(messageInfos);
   if (mostRecentType === messageTypes.TEXT) {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.TEXT,
       'messageInfo should be messageTypes.TEXT!',
     );
     if (!threadInfo.name && !threadIsGroupChat(threadInfo)) {
       return {
         merged: `${threadInfo.uiName}: ${messageInfo.text}`,
         body: messageInfo.text,
         title: threadInfo.uiName,
       };
     } else {
       const userString = stringForUser(messageInfo.creator);
       const threadName = notifThreadName(threadInfo);
       return {
         merged: `${userString} to ${threadName}: ${messageInfo.text}`,
         body: messageInfo.text,
         title: threadInfo.uiName,
         prefix: `${userString}:`,
       };
     }
   } else if (mostRecentType === messageTypes.CREATE_THREAD) {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.CREATE_THREAD,
       'messageInfo should be messageTypes.CREATE_THREAD!',
     );
     const parentThreadInfo = messageInfo.initialThreadState.parentThreadInfo;
     if (parentThreadInfo) {
       return notifTextForSubthreadCreation(
         messageInfo.creator,
+        messageInfo.initialThreadState.type,
         parentThreadInfo,
         messageInfo.initialThreadState.name,
         threadInfo.uiName,
       );
     }
     const prefix = stringForUser(messageInfo.creator);
     const body = 'created a new thread';
     let merged = `${prefix} ${body}`;
     if (messageInfo.initialThreadState.name) {
       merged += ` called "${messageInfo.initialThreadState.name}"`;
     }
     return {
       merged,
       body,
       title: threadInfo.uiName,
       prefix,
     };
   } else if (mostRecentType === messageTypes.ADD_MEMBERS) {
     const addedMembersObject = {};
     for (let messageInfo of messageInfos) {
       invariant(
         messageInfo.type === messageTypes.ADD_MEMBERS,
         'messageInfo should be messageTypes.ADD_MEMBERS!',
       );
       for (let 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 = strippedRobotextForMessageInfo(
       mergedMessageInfo,
       threadInfo,
     );
     const merged = `${robotext} to ${notifThreadName(threadInfo)}`;
     return {
       merged,
       title: threadInfo.uiName,
       body: robotext,
     };
   } else if (mostRecentType === messageTypes.CREATE_SUB_THREAD) {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.CREATE_SUB_THREAD,
       'messageInfo should be messageTypes.CREATE_SUB_THREAD!',
     );
     return notifTextForSubthreadCreation(
       messageInfo.creator,
+      messageInfo.childThreadInfo.type,
       threadInfo,
       messageInfo.childThreadInfo.name,
       messageInfo.childThreadInfo.uiName,
     );
   } else if (mostRecentType === messageTypes.REMOVE_MEMBERS) {
     const removedMembersObject = {};
     for (let messageInfo of messageInfos) {
       invariant(
         messageInfo.type === messageTypes.REMOVE_MEMBERS,
         'messageInfo should be messageTypes.REMOVE_MEMBERS!',
       );
       for (let 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 = strippedRobotextForMessageInfo(
       mergedMessageInfo,
       threadInfo,
     );
     const merged = `${robotext} from ${notifThreadName(threadInfo)}`;
     return {
       merged,
       title: threadInfo.uiName,
       body: robotext,
     };
   } else if (mostRecentType === messageTypes.CHANGE_ROLE) {
     const membersObject = {};
     for (let messageInfo of messageInfos) {
       invariant(
         messageInfo.type === messageTypes.CHANGE_ROLE,
         'messageInfo should be messageTypes.CHANGE_ROLE!',
       );
       for (let 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 = strippedRobotextForMessageInfo(
       mergedMessageInfo,
       threadInfo,
     );
     const merged = `${robotext} from ${notifThreadName(threadInfo)}`;
     return {
       merged,
       title: threadInfo.uiName,
       body: robotext,
     };
   } else if (mostRecentType === messageTypes.LEAVE_THREAD) {
     const leaverBeavers = {};
     for (let 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} ${notifThreadName(threadInfo)}`;
     return {
       merged,
       title: threadInfo.uiName,
       body,
     };
   } else if (mostRecentType === messageTypes.JOIN_THREAD) {
     const joinerArray = {};
     for (let 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} ${notifThreadName(threadInfo)}`;
     return {
       merged,
       title: threadInfo.uiName,
       body,
     };
   } else if (
     mostRecentType === messageTypes.CREATE_ENTRY ||
     mostRecentType === messageTypes.EDIT_ENTRY
   ) {
     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 ` +
         `${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 ${notifThreadName(threadInfo)} ` +
       `scheduled for ${prettyDate(messageInfo.date)}: "${messageInfo.text}"`;
     const merged = `${prefix} ${body}`;
     return {
       merged,
       title: threadInfo.uiName,
       body,
       prefix,
     };
   } else if (mostRecentType === messageTypes.DELETE_ENTRY) {
     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 ${notifThreadName(threadInfo)} ` +
       `scheduled for ${prettyDate(messageInfo.date)}: "${messageInfo.text}"`;
     const merged = `${prefix} ${body}`;
     return {
       merged,
       title: threadInfo.uiName,
       body,
       prefix,
     };
   } else if (mostRecentType === messageTypes.RESTORE_ENTRY) {
     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 ${notifThreadName(threadInfo)} ` +
       `scheduled for ${prettyDate(messageInfo.date)}: "${messageInfo.text}"`;
     const merged = `${prefix} ${body}`;
     return {
       merged,
       title: threadInfo.uiName,
       body,
       prefix,
     };
   } else if (mostRecentType === messageTypes.CHANGE_SETTINGS) {
     const mostRecentMessageInfo = messageInfos[0];
     invariant(
       mostRecentMessageInfo.type === messageTypes.CHANGE_SETTINGS,
       'messageInfo should be messageTypes.CHANGE_SETTINGS!',
     );
     const body = strippedRobotextForMessageInfo(
       mostRecentMessageInfo,
       threadInfo,
     );
     return {
       merged: body,
       title: threadInfo.uiName,
       body,
     };
   } else if (
     mostRecentType === messageTypes.IMAGES ||
     mostRecentType === messageTypes.MULTIMEDIA
   ) {
     const media = [];
     for (let messageInfo of messageInfos) {
       invariant(
         messageInfo.type === messageTypes.IMAGES ||
           messageInfo.type === messageTypes.MULTIMEDIA,
         'messageInfo should be multimedia type!',
       );
       for (let singleMedia of messageInfo.media) {
         media.push(singleMedia);
       }
     }
     const contentString = contentStringForMediaArray(media);
     const userString = stringForUser(messageInfos[0].creator);
 
     let body, merged;
     if (!threadInfo.name && !threadIsGroupChat(threadInfo)) {
       body = `sent you ${contentString}`;
       merged = body;
     } else {
       body = `sent ${contentString}`;
       const threadName = notifThreadName(threadInfo);
       merged = `${body} to ${threadName}`;
     }
     merged = `${userString} ${merged}`;
 
     return {
       merged,
       body,
       title: threadInfo.uiName,
       prefix: userString,
     };
   } else if (mostRecentType === messageTypes.UPDATE_RELATIONSHIP) {
     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,
     };
   } else {
     invariant(false, `we're not aware of messageType ${mostRecentType}`);
   }
 }
 
 function strippedRobotextForMessageInfo(
   messageInfo: RobotextMessageInfo,
   threadInfo: ThreadInfo,
 ): string {
   const robotext = robotextForMessageInfo(messageInfo, threadInfo);
   const threadEntityRegex = new RegExp(`<[^<>\\|]+\\|t${threadInfo.id}>`);
   const threadMadeExplicit = robotext.replace(
     threadEntityRegex,
     notifThreadName(threadInfo),
   );
   return robotextToRawString(threadMadeExplicit);
 }
 
 const joinResult = (...keys: (string | number)[]) => keys.join('|');
 function notifCollapseKeyForRawMessageInfo(
   rawMessageInfo: RawMessageInfo,
 ): ?string {
   if (
     rawMessageInfo.type === messageTypes.ADD_MEMBERS ||
     rawMessageInfo.type === messageTypes.REMOVE_MEMBERS
   ) {
     return joinResult(
       rawMessageInfo.type,
       rawMessageInfo.threadID,
       rawMessageInfo.creatorID,
     );
   } else if (
     rawMessageInfo.type === messageTypes.IMAGES ||
     rawMessageInfo.type === messageTypes.MULTIMEDIA
   ) {
     // We use the legacy constant here to collapse both types into one
     return joinResult(
       messageTypes.IMAGES,
       rawMessageInfo.threadID,
       rawMessageInfo.creatorID,
     );
   } else if (rawMessageInfo.type === messageTypes.CHANGE_SETTINGS) {
     return joinResult(
       rawMessageInfo.type,
       rawMessageInfo.threadID,
       rawMessageInfo.creatorID,
       rawMessageInfo.field,
     );
   } else if (rawMessageInfo.type === messageTypes.CHANGE_ROLE) {
     return joinResult(
       rawMessageInfo.type,
       rawMessageInfo.threadID,
       rawMessageInfo.creatorID,
       rawMessageInfo.newRole,
     );
   } else if (
     rawMessageInfo.type === messageTypes.JOIN_THREAD ||
     rawMessageInfo.type === messageTypes.LEAVE_THREAD
   ) {
     return joinResult(rawMessageInfo.type, rawMessageInfo.threadID);
   } else if (
     rawMessageInfo.type === messageTypes.CREATE_ENTRY ||
     rawMessageInfo.type === messageTypes.EDIT_ENTRY
   ) {
     return joinResult(rawMessageInfo.creatorID, rawMessageInfo.entryID);
   } else {
     return 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/lib/shared/thread-utils.js b/lib/shared/thread-utils.js
index d25b2d9db..3b5f93d18 100644
--- a/lib/shared/thread-utils.js
+++ b/lib/shared/thread-utils.js
@@ -1,684 +1,689 @@
 // @flow
 
 import invariant from 'invariant';
 import _find from 'lodash/fp/find';
 import tinycolor from 'tinycolor2';
 
 import {
   permissionLookup,
   getAllThreadPermissions,
   makePermissionsBlob,
 } from '../permissions/thread-permissions';
 import type { ChatThreadItem } from '../selectors/chat-selectors';
 import { userRelationshipStatus } from '../types/relationship-types';
 import {
   type RawThreadInfo,
   type ThreadInfo,
   type ThreadPermission,
   type MemberInfo,
   type ServerThreadInfo,
   type RelativeMemberInfo,
   type ThreadCurrentUserInfo,
   type RoleInfo,
   type ServerMemberInfo,
   type ThreadPermissionsInfo,
   threadTypes,
   threadPermissions,
 } from '../types/thread-types';
 import type { ThreadType } from '../types/thread-types';
 import { type UpdateInfo, updateTypes } from '../types/update-types';
 import type {
   GlobalAccountUserInfo,
   UserInfo,
   UserInfos,
 } from '../types/user-types';
 import { pluralize } from '../utils/text-utils';
 
 function colorIsDark(color: string) {
   return tinycolor(`#${color}`).isDark();
 }
 
 // Randomly distributed in RGB-space
 const hexNumerals = '0123456789abcdef';
 function generateRandomColor() {
   let color = '';
   for (let i = 0; i < 6; i++) {
     color += hexNumerals[Math.floor(Math.random() * 16)];
   }
   return color;
 }
 
 function generatePendingThreadColor(
   userIDs: $ReadOnlyArray<string>,
   viewerID: string,
 ) {
   const ids = [...userIDs, viewerID].sort().join('#');
 
   let hash = 0;
   for (let i = 0; i < ids.length; i++) {
     hash = 1009 * hash + ids.charCodeAt(i) * 83;
     hash %= 1000000007;
   }
   const hashString = hash.toString(16);
   return hashString.substring(hashString.length - 6).padStart(6, '8');
 }
 
 function threadHasPermission(
   threadInfo: ?(ThreadInfo | RawThreadInfo),
   permission: ThreadPermission,
 ): boolean {
   invariant(
     !permissionsDisabledByBlock.has(permission) || threadInfo?.uiName,
     `${permission} can be disabled by a block, but threadHasPermission can't ` +
       'check for a block on RawThreadInfo. Please pass in ThreadInfo instead!',
   );
   if (!threadInfo || !threadInfo.currentUser.permissions[permission]) {
     return false;
   }
   return threadInfo.currentUser.permissions[permission].value;
 }
 
 function viewerIsMember(threadInfo: ?(ThreadInfo | RawThreadInfo)): boolean {
   return !!(
     threadInfo &&
     threadInfo.currentUser.role !== null &&
     threadInfo.currentUser.role !== undefined
   );
 }
 
 function threadIsInHome(threadInfo: ?(ThreadInfo | RawThreadInfo)): boolean {
   return !!(threadInfo && threadInfo.currentUser.subscription.home);
 }
 
 // Can have messages
 function threadInChatList(threadInfo: ?(ThreadInfo | RawThreadInfo)): boolean {
   return (
     viewerIsMember(threadInfo) &&
     threadHasPermission(threadInfo, threadPermissions.VISIBLE)
   );
 }
 
 function threadIsTopLevel(threadInfo: ?(ThreadInfo | RawThreadInfo)): boolean {
   return !!(
     threadInChatList(threadInfo) &&
     threadInfo &&
     threadInfo.type !== threadTypes.SIDEBAR
   );
 }
 
 function threadInBackgroundChatList(
   threadInfo: ?(ThreadInfo | RawThreadInfo),
 ): boolean {
   return threadInChatList(threadInfo) && !threadIsInHome(threadInfo);
 }
 
 function threadInHomeChatList(
   threadInfo: ?(ThreadInfo | RawThreadInfo),
 ): boolean {
   return threadInChatList(threadInfo) && threadIsInHome(threadInfo);
 }
 
 // Can have Calendar entries,
 // does appear as a top-level entity in the thread list
 function threadInFilterList(
   threadInfo: ?(ThreadInfo | RawThreadInfo),
 ): boolean {
   return (
     threadInChatList(threadInfo) &&
     !!threadInfo &&
     threadInfo.type !== threadTypes.SIDEBAR
   );
 }
 
 function userIsMember(
   threadInfo: ?(ThreadInfo | RawThreadInfo),
   userID: string,
 ): boolean {
   if (!threadInfo) {
     return false;
   }
   return threadInfo.members.some(
     (member) =>
       member.id === userID && member.role !== null && member.role !== undefined,
   );
 }
 
 function threadActualMembers(
   memberInfos: $ReadOnlyArray<MemberInfo>,
 ): $ReadOnlyArray<string> {
   return memberInfos
     .filter(
       (memberInfo) => memberInfo.role !== null && memberInfo.role !== undefined,
     )
     .map((memberInfo) => memberInfo.id);
 }
 
 function threadIsGroupChat(threadInfo: ThreadInfo | RawThreadInfo) {
   return (
     threadInfo.members.filter(
       (member) =>
         member.role || member.permissions[threadPermissions.VOICED]?.value,
     ).length > 2
   );
 }
 
 function threadOrParentThreadIsGroupChat(
   threadInfo: RawThreadInfo | ThreadInfo,
 ) {
   return threadInfo.members.length > 2;
 }
 
 function threadIsPending(threadID: ?string) {
   return threadID?.startsWith('pending');
 }
 
 function threadIsPersonalAndPending(threadInfo: ?(ThreadInfo | RawThreadInfo)) {
   return (
     threadInfo?.type === threadTypes.PERSONAL && threadIsPending(threadInfo?.id)
   );
 }
 
 function getPendingThreadOtherUsers(threadInfo: ThreadInfo | RawThreadInfo) {
   invariant(threadIsPending(threadInfo.id), 'Thread should be pending');
 
   const otherUserIDs = threadInfo.id.split('/')[1];
   invariant(
     otherUserIDs,
     'Pending thread should contain other members id in its id',
   );
   return otherUserIDs.split('+');
 }
 
 function getSingleOtherUser(
   threadInfo: ThreadInfo | RawThreadInfo,
   viewerID: ?string,
 ) {
   if (!viewerID) {
     return undefined;
   }
 
   const otherMemberIDs = threadInfo.members
     .map((member) => member.id)
     .filter((id) => id !== viewerID);
   if (otherMemberIDs.length !== 1) {
     return undefined;
   }
   return otherMemberIDs[0];
 }
 
 function getPendingThreadKey(memberIDs: $ReadOnlyArray<string>) {
   return [...memberIDs].sort().join('+');
 }
 
 function createPendingThread(
   viewerID: string,
   threadType: ThreadType,
   members: $ReadOnlyArray<GlobalAccountUserInfo | UserInfo>,
 ) {
   const now = Date.now();
   const memberIDs = members.map((member) => member.id);
   const threadID = `pending/${getPendingThreadKey(memberIDs)}`;
 
   const permissions = {
     [threadPermissions.KNOW_OF]: true,
     [threadPermissions.VISIBLE]: true,
     [threadPermissions.VOICED]: true,
   };
 
   const membershipPermissions = getAllThreadPermissions(
     makePermissionsBlob(permissions, null, threadID, threadType),
     threadID,
   );
   const role = {
     id: `${threadID}/role`,
     name: 'Members',
     permissions,
     isDefault: true,
   };
 
   const rawThreadInfo = {
     id: threadID,
     type: threadType,
     name: null,
     description: null,
     color: generatePendingThreadColor(memberIDs, viewerID),
     creationTime: now,
     parentThreadID: null,
     members: [
       {
         id: viewerID,
         role: role.id,
         permissions: membershipPermissions,
       },
       ...members.map((member) => ({
         id: member.id,
         role: role.id,
         permissions: membershipPermissions,
       })),
     ],
     roles: {
       [role.id]: role,
     },
     currentUser: {
       role: role.id,
       permissions: membershipPermissions,
       subscription: {
         pushNotifs: false,
         home: false,
       },
       unread: false,
     },
   };
 
   const userInfos = Object.fromEntries(
     members.map((member) => [member.id, member]),
   );
 
   return threadInfoFromRawThreadInfo(rawThreadInfo, viewerID, userInfos);
 }
 
 function createPendingThreadItem(
   viewerID: string,
   user: GlobalAccountUserInfo,
 ): ChatThreadItem {
   const threadInfo = createPendingThread(viewerID, threadTypes.PERSONAL, [
     user,
   ]);
 
   return {
     type: 'chatThreadItem',
     threadInfo,
     mostRecentMessageInfo: null,
     mostRecentNonLocalMessage: null,
     lastUpdatedTime: threadInfo.creationTime,
     lastUpdatedTimeIncludingSidebars: threadInfo.creationTime,
     sidebars: [],
     pendingPersonalThreadUserInfo: {
       id: user.id,
       username: user.username,
     },
   };
 }
 
 function pendingThreadType(numberOfOtherMembers: number) {
   return numberOfOtherMembers === 1
     ? threadTypes.PERSONAL
     : threadTypes.CHAT_SECRET;
 }
 
 type RawThreadInfoOptions = {|
   +includeVisibilityRules?: ?boolean,
   +filterMemberList?: ?boolean,
 |};
 function rawThreadInfoFromServerThreadInfo(
   serverThreadInfo: ServerThreadInfo,
   viewerID: string,
   options?: RawThreadInfoOptions,
 ): ?RawThreadInfo {
   const includeVisibilityRules = options?.includeVisibilityRules;
   const filterMemberList = options?.filterMemberList;
 
   const members = [];
   let currentUser;
   for (const serverMember of serverThreadInfo.members) {
     if (
       filterMemberList &&
       serverMember.id !== viewerID &&
       !serverMember.role &&
       !memberHasAdminPowers(serverMember)
     ) {
       continue;
     }
     members.push({
       id: serverMember.id,
       role: serverMember.role,
       permissions: serverMember.permissions,
     });
     if (serverMember.id === viewerID) {
       currentUser = {
         role: serverMember.role,
         permissions: serverMember.permissions,
         subscription: serverMember.subscription,
         unread: serverMember.unread,
       };
     }
   }
 
   let currentUserPermissions;
   if (currentUser) {
     currentUserPermissions = currentUser.permissions;
   } else {
     currentUserPermissions = getAllThreadPermissions(null, serverThreadInfo.id);
     currentUser = {
       role: null,
       permissions: currentUserPermissions,
       subscription: {
         home: false,
         pushNotifs: false,
       },
       unread: null,
     };
   }
   if (!permissionLookup(currentUserPermissions, threadPermissions.KNOW_OF)) {
     return null;
   }
 
   const rawThreadInfo = {
     id: serverThreadInfo.id,
     type: serverThreadInfo.type,
     name: serverThreadInfo.name,
     description: serverThreadInfo.description,
     color: serverThreadInfo.color,
     creationTime: serverThreadInfo.creationTime,
     parentThreadID: serverThreadInfo.parentThreadID,
     members,
     roles: serverThreadInfo.roles,
     currentUser,
     sourceMessageID: serverThreadInfo.sourceMessageID,
   };
   if (!includeVisibilityRules) {
     return rawThreadInfo;
   }
   return ({
     ...rawThreadInfo,
     visibilityRules: rawThreadInfo.type,
   }: any);
 }
 
 function robotextName(
   threadInfo: RawThreadInfo | ThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
 ): string {
   const threadUsernames: string[] = threadInfo.members
     .filter(
       (threadMember) =>
         threadMember.id !== viewerID &&
         (threadMember.role || memberHasAdminPowers(threadMember)),
     )
     .map(
       (threadMember) =>
         userInfos[threadMember.id] && userInfos[threadMember.id].username,
     )
     .filter(Boolean);
   if (threadUsernames.length === 0) {
     return 'just you';
   }
   return pluralize(threadUsernames);
 }
 
 function threadUIName(
   threadInfo: RawThreadInfo | ThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
 ): string {
   if (threadInfo.name) {
     return threadInfo.name;
   }
   return robotextName(threadInfo, viewerID, userInfos);
 }
 
 function threadInfoFromRawThreadInfo(
   rawThreadInfo: RawThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
 ): ThreadInfo {
   return {
     id: rawThreadInfo.id,
     type: rawThreadInfo.type,
     name: rawThreadInfo.name,
     uiName: threadUIName(rawThreadInfo, viewerID, userInfos),
     description: rawThreadInfo.description,
     color: rawThreadInfo.color,
     creationTime: rawThreadInfo.creationTime,
     parentThreadID: rawThreadInfo.parentThreadID,
     members: rawThreadInfo.members,
     roles: rawThreadInfo.roles,
     currentUser: getCurrentUser(rawThreadInfo, viewerID, userInfos),
     sourceMessageID: rawThreadInfo.sourceMessageID,
   };
 }
 
 function getCurrentUser(
   threadInfo: RawThreadInfo | ThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
 ): ThreadCurrentUserInfo {
   if (!threadFrozenDueToBlock(threadInfo, viewerID, userInfos)) {
     return threadInfo.currentUser;
   }
 
   return {
     ...threadInfo.currentUser,
     permissions: {
       ...threadInfo.currentUser.permissions,
       ...disabledPermissions,
     },
   };
 }
 
 function threadIsWithBlockedUserOnly(
   threadInfo: RawThreadInfo | ThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
   checkOnlyViewerBlock?: boolean,
 ): boolean {
   if (
     threadOrParentThreadIsGroupChat(threadInfo) ||
     threadOrParentThreadHasAdminRole(threadInfo)
   ) {
     return false;
   }
 
   const otherUserID = getSingleOtherUser(threadInfo, viewerID);
   if (!otherUserID) {
     return false;
   }
   const otherUserRelationshipStatus =
     userInfos[otherUserID]?.relationshipStatus;
 
   if (checkOnlyViewerBlock) {
     return (
       otherUserRelationshipStatus === userRelationshipStatus.BLOCKED_BY_VIEWER
     );
   }
 
   return (
     otherUserRelationshipStatus === userRelationshipStatus.BLOCKED_BY_VIEWER ||
     otherUserRelationshipStatus === userRelationshipStatus.BLOCKED_VIEWER ||
     otherUserRelationshipStatus === userRelationshipStatus.BOTH_BLOCKED
   );
 }
 
 function threadFrozenDueToBlock(
   threadInfo: RawThreadInfo | ThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
 ): boolean {
   return threadIsWithBlockedUserOnly(threadInfo, viewerID, userInfos);
 }
 
 function threadFrozenDueToViewerBlock(
   threadInfo: RawThreadInfo | ThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
 ): boolean {
   return threadIsWithBlockedUserOnly(threadInfo, viewerID, userInfos, true);
 }
 
 function rawThreadInfoFromThreadInfo(threadInfo: ThreadInfo): RawThreadInfo {
   return {
     id: threadInfo.id,
     type: threadInfo.type,
     name: threadInfo.name,
     description: threadInfo.description,
     color: threadInfo.color,
     creationTime: threadInfo.creationTime,
     parentThreadID: threadInfo.parentThreadID,
     members: threadInfo.members,
     roles: threadInfo.roles,
     currentUser: threadInfo.currentUser,
   };
 }
 
 const threadTypeDescriptions = {
   [threadTypes.CHAT_NESTED_OPEN]:
     'Anybody in the parent thread can see an open child thread.',
   [threadTypes.CHAT_SECRET]:
     'Only visible to its members and admins of ancestor threads.',
 };
 
 function usersInThreadInfo(threadInfo: RawThreadInfo | ThreadInfo): string[] {
   const userIDs = new Set();
   for (let member of threadInfo.members) {
     userIDs.add(member.id);
   }
   return [...userIDs];
 }
 
 function memberIsAdmin(
   memberInfo: RelativeMemberInfo | MemberInfo,
   threadInfo: ThreadInfo | RawThreadInfo,
 ) {
   return memberInfo.role && roleIsAdminRole(threadInfo.roles[memberInfo.role]);
 }
 
 // Since we don't have access to all of the ancestor ThreadInfos, we approximate
 // "parent admin" as anybody with CHANGE_ROLE permissions.
 function memberHasAdminPowers(
   memberInfo: RelativeMemberInfo | MemberInfo | ServerMemberInfo,
 ): boolean {
   return !!memberInfo.permissions[threadPermissions.CHANGE_ROLE]?.value;
 }
 
 function roleIsAdminRole(roleInfo: ?RoleInfo) {
   return roleInfo && !roleInfo.isDefault && roleInfo.name === 'Admins';
 }
 
 function threadHasAdminRole(
   threadInfo: ?(RawThreadInfo | ThreadInfo | ServerThreadInfo),
 ) {
   if (!threadInfo) {
     return false;
   }
   return _find({ name: 'Admins' })(threadInfo.roles);
 }
 
 function threadOrParentThreadHasAdminRole(
   threadInfo: RawThreadInfo | ThreadInfo,
 ) {
   return (
     threadInfo.members.filter((member) => memberHasAdminPowers(member)).length >
     0
   );
 }
 
 function identifyInvalidatedThreads(
   updateInfos: $ReadOnlyArray<UpdateInfo>,
 ): Set<string> {
   const invalidated = new Set();
   for (const updateInfo of updateInfos) {
     if (updateInfo.type === updateTypes.DELETE_THREAD) {
       invalidated.add(updateInfo.threadID);
     }
   }
   return invalidated;
 }
 
 const permissionsDisabledByBlockArray = [
   threadPermissions.VOICED,
   threadPermissions.EDIT_ENTRIES,
   threadPermissions.EDIT_THREAD,
   threadPermissions.CREATE_SUBTHREADS,
   threadPermissions.CREATE_SIDEBARS,
   threadPermissions.JOIN_THREAD,
   threadPermissions.EDIT_PERMISSIONS,
   threadPermissions.ADD_MEMBERS,
   threadPermissions.REMOVE_MEMBERS,
 ];
 
 const permissionsDisabledByBlock: Set<ThreadPermission> = new Set(
   permissionsDisabledByBlockArray,
 );
 
 const disabledPermissions: ThreadPermissionsInfo = permissionsDisabledByBlockArray.reduce(
   (permissions: ThreadPermissionsInfo, permission: string) => ({
     ...permissions,
     [permission]: { value: false, source: null },
   }),
   {},
 );
 
 // Consider updating itemHeight in native/chat/chat-thread-list.react.js
 // if you change this
 const emptyItemText =
   `Background threads are just like normal threads, except they don't ` +
   `contribute to your unread count.\n\n` +
   `To move a thread over here, switch the “Background” option in its settings.`;
 
 const threadSearchText = (
   threadInfo: RawThreadInfo | ThreadInfo,
   userInfos: UserInfos,
 ): string => {
   const searchTextArray = [];
   if (threadInfo.name) {
     searchTextArray.push(threadInfo.name);
   }
   if (threadInfo.description) {
     searchTextArray.push(threadInfo.description);
   }
   for (let member of threadInfo.members) {
     const isParentAdmin = memberHasAdminPowers(member);
     if (!member.role && !isParentAdmin) {
       continue;
     }
 
     const userInfo = userInfos[member.id];
     if (userInfo && userInfo.username) {
       searchTextArray.push(userInfo.username);
     }
   }
   return searchTextArray.join(' ');
 };
 
+function threadNoun(threadType: ThreadType) {
+  return threadType === threadTypes.SIDEBAR ? 'sidebar' : 'thread';
+}
+
 export {
   colorIsDark,
   generateRandomColor,
   generatePendingThreadColor,
   threadHasPermission,
   viewerIsMember,
   threadInChatList,
   threadIsTopLevel,
   threadInBackgroundChatList,
   threadInHomeChatList,
   threadIsInHome,
   threadInFilterList,
   userIsMember,
   threadActualMembers,
   threadIsGroupChat,
   threadIsPending,
   threadIsPersonalAndPending,
   getPendingThreadOtherUsers,
   getSingleOtherUser,
   getPendingThreadKey,
   createPendingThread,
   createPendingThreadItem,
   pendingThreadType,
   getCurrentUser,
   threadFrozenDueToBlock,
   threadFrozenDueToViewerBlock,
   rawThreadInfoFromServerThreadInfo,
   robotextName,
   threadInfoFromRawThreadInfo,
   rawThreadInfoFromThreadInfo,
   threadTypeDescriptions,
   usersInThreadInfo,
   memberIsAdmin,
   memberHasAdminPowers,
   roleIsAdminRole,
   threadHasAdminRole,
   identifyInvalidatedThreads,
   permissionsDisabledByBlock,
   emptyItemText,
   threadSearchText,
+  threadNoun,
 };