diff --git a/lib/push/send-hooks.react.js b/lib/push/send-hooks.react.js
index 7db262720..c1294a999 100644
--- a/lib/push/send-hooks.react.js
+++ b/lib/push/send-hooks.react.js
@@ -1,60 +1,61 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   preparePushNotifs,
   type PerUserTargetedNotifications,
 } from './send-utils.js';
 import { ENSCacheContext } from '../components/ens-cache-provider.react.js';
 import { NeynarClientContext } from '../components/neynar-client-provider.react.js';
+import { thickRawThreadInfosSelector } from '../selectors/thread-selectors.js';
 import type { MessageData } from '../types/message-types.js';
 import type {
   EncryptedNotifUtilsAPI,
   SenderDeviceDescriptor,
 } from '../types/notif-types.js';
 import { useSelector } from '../utils/redux-utils.js';
 
 function usePreparePushNotifs(): (
   encryptedNotifsUtilsAPI: EncryptedNotifUtilsAPI,
   senderDeviceDescriptor: SenderDeviceDescriptor,
   messageDatas: $ReadOnlyArray<MessageData>,
 ) => Promise<?PerUserTargetedNotifications> {
   const rawMessageInfos = useSelector(state => state.messageStore.messages);
-  const rawThreadInfos = useSelector(state => state.threadStore.threadInfos);
+  const thickRawThreadInfos = useSelector(thickRawThreadInfosSelector);
   const auxUserInfos = useSelector(state => state.auxUserStore.auxUserInfos);
   const userInfos = useSelector(state => state.userStore.userInfos);
 
   const { getENSNames } = React.useContext(ENSCacheContext);
   const getFCNames = React.useContext(NeynarClientContext)?.getFCNames;
 
   return React.useCallback(
     (
       encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
       senderDeviceDescriptor: SenderDeviceDescriptor,
       messageDatas: $ReadOnlyArray<MessageData>,
     ) => {
       return preparePushNotifs({
         encryptedNotifUtilsAPI,
         senderDeviceDescriptor,
         messageInfos: rawMessageInfos,
-        rawThreadInfos,
+        thickRawThreadInfos,
         auxUserInfos,
         messageDatas,
         userInfos,
         getENSNames,
         getFCNames,
       });
     },
     [
       rawMessageInfos,
-      rawThreadInfos,
+      thickRawThreadInfos,
       auxUserInfos,
       userInfos,
       getENSNames,
       getFCNames,
     ],
   );
 }
 
 export { usePreparePushNotifs };
diff --git a/lib/push/send-utils.js b/lib/push/send-utils.js
index a9b5ace5e..96d73c68e 100644
--- a/lib/push/send-utils.js
+++ b/lib/push/send-utils.js
@@ -1,704 +1,703 @@
 // @flow
 
 import _pickBy from 'lodash/fp/pickBy.js';
 import uuidv4 from 'uuid/v4.js';
 
 import { createAndroidVisualNotification } from './android-notif-creators.js';
 import { createAPNsVisualNotification } from './apns-notif-creators.js';
 import {
   stringToVersionKey,
   getDevicesByPlatform,
   generateNotifUserInfoPromise,
   userAllowsNotif,
 } from './utils.js';
 import { createWebNotification } from './web-notif-creators.js';
 import { createWNSNotification } from './wns-notif-creators.js';
 import { hasPermission } from '../permissions/minimally-encoded-thread-permissions.js';
 import {
   rawMessageInfoFromMessageData,
   createMessageInfo,
   shimUnsupportedRawMessageInfos,
 } from '../shared/message-utils.js';
 import { pushTypes } from '../shared/messages/message-spec.js';
 import { messageSpecs } from '../shared/messages/message-specs.js';
 import { notifTextsForMessageInfo } from '../shared/notif-utils.js';
 import {
   isMemberActive,
   threadInfoFromRawThreadInfo,
 } from '../shared/thread-utils.js';
 import type { AuxUserInfos } from '../types/aux-user-types.js';
 import type { PlatformDetails, Platform } from '../types/device-types.js';
 import {
   identityDeviceTypeToPlatform,
   type IdentityPlatformDetails,
 } from '../types/identity-service-types.js';
 import {
   type MessageData,
   type RawMessageInfo,
   messageDataLocalID,
 } from '../types/message-types.js';
 import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
 import type {
   ResolvedNotifTexts,
   NotificationTargetDevice,
   TargetedNotificationWithPlatform,
   SenderDeviceDescriptor,
   EncryptedNotifUtilsAPI,
 } from '../types/notif-types.js';
 import type { ThreadSubscription } from '../types/subscription-types.js';
-import type { RawThreadInfos } from '../types/thread-types.js';
+import type { ThickRawThreadInfos } from '../types/thread-types.js';
 import type { UserInfos } from '../types/user-types.js';
 import { type GetENSNames } from '../utils/ens-helpers.js';
 import { type GetFCNames } from '../utils/farcaster-helpers.js';
 import { promiseAll } from '../utils/promises.js';
 
 export type Device = {
   +platformDetails: PlatformDetails,
   +deliveryID: string,
   +cryptoID: string,
 };
 
 export type ThreadSubscriptionWithRole = $ReadOnly<{
   ...ThreadSubscription,
   +role: ?string,
 }>;
 
 export type PushUserInfo = {
   +devices: $ReadOnlyArray<Device>,
   +messageInfos: RawMessageInfo[],
   +messageDatas: MessageData[],
   +subscriptions?: {
     +[threadID: string]: ThreadSubscriptionWithRole,
   },
 };
 
 export type PushInfo = { +[userID: string]: PushUserInfo };
 
 function identityPlatformDetailsToPlatformDetails(
   identityPlatformDetails: IdentityPlatformDetails,
 ): PlatformDetails {
   const { deviceType, ...rest } = identityPlatformDetails;
   return {
     ...rest,
     platform: identityDeviceTypeToPlatform[deviceType],
   };
 }
 
 async function getPushUserInfo(
   messageInfos: { +[id: string]: RawMessageInfo },
-  rawThreadInfos: RawThreadInfos,
+  thickRawThreadInfos: ThickRawThreadInfos,
   auxUserInfos: AuxUserInfos,
   messageDatas: $ReadOnlyArray<MessageData>,
 ): Promise<{
   +pushInfos: ?PushInfo,
   +rescindInfos: ?PushInfo,
 }> {
   if (messageDatas.length === 0) {
     return { pushInfos: null, rescindInfos: null };
   }
 
   const threadsToMessageIndices: Map<string, number[]> = new Map();
   const newMessageInfos: RawMessageInfo[] = [];
 
   let nextNewMessageIndex = 0;
   for (let i = 0; i < messageDatas.length; i++) {
     const messageData = messageDatas[i];
     const threadID = messageData.threadID;
 
     let messageIndices = threadsToMessageIndices.get(threadID);
     if (!messageIndices) {
       messageIndices = [];
       threadsToMessageIndices.set(threadID, messageIndices);
     }
 
     const newMessageIndex = nextNewMessageIndex++;
     messageIndices.push(newMessageIndex);
 
     const messageID = messageDataLocalID(messageData) ?? uuidv4();
     const rawMessageInfo = rawMessageInfoFromMessageData(
       messageData,
       messageID,
     );
     newMessageInfos.push(rawMessageInfo);
   }
 
   const pushUserThreadInfos: {
     [userID: string]: {
       devices: $ReadOnlyArray<Device>,
       threadsWithSubscriptions: {
         [threadID: string]: ThreadSubscriptionWithRole,
       },
     },
   } = {};
 
   for (const threadID of threadsToMessageIndices.keys()) {
-    const threadInfo = rawThreadInfos[threadID];
+    const threadInfo = thickRawThreadInfos[threadID];
     for (const memberInfo of threadInfo.members) {
       if (
         !isMemberActive(memberInfo) ||
-        !hasPermission(memberInfo.permissions, 'visible') ||
-        !memberInfo.subscription
+        !hasPermission(memberInfo.permissions, 'visible')
       ) {
         continue;
       }
 
       if (pushUserThreadInfos[memberInfo.id]) {
         pushUserThreadInfos[memberInfo.id].threadsWithSubscriptions[threadID] =
           { ...memberInfo.subscription, role: memberInfo.role };
         continue;
       }
 
       const devicesPlatformDetails =
         auxUserInfos[memberInfo.id].devicesPlatformDetails;
 
       if (!devicesPlatformDetails) {
         continue;
       }
 
       const devices = Object.entries(devicesPlatformDetails).map(
         ([deviceID, identityPlatformDetails]) => ({
           platformDetails: identityPlatformDetailsToPlatformDetails(
             identityPlatformDetails,
           ),
           deliveryID: deviceID,
           cryptoID: deviceID,
         }),
       );
 
       pushUserThreadInfos[memberInfo.id] = {
         devices,
         threadsWithSubscriptions: {
           [threadID]: { ...memberInfo.subscription, role: memberInfo.role },
         },
       };
     }
   }
 
   const userPushInfoPromises: { [string]: Promise<?PushUserInfo> } = {};
   const userRescindInfoPromises: { [string]: Promise<?PushUserInfo> } = {};
 
   for (const userID in pushUserThreadInfos) {
     const pushUserThreadInfo = pushUserThreadInfos[userID];
 
     userPushInfoPromises[userID] = (async () => {
       const pushInfosWithoutSubscriptions = await generateNotifUserInfoPromise({
         pushType: pushTypes.NOTIF,
         devices: pushUserThreadInfo.devices,
         newMessageInfos,
         messageDatas,
         threadsToMessageIndices,
         threadIDs: Object.keys(pushUserThreadInfo.threadsWithSubscriptions),
         userNotMemberOfSubthreads: new Set(),
         fetchMessageInfoByID: (messageID: string) =>
           (async () => messageInfos[messageID])(),
         userID,
       });
       if (!pushInfosWithoutSubscriptions) {
         return null;
       }
       return {
         ...pushInfosWithoutSubscriptions,
         subscriptions: pushUserThreadInfo.threadsWithSubscriptions,
       };
     })();
 
     userRescindInfoPromises[userID] = (async () => {
       const pushInfosWithoutSubscriptions = await generateNotifUserInfoPromise({
         pushType: pushTypes.RESCIND,
         devices: pushUserThreadInfo.devices,
         newMessageInfos,
         messageDatas,
         threadsToMessageIndices,
         threadIDs: Object.keys(pushUserThreadInfo.threadsWithSubscriptions),
         userNotMemberOfSubthreads: new Set(),
         fetchMessageInfoByID: (messageID: string) =>
           (async () => messageInfos[messageID])(),
         userID,
       });
       if (!pushInfosWithoutSubscriptions) {
         return null;
       }
       return {
         ...pushInfosWithoutSubscriptions,
         subscriptions: pushUserThreadInfo.threadsWithSubscriptions,
       };
     })();
   }
 
   const [pushInfo, rescindInfo] = await Promise.all([
     promiseAll(userPushInfoPromises),
     promiseAll(userRescindInfoPromises),
   ]);
 
   return {
     pushInfos: _pickBy(Boolean)(pushInfo),
     rescindInfos: _pickBy(Boolean)(rescindInfo),
   };
 }
 
 async function buildNotifText(
   rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   userID: string,
   threadInfos: { +[id: string]: ThreadInfo },
   subscriptions: ?{ +[threadID: string]: ThreadSubscriptionWithRole },
   userInfos: UserInfos,
   getENSNames: ?GetENSNames,
   getFCNames: ?GetFCNames,
 ): Promise<?{
   +notifTexts: ResolvedNotifTexts,
   +newRawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +badgeOnly: boolean,
 }> {
   if (!subscriptions) {
     return null;
   }
 
   const hydrateMessageInfo = (rawMessageInfo: RawMessageInfo) =>
     createMessageInfo(rawMessageInfo, userID, userInfos, threadInfos);
 
   const newMessageInfos = [];
   const newRawMessageInfos = [];
 
   for (const rawMessageInfo of rawMessageInfos) {
     const newMessageInfo = hydrateMessageInfo(rawMessageInfo);
     if (newMessageInfo) {
       newMessageInfos.push(newMessageInfo);
       newRawMessageInfos.push(rawMessageInfo);
     }
   }
 
   if (newMessageInfos.length === 0) {
     return null;
   }
 
   const [{ threadID }] = newMessageInfos;
   const threadInfo = threadInfos[threadID];
   const parentThreadInfo = threadInfo.parentThreadID
     ? threadInfos[threadInfo.parentThreadID]
     : null;
 
   const subscription = subscriptions[threadID];
   if (!subscription) {
     return null;
   }
 
   const username = userInfos[userID] && userInfos[userID].username;
   const { notifAllowed, badgeOnly } = await userAllowsNotif({
     subscription,
     userID,
     newMessageInfos,
     userInfos,
     username,
     getENSNames,
   });
 
   if (!notifAllowed) {
     return null;
   }
 
   const notifTargetUserInfo = { id: userID, username };
   const notifTexts = await notifTextsForMessageInfo(
     newMessageInfos,
     threadInfo,
     parentThreadInfo,
     notifTargetUserInfo,
     getENSNames,
     getFCNames,
   );
   if (!notifTexts) {
     return null;
   }
 
   return { notifTexts, newRawMessageInfos, badgeOnly };
 }
 
 type BuildNotifsForUserDevicesInputData = {
   +encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
   +senderDeviceDescriptor: SenderDeviceDescriptor,
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +userID: string,
   +threadInfos: { +[id: string]: ThreadInfo },
   +subscriptions: ?{ +[threadID: string]: ThreadSubscriptionWithRole },
   +userInfos: UserInfos,
   +getENSNames: ?GetENSNames,
   +getFCNames: ?GetFCNames,
   +devicesByPlatform: $ReadOnlyMap<
     Platform,
     $ReadOnlyMap<string, $ReadOnlyArray<NotificationTargetDevice>>,
   >,
 };
 
 async function buildNotifsForUserDevices(
   inputData: BuildNotifsForUserDevicesInputData,
 ): Promise<?$ReadOnlyArray<TargetedNotificationWithPlatform>> {
   const {
     encryptedNotifUtilsAPI,
     senderDeviceDescriptor,
     rawMessageInfos,
     userID,
     threadInfos,
     subscriptions,
     userInfos,
     getENSNames,
     getFCNames,
     devicesByPlatform,
   } = inputData;
 
   const notifTextWithNewRawMessageInfos = await buildNotifText(
     rawMessageInfos,
     userID,
     threadInfos,
     subscriptions,
     userInfos,
     getENSNames,
     getFCNames,
   );
 
   if (!notifTextWithNewRawMessageInfos) {
     return null;
   }
 
   const { notifTexts, newRawMessageInfos, badgeOnly } =
     notifTextWithNewRawMessageInfos;
   const [{ threadID }] = newRawMessageInfos;
 
   const promises: Array<
     Promise<$ReadOnlyArray<TargetedNotificationWithPlatform>>,
   > = [];
 
   const iosVersionToDevices = devicesByPlatform.get('ios');
   if (iosVersionToDevices) {
     for (const [versionKey, devices] of iosVersionToDevices) {
       const { codeVersion, stateVersion } = stringToVersionKey(versionKey);
       const platformDetails = {
         platform: 'ios',
         codeVersion,
         stateVersion,
       };
       const shimmedNewRawMessageInfos = shimUnsupportedRawMessageInfos(
         newRawMessageInfos,
         platformDetails,
       );
 
       promises.push(
         (async () => {
           return (
             await createAPNsVisualNotification(
               encryptedNotifUtilsAPI,
               {
                 senderDeviceDescriptor,
                 notifTexts,
                 newRawMessageInfos: shimmedNewRawMessageInfos,
                 threadID,
                 collapseKey: undefined,
                 badgeOnly,
                 unreadCount: undefined,
                 platformDetails,
                 uniqueID: uuidv4(),
               },
               devices,
             )
           ).map(targetedNotification => ({
             platform: 'ios',
             targetedNotification,
           }));
         })(),
       );
     }
   }
 
   const androidVersionToDevices = devicesByPlatform.get('android');
   if (androidVersionToDevices) {
     for (const [versionKey, devices] of androidVersionToDevices) {
       const { codeVersion, stateVersion } = stringToVersionKey(versionKey);
       const platformDetails = {
         platform: 'android',
         codeVersion,
         stateVersion,
       };
       const shimmedNewRawMessageInfos = shimUnsupportedRawMessageInfos(
         newRawMessageInfos,
         platformDetails,
       );
 
       promises.push(
         (async () => {
           return (
             await createAndroidVisualNotification(
               encryptedNotifUtilsAPI,
               {
                 senderDeviceDescriptor,
                 notifTexts,
                 newRawMessageInfos: shimmedNewRawMessageInfos,
                 threadID,
                 collapseKey: undefined,
                 badgeOnly,
                 unreadCount: undefined,
                 platformDetails,
                 notifID: uuidv4(),
               },
               devices,
             )
           ).map(targetedNotification => ({
             platform: 'android',
             targetedNotification,
           }));
         })(),
       );
     }
   }
 
   const macosVersionToDevices = devicesByPlatform.get('macos');
   if (macosVersionToDevices) {
     for (const [versionKey, devices] of macosVersionToDevices) {
       const { codeVersion, stateVersion, majorDesktopVersion } =
         stringToVersionKey(versionKey);
       const platformDetails = {
         platform: 'macos',
         codeVersion,
         stateVersion,
         majorDesktopVersion,
       };
       const shimmedNewRawMessageInfos = shimUnsupportedRawMessageInfos(
         newRawMessageInfos,
         platformDetails,
       );
 
       promises.push(
         (async () => {
           return (
             await createAPNsVisualNotification(
               encryptedNotifUtilsAPI,
               {
                 senderDeviceDescriptor,
                 notifTexts,
                 newRawMessageInfos: shimmedNewRawMessageInfos,
                 threadID,
                 collapseKey: undefined,
                 badgeOnly,
                 unreadCount: undefined,
                 platformDetails,
                 uniqueID: uuidv4(),
               },
               devices,
             )
           ).map(targetedNotification => ({
             platform: 'macos',
             targetedNotification,
           }));
         })(),
       );
     }
   }
 
   const windowsVersionToDevices = devicesByPlatform.get('windows');
   if (windowsVersionToDevices) {
     for (const [versionKey, devices] of windowsVersionToDevices) {
       const { codeVersion, stateVersion, majorDesktopVersion } =
         stringToVersionKey(versionKey);
       const platformDetails = {
         platform: 'windows',
         codeVersion,
         stateVersion,
         majorDesktopVersion,
       };
 
       promises.push(
         (async () => {
           return (
             await createWNSNotification(
               encryptedNotifUtilsAPI,
               {
                 notifTexts,
                 threadID,
                 senderDeviceDescriptor,
                 platformDetails,
               },
               devices,
             )
           ).map(targetedNotification => ({
             platform: 'windows',
             targetedNotification,
           }));
         })(),
       );
     }
   }
 
   const webVersionToDevices = devicesByPlatform.get('web');
   if (webVersionToDevices) {
     for (const [versionKey, devices] of webVersionToDevices) {
       const { codeVersion, stateVersion } = stringToVersionKey(versionKey);
       const platformDetails = {
         platform: 'web',
         codeVersion,
         stateVersion,
       };
 
       promises.push(
         (async () => {
           return (
             await createWebNotification(
               encryptedNotifUtilsAPI,
               {
                 notifTexts,
                 threadID,
                 senderDeviceDescriptor,
                 platformDetails,
                 id: uuidv4(),
               },
               devices,
             )
           ).map(targetedNotification => ({
             platform: 'web',
             targetedNotification,
           }));
         })(),
       );
     }
   }
 
   return (await Promise.all(promises)).flat();
 }
 
 export type PerUserTargetedNotifications = {
   +[userID: string]: $ReadOnlyArray<TargetedNotificationWithPlatform>,
 };
 
 type BuildNotifsFromPushInfoInputData = {
   +encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
   +senderDeviceDescriptor: SenderDeviceDescriptor,
   +pushInfo: PushInfo,
-  +rawThreadInfos: RawThreadInfos,
+  +thickRawThreadInfos: ThickRawThreadInfos,
   +userInfos: UserInfos,
   +getENSNames: ?GetENSNames,
   +getFCNames: ?GetFCNames,
 };
 
 async function buildNotifsFromPushInfo(
   inputData: BuildNotifsFromPushInfoInputData,
 ): Promise<PerUserTargetedNotifications> {
   const {
     encryptedNotifUtilsAPI,
     senderDeviceDescriptor,
     pushInfo,
-    rawThreadInfos,
+    thickRawThreadInfos,
     userInfos,
     getENSNames,
     getFCNames,
   } = inputData;
   const threadIDs = new Set<string>();
 
   for (const userID in pushInfo) {
     for (const rawMessageInfo of pushInfo[userID].messageInfos) {
       const threadID = rawMessageInfo.threadID;
       threadIDs.add(threadID);
 
       const messageSpec = messageSpecs[rawMessageInfo.type];
       if (messageSpec.threadIDs) {
         for (const id of messageSpec.threadIDs(rawMessageInfo)) {
           threadIDs.add(id);
         }
       }
     }
   }
 
   const perUserBuildNotifsResultPromises: {
     [userID: string]: Promise<$ReadOnlyArray<TargetedNotificationWithPlatform>>,
   } = {};
 
   for (const userID in pushInfo) {
     const threadInfos = Object.fromEntries(
       [...threadIDs].map(threadID => [
         threadID,
         threadInfoFromRawThreadInfo(
-          rawThreadInfos[threadID],
+          thickRawThreadInfos[threadID],
           userID,
           userInfos,
         ),
       ]),
     );
     const devicesByPlatform = getDevicesByPlatform(pushInfo[userID].devices);
     const singleNotificationPromises = [];
 
     for (const rawMessageInfos of pushInfo[userID].messageInfos) {
       singleNotificationPromises.push(
         // We always pass one element array here
         // because coalescing is not supported for
         // notifications generated on the client
         buildNotifsForUserDevices({
           encryptedNotifUtilsAPI,
           senderDeviceDescriptor,
           rawMessageInfos: [rawMessageInfos],
           userID,
           threadInfos,
           subscriptions: pushInfo[userID].subscriptions,
           userInfos,
           getENSNames,
           getFCNames,
           devicesByPlatform,
         }),
       );
     }
 
     perUserBuildNotifsResultPromises[userID] = (async () => {
       const singleNotificationResults = await Promise.all(
         singleNotificationPromises,
       );
       return singleNotificationResults.filter(Boolean).flat();
     })();
   }
 
   return promiseAll(perUserBuildNotifsResultPromises);
 }
 
 type PreparePushNotifsInputData = {
   +encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
   +senderDeviceDescriptor: SenderDeviceDescriptor,
   +messageInfos: { +[id: string]: RawMessageInfo },
-  +rawThreadInfos: RawThreadInfos,
+  +thickRawThreadInfos: ThickRawThreadInfos,
   +auxUserInfos: AuxUserInfos,
   +messageDatas: $ReadOnlyArray<MessageData>,
   +userInfos: UserInfos,
   +getENSNames: ?GetENSNames,
   +getFCNames: ?GetFCNames,
 };
 
 async function preparePushNotifs(
   inputData: PreparePushNotifsInputData,
 ): Promise<?PerUserTargetedNotifications> {
   const {
     encryptedNotifUtilsAPI,
     senderDeviceDescriptor,
     messageDatas,
     messageInfos,
     auxUserInfos,
-    rawThreadInfos,
+    thickRawThreadInfos,
     userInfos,
     getENSNames,
     getFCNames,
   } = inputData;
 
   const { pushInfos } = await getPushUserInfo(
     messageInfos,
-    rawThreadInfos,
+    thickRawThreadInfos,
     auxUserInfos,
     messageDatas,
   );
 
   if (!pushInfos) {
     return null;
   }
 
   return await buildNotifsFromPushInfo({
     encryptedNotifUtilsAPI,
     senderDeviceDescriptor,
     pushInfo: pushInfos,
-    rawThreadInfos,
+    thickRawThreadInfos,
     userInfos,
     getENSNames,
     getFCNames,
   });
 }
 
 export { preparePushNotifs, generateNotifUserInfoPromise };
diff --git a/lib/selectors/thread-selectors.js b/lib/selectors/thread-selectors.js
index 04542eee6..fb33de972 100644
--- a/lib/selectors/thread-selectors.js
+++ b/lib/selectors/thread-selectors.js
@@ -1,522 +1,542 @@
 // @flow
 
 import _compact from 'lodash/fp/compact.js';
 import _filter from 'lodash/fp/filter.js';
 import _flow from 'lodash/fp/flow.js';
 import _groupBy from 'lodash/fp/groupBy.js';
 import _map from 'lodash/fp/map.js';
 import _mapValues from 'lodash/fp/mapValues.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 { extractKeyserverIDFromID } from '../keyserver-conn/keyserver-call-utils.js';
 import {
   getAvatarForThread,
   getRandomDefaultEmojiAvatar,
 } from '../shared/avatar-utils.js';
 import { createEntryInfo } from '../shared/entry-utils.js';
 import {
   threadInHomeChatList,
   threadInBackgroundChatList,
   threadInFilterList,
   threadInfoFromRawThreadInfo,
   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 } from '../types/message-types.js';
 import type {
   RelativeMemberInfo,
   ThreadInfo,
   RawThreadInfo,
+  ThickRawThreadInfo,
 } from '../types/minimally-encoded-thread-permissions-types.js';
 import type { BaseAppState } from '../types/redux-types.js';
 import {
   threadTypes,
   threadTypeIsCommunityRoot,
   type ThreadType,
 } from '../types/thread-types-enum.js';
 import type {
   MixedRawThreadInfos,
   RawThreadInfos,
+  ThickRawThreadInfos,
 } 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 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;
   },
 );
 
+const thickRawThreadInfosSelector: (
+  state: BaseAppState<>,
+) => ThickRawThreadInfos = createSelector(
+  (state: BaseAppState<>) => state.threadStore.threadInfos,
+  (threadInfos: RawThreadInfos): ThickRawThreadInfos => {
+    const thickRawThreadInfos: { [id: string]: ThickRawThreadInfo } = {};
+    for (const id in threadInfos) {
+      const threadInfo = threadInfos[id];
+      if (!threadInfo.thick) {
+        continue;
+      }
+      thickRawThreadInfos[id] = threadInfo;
+    }
+    return thickRawThreadInfos;
+  },
+);
+
 const unreadCount: (state: BaseAppState<>) => number = createSelector(
   (state: BaseAppState<>) => state.threadStore.threadInfos,
   (threadInfos: RawThreadInfos): number =>
     values(threadInfos).filter(
       threadInfo =>
         threadInHomeChatList(threadInfo) && threadInfo.currentUser.unread,
     ).length,
 );
 
 const allUnreadCounts: (state: BaseAppState<>) => {
   +[keyserverID: string]: number,
 } = createSelector(
   (state: BaseAppState<>) => state.threadStore.threadInfos,
   (threadInfos: RawThreadInfos): { +[keyserverID: string]: number } => {
     const keyserverToThreads = _groupBy(threadInfo =>
       extractKeyserverIDFromID(threadInfo.id),
     )(
       values(threadInfos).filter(threadInfo =>
         threadInHomeChatList(threadInfo),
       ),
     );
 
     const keyserverUnreadCountPairs = Object.entries(keyserverToThreads).map(
       ([keyserverID, keyserverThreadInfos]) => [
         keyserverID,
         keyserverThreadInfos.filter(threadInfo => threadInfo.currentUser.unread)
           .length,
       ],
     );
 
     return Object.fromEntries(keyserverUnreadCountPairs);
   },
 );
 
 const unreadBackgroundCount: (state: BaseAppState<>) => number = createSelector(
   (state: BaseAppState<>) => state.threadStore.threadInfos,
   (threadInfos: RawThreadInfos): number =>
     values(threadInfos).filter(
       threadInfo =>
         threadInBackgroundChatList(threadInfo) && threadInfo.currentUser.unread,
     ).length,
 );
 
 const baseUnreadCountSelectorForCommunity: (
   communityID: string,
 ) => (BaseAppState<>) => number = (communityID: string) =>
   createSelector(
     (state: BaseAppState<>) => state.threadStore.threadInfos,
     (threadInfos: RawThreadInfos): number =>
       Object.values(threadInfos).filter(
         threadInfo =>
           threadInHomeChatList(threadInfo) &&
           threadInfo.currentUser.unread &&
           (communityID === threadInfo.community ||
             communityID === threadInfo.id),
       ).length,
   );
 
 const unreadCountSelectorForCommunity: (
   communityID: string,
 ) => (state: BaseAppState<>) => number = _memoize(
   baseUnreadCountSelectorForCommunity,
 );
 
 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: MixedRawThreadInfos,
 ): ?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: 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,
   entryInfoSelector,
   currentDaysToEntries,
   childThreadInfos,
   containedThreadInfos,
   unreadCount,
   allUnreadCounts,
   unreadBackgroundCount,
   unreadCountSelectorForCommunity,
   otherUsersButNoOtherAdmins,
   mostRecentlyReadThread,
   mostRecentlyReadThreadSelector,
   threadInfoFromSourceMessageIDSelector,
   pendingToRealizedThreadIDsSelector,
   savedEmojiAvatarSelectorForThread,
   threadInfosSelectorForThreadType,
+  thickRawThreadInfosSelector,
 };
diff --git a/lib/types/thread-types.js b/lib/types/thread-types.js
index 30d11f95b..400c2f8b9 100644
--- a/lib/types/thread-types.js
+++ b/lib/types/thread-types.js
@@ -1,468 +1,472 @@
 // @flow
 
 import t, { type TInterface } from 'tcomb';
 
 import {
   type AvatarDBContent,
   type ClientAvatar,
   clientAvatarValidator,
   type UpdateUserAvatarRequest,
 } from './avatar-types.js';
 import type { CalendarQuery } from './entry-types.js';
 import type { Media } from './media-types.js';
 import type {
   MessageTruncationStatuses,
   RawMessageInfo,
 } from './message-types.js';
 import type {
   RawThreadInfo,
   ResolvedThreadInfo,
   ThreadInfo,
+  ThickRawThreadInfo,
 } from './minimally-encoded-thread-permissions-types.js';
 import {
   type ThreadSubscription,
   threadSubscriptionValidator,
 } from './subscription-types.js';
 import {
   type ThreadPermissionsInfo,
   threadPermissionsInfoValidator,
   type ThreadRolePermissionsBlob,
   threadRolePermissionsBlobValidator,
   type UserSurfacedPermission,
 } from './thread-permission-types.js';
 import {
   type ThreadType,
   type ThinThreadType,
   type ThickThreadType,
   threadTypeValidator,
 } from './thread-types-enum.js';
 import type { ClientUpdateInfo, ServerUpdateInfo } from './update-types.js';
 import type { UserInfo, UserInfos } from './user-types.js';
 import type { SpecialRole } from '../permissions/special-roles.js';
 import { type ThreadEntity } from '../utils/entity-text.js';
 import { tID, tShape, tUserID } from '../utils/validation-utils.js';
 
 export type LegacyMemberInfo = {
   +id: string,
   +role: ?string,
   +permissions: ThreadPermissionsInfo,
   +isSender: boolean,
 };
 export const legacyMemberInfoValidator: TInterface<LegacyMemberInfo> =
   tShape<LegacyMemberInfo>({
     id: tUserID,
     role: t.maybe(tID),
     permissions: threadPermissionsInfoValidator,
     isSender: t.Boolean,
   });
 
 export type ClientLegacyRoleInfo = {
   +id: string,
   +name: string,
   +permissions: ThreadRolePermissionsBlob,
   +isDefault: boolean,
 };
 export const clientLegacyRoleInfoValidator: TInterface<ClientLegacyRoleInfo> =
   tShape<ClientLegacyRoleInfo>({
     id: tID,
     name: t.String,
     permissions: threadRolePermissionsBlobValidator,
     isDefault: t.Boolean,
   });
 
 export type ServerLegacyRoleInfo = {
   +id: string,
   +name: string,
   +permissions: ThreadRolePermissionsBlob,
   +isDefault: boolean,
   +specialRole: ?SpecialRole,
 };
 
 export type LegacyThreadCurrentUserInfo = {
   +role: ?string,
   +permissions: ThreadPermissionsInfo,
   +subscription: ThreadSubscription,
   +unread: ?boolean,
 };
 export const legacyThreadCurrentUserInfoValidator: TInterface<LegacyThreadCurrentUserInfo> =
   tShape<LegacyThreadCurrentUserInfo>({
     role: t.maybe(tID),
     permissions: threadPermissionsInfoValidator,
     subscription: threadSubscriptionValidator,
     unread: t.maybe(t.Boolean),
   });
 
 export type LegacyThinRawThreadInfo = {
   +id: string,
   +type: ThinThreadType,
   +name?: ?string,
   +avatar?: ?ClientAvatar,
   +description?: ?string,
   +color: string, // hex, without "#" or "0x"
   +creationTime: number, // millisecond timestamp
   +parentThreadID: ?string,
   +containingThreadID?: ?string,
   +community: ?string,
   +members: $ReadOnlyArray<LegacyMemberInfo>,
   +roles: { +[id: string]: ClientLegacyRoleInfo },
   +currentUser: LegacyThreadCurrentUserInfo,
   +sourceMessageID?: string,
   +repliesCount: number,
   +pinnedCount?: number,
 };
 
 export type ThickMemberInfo = {
   +id: string,
   +role: ?string,
   +permissions: ThreadPermissionsInfo,
   +subscription: ThreadSubscription,
   +isSender: boolean,
 };
 
 export type LegacyThickRawThreadInfo = {
   +thick: true,
   +id: string,
   +type: ThickThreadType,
   +name?: ?string,
   +avatar?: ?ClientAvatar,
   +description?: ?string,
   +color: string, // hex, without "#" or "0x"
   +creationTime: number, // millisecond timestamp
   +parentThreadID?: ?string,
   +containingThreadID?: ?string,
   +community?: ?string,
   +members: $ReadOnlyArray<ThickMemberInfo>,
   +roles: { +[id: string]: ClientLegacyRoleInfo },
   +currentUser: LegacyThreadCurrentUserInfo,
   +sourceMessageID?: string,
   +repliesCount: number,
   +pinnedCount?: number,
 };
 
 export type LegacyRawThreadInfo =
   | LegacyThinRawThreadInfo
   | LegacyThickRawThreadInfo;
 
 export type LegacyRawThreadInfos = {
   +[id: string]: LegacyRawThreadInfo,
 };
 export const legacyRawThreadInfoValidator: TInterface<LegacyRawThreadInfo> =
   tShape<LegacyRawThreadInfo>({
     id: tID,
     type: threadTypeValidator,
     name: t.maybe(t.String),
     avatar: t.maybe(clientAvatarValidator),
     description: t.maybe(t.String),
     color: t.String,
     creationTime: t.Number,
     parentThreadID: t.maybe(tID),
     containingThreadID: t.maybe(tID),
     community: t.maybe(tID),
     members: t.list(legacyMemberInfoValidator),
     roles: t.dict(tID, clientLegacyRoleInfoValidator),
     currentUser: legacyThreadCurrentUserInfoValidator,
     sourceMessageID: t.maybe(tID),
     repliesCount: t.Number,
     pinnedCount: t.maybe(t.Number),
   });
 
 export type MixedRawThreadInfos = {
   +[id: string]: LegacyRawThreadInfo | RawThreadInfo,
 };
+export type ThickRawThreadInfos = {
+  +[id: string]: ThickRawThreadInfo,
+};
 export type RawThreadInfos = {
   +[id: string]: RawThreadInfo,
 };
 
 export type ServerMemberInfo = {
   +id: string,
   +role: ?string,
   +permissions: ThreadPermissionsInfo,
   +subscription: ThreadSubscription,
   +unread: ?boolean,
   +isSender: boolean,
 };
 
 export type ServerThreadInfo = {
   +id: string,
   +type: ThinThreadType,
   +name: ?string,
   +avatar?: AvatarDBContent,
   +description: ?string,
   +color: string, // hex, without "#" or "0x"
   +creationTime: number, // millisecond timestamp
   +parentThreadID: ?string,
   +containingThreadID: ?string,
   +community: ?string,
   +depth: number,
   +members: $ReadOnlyArray<ServerMemberInfo>,
   +roles: { +[id: string]: ServerLegacyRoleInfo },
   +sourceMessageID?: string,
   +repliesCount: number,
   +pinnedCount: number,
 };
 
 export type LegacyThreadStore = {
   +threadInfos: MixedRawThreadInfos,
 };
 
 export type ThreadStore = {
   +threadInfos: RawThreadInfos,
 };
 
 export type ClientDBThreadInfo = {
   +id: string,
   +type: number,
   +name: ?string,
   +avatar?: ?string,
   +description: ?string,
   +color: string,
   +creationTime: string,
   +parentThreadID: ?string,
   +containingThreadID: ?string,
   +community: ?string,
   +members: string,
   +roles: string,
   +currentUser: string,
   +sourceMessageID?: string,
   +repliesCount: number,
   +pinnedCount?: number,
 };
 
 export type ThreadDeletionRequest = {
   +threadID: string,
   +accountPassword?: empty,
 };
 
 export type RemoveMembersRequest = {
   +threadID: string,
   +memberIDs: $ReadOnlyArray<string>,
 };
 
 export type RoleChangeRequest = {
   +threadID: string,
   +memberIDs: $ReadOnlyArray<string>,
   +role: string,
 };
 
 export type ChangeThreadSettingsResult = {
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   },
   +newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
 };
 
 export type ChangeThreadSettingsPayload = {
   +threadID: string,
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   },
   +newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
 };
 
 export type LeaveThreadRequest = {
   +threadID: string,
 };
 export type LeaveThreadResult = {
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   },
 };
 
 export type LeaveThreadPayload = {
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   },
 };
 
 export type ThreadChanges = Partial<{
   +type: ThreadType,
   +name: string,
   +description: string,
   +color: string,
   +parentThreadID: ?string,
   +newMemberIDs: $ReadOnlyArray<string>,
   +avatar: UpdateUserAvatarRequest,
 }>;
 
 export type UpdateThreadRequest = {
   +threadID: string,
   +changes: ThreadChanges,
   +accountPassword?: empty,
 };
 
 export type BaseNewThreadRequest = {
   +id?: ?string,
   +name?: ?string,
   +description?: ?string,
   +color?: ?string,
   +parentThreadID?: ?string,
   +initialMemberIDs?: ?$ReadOnlyArray<string>,
   +ghostMemberIDs?: ?$ReadOnlyArray<string>,
 };
 type NewThinThreadRequest =
   | {
       +type: 3 | 4 | 6 | 7 | 8 | 9 | 10 | 11 | 12,
       ...BaseNewThreadRequest,
     }
   | {
       +type: 5,
       +sourceMessageID: string,
       ...BaseNewThreadRequest,
     };
 
 export type ClientNewThinThreadRequest = {
   ...NewThinThreadRequest,
   +calendarQuery: CalendarQuery,
 };
 export type ServerNewThinThreadRequest = {
   ...NewThinThreadRequest,
   +calendarQuery?: ?CalendarQuery,
 };
 
 export type NewThreadResponse = {
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   },
   +newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +userInfos: UserInfos,
   +newThreadID: string,
 };
 export type NewThreadResult = {
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   },
   +newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +userInfos: UserInfos,
   +newThreadID: string,
 };
 
 export type ServerThreadJoinRequest = {
   +threadID: string,
   +calendarQuery?: ?CalendarQuery,
   +inviteLinkSecret?: string,
   +defaultSubscription?: ThreadSubscription,
 };
 export type ClientThreadJoinRequest = {
   +threadID: string,
   +calendarQuery: CalendarQuery,
   +inviteLinkSecret?: string,
   +defaultSubscription?: ThreadSubscription,
 };
 export type ThreadJoinResult = {
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   },
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatuses: MessageTruncationStatuses,
   +userInfos: UserInfos,
 };
 export type ThreadJoinPayload = {
   +updatesResult: {
     newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   },
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatuses: MessageTruncationStatuses,
   +userInfos: $ReadOnlyArray<UserInfo>,
   +keyserverID: string,
 };
 
 export type ThreadFetchMediaResult = {
   +media: $ReadOnlyArray<Media>,
 };
 export type ThreadFetchMediaRequest = {
   +threadID: string,
   +limit: number,
   +offset: number,
 };
 
 export type SidebarInfo = {
   +threadInfo: ThreadInfo,
   +lastUpdatedTime: number,
   +mostRecentNonLocalMessage: ?string,
 };
 
 export type ToggleMessagePinRequest = {
   +messageID: string,
   +action: 'pin' | 'unpin',
 };
 
 export type ToggleMessagePinResult = {
   +newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +threadID: string,
 };
 
 type CreateRoleAction = {
   +community: string,
   +name: string,
   +permissions: $ReadOnlyArray<UserSurfacedPermission>,
   +action: 'create_role',
 };
 
 type EditRoleAction = {
   +community: string,
   +existingRoleID: string,
   +name: string,
   +permissions: $ReadOnlyArray<UserSurfacedPermission>,
   +action: 'edit_role',
 };
 
 export type RoleModificationRequest = CreateRoleAction | EditRoleAction;
 
 export type RoleModificationResult = {
   +threadInfo: LegacyRawThreadInfo | RawThreadInfo,
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   },
 };
 
 export type RoleModificationPayload = {
   +threadInfo: LegacyRawThreadInfo | RawThreadInfo,
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   },
 };
 
 export type RoleDeletionRequest = {
   +community: string,
   +roleID: string,
 };
 
 export type RoleDeletionResult = {
   +threadInfo: LegacyRawThreadInfo | RawThreadInfo,
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   },
 };
 
 export type RoleDeletionPayload = {
   +threadInfo: LegacyRawThreadInfo | RawThreadInfo,
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   },
 };
 
 // We can show a max of 3 sidebars inline underneath their parent in the chat
 // tab. If there are more, we show a button that opens a modal to see the rest
 export const maxReadSidebars = 3;
 
 // We can show a max of 5 sidebars inline underneath their parent
 // in the chat tab if every one of the displayed sidebars is unread
 export const maxUnreadSidebars = 5;
 
 export type ThreadStoreThreadInfos = LegacyRawThreadInfos;
 
 export type ChatMentionCandidate = {
   +threadInfo: ResolvedThreadInfo,
   +rawChatName: string | ThreadEntity,
 };
 export type ChatMentionCandidates = {
   +[id: string]: ChatMentionCandidate,
 };
 export type ChatMentionCandidatesObj = {
   +[id: string]: ChatMentionCandidates,
 };
 
 export type UserProfileThreadInfo = {
   +threadInfo: ThreadInfo,
   +pendingPersonalThreadUserInfo?: UserInfo,
 };