diff --git a/lib/selectors/thread-selectors.js b/lib/selectors/thread-selectors.js
index 245322757..3b88ecedf 100644
--- a/lib/selectors/thread-selectors.js
+++ b/lib/selectors/thread-selectors.js
@@ -1,530 +1,529 @@
 // @flow
 
 import _compact from 'lodash/fp/compact.js';
 import _filter from 'lodash/fp/filter.js';
 import _flow from 'lodash/fp/flow.js';
 import _map from 'lodash/fp/map.js';
 import _mapValues from 'lodash/fp/mapValues.js';
 import _orderBy from 'lodash/fp/orderBy.js';
 import _some from 'lodash/fp/some.js';
 import _sortBy from 'lodash/fp/sortBy.js';
 import _memoize from 'lodash/memoize.js';
 import { createSelector } from 'reselect';
 import { createObjectSelector } from 'reselect-map';
 
 import {
   filteredThreadIDsSelector,
   includeDeletedSelector,
 } from './calendar-filter-selectors.js';
 import { relativeMemberInfoSelectorForMembersOfThread } from './user-selectors.js';
 import genesis from '../facts/genesis.js';
 import {
   getAvatarForThread,
   getRandomDefaultEmojiAvatar,
 } from '../shared/avatar-utils.js';
 import { createEntryInfo } from '../shared/entry-utils.js';
 import { getMostRecentNonLocalMessageID } from '../shared/message-utils.js';
 import {
   threadInHomeChatList,
   threadInBackgroundChatList,
   threadInFilterList,
   threadInfoFromRawThreadInfo,
   threadHasPermission,
   threadInChatList,
   threadHasAdminRole,
   roleIsAdminRole,
   threadIsPending,
   getPendingThreadID,
 } from '../shared/thread-utils.js';
 import type { ClientAvatar, ClientEmojiAvatar } from '../types/avatar-types';
 import type { EntryInfo } from '../types/entry-types.js';
 import type { MessageStore, RawMessageInfo } from '../types/message-types.js';
 import type { BaseAppState } from '../types/redux-types.js';
 import { threadPermissions } from '../types/thread-permission-types.js';
 import {
   threadTypes,
   threadTypeIsCommunityRoot,
   type ThreadType,
 } from '../types/thread-types-enum.js';
-import {
-  type SidebarInfo,
-  type LegacyRawThreadInfos,
-  type RelativeMemberInfo,
-  type ThreadInfo,
-  type RawThreadInfo,
-  type RawThreadInfos,
+import type {
+  SidebarInfo,
+  RelativeMemberInfo,
+  ThreadInfo,
+  RawThreadInfo,
+  RawThreadInfos,
 } from '../types/thread-types.js';
 import { dateString, dateFromString } from '../utils/date-utils.js';
 import { values } from '../utils/objects.js';
 
 const _mapValuesWithKeys = _mapValues.convert({ cap: false });
 
 type ThreadInfoSelectorType = (state: BaseAppState<>) => {
   +[id: string]: ThreadInfo,
 };
 const threadInfoSelector: ThreadInfoSelectorType = createObjectSelector(
   (state: BaseAppState<>) => state.threadStore.threadInfos,
   (state: BaseAppState<>) => state.currentUserInfo && state.currentUserInfo.id,
   (state: BaseAppState<>) => state.userStore.userInfos,
   threadInfoFromRawThreadInfo,
 );
 
 const communityThreadSelector: (
   state: BaseAppState<>,
 ) => $ReadOnlyArray<ThreadInfo> = createSelector(
   threadInfoSelector,
   (threadInfos: { +[id: string]: ThreadInfo }) => {
     const result = [];
     for (const threadID in threadInfos) {
       const threadInfo = threadInfos[threadID];
       if (!threadTypeIsCommunityRoot(threadInfo.type)) {
         continue;
       }
       result.push(threadInfo);
     }
     return result;
   },
 );
 
 const canBeOnScreenThreadInfos: (
   state: BaseAppState<>,
 ) => $ReadOnlyArray<ThreadInfo> = createSelector(
   threadInfoSelector,
   (threadInfos: { +[id: string]: ThreadInfo }) => {
     const result = [];
     for (const threadID in threadInfos) {
       const threadInfo = threadInfos[threadID];
       if (!threadInFilterList(threadInfo)) {
         continue;
       }
       result.push(threadInfo);
     }
     return result;
   },
 );
 
 const onScreenThreadInfos: (
   state: BaseAppState<>,
 ) => $ReadOnlyArray<ThreadInfo> = createSelector(
   filteredThreadIDsSelector,
   canBeOnScreenThreadInfos,
   (
     inputThreadIDs: ?$ReadOnlySet<string>,
     threadInfos: $ReadOnlyArray<ThreadInfo>,
   ): $ReadOnlyArray<ThreadInfo> => {
     const threadIDs = inputThreadIDs;
     if (!threadIDs) {
       return threadInfos;
     }
     return threadInfos.filter(threadInfo => threadIDs.has(threadInfo.id));
   },
 );
 
 const onScreenEntryEditableThreadInfos: (
   state: BaseAppState<>,
 ) => $ReadOnlyArray<ThreadInfo> = createSelector(
   onScreenThreadInfos,
   (threadInfos: $ReadOnlyArray<ThreadInfo>): $ReadOnlyArray<ThreadInfo> =>
     threadInfos.filter(threadInfo =>
       threadHasPermission(threadInfo, threadPermissions.EDIT_ENTRIES),
     ),
 );
 
 const entryInfoSelector: (state: BaseAppState<>) => {
   +[id: string]: EntryInfo,
 } = createObjectSelector(
   (state: BaseAppState<>) => state.entryStore.entryInfos,
   (state: BaseAppState<>) => state.currentUserInfo && state.currentUserInfo.id,
   (state: BaseAppState<>) => state.userStore.userInfos,
   createEntryInfo,
 );
 
 // "current" means within startDate/endDate range, not deleted, and in
 // onScreenThreadInfos
 const currentDaysToEntries: (state: BaseAppState<>) => {
   +[dayString: string]: EntryInfo[],
 } = createSelector(
   entryInfoSelector,
   (state: BaseAppState<>) => state.entryStore.daysToEntries,
   (state: BaseAppState<>) => state.navInfo.startDate,
   (state: BaseAppState<>) => state.navInfo.endDate,
   onScreenThreadInfos,
   includeDeletedSelector,
   (
     entryInfos: { +[id: string]: EntryInfo },
     daysToEntries: { +[day: string]: string[] },
     startDateString: string,
     endDateString: string,
     onScreen: $ReadOnlyArray<ThreadInfo>,
     includeDeleted: boolean,
   ) => {
     const allDaysWithinRange: { [string]: string[] } = {},
       startDate = dateFromString(startDateString),
       endDate = dateFromString(endDateString);
     for (
       const curDate = startDate;
       curDate <= endDate;
       curDate.setDate(curDate.getDate() + 1)
     ) {
       allDaysWithinRange[dateString(curDate)] = [];
     }
     return _mapValuesWithKeys((_: string[], dayString: string) =>
       _flow(
         _map((entryID: string) => entryInfos[entryID]),
         _compact,
         _filter(
           (entryInfo: EntryInfo) =>
             (includeDeleted || !entryInfo.deleted) &&
             _some(['id', entryInfo.threadID])(onScreen),
         ),
         _sortBy('creationTime'),
       )(daysToEntries[dayString] ? daysToEntries[dayString] : []),
     )(allDaysWithinRange);
   },
 );
 
 const childThreadInfos: (state: BaseAppState<>) => {
   +[id: string]: $ReadOnlyArray<ThreadInfo>,
 } = createSelector(
   threadInfoSelector,
   (threadInfos: { +[id: string]: ThreadInfo }) => {
     const result: { [string]: ThreadInfo[] } = {};
     for (const id in threadInfos) {
       const threadInfo = threadInfos[id];
       const parentThreadID = threadInfo.parentThreadID;
       if (parentThreadID === null || parentThreadID === undefined) {
         continue;
       }
       if (result[parentThreadID] === undefined) {
         result[parentThreadID] = ([]: ThreadInfo[]);
       }
       result[parentThreadID].push(threadInfo);
     }
     return result;
   },
 );
 
 const containedThreadInfos: (state: BaseAppState<>) => {
   +[id: string]: $ReadOnlyArray<ThreadInfo>,
 } = createSelector(
   threadInfoSelector,
   (threadInfos: { +[id: string]: ThreadInfo }) => {
     const result: { [string]: ThreadInfo[] } = {};
     for (const id in threadInfos) {
       const threadInfo = threadInfos[id];
       const { containingThreadID } = threadInfo;
       if (containingThreadID === null || containingThreadID === undefined) {
         continue;
       }
       if (result[containingThreadID] === undefined) {
         result[containingThreadID] = ([]: ThreadInfo[]);
       }
       result[containingThreadID].push(threadInfo);
     }
     return result;
   },
 );
 
 function getMostRecentRawMessageInfo(
   threadInfo: ThreadInfo,
   messageStore: MessageStore,
 ): ?RawMessageInfo {
   const thread = messageStore.threads[threadInfo.id];
   if (!thread) {
     return null;
   }
   for (const messageID of thread.messageIDs) {
     return messageStore.messages[messageID];
   }
   return null;
 }
 
 const sidebarInfoSelector: (state: BaseAppState<>) => {
   +[id: string]: $ReadOnlyArray<SidebarInfo>,
 } = createObjectSelector(
   childThreadInfos,
   (state: BaseAppState<>) => state.messageStore,
   (childThreads: $ReadOnlyArray<ThreadInfo>, messageStore: MessageStore) => {
     const sidebarInfos = [];
     for (const childThreadInfo of childThreads) {
       if (
         !threadInChatList(childThreadInfo) ||
         childThreadInfo.type !== threadTypes.SIDEBAR
       ) {
         continue;
       }
       const mostRecentRawMessageInfo = getMostRecentRawMessageInfo(
         childThreadInfo,
         messageStore,
       );
       const lastUpdatedTime =
         mostRecentRawMessageInfo?.time ?? childThreadInfo.creationTime;
       const mostRecentNonLocalMessage = getMostRecentNonLocalMessageID(
         childThreadInfo.id,
         messageStore,
       );
       sidebarInfos.push({
         threadInfo: childThreadInfo,
         lastUpdatedTime,
         mostRecentNonLocalMessage,
       });
     }
     return _orderBy('lastUpdatedTime')('desc')(sidebarInfos);
   },
 );
 
 const unreadCount: (state: BaseAppState<>) => number = createSelector(
   (state: BaseAppState<>) => state.threadStore.threadInfos,
-  (threadInfos: LegacyRawThreadInfos): number =>
+  (threadInfos: RawThreadInfos): number =>
     values(threadInfos).filter(
       threadInfo =>
         threadInHomeChatList(threadInfo) && threadInfo.currentUser.unread,
     ).length,
 );
 
 const unreadBackgroundCount: (state: BaseAppState<>) => number = createSelector(
   (state: BaseAppState<>) => state.threadStore.threadInfos,
-  (threadInfos: LegacyRawThreadInfos): number =>
+  (threadInfos: RawThreadInfos): number =>
     values(threadInfos).filter(
       threadInfo =>
         threadInBackgroundChatList(threadInfo) && threadInfo.currentUser.unread,
     ).length,
 );
 
 const baseAncestorThreadInfos: (
   threadID: string,
 ) => (BaseAppState<>) => $ReadOnlyArray<ThreadInfo> = (threadID: string) =>
   createSelector(
     (state: BaseAppState<>) => threadInfoSelector(state),
     (threadInfos: {
       +[id: string]: ThreadInfo,
     }): $ReadOnlyArray<ThreadInfo> => {
       const pathComponents: ThreadInfo[] = [];
       let node: ?ThreadInfo = threadInfos[threadID];
       while (node) {
         pathComponents.push(node);
         node = node.parentThreadID ? threadInfos[node.parentThreadID] : null;
       }
       pathComponents.reverse();
       return pathComponents;
     },
   );
 
 const ancestorThreadInfos: (
   threadID: string,
 ) => (state: BaseAppState<>) => $ReadOnlyArray<ThreadInfo> = _memoize(
   baseAncestorThreadInfos,
 );
 
 const baseOtherUsersButNoOtherAdmins: (
   threadID: string,
 ) => (BaseAppState<>) => boolean = (threadID: string) =>
   createSelector(
     (state: BaseAppState<>) => state.threadStore.threadInfos[threadID],
     relativeMemberInfoSelectorForMembersOfThread(threadID),
     (
       threadInfo: ?RawThreadInfo,
       members: $ReadOnlyArray<RelativeMemberInfo>,
     ): boolean => {
       if (!threadInfo) {
         return false;
       }
       if (!threadHasAdminRole(threadInfo)) {
         return false;
       }
       let otherUsersExist = false;
       let otherAdminsExist = false;
       for (const member of members) {
         const role = member.role;
         if (role === undefined || role === null || member.isViewer) {
           continue;
         }
         otherUsersExist = true;
         if (roleIsAdminRole(threadInfo?.roles[role])) {
           otherAdminsExist = true;
           break;
         }
       }
       return otherUsersExist && !otherAdminsExist;
     },
   );
 
 const otherUsersButNoOtherAdmins: (
   threadID: string,
 ) => (state: BaseAppState<>) => boolean = _memoize(
   baseOtherUsersButNoOtherAdmins,
 );
 
 function mostRecentlyReadThread(
   messageStore: MessageStore,
-  threadInfos: LegacyRawThreadInfos,
+  threadInfos: RawThreadInfos,
 ): ?string {
   let mostRecent = null;
   for (const threadID in threadInfos) {
     const threadInfo = threadInfos[threadID];
     if (threadInfo.currentUser.unread) {
       continue;
     }
     const threadMessageInfo = messageStore.threads[threadID];
     if (!threadMessageInfo) {
       continue;
     }
     const mostRecentMessageTime =
       threadMessageInfo.messageIDs.length === 0
         ? threadInfo.creationTime
         : messageStore.messages[threadMessageInfo.messageIDs[0]].time;
     if (mostRecent && mostRecent.time >= mostRecentMessageTime) {
       continue;
     }
 
     const topLevelThreadID =
       threadInfo.type === threadTypes.SIDEBAR
         ? threadInfo.parentThreadID
         : threadID;
     mostRecent = { threadID: topLevelThreadID, time: mostRecentMessageTime };
   }
   return mostRecent ? mostRecent.threadID : null;
 }
 
 const mostRecentlyReadThreadSelector: (state: BaseAppState<>) => ?string =
   createSelector(
     (state: BaseAppState<>) => state.messageStore,
     (state: BaseAppState<>) => state.threadStore.threadInfos,
     mostRecentlyReadThread,
   );
 
 const threadInfoFromSourceMessageIDSelector: (state: BaseAppState<>) => {
   +[id: string]: ThreadInfo,
 } = createSelector(
   (state: BaseAppState<>) => state.threadStore.threadInfos,
   threadInfoSelector,
   (
-    rawThreadInfos: LegacyRawThreadInfos,
+    rawThreadInfos: RawThreadInfos,
     threadInfos: { +[id: string]: ThreadInfo },
   ) => {
     const pendingToRealizedThreadIDs =
       pendingToRealizedThreadIDsSelector(rawThreadInfos);
     const result: { [string]: ThreadInfo } = {};
     for (const realizedID of pendingToRealizedThreadIDs.values()) {
       const threadInfo = threadInfos[realizedID];
       if (threadInfo && threadInfo.sourceMessageID) {
         result[threadInfo.sourceMessageID] = threadInfo;
       }
     }
     return result;
   },
 );
 const pendingToRealizedThreadIDsSelector: (
   rawThreadInfos: RawThreadInfos,
 ) => $ReadOnlyMap<string, string> = createSelector(
   (rawThreadInfos: RawThreadInfos) => rawThreadInfos,
   (rawThreadInfos: RawThreadInfos) => {
     const result = new Map<string, string>();
     for (const threadID in rawThreadInfos) {
       const rawThreadInfo = rawThreadInfos[threadID];
       if (
         threadIsPending(threadID) ||
         (rawThreadInfo.parentThreadID !== genesis.id &&
           rawThreadInfo.type !== threadTypes.SIDEBAR)
       ) {
         continue;
       }
       const actualMemberIDs = rawThreadInfo.members
         .filter(member => member.role)
         .map(member => member.id);
       const pendingThreadID = getPendingThreadID(
         rawThreadInfo.type,
         actualMemberIDs,
         rawThreadInfo.sourceMessageID,
       );
       const existingResult = result.get(pendingThreadID);
       if (
         !existingResult ||
         rawThreadInfos[existingResult].creationTime > rawThreadInfo.creationTime
       ) {
         result.set(pendingThreadID, threadID);
       }
     }
     return result;
   },
 );
 
 const baseSavedEmojiAvatarSelectorForThread: (
   threadID: string,
   containingThreadID: ?string,
 ) => (BaseAppState<>) => () => ClientAvatar = (
   threadID: string,
   containingThreadID: ?string,
 ) =>
   createSelector(
     (state: BaseAppState<>) => threadInfoSelector(state)[threadID],
     (state: BaseAppState<>) =>
       containingThreadID ? threadInfoSelector(state)[containingThreadID] : null,
     (threadInfo: ThreadInfo, containingThreadInfo: ?ThreadInfo) => {
       return () => {
         let threadAvatar = getAvatarForThread(threadInfo, containingThreadInfo);
         if (threadAvatar.type !== 'emoji') {
           threadAvatar = getRandomDefaultEmojiAvatar();
         }
         return threadAvatar;
       };
     },
   );
 
 const savedEmojiAvatarSelectorForThread: (
   threadID: string,
   containingThreadID: ?string,
 ) => (state: BaseAppState<>) => () => ClientEmojiAvatar = _memoize(
   baseSavedEmojiAvatarSelectorForThread,
 );
 
 const baseThreadInfosSelectorForThreadType: (
   threadType: ThreadType,
 ) => (BaseAppState<>) => $ReadOnlyArray<ThreadInfo> = (
   threadType: ThreadType,
 ) =>
   createSelector(
     (state: BaseAppState<>) => threadInfoSelector(state),
     (threadInfos: {
       +[id: string]: ThreadInfo,
     }): $ReadOnlyArray<ThreadInfo> => {
       const result = [];
 
       for (const threadID in threadInfos) {
         const threadInfo = threadInfos[threadID];
         if (threadInfo.type === threadType) {
           result.push(threadInfo);
         }
       }
 
       return result;
     },
   );
 
 const threadInfosSelectorForThreadType: (
   threadType: ThreadType,
 ) => (state: BaseAppState<>) => $ReadOnlyArray<ThreadInfo> = _memoize(
   baseThreadInfosSelectorForThreadType,
 );
 
 export {
   ancestorThreadInfos,
   threadInfoSelector,
   communityThreadSelector,
   onScreenThreadInfos,
   onScreenEntryEditableThreadInfos,
   entryInfoSelector,
   currentDaysToEntries,
   childThreadInfos,
   containedThreadInfos,
   unreadCount,
   unreadBackgroundCount,
   otherUsersButNoOtherAdmins,
   mostRecentlyReadThread,
   mostRecentlyReadThreadSelector,
   sidebarInfoSelector,
   threadInfoFromSourceMessageIDSelector,
   pendingToRealizedThreadIDsSelector,
   savedEmojiAvatarSelectorForThread,
   threadInfosSelectorForThreadType,
 };
diff --git a/lib/selectors/user-selectors.js b/lib/selectors/user-selectors.js
index 07f84607e..5635780fa 100644
--- a/lib/selectors/user-selectors.js
+++ b/lib/selectors/user-selectors.js
@@ -1,259 +1,259 @@
 // @flow
 
 import _memoize from 'lodash/memoize.js';
 import { createSelector } from 'reselect';
 
 import {
   getAvatarForUser,
   getRandomDefaultEmojiAvatar,
 } from '../shared/avatar-utils.js';
 import SearchIndex from '../shared/search-index.js';
 import SentencePrefixSearchIndex from '../shared/sentence-prefix-search-index.js';
 import { getSingleOtherUser } from '../shared/thread-utils.js';
 import type { ClientEmojiAvatar } from '../types/avatar-types';
 import type { BaseAppState } from '../types/redux-types.js';
 import { userRelationshipStatus } from '../types/relationship-types.js';
 import { threadTypes } from '../types/thread-types-enum.js';
-import {
-  type LegacyRawThreadInfo,
-  type LegacyRelativeMemberInfo,
-  type LegacyRawThreadInfos,
-  type RelativeMemberInfo,
+import type {
+  LegacyRawThreadInfo,
+  LegacyRelativeMemberInfo,
+  RelativeMemberInfo,
+  RawThreadInfos,
 } from '../types/thread-types.js';
 import type {
   UserInfos,
   RelativeUserInfo,
   AccountUserInfo,
   CurrentUserInfo,
 } from '../types/user-types.js';
 
 // Used for specific message payloads that include an array of user IDs, ie.
 // array of initial users, array of added users
 function userIDsToRelativeUserInfos(
   userIDs: $ReadOnlyArray<string>,
   viewerID: ?string,
   userInfos: UserInfos,
 ): RelativeUserInfo[] {
   const relativeUserInfos: RelativeUserInfo[] = [];
   for (const userID of userIDs) {
     const username = userInfos[userID] ? userInfos[userID].username : null;
     if (userID === viewerID) {
       relativeUserInfos.unshift({
         id: userID,
         username,
         isViewer: true,
       });
     } else {
       relativeUserInfos.push({
         id: userID,
         username,
         isViewer: false,
       });
     }
   }
   return relativeUserInfos;
 }
 
 function getRelativeMemberInfos(
   threadInfo: ?LegacyRawThreadInfo,
   currentUserID: ?string,
   userInfos: UserInfos,
 ): $ReadOnlyArray<LegacyRelativeMemberInfo> {
   const relativeMemberInfos = [];
   if (!threadInfo) {
     return relativeMemberInfos;
   }
   const memberInfos = threadInfo.members;
   for (const memberInfo of memberInfos) {
     if (!memberInfo.role) {
       continue;
     }
     const username = userInfos[memberInfo.id]
       ? userInfos[memberInfo.id].username
       : null;
     if (memberInfo.id === currentUserID) {
       relativeMemberInfos.unshift({
         id: memberInfo.id,
         role: memberInfo.role,
         permissions: memberInfo.permissions,
         username,
         isViewer: true,
         isSender: memberInfo.isSender,
       });
     } else {
       relativeMemberInfos.push({
         id: memberInfo.id,
         role: memberInfo.role,
         permissions: memberInfo.permissions,
         username,
         isViewer: false,
         isSender: memberInfo.isSender,
       });
     }
   }
   return relativeMemberInfos;
 }
 
 const emptyArray: $ReadOnlyArray<LegacyRelativeMemberInfo> = [];
 
 // Includes current user at the start
 const baseRelativeMemberInfoSelectorForMembersOfThread: (
   threadID: ?string,
 ) => (state: BaseAppState<>) => $ReadOnlyArray<LegacyRelativeMemberInfo> = (
   threadID: ?string,
 ) => {
   if (!threadID) {
     return () => emptyArray;
   }
   return createSelector(
     (state: BaseAppState<>) => state.threadStore.threadInfos[threadID],
     (state: BaseAppState<>) =>
       state.currentUserInfo && state.currentUserInfo.id,
     (state: BaseAppState<>) => state.userStore.userInfos,
     getRelativeMemberInfos,
   );
 };
 
 const relativeMemberInfoSelectorForMembersOfThread: (
   threadID: ?string,
 ) => (state: BaseAppState<>) => $ReadOnlyArray<RelativeMemberInfo> = _memoize(
   baseRelativeMemberInfoSelectorForMembersOfThread,
 );
 
 const userInfoSelectorForPotentialMembers: (state: BaseAppState<>) => {
   [id: string]: AccountUserInfo,
 } = createSelector(
   (state: BaseAppState<>) => state.userStore.userInfos,
   (state: BaseAppState<>) => state.currentUserInfo && state.currentUserInfo.id,
   (
     userInfos: UserInfos,
     currentUserID: ?string,
   ): { [id: string]: AccountUserInfo } => {
     const availableUsers: { [id: string]: AccountUserInfo } = {};
 
     for (const id in userInfos) {
       const { username, relationshipStatus } = userInfos[id];
       if (id === currentUserID || !username) {
         continue;
       }
       if (
         relationshipStatus !== userRelationshipStatus.BLOCKED_VIEWER &&
         relationshipStatus !== userRelationshipStatus.BOTH_BLOCKED
       ) {
         availableUsers[id] = { id, username, relationshipStatus };
       }
     }
     return availableUsers;
   },
 );
 
 function searchIndexFromUserInfos(userInfos: {
   [id: string]: AccountUserInfo,
 }) {
   const searchIndex = new SearchIndex();
   for (const id in userInfos) {
     searchIndex.addEntry(id, userInfos[id].username);
   }
   return searchIndex;
 }
 
 const userSearchIndexForPotentialMembers: (
   state: BaseAppState<>,
 ) => SearchIndex = createSelector(
   userInfoSelectorForPotentialMembers,
   searchIndexFromUserInfos,
 );
 
 const isLoggedIn = (state: BaseAppState<>): boolean =>
   !!(
     state.currentUserInfo &&
     !state.currentUserInfo.anonymous &&
     state.dataLoaded
   );
 
 const addUsersToSearchIndex = (
   userInfos: UserInfos,
   searchIndex: SearchIndex | SentencePrefixSearchIndex,
 ): void => {
   for (const id in userInfos) {
     const { username } = userInfos[id];
     if (!username) {
       continue;
     }
     searchIndex.addEntry(id, username);
   }
 };
 
 const userStoreSearchIndex: (state: BaseAppState<>) => SearchIndex =
   createSelector(
     (state: BaseAppState<>) => state.userStore.userInfos,
     (userInfos: UserInfos) => {
       const searchIndex = new SearchIndex();
       addUsersToSearchIndex(userInfos, searchIndex);
       return searchIndex;
     },
   );
 
 const userStoreMentionSearchIndex: (
   state: BaseAppState<>,
 ) => SentencePrefixSearchIndex = createSelector(
   (state: BaseAppState<>) => state.userStore.userInfos,
   (userInfos: UserInfos) => {
     const searchIndex = new SentencePrefixSearchIndex();
     addUsersToSearchIndex(userInfos, searchIndex);
     return searchIndex;
   },
 );
 
 const usersWithPersonalThreadSelector: (
   state: BaseAppState<>,
 ) => $ReadOnlySet<string> = createSelector(
   (state: BaseAppState<>) => state.currentUserInfo && state.currentUserInfo.id,
   (state: BaseAppState<>) => state.threadStore.threadInfos,
-  (viewerID: ?string, threadInfos: LegacyRawThreadInfos) => {
+  (viewerID: ?string, threadInfos: RawThreadInfos) => {
     const personalThreadMembers = new Set<string>();
 
     for (const threadID in threadInfos) {
       const thread = threadInfos[threadID];
       if (
         thread.type !== threadTypes.PERSONAL ||
         !thread.members.find(member => member.id === viewerID)
       ) {
         continue;
       }
       const otherMemberID = getSingleOtherUser(thread, viewerID);
       if (otherMemberID) {
         personalThreadMembers.add(otherMemberID);
       }
     }
     return personalThreadMembers;
   },
 );
 
 const savedEmojiAvatarSelectorForCurrentUser: (
   state: BaseAppState<>,
 ) => () => ClientEmojiAvatar = createSelector(
   (state: BaseAppState<>) => state.currentUserInfo && state.currentUserInfo,
   (currentUser: ?CurrentUserInfo) => {
     return () => {
       let userAvatar = getAvatarForUser(currentUser);
       if (userAvatar.type !== 'emoji') {
         userAvatar = getRandomDefaultEmojiAvatar();
       }
       return userAvatar;
     };
   },
 );
 
 export {
   userIDsToRelativeUserInfos,
   getRelativeMemberInfos,
   relativeMemberInfoSelectorForMembersOfThread,
   userInfoSelectorForPotentialMembers,
   userSearchIndexForPotentialMembers,
   isLoggedIn,
   userStoreSearchIndex,
   userStoreMentionSearchIndex,
   usersWithPersonalThreadSelector,
   savedEmojiAvatarSelectorForCurrentUser,
 };