diff --git a/lib/selectors/user-selectors.js b/lib/selectors/user-selectors.js
index e58ac0379..01d0e5d45 100644
--- a/lib/selectors/user-selectors.js
+++ b/lib/selectors/user-selectors.js
@@ -1,270 +1,276 @@
 // @flow
 
 import _memoize from 'lodash/memoize.js';
 import { createSelector } from 'reselect';
 
 import bots from '../facts/bots.js';
 import {
   getAvatarForUser,
   getRandomDefaultEmojiAvatar,
 } from '../shared/avatar-utils.js';
 import { getSingleOtherUser } from '../shared/thread-utils.js';
 import {
   type AuxUserInfos,
   type AuxUserInfo,
 } from '../types/aux-user-types.js';
 import type { ClientEmojiAvatar } from '../types/avatar-types';
 import type {
   RelativeMemberInfo,
   RawThreadInfo,
 } from '../types/minimally-encoded-thread-permissions-types.js';
 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 { RawThreadInfos } from '../types/thread-types.js';
 import type {
   UserInfos,
   RelativeUserInfo,
   AccountUserInfo,
   CurrentUserInfo,
 } from '../types/user-types.js';
 import { entries, values } from '../utils/objects.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;
     const relativeUserInfo = {
       id: userID,
       username,
       isViewer: userID === viewerID,
     };
     if (userID === viewerID) {
       relativeUserInfos.unshift(relativeUserInfo);
     } else {
       relativeUserInfos.push(relativeUserInfo);
     }
   }
   return relativeUserInfos;
 }
 
 function getRelativeMemberInfos(
   threadInfo: ?RawThreadInfo,
   currentUserID: ?string,
   userInfos: UserInfos,
 ): $ReadOnlyArray<RelativeMemberInfo> {
   const relativeMemberInfos: RelativeMemberInfo[] = [];
   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;
-    const { permissions, ...memberInfoSansPermissions } = memberInfo;
+    const { id, role, isSender, minimallyEncoded } = memberInfo;
     if (memberInfo.id === currentUserID) {
       relativeMemberInfos.unshift({
-        ...memberInfoSansPermissions,
+        id,
+        role,
+        isSender,
+        minimallyEncoded,
         username,
         isViewer: true,
       });
     } else {
       relativeMemberInfos.push({
-        ...memberInfoSansPermissions,
+        id,
+        role,
+        isSender,
+        minimallyEncoded,
         username,
         isViewer: false,
       });
     }
   }
   return relativeMemberInfos;
 }
 
 const emptyArray: $ReadOnlyArray<RelativeMemberInfo> = [];
 
 // Includes current user at the start
 const baseRelativeMemberInfoSelectorForMembersOfThread: (
   threadID: ?string,
 ) => (state: BaseAppState<>) => $ReadOnlyArray<RelativeMemberInfo> = (
   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;
   },
 );
 
 const isLoggedIn = (state: BaseAppState<>): boolean =>
   !!(
     state.currentUserInfo &&
     !state.currentUserInfo.anonymous &&
     state.dataLoaded
   );
 
 const isLoggedInToKeyserver: (
   keyserverID: ?string,
 ) => (state: BaseAppState<>) => boolean = _memoize(
   (keyserverID: ?string) => (state: BaseAppState<>) => {
     if (!keyserverID) {
       return false;
     }
     const cookie = state.keyserverStore.keyserverInfos[keyserverID]?.cookie;
     return !!cookie && cookie.startsWith('user=');
   },
 );
 
 const usersWithPersonalThreadSelector: (
   state: BaseAppState<>,
 ) => $ReadOnlySet<string> = createSelector(
   (state: BaseAppState<>) => state.currentUserInfo && state.currentUserInfo.id,
   (state: BaseAppState<>) => state.threadStore.threadInfos,
   (viewerID: ?string, threadInfos: RawThreadInfos) => {
     const personalThreadMembers = new Set<string>();
 
     for (const threadID in threadInfos) {
       const thread = threadInfos[threadID];
       if (
         thread.type !== threadTypes.GENESIS_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;
     };
   },
 );
 
 const getRelativeUserIDs: (state: BaseAppState<>) => $ReadOnlyArray<string> =
   createSelector(
     (state: BaseAppState<>) => state.userStore.userInfos,
     (userInfos: UserInfos): $ReadOnlyArray<string> => Object.keys(userInfos),
   );
 
 const usersWithMissingDeviceListSelector: (
   state: BaseAppState<>,
 ) => $ReadOnlyArray<string> = createSelector(
   getRelativeUserIDs,
   (state: BaseAppState<>) => state.auxUserStore.auxUserInfos,
   (
     userIDs: $ReadOnlyArray<string>,
     auxUserInfos: AuxUserInfos,
   ): $ReadOnlyArray<string> =>
     userIDs.filter(
       userID =>
         (!auxUserInfos[userID] || !auxUserInfos[userID].deviceList) &&
         userID !== bots.commbot.userID,
     ),
 );
 
 // Foreign Peer Devices are all devices of users we are aware of,
 // but not our own devices.
 const getForeignPeerDevices: (state: BaseAppState<>) => $ReadOnlyArray<string> =
   createSelector(
     (state: BaseAppState<>) => state.auxUserStore.auxUserInfos,
     (state: BaseAppState<>) =>
       state.currentUserInfo && state.currentUserInfo.id,
     (
       auxUserInfos: AuxUserInfos,
       currentUserID: ?string,
     ): $ReadOnlyArray<string> =>
       entries(auxUserInfos)
         .map(([userID, auxUserInfo]: [string, AuxUserInfo]) =>
           userID !== currentUserID && auxUserInfo.deviceList?.devices
             ? auxUserInfo.deviceList.devices
             : [],
         )
         .flat(),
   );
 
 const getAllPeerDevices: (state: BaseAppState<>) => $ReadOnlyArray<string> =
   createSelector(
     (state: BaseAppState<>) => state.auxUserStore.auxUserInfos,
     (auxUserInfos: AuxUserInfos): $ReadOnlyArray<string> =>
       values(auxUserInfos)
         .map(
           (auxUserInfo: AuxUserInfo) => auxUserInfo.deviceList?.devices ?? [],
         )
         .flat(),
   );
 
 export {
   userIDsToRelativeUserInfos,
   getRelativeMemberInfos,
   relativeMemberInfoSelectorForMembersOfThread,
   userInfoSelectorForPotentialMembers,
   isLoggedIn,
   isLoggedInToKeyserver,
   usersWithPersonalThreadSelector,
   savedEmojiAvatarSelectorForCurrentUser,
   getRelativeUserIDs,
   usersWithMissingDeviceListSelector,
   getForeignPeerDevices,
   getAllPeerDevices,
 };
diff --git a/lib/shared/redux/legacy-update-roles-and-permissions.js b/lib/shared/redux/legacy-update-roles-and-permissions.js
index 33d36eff0..6d32a0708 100644
--- a/lib/shared/redux/legacy-update-roles-and-permissions.js
+++ b/lib/shared/redux/legacy-update-roles-and-permissions.js
@@ -1,175 +1,223 @@
 // @flow
 
 import {
   getAllThreadPermissions,
   getRolePermissionBlobs,
   makePermissionsBlob,
   makePermissionsForChildrenBlob,
 } from '../../permissions/thread-permissions.js';
 import { assertAllThreadInfosAreLegacy } from '../../shared/thread-utils.js';
 import type { ThreadPermissionsBlob } from '../../types/thread-permission-types.js';
 import type {
   LegacyRawThreadInfo,
   LegacyRawThreadInfos,
   ThreadStoreThreadInfos,
   LegacyMemberInfo,
   MixedRawThreadInfos,
+  ThickMemberInfo,
 } from '../../types/thread-types.js';
 import { values } from '../../utils/objects.js';
 
 type ThreadTraversalNode = {
   +threadID: string,
   +children: ?$ReadOnlyArray<ThreadTraversalNode>,
 };
 
 function constructThreadTraversalNodes(
   threadStoreInfos: ThreadStoreThreadInfos,
 ): $ReadOnlyArray<$ReadOnly<ThreadTraversalNode>> {
   const parentThreadMap: { [string]: Array<string> } = {};
 
   for (const threadInfo of values(threadStoreInfos)) {
     const parentThreadID = threadInfo.parentThreadID ?? 'root';
     parentThreadMap[parentThreadID] = [
       ...(parentThreadMap[parentThreadID] ?? []),
       threadInfo.id,
     ];
   }
 
   const constructNodes = (nodeID: string): ThreadTraversalNode => ({
     threadID: nodeID,
     children: parentThreadMap[nodeID]?.map(constructNodes) ?? null,
   });
 
   if (!parentThreadMap['root']) {
     return [];
   }
 
   return parentThreadMap['root'].map(constructNodes);
 }
 
 type MemberToThreadPermissionsFromParent = {
   +[member: string]: ?ThreadPermissionsBlob,
 };
 
+type BaseMemberInfo = {
+  +id: string,
+  +role: ?string,
+  ...
+};
+
 // This migration utility can only be used with LegacyRawThreadInfos
 function legacyUpdateRolesAndPermissions(
   threadStoreInfos: MixedRawThreadInfos,
 ): LegacyRawThreadInfos {
   const updatedThreadStoreInfos = assertAllThreadInfosAreLegacy({
     ...threadStoreInfos,
   });
 
   const recursivelyUpdateRoles = (
     node: $ReadOnly<ThreadTraversalNode>,
   ): void => {
     const threadInfo: LegacyRawThreadInfo =
       updatedThreadStoreInfos[node.threadID];
     const computedRolePermissionBlobs = getRolePermissionBlobs(threadInfo.type);
 
     const roles = { ...threadInfo.roles };
     for (const roleID of Object.keys(roles)) {
       roles[roleID] = {
         ...roles[roleID],
         permissions: computedRolePermissionBlobs[roles[roleID].name],
       };
     }
     updatedThreadStoreInfos[node.threadID] = {
       ...threadInfo,
       roles,
     };
 
     node.children?.map(recursivelyUpdateRoles);
   };
 
-  const recursivelyUpdatePermissions = (
-    node: $ReadOnly<ThreadTraversalNode>,
+  const updateMembers = <T: BaseMemberInfo>(
+    threadInfo: LegacyRawThreadInfo,
+    members: $ReadOnlyArray<$ReadOnly<T>>,
     memberToThreadPermissionsFromParent: ?MemberToThreadPermissionsFromParent,
-  ): void => {
-    const threadInfo: LegacyRawThreadInfo =
-      updatedThreadStoreInfos[node.threadID];
-
+  ): {
+    members: $ReadOnlyArray<$ReadOnly<T>>,
+    memberToThreadPermissionsForChildren: { [string]: ?ThreadPermissionsBlob },
+  } => {
     const updatedMembers = [];
     const memberToThreadPermissionsForChildren: {
       [string]: ?ThreadPermissionsBlob,
     } = {};
-    for (const member: LegacyMemberInfo of threadInfo.members) {
+    for (const member of members) {
       const { id, role } = member;
 
       const rolePermissions = role ? threadInfo.roles[role].permissions : null;
       const permissionsFromParent = memberToThreadPermissionsFromParent?.[id];
 
       const computedPermissions = makePermissionsBlob(
         rolePermissions,
         permissionsFromParent,
         threadInfo.id,
         threadInfo.type,
       );
 
       updatedMembers.push({
         ...member,
         permissions: getAllThreadPermissions(
           computedPermissions,
           threadInfo.id,
         ),
       });
 
       memberToThreadPermissionsForChildren[member.id] =
         makePermissionsForChildrenBlob(computedPermissions);
     }
-
-    updatedThreadStoreInfos[node.threadID] = {
-      ...threadInfo,
+    return {
       members: updatedMembers,
+      memberToThreadPermissionsForChildren,
     };
+  };
+
+  const recursivelyUpdatePermissions = (
+    node: $ReadOnly<ThreadTraversalNode>,
+    memberToThreadPermissionsFromParent: ?MemberToThreadPermissionsFromParent,
+  ): void => {
+    const threadInfo: LegacyRawThreadInfo =
+      updatedThreadStoreInfos[node.threadID];
+
+    let memberToThreadPermissionsForChildren: {
+      [string]: ?ThreadPermissionsBlob,
+    };
+    if (threadInfo.thick) {
+      const {
+        members: updatedMembers,
+        memberToThreadPermissionsForChildren: test,
+      } = updateMembers<ThickMemberInfo>(
+        threadInfo,
+        threadInfo.members,
+        memberToThreadPermissionsFromParent,
+      );
+      updatedThreadStoreInfos[node.threadID] = {
+        ...threadInfo,
+        members: updatedMembers,
+      };
+      memberToThreadPermissionsForChildren = test;
+    } else {
+      const {
+        members: updatedMembers,
+        memberToThreadPermissionsForChildren: test,
+      } = updateMembers<LegacyMemberInfo>(
+        threadInfo,
+        threadInfo.members,
+        memberToThreadPermissionsFromParent,
+      );
+      updatedThreadStoreInfos[node.threadID] = {
+        ...threadInfo,
+        members: updatedMembers,
+      };
+      memberToThreadPermissionsForChildren = test;
+    }
 
     node.children?.map(child =>
       recursivelyUpdatePermissions(child, memberToThreadPermissionsForChildren),
     );
   };
 
   const recursivelyUpdateCurrentMemberPermissions = (
     node: $ReadOnly<ThreadTraversalNode>,
     permissionsFromParent: ?ThreadPermissionsBlob,
   ): void => {
     const threadInfo: LegacyRawThreadInfo =
       updatedThreadStoreInfos[node.threadID];
     const { currentUser, roles } = threadInfo;
     const { role } = currentUser;
 
     const rolePermissions = role ? roles[role].permissions : null;
     const computedPermissions = makePermissionsBlob(
       rolePermissions,
       permissionsFromParent,
       threadInfo.id,
       threadInfo.type,
     );
 
     updatedThreadStoreInfos[node.threadID] = {
       ...threadInfo,
       currentUser: {
         ...currentUser,
         permissions: getAllThreadPermissions(
           computedPermissions,
           threadInfo.id,
         ),
       },
     };
 
     node.children?.map(child =>
       recursivelyUpdateCurrentMemberPermissions(
         child,
         makePermissionsForChildrenBlob(computedPermissions),
       ),
     );
   };
 
   const rootNodes = constructThreadTraversalNodes(updatedThreadStoreInfos);
   rootNodes.forEach(recursivelyUpdateRoles);
   rootNodes.forEach(node => recursivelyUpdatePermissions(node, null));
   rootNodes.forEach(node =>
     recursivelyUpdateCurrentMemberPermissions(node, null),
   );
   return updatedThreadStoreInfos;
 }
 
 export { legacyUpdateRolesAndPermissions };
diff --git a/lib/shared/thread-utils.js b/lib/shared/thread-utils.js
index 072b0bb37..a908ce3c2 100644
--- a/lib/shared/thread-utils.js
+++ b/lib/shared/thread-utils.js
@@ -1,1736 +1,1787 @@
 // @flow
 
 import invariant from 'invariant';
 import _find from 'lodash/fp/find.js';
 import _keyBy from 'lodash/fp/keyBy.js';
 import _mapValues from 'lodash/fp/mapValues.js';
 import _omit from 'lodash/fp/omit.js';
 import _omitBy from 'lodash/fp/omitBy.js';
 import * as React from 'react';
 
 import { getUserAvatarForThread } from './avatar-utils.js';
 import { generatePendingThreadColor } from './color-utils.js';
 import { extractUserMentionsFromText } from './mention-utils.js';
 import { relationshipBlockedInEitherDirection } from './relationship-utils.js';
 import ashoat from '../facts/ashoat.js';
 import genesis from '../facts/genesis.js';
 import { useLoggedInUserInfo } from '../hooks/account-hooks.js';
 import { extractKeyserverIDFromID } from '../keyserver-conn/keyserver-call-utils.js';
 import {
   hasPermission,
   permissionsToBitmaskHex,
   threadPermissionsFromBitmaskHex,
 } from '../permissions/minimally-encoded-thread-permissions.js';
 import { specialRoles } from '../permissions/special-roles.js';
 import type { SpecialRole } from '../permissions/special-roles.js';
 import {
   permissionLookup,
   getAllThreadPermissions,
   makePermissionsBlob,
 } from '../permissions/thread-permissions.js';
 import type { ChatThreadItem } from '../selectors/chat-selectors.js';
 import {
   threadInfoSelector,
   pendingToRealizedThreadIDsSelector,
   threadInfosSelectorForThreadType,
   onScreenThreadInfos,
 } from '../selectors/thread-selectors.js';
 import {
   getRelativeMemberInfos,
   usersWithPersonalThreadSelector,
 } from '../selectors/user-selectors.js';
 import type {
   RelativeMemberInfo,
   RawThreadInfo,
   MemberInfoWithPermissions,
   RoleInfo,
   ThreadInfo,
 } from '../types/minimally-encoded-thread-permissions-types.js';
 import {
   decodeMinimallyEncodedRoleInfo,
   minimallyEncodeMemberInfo,
   minimallyEncodeRawThreadInfo,
   minimallyEncodeRoleInfo,
   minimallyEncodeThreadCurrentUserInfo,
 } from '../types/minimally-encoded-thread-permissions-types.js';
 import { userRelationshipStatus } from '../types/relationship-types.js';
 import {
   threadPermissionPropagationPrefixes,
   threadPermissions,
   configurableCommunityPermissions,
   type ThreadPermission,
   type ThreadPermissionsInfo,
   type ThreadRolePermissionsBlob,
   type UserSurfacedPermission,
   threadPermissionFilterPrefixes,
   threadPermissionsDisabledByBlock,
   type ThreadPermissionNotAffectedByBlock,
 } from '../types/thread-permission-types.js';
 import {
   type ThreadType,
   threadTypes,
   threadTypeIsCommunityRoot,
   assertThreadType,
+  threadTypeIsThick,
+  assertThinThreadType,
+  assertThickThreadType,
 } from '../types/thread-types-enum.js';
 import type {
   LegacyRawThreadInfo,
   ClientLegacyRoleInfo,
   ServerThreadInfo,
-  ServerMemberInfo,
+  ThickMemberInfo,
   UserProfileThreadInfo,
   MixedRawThreadInfos,
   LegacyMemberInfo,
 } from '../types/thread-types.js';
 import { updateTypes } from '../types/update-types-enum.js';
 import { type ClientUpdateInfo } from '../types/update-types.js';
 import type {
   GlobalAccountUserInfo,
   UserInfos,
   AccountUserInfo,
   LoggedInUserInfo,
   UserInfo,
 } from '../types/user-types.js';
 import {
   ET,
   type ThreadEntity,
   type UserEntity,
 } from '../utils/entity-text.js';
 import { entries, values } from '../utils/objects.js';
 import { useSelector } from '../utils/redux-utils.js';
 import { usingOlmViaTunnelbrokerForDMs } from '../utils/services-utils.js';
 import { firstLine } from '../utils/string-utils.js';
 import { pendingThreadIDRegex } from '../utils/validation-utils.js';
 
 function threadHasPermission(
   threadInfo: ?(ThreadInfo | LegacyRawThreadInfo | RawThreadInfo),
   permission: ThreadPermissionNotAffectedByBlock,
 ): boolean {
   if (!threadInfo) {
     return false;
   }
   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.minimallyEncoded) {
     return hasPermission(threadInfo.currentUser.permissions, permission);
   }
   return permissionLookup(threadInfo.currentUser.permissions, permission);
 }
 
 type CommunityRootMembersToRoleType = {
   +[threadID: ?string]: {
     +[memberID: string]: ?RoleInfo,
   },
 };
 function useCommunityRootMembersToRole(
   threadInfos: $ReadOnlyArray<RawThreadInfo | ThreadInfo>,
 ): CommunityRootMembersToRoleType {
   const communityRootMembersToRole = React.useMemo(() => {
     const communityThreadInfos = threadInfos.filter(threadInfo =>
       threadTypeIsCommunityRoot(threadInfo.type),
     );
 
     if (communityThreadInfos.length === 0) {
       return {};
     }
 
     const communityRoots = _keyBy('id')(communityThreadInfos);
     return _mapValues((threadInfo: ThreadInfo) => {
       const keyedMembers = _keyBy('id')(threadInfo.members);
       const keyedMembersToRole = _mapValues(
         (member: MemberInfoWithPermissions | RelativeMemberInfo) => {
           return member.role ? threadInfo.roles[member.role] : null;
         },
       )(keyedMembers);
       return keyedMembersToRole;
     })(communityRoots);
   }, [threadInfos]);
 
   return communityRootMembersToRole;
 }
 
 function useThreadsWithPermission(
   threadInfos: $ReadOnlyArray<ThreadInfo>,
   permission: ThreadPermission,
 ): $ReadOnlyArray<ThreadInfo> {
   const loggedInUserInfo = useLoggedInUserInfo();
   const userInfos = useSelector(state => state.userStore.userInfos);
   const allThreadInfos = useSelector(state => state.threadStore.threadInfos);
   const allThreadInfosArray = React.useMemo(
     () => values(allThreadInfos),
     [allThreadInfos],
   );
 
   const communityRootMembersToRole =
     useCommunityRootMembersToRole(allThreadInfosArray);
 
   return React.useMemo(() => {
     return threadInfos.filter((threadInfo: ThreadInfo) => {
       const membersToRole = communityRootMembersToRole[threadInfo.id];
       const memberHasAdminRole = threadMembersWithoutAddedAdmin(
         threadInfo,
       ).some(member => roleIsAdminRole(membersToRole?.[member.id]));
 
       if (memberHasAdminRole || !loggedInUserInfo) {
         return hasPermission(threadInfo.currentUser.permissions, permission);
       }
 
       const threadFrozen = threadIsWithBlockedUserOnlyWithoutAdminRoleCheck(
         threadInfo,
         loggedInUserInfo.id,
         userInfos,
         false,
       );
 
       const permissions = threadFrozen
         ? filterOutDisabledPermissions(threadInfo.currentUser.permissions)
         : threadInfo.currentUser.permissions;
 
       return hasPermission(permissions, permission);
     });
   }, [
     threadInfos,
     communityRootMembersToRole,
     loggedInUserInfo,
     userInfos,
     permission,
   ]);
 }
 
 function useThreadHasPermission(
   threadInfo: ?ThreadInfo,
   permission: ThreadPermission,
 ): boolean {
   const threads = useThreadsWithPermission(
     threadInfo ? [threadInfo] : [],
     permission,
   );
   return threads.length === 1;
 }
 
 function viewerIsMember(
   threadInfo: ?(ThreadInfo | LegacyRawThreadInfo | RawThreadInfo),
 ): boolean {
   return !!(
     threadInfo &&
     threadInfo.currentUser.role !== null &&
     threadInfo.currentUser.role !== undefined
   );
 }
 
 function threadIsInHome(threadInfo: ?(RawThreadInfo | ThreadInfo)): boolean {
   return !!(threadInfo && threadInfo.currentUser.subscription.home);
 }
 
 // Can have messages
 function threadInChatList(
   threadInfo: ?(LegacyRawThreadInfo | RawThreadInfo | ThreadInfo),
 ): boolean {
   return (
     viewerIsMember(threadInfo) &&
     threadHasPermission(threadInfo, threadPermissions.VISIBLE)
   );
 }
 
 function useIsThreadInChatList(threadInfo: ?ThreadInfo): boolean {
   const threadIsVisible = useThreadHasPermission(
     threadInfo,
     threadPermissions.VISIBLE,
   );
   return viewerIsMember(threadInfo) && threadIsVisible;
 }
 
 function useThreadsInChatList(
   threadInfos: $ReadOnlyArray<ThreadInfo>,
 ): $ReadOnlyArray<ThreadInfo> {
   const visibleThreads = useThreadsWithPermission(
     threadInfos,
     threadPermissions.VISIBLE,
   );
   return React.useMemo(
     () => visibleThreads.filter(viewerIsMember),
     [visibleThreads],
   );
 }
 
 function threadIsTopLevel(threadInfo: ?(RawThreadInfo | ThreadInfo)): boolean {
   return threadInChatList(threadInfo) && threadIsChannel(threadInfo);
 }
 
 function threadIsChannel(threadInfo: ?(RawThreadInfo | ThreadInfo)): boolean {
   return !!(threadInfo && threadInfo.type !== threadTypes.SIDEBAR);
 }
 
 function threadIsSidebar(threadInfo: ?(RawThreadInfo | ThreadInfo)): boolean {
   return threadInfo?.type === threadTypes.SIDEBAR;
 }
 
 function threadInBackgroundChatList(
   threadInfo: ?(RawThreadInfo | ThreadInfo),
 ): boolean {
   return threadInChatList(threadInfo) && !threadIsInHome(threadInfo);
 }
 
 function threadInHomeChatList(
   threadInfo: ?(RawThreadInfo | ThreadInfo),
 ): boolean {
   return threadInChatList(threadInfo) && threadIsInHome(threadInfo);
 }
 
 // Can have Calendar entries,
 // does appear as a top-level entity in the thread list
 function threadInFilterList(
   threadInfo: ?(LegacyRawThreadInfo | RawThreadInfo | ThreadInfo),
 ): boolean {
   return (
     threadInChatList(threadInfo) &&
     !!threadInfo &&
     threadInfo.type !== threadTypes.SIDEBAR
   );
 }
 
 function userIsMember(
   threadInfo: ?(RawThreadInfo | ThreadInfo),
   userID: string,
 ): boolean {
   if (!threadInfo) {
     return false;
   }
   if (threadInfo.id === genesis().id) {
     return true;
   }
   return threadInfo.members.some(member => member.id === userID && member.role);
 }
 
 function threadActualMembers(
   memberInfos: $ReadOnlyArray<MemberInfoWithPermissions | RelativeMemberInfo>,
 ): $ReadOnlyArray<string> {
   return memberInfos
     .filter(memberInfo => memberInfo.role)
     .map(memberInfo => memberInfo.id);
 }
 
 type MemberIDAndRole = {
   +id: string,
   +role: ?string,
   ...
 };
 function threadOtherMembers<T: MemberIDAndRole>(
   memberInfos: $ReadOnlyArray<T>,
   viewerID: ?string,
 ): $ReadOnlyArray<T> {
   return memberInfos.filter(
     memberInfo => memberInfo.role && memberInfo.id !== viewerID,
   );
 }
 
 function threadMembersWithoutAddedAdmin<
   T: LegacyRawThreadInfo | RawThreadInfo | ThreadInfo,
 >(threadInfo: T): $PropertyType<T, 'members'> {
   if (threadInfo.community !== genesis().id) {
     return threadInfo.members;
   }
   const adminID = extractKeyserverIDFromID(threadInfo.id);
 
   return threadInfo.members.filter(
     member => member.id !== adminID || member.role,
   );
 }
 
 function threadIsGroupChat(threadInfo: ThreadInfo): boolean {
   return threadInfo.members.length > 2;
 }
 
 function threadOrParentThreadIsGroupChat(
   threadInfo: LegacyRawThreadInfo | RawThreadInfo | ThreadInfo,
 ) {
   return threadMembersWithoutAddedAdmin(threadInfo).length > 2;
 }
 
 function threadIsPending(threadID: ?string): boolean {
   return !!threadID?.startsWith('pending');
 }
 
 function threadIsPendingSidebar(threadID: ?string): boolean {
   return !!threadID?.startsWith('pending/sidebar/');
 }
 
 function getSingleOtherUser(
   threadInfo: LegacyRawThreadInfo | RawThreadInfo | ThreadInfo,
   viewerID: ?string,
 ): ?string {
   if (!viewerID) {
     return undefined;
   }
   const otherMembers = threadOtherMembers(threadInfo.members, viewerID);
   if (otherMembers.length !== 1) {
     return undefined;
   }
   return otherMembers[0].id;
 }
 
 function getPendingThreadID(
   threadType: ThreadType,
   memberIDs: $ReadOnlyArray<string>,
   sourceMessageID: ?string,
 ): string {
   const pendingThreadKey = sourceMessageID
     ? `sidebar/${sourceMessageID}`
     : [...memberIDs].sort().join('+');
   const pendingThreadTypeString = sourceMessageID ? '' : `type${threadType}/`;
   return `pending/${pendingThreadTypeString}${pendingThreadKey}`;
 }
 
 type PendingThreadIDContents = {
   +threadType: ThreadType,
   +memberIDs: $ReadOnlyArray<string>,
   +sourceMessageID: ?string,
 };
 
 function parsePendingThreadID(
   pendingThreadID: string,
 ): ?PendingThreadIDContents {
   const pendingRegex = new RegExp(`^${pendingThreadIDRegex}$`);
   const pendingThreadIDMatches = pendingRegex.exec(pendingThreadID);
   if (!pendingThreadIDMatches) {
     return null;
   }
   const [threadTypeString, threadKey] = pendingThreadIDMatches[1].split('/');
   const threadType =
     threadTypeString === 'sidebar'
       ? threadTypes.SIDEBAR
       : assertThreadType(Number(threadTypeString.replace('type', '')));
   const memberIDs = threadTypeString === 'sidebar' ? [] : threadKey.split('+');
   const sourceMessageID = threadTypeString === 'sidebar' ? threadKey : null;
   return {
     threadType,
     memberIDs,
     sourceMessageID,
   };
 }
 
 type UserIDAndUsername = {
   +id: string,
   +username: string,
   ...
 };
 type CreatePendingThreadArgs = {
   +viewerID: string,
   +threadType: ThreadType,
   +members: $ReadOnlyArray<UserIDAndUsername>,
   +parentThreadInfo?: ?ThreadInfo,
   +threadColor?: ?string,
   +name?: ?string,
   +sourceMessageID?: string,
 };
 
 const defaultSubscription = {
   pushNotifs: false,
   home: false,
 };
 
 function createPendingThread({
   viewerID,
   threadType,
   members,
   parentThreadInfo,
   threadColor,
   name,
   sourceMessageID,
 }: CreatePendingThreadArgs): ThreadInfo {
   const now = Date.now();
   if (!members.some(member => member.id === viewerID)) {
     throw new Error(
       'createPendingThread should be called with the viewer as a member',
     );
   }
 
   const memberIDs = members.map(member => member.id);
   const threadID = getPendingThreadID(threadType, memberIDs, sourceMessageID);
 
   const permissions: ThreadRolePermissionsBlob = {
     [threadPermissions.KNOW_OF]: true,
     [threadPermissions.VISIBLE]: true,
     [threadPermissions.VOICED]: true,
   };
 
   const membershipPermissions = getAllThreadPermissions(
     makePermissionsBlob(permissions, null, threadID, threadType),
     threadID,
   );
   const role: RoleInfo = {
     ...minimallyEncodeRoleInfo({
       id: `${threadID}/role`,
       name: 'Members',
       permissions,
       isDefault: true,
     }),
     specialRole: specialRoles.DEFAULT_ROLE,
   };
 
-  const rawThreadInfo: RawThreadInfo = {
-    minimallyEncoded: true,
-    id: threadID,
-    type: threadType,
-    name: name ?? null,
-    description: null,
-    color: threadColor ?? generatePendingThreadColor(memberIDs),
-    creationTime: now,
-    parentThreadID: parentThreadInfo?.id ?? null,
-    containingThreadID: getContainingThreadID(parentThreadInfo, threadType),
-    community: getCommunity(parentThreadInfo),
-    members: members.map(member =>
-      minimallyEncodeMemberInfo({
-        id: member.id,
+  let rawThreadInfo: RawThreadInfo;
+  if (threadTypeIsThick(threadType)) {
+    const thickThreadType = assertThickThreadType(threadType);
+    rawThreadInfo = {
+      minimallyEncoded: true,
+      thick: true,
+      id: threadID,
+      type: thickThreadType,
+      name: name ?? null,
+      description: null,
+      color: threadColor ?? generatePendingThreadColor(memberIDs),
+      creationTime: now,
+      parentThreadID: parentThreadInfo?.id ?? null,
+      containingThreadID: getContainingThreadID(
+        parentThreadInfo,
+        thickThreadType,
+      ),
+      community: getCommunity(parentThreadInfo),
+      members: members.map(member =>
+        minimallyEncodeMemberInfo<ThickMemberInfo>({
+          id: member.id,
+          role: role.id,
+          permissions: membershipPermissions,
+          isSender: false,
+          subscription: defaultSubscription,
+        }),
+      ),
+      roles: {
+        [role.id]: role,
+      },
+      currentUser: minimallyEncodeThreadCurrentUserInfo({
         role: role.id,
         permissions: membershipPermissions,
-        isSender: false,
+        subscription: defaultSubscription,
+        unread: false,
       }),
-    ),
-    roles: {
-      [role.id]: role,
-    },
-    currentUser: minimallyEncodeThreadCurrentUserInfo({
-      role: role.id,
-      permissions: membershipPermissions,
-      subscription: defaultSubscription,
-      unread: false,
-    }),
-    repliesCount: 0,
-    sourceMessageID,
-    pinnedCount: 0,
-  };
+      repliesCount: 0,
+      sourceMessageID,
+      pinnedCount: 0,
+    };
+  } else {
+    const thinThreadType = assertThinThreadType(threadType);
+    rawThreadInfo = {
+      minimallyEncoded: true,
+      id: threadID,
+      type: thinThreadType,
+      name: name ?? null,
+      description: null,
+      color: threadColor ?? generatePendingThreadColor(memberIDs),
+      creationTime: now,
+      parentThreadID: parentThreadInfo?.id ?? null,
+      containingThreadID: getContainingThreadID(
+        parentThreadInfo,
+        thinThreadType,
+      ),
+      community: getCommunity(parentThreadInfo),
+      members: members.map(member =>
+        minimallyEncodeMemberInfo<LegacyMemberInfo>({
+          id: member.id,
+          role: role.id,
+          permissions: membershipPermissions,
+          isSender: false,
+        }),
+      ),
+      roles: {
+        [role.id]: role,
+      },
+      currentUser: minimallyEncodeThreadCurrentUserInfo({
+        role: role.id,
+        permissions: membershipPermissions,
+        subscription: defaultSubscription,
+        unread: false,
+      }),
+      repliesCount: 0,
+      sourceMessageID,
+      pinnedCount: 0,
+    };
+  }
 
   const userInfos: { [string]: UserInfo } = {};
   for (const member of members) {
     const { id, username } = member;
     userInfos[id] = { id, username };
   }
 
   return threadInfoFromRawThreadInfo(rawThreadInfo, viewerID, userInfos);
 }
 
 type PendingPersonalThread = {
   +threadInfo: ThreadInfo,
   +pendingPersonalThreadUserInfo: UserInfo,
 };
 
 function createPendingPersonalThread(
   loggedInUserInfo: LoggedInUserInfo,
   userID: string,
   username: string,
 ): PendingPersonalThread {
   const pendingPersonalThreadUserInfo = {
     id: userID,
     username: username,
   };
 
   const threadInfo = createPendingThread({
     viewerID: loggedInUserInfo.id,
     threadType: threadTypes.GENESIS_PERSONAL,
     members: [loggedInUserInfo, pendingPersonalThreadUserInfo],
   });
 
   return { threadInfo, pendingPersonalThreadUserInfo };
 }
 
 function createPendingThreadItem(
   loggedInUserInfo: LoggedInUserInfo,
   user: UserIDAndUsername,
 ): ChatThreadItem {
   const { threadInfo, pendingPersonalThreadUserInfo } =
     createPendingPersonalThread(loggedInUserInfo, user.id, user.username);
 
   return {
     type: 'chatThreadItem',
     threadInfo,
     mostRecentMessageInfo: null,
     mostRecentNonLocalMessage: null,
     lastUpdatedTime: threadInfo.creationTime,
     lastUpdatedTimeIncludingSidebars: threadInfo.creationTime,
     sidebars: [],
     pendingPersonalThreadUserInfo,
   };
 }
 
 // Returns map from lowercase username to AccountUserInfo
 function memberLowercaseUsernameMap(
   members: $ReadOnlyArray<RelativeMemberInfo>,
 ): Map<string, AccountUserInfo> {
   const memberMap = new Map<string, AccountUserInfo>();
   for (const member of members) {
     const { id, role, username } = member;
     if (!role || !username) {
       continue;
     }
     memberMap.set(username.toLowerCase(), { id, username });
   }
   return memberMap;
 }
 
 // Returns map from user ID to AccountUserInfo
 function extractMentionedMembers(
   text: string,
   threadInfo: ThreadInfo,
 ): Map<string, AccountUserInfo> {
   const memberMap = memberLowercaseUsernameMap(threadInfo.members);
   const mentions = extractUserMentionsFromText(text);
 
   const mentionedMembers = new Map<string, AccountUserInfo>();
   for (const mention of mentions) {
     const userInfo = memberMap.get(mention.toLowerCase());
     if (userInfo) {
       mentionedMembers.set(userInfo.id, userInfo);
     }
   }
   return mentionedMembers;
 }
 
 // When a member of the parent is mentioned in a sidebar,
 // they will be automatically added to that sidebar
 function extractNewMentionedParentMembers(
   messageText: string,
   threadInfo: ThreadInfo,
   parentThreadInfo: ThreadInfo,
 ): AccountUserInfo[] {
   const mentionedMembersOfParent = extractMentionedMembers(
     messageText,
     parentThreadInfo,
   );
   for (const member of threadInfo.members) {
     if (member.role) {
       mentionedMembersOfParent.delete(member.id);
     }
   }
   return [...mentionedMembersOfParent.values()];
 }
 
 function pendingThreadType(
   numberOfOtherMembers: number,
 ): 4 | 6 | 7 | 13 | 14 | 15 {
   if (usingOlmViaTunnelbrokerForDMs) {
     if (numberOfOtherMembers === 0) {
       return threadTypes.PRIVATE;
     } else if (numberOfOtherMembers === 1) {
       return threadTypes.PERSONAL;
     } else {
       return threadTypes.LOCAL;
     }
   } else {
     if (numberOfOtherMembers === 0) {
       return threadTypes.GENESIS_PRIVATE;
     } else if (numberOfOtherMembers === 1) {
       return threadTypes.GENESIS_PERSONAL;
     } else {
       return threadTypes.COMMUNITY_SECRET_SUBTHREAD;
     }
   }
 }
 
 function threadTypeCanBePending(threadType: ThreadType): boolean {
   return (
     threadType === threadTypes.GENESIS_PERSONAL ||
     threadType === threadTypes.COMMUNITY_SECRET_SUBTHREAD ||
     threadType === threadTypes.SIDEBAR ||
     threadType === threadTypes.GENESIS_PRIVATE ||
     threadType === threadTypes.PERSONAL ||
     threadType === threadTypes.LOCAL ||
     threadType === threadTypes.THICK_SIDEBAR ||
     threadType === threadTypes.PRIVATE
   );
 }
 
 type RawThreadInfoOptions = {
   +filterThreadEditAvatarPermission?: boolean,
   +excludePinInfo?: boolean,
   +filterManageInviteLinksPermission?: boolean,
   +filterVoicedInAnnouncementChannelsPermission?: boolean,
   +minimallyEncodePermissions?: boolean,
   +includeSpecialRoleFieldInRoles?: boolean,
   +allowAddingUsersToCommunityRoot?: boolean,
   +filterManageFarcasterChannelTagsPermission?: boolean,
 };
 
 function rawThreadInfoFromServerThreadInfo(
   serverThreadInfo: ServerThreadInfo,
   viewerID: string,
   options?: RawThreadInfoOptions,
 ): ?LegacyRawThreadInfo | ?RawThreadInfo {
   const filterThreadEditAvatarPermission =
     options?.filterThreadEditAvatarPermission;
   const excludePinInfo = options?.excludePinInfo;
   const filterManageInviteLinksPermission =
     options?.filterManageInviteLinksPermission;
   const filterVoicedInAnnouncementChannelsPermission =
     options?.filterVoicedInAnnouncementChannelsPermission;
   const shouldMinimallyEncodePermissions = options?.minimallyEncodePermissions;
   const shouldIncludeSpecialRoleFieldInRoles =
     options?.includeSpecialRoleFieldInRoles;
   const allowAddingUsersToCommunityRoot =
     options?.allowAddingUsersToCommunityRoot;
   const filterManageFarcasterChannelTagsPermission =
     options?.filterManageFarcasterChannelTagsPermission;
 
   const filterThreadPermissions = (
     innerThreadPermissions: ThreadPermissionsInfo,
   ) => {
     if (
       allowAddingUsersToCommunityRoot &&
       (serverThreadInfo.type === threadTypes.COMMUNITY_ANNOUNCEMENT_ROOT ||
         serverThreadInfo.type === threadTypes.COMMUNITY_ROOT)
     ) {
       innerThreadPermissions = {
         ...innerThreadPermissions,
         [threadPermissions.ADD_MEMBERS]: {
           value: true,
           source: serverThreadInfo.id,
         },
       };
     }
     return _omitBy(
       (v, k) =>
         (filterThreadEditAvatarPermission &&
           [
             threadPermissions.EDIT_THREAD_AVATAR,
             threadPermissionPropagationPrefixes.DESCENDANT +
               threadPermissions.EDIT_THREAD_AVATAR,
           ].includes(k)) ||
         (excludePinInfo &&
           [
             threadPermissions.MANAGE_PINS,
             threadPermissionPropagationPrefixes.DESCENDANT +
               threadPermissions.MANAGE_PINS,
           ].includes(k)) ||
         (filterManageInviteLinksPermission &&
           [threadPermissions.MANAGE_INVITE_LINKS].includes(k)) ||
         (filterVoicedInAnnouncementChannelsPermission &&
           [
             threadPermissions.VOICED_IN_ANNOUNCEMENT_CHANNELS,
             threadPermissionPropagationPrefixes.DESCENDANT +
               threadPermissionFilterPrefixes.TOP_LEVEL +
               threadPermissions.VOICED_IN_ANNOUNCEMENT_CHANNELS,
           ].includes(k)) ||
         (filterManageFarcasterChannelTagsPermission &&
           [threadPermissions.MANAGE_FARCASTER_CHANNEL_TAGS].includes(k)),
     )(innerThreadPermissions);
   };
 
   const members = [];
   let currentUser;
   for (const serverMember of serverThreadInfo.members) {
     if (
       serverThreadInfo.id === genesis().id &&
       serverMember.id !== viewerID &&
       serverMember.id !== ashoat.id
     ) {
       continue;
     }
 
     const memberPermissions = filterThreadPermissions(serverMember.permissions);
 
     members.push({
       id: serverMember.id,
       role: serverMember.role,
       permissions: memberPermissions,
       isSender: serverMember.isSender,
     });
     if (serverMember.id === viewerID) {
       currentUser = {
         role: serverMember.role,
         permissions: memberPermissions,
         subscription: serverMember.subscription,
         unread: serverMember.unread,
       };
     }
   }
 
   let currentUserPermissions;
   if (currentUser) {
     currentUserPermissions = currentUser.permissions;
   } else {
     currentUserPermissions = filterThreadPermissions(
       getAllThreadPermissions(null, serverThreadInfo.id),
     );
     currentUser = {
       role: null,
       permissions: currentUserPermissions,
       subscription: defaultSubscription,
       unread: null,
     };
   }
   if (!permissionLookup(currentUserPermissions, threadPermissions.KNOW_OF)) {
     return null;
   }
 
   const rolesWithFilteredThreadPermissions = _mapValues(role => ({
     ...role,
     permissions: filterThreadPermissions(role.permissions),
   }))(serverThreadInfo.roles);
 
   const rolesWithoutSpecialRoleField = _mapValues(role => {
     const { specialRole, ...roleSansSpecialRole } = role;
     return roleSansSpecialRole;
   })(rolesWithFilteredThreadPermissions);
 
   let rawThreadInfo: any = {
     id: serverThreadInfo.id,
     type: serverThreadInfo.type,
     name: serverThreadInfo.name,
     description: serverThreadInfo.description,
     color: serverThreadInfo.color,
     creationTime: serverThreadInfo.creationTime,
     parentThreadID: serverThreadInfo.parentThreadID,
     members,
     roles: rolesWithoutSpecialRoleField,
     currentUser,
     repliesCount: serverThreadInfo.repliesCount,
     containingThreadID: serverThreadInfo.containingThreadID,
     community: serverThreadInfo.community,
   };
   const sourceMessageID = serverThreadInfo.sourceMessageID;
   if (sourceMessageID) {
     rawThreadInfo = { ...rawThreadInfo, sourceMessageID };
   }
   if (serverThreadInfo.avatar) {
     rawThreadInfo = { ...rawThreadInfo, avatar: serverThreadInfo.avatar };
   }
   if (!excludePinInfo) {
     rawThreadInfo = {
       ...rawThreadInfo,
       pinnedCount: serverThreadInfo.pinnedCount,
     };
   }
 
   if (!shouldMinimallyEncodePermissions) {
     return rawThreadInfo;
   }
 
   const minimallyEncoded = minimallyEncodeRawThreadInfo(rawThreadInfo);
   if (shouldIncludeSpecialRoleFieldInRoles) {
     return minimallyEncoded;
   }
 
   const minimallyEncodedRolesWithoutSpecialRoleField = Object.fromEntries(
     entries(minimallyEncoded.roles).map(([key, role]) => [
       key,
       {
         ..._omit('specialRole')(role),
         isDefault: roleIsDefaultRole(role),
       },
     ]),
   );
 
   return {
     ...minimallyEncoded,
     roles: minimallyEncodedRolesWithoutSpecialRoleField,
   };
 }
 
 function threadUIName(threadInfo: ThreadInfo): string | ThreadEntity {
   if (threadInfo.name) {
     return firstLine(threadInfo.name);
   }
 
   const threadMembers: $ReadOnlyArray<RelativeMemberInfo> =
     threadInfo.members.filter(memberInfo => memberInfo.role);
   const memberEntities: $ReadOnlyArray<UserEntity> = threadMembers.map(member =>
     ET.user({ userInfo: member }),
   );
 
   return {
     type: 'thread',
     id: threadInfo.id,
     name: threadInfo.name,
     display: 'uiName',
     uiName: memberEntities,
     ifJustViewer:
       threadInfo.type === threadTypes.GENESIS_PRIVATE
         ? 'viewer_username'
         : 'just_you_string',
   };
 }
 
 function threadInfoFromRawThreadInfo(
   rawThreadInfo: RawThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
 ): ThreadInfo {
   let threadInfo: ThreadInfo = {
     minimallyEncoded: true,
     id: rawThreadInfo.id,
     type: rawThreadInfo.type,
     name: rawThreadInfo.name,
     uiName: '',
     description: rawThreadInfo.description,
     color: rawThreadInfo.color,
     creationTime: rawThreadInfo.creationTime,
     parentThreadID: rawThreadInfo.parentThreadID,
     containingThreadID: rawThreadInfo.containingThreadID,
     community: rawThreadInfo.community,
     members: getRelativeMemberInfos(rawThreadInfo, viewerID, userInfos),
     roles: rawThreadInfo.roles,
     currentUser: rawThreadInfo.currentUser,
     repliesCount: rawThreadInfo.repliesCount,
   };
 
   threadInfo = {
     ...threadInfo,
     uiName: threadUIName(threadInfo),
   };
   const { sourceMessageID, avatar, pinnedCount } = rawThreadInfo;
   if (sourceMessageID) {
     threadInfo = { ...threadInfo, sourceMessageID };
   }
 
   if (avatar) {
     threadInfo = { ...threadInfo, avatar };
   } else if (
     rawThreadInfo.type === threadTypes.GENESIS_PERSONAL ||
     rawThreadInfo.type === threadTypes.GENESIS_PRIVATE
   ) {
     threadInfo = {
       ...threadInfo,
       avatar: getUserAvatarForThread(rawThreadInfo, viewerID, userInfos),
     };
   }
 
   if (pinnedCount) {
     threadInfo = { ...threadInfo, pinnedCount };
   }
   return threadInfo;
 }
 
 function filterOutDisabledPermissions(permissionsBitmask: string): string {
   const decodedPermissions: ThreadPermissionsInfo =
     threadPermissionsFromBitmaskHex(permissionsBitmask);
   const updatedPermissions = { ...decodedPermissions, ...disabledPermissions };
   const encodedUpdatedPermissions: string =
     permissionsToBitmaskHex(updatedPermissions);
   return encodedUpdatedPermissions;
 }
 
 function baseThreadIsWithBlockedUserOnly(
   threadInfo: LegacyRawThreadInfo | RawThreadInfo | ThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
   checkOnlyViewerBlock: boolean,
 ) {
   const otherUserID = getSingleOtherUser(threadInfo, viewerID);
   if (!otherUserID) {
     return false;
   }
   const otherUserRelationshipStatus =
     userInfos[otherUserID]?.relationshipStatus;
 
   if (checkOnlyViewerBlock) {
     return (
       otherUserRelationshipStatus === userRelationshipStatus.BLOCKED_BY_VIEWER
     );
   }
 
   return (
     !!otherUserRelationshipStatus &&
     relationshipBlockedInEitherDirection(otherUserRelationshipStatus)
   );
 }
 
 function threadIsWithBlockedUserOnly(
   threadInfo: LegacyRawThreadInfo | RawThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
   checkOnlyViewerBlock: boolean,
 ): boolean {
   if (
     threadOrParentThreadIsGroupChat(threadInfo) ||
     threadOrParentThreadHasAdminRole(threadInfo)
   ) {
     return false;
   }
   return baseThreadIsWithBlockedUserOnly(
     threadInfo,
     viewerID,
     userInfos,
     checkOnlyViewerBlock,
   );
 }
 
 function threadIsWithBlockedUserOnlyWithoutAdminRoleCheck(
   threadInfo: ThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
   checkOnlyViewerBlock: boolean,
 ): boolean {
   if (threadOrParentThreadIsGroupChat(threadInfo)) {
     return false;
   }
   return baseThreadIsWithBlockedUserOnly(
     threadInfo,
     viewerID,
     userInfos,
     checkOnlyViewerBlock,
   );
 }
 
 function threadFrozenDueToBlock(
   threadInfo: LegacyRawThreadInfo | RawThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
 ): boolean {
   return threadIsWithBlockedUserOnly(threadInfo, viewerID, userInfos, false);
 }
 
 function useThreadFrozenDueToViewerBlock(
   threadInfo: ThreadInfo,
   communityThreadInfo: ?ThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
 ): boolean {
   const communityThreadInfoArray = React.useMemo(
     () => (communityThreadInfo ? [communityThreadInfo] : []),
     [communityThreadInfo],
   );
   const communityRootsMembersToRole = useCommunityRootMembersToRole(
     communityThreadInfoArray,
   );
   const memberToRole = communityRootsMembersToRole[communityThreadInfo?.id];
 
   const memberHasAdminRole = threadMembersWithoutAddedAdmin(threadInfo).some(
     m => roleIsAdminRole(memberToRole?.[m.id]),
   );
 
   return React.useMemo(() => {
     if (memberHasAdminRole) {
       return false;
     }
 
     return threadIsWithBlockedUserOnlyWithoutAdminRoleCheck(
       threadInfo,
       viewerID,
       userInfos,
       true,
     );
   }, [memberHasAdminRole, threadInfo, userInfos, viewerID]);
 }
 
 const threadTypeDescriptions: { [ThreadType]: string } = {
   [threadTypes.COMMUNITY_OPEN_SUBTHREAD]:
     'Anybody in the parent channel can see an open subchannel.',
   [threadTypes.COMMUNITY_SECRET_SUBTHREAD]:
     'Only visible to its members and admins of ancestor channels.',
 };
 
 // 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: LegacyMemberInfo | MemberInfoWithPermissions | ServerMemberInfo,
+  memberInfo:
+    | { +minimallyEncoded: true, +permissions: string, ... }
+    | { +minimallyEncoded?: void, +permissions: ThreadPermissionsInfo, ... },
 ): boolean {
   if (memberInfo.minimallyEncoded) {
     return hasPermission(memberInfo.permissions, threadPermissions.CHANGE_ROLE);
   }
   return !!memberInfo.permissions[threadPermissions.CHANGE_ROLE]?.value;
 }
 
 function roleIsDefaultRole(
   roleInfo: ?ClientLegacyRoleInfo | ?RoleInfo,
 ): boolean {
   if (roleInfo?.specialRole === specialRoles.DEFAULT_ROLE) {
     return true;
   }
   return !!(roleInfo && roleInfo.isDefault);
 }
 
 function roleIsAdminRole(roleInfo: ?ClientLegacyRoleInfo | ?RoleInfo): boolean {
   if (roleInfo?.specialRole === specialRoles.ADMIN_ROLE) {
     return true;
   }
   return !!(roleInfo && !roleInfo.isDefault && roleInfo.name === 'Admins');
 }
 
 function threadHasAdminRole(
   threadInfo: ?(
     | LegacyRawThreadInfo
     | RawThreadInfo
     | ThreadInfo
     | ServerThreadInfo
   ),
 ): boolean {
   if (!threadInfo) {
     return false;
   }
   let hasSpecialRoleFieldBeenEncountered = false;
   for (const role of Object.values(threadInfo.roles)) {
     if (role.specialRole === specialRoles.ADMIN_ROLE) {
       return true;
     }
     if (role.specialRole !== undefined) {
       hasSpecialRoleFieldBeenEncountered = true;
     }
   }
   if (hasSpecialRoleFieldBeenEncountered) {
     return false;
   }
   return !!_find({ name: 'Admins' })(threadInfo.roles);
 }
 
 function threadOrParentThreadHasAdminRole(
   threadInfo: LegacyRawThreadInfo | RawThreadInfo,
 ) {
   return (
     threadMembersWithoutAddedAdmin(threadInfo).filter(member =>
       memberHasAdminPowers(member),
     ).length > 0
   );
 }
 
 function identifyInvalidatedThreads(
   updateInfos: $ReadOnlyArray<ClientUpdateInfo>,
 ): Set<string> {
   const invalidated = new Set<string>();
   for (const updateInfo of updateInfos) {
     if (updateInfo.type === updateTypes.DELETE_THREAD) {
       invalidated.add(updateInfo.threadID);
     }
   }
   return invalidated;
 }
 
 const permissionsDisabledByBlockArray = values(
   threadPermissionsDisabledByBlock,
 );
 
 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: string =
   `Background chats are just like normal chats, except they don't ` +
   `contribute to your unread count.\n\n` +
   `To move a chat over here, switch the “Background” option in its settings.`;
 
 function threadNoun(threadType: ThreadType, parentThreadID: ?string): string {
   if (threadType === threadTypes.SIDEBAR) {
     return 'thread';
   } else if (
     threadType === threadTypes.COMMUNITY_SECRET_SUBTHREAD &&
     parentThreadID === genesis().id
   ) {
     return 'chat';
   } else if (
     threadType === threadTypes.COMMUNITY_ROOT ||
     threadType === threadTypes.COMMUNITY_ANNOUNCEMENT_ROOT ||
     threadType === threadTypes.COMMUNITY_OPEN_SUBTHREAD ||
     threadType === threadTypes.COMMUNITY_OPEN_ANNOUNCEMENT_SUBTHREAD ||
     threadType === threadTypes.COMMUNITY_SECRET_SUBTHREAD ||
     threadType === threadTypes.COMMUNITY_SECRET_ANNOUNCEMENT_SUBTHREAD ||
     threadType === threadTypes.GENESIS
   ) {
     return 'channel';
   } else {
     return 'chat';
   }
 }
 
 function threadLabel(threadType: ThreadType): string {
   if (
     threadType === threadTypes.COMMUNITY_OPEN_SUBTHREAD ||
     threadType === threadTypes.COMMUNITY_OPEN_ANNOUNCEMENT_SUBTHREAD
   ) {
     return 'Open';
   } else if (threadType === threadTypes.GENESIS_PERSONAL) {
     return 'Personal';
   } else if (threadType === threadTypes.SIDEBAR) {
     return 'Thread';
   } else if (threadType === threadTypes.GENESIS_PRIVATE) {
     return 'Private';
   } else if (
     threadType === threadTypes.COMMUNITY_ROOT ||
     threadType === threadTypes.COMMUNITY_ANNOUNCEMENT_ROOT ||
     threadType === threadTypes.GENESIS
   ) {
     return 'Community';
   } else {
     return 'Secret';
   }
 }
 
 type ExistingThreadInfoFinderParams = {
   +searching: boolean,
   +userInfoInputArray: $ReadOnlyArray<AccountUserInfo>,
 };
 type ExistingThreadInfoFinder = (
   params: ExistingThreadInfoFinderParams,
 ) => ?ThreadInfo;
 
 function useExistingThreadInfoFinder(
   baseThreadInfo: ?ThreadInfo,
 ): ExistingThreadInfoFinder {
   const threadInfos = useSelector(threadInfoSelector);
   const loggedInUserInfo = useLoggedInUserInfo();
 
   const pendingToRealizedThreadIDs = useSelector(state =>
     pendingToRealizedThreadIDsSelector(state.threadStore.threadInfos),
   );
   return React.useCallback(
     (params: ExistingThreadInfoFinderParams): ?ThreadInfo => {
       if (!baseThreadInfo) {
         return null;
       }
 
       const realizedThreadInfo = threadInfos[baseThreadInfo.id];
       if (realizedThreadInfo) {
         return realizedThreadInfo;
       }
 
       if (!loggedInUserInfo || !threadIsPending(baseThreadInfo.id)) {
         return baseThreadInfo;
       }
       const viewerID = loggedInUserInfo?.id;
 
       invariant(
         threadTypeCanBePending(baseThreadInfo.type),
         `ThreadInfo has pending ID ${baseThreadInfo.id}, but type that ` +
           `should not be pending ${baseThreadInfo.type}`,
       );
 
       const { searching, userInfoInputArray } = params;
 
       const { sourceMessageID } = baseThreadInfo;
       const pendingThreadID = searching
         ? getPendingThreadID(
             pendingThreadType(userInfoInputArray.length),
             [...userInfoInputArray.map(user => user.id), viewerID],
             sourceMessageID,
           )
         : getPendingThreadID(
             baseThreadInfo.type,
             baseThreadInfo.members.map(member => member.id),
             sourceMessageID,
           );
 
       const realizedThreadID = pendingToRealizedThreadIDs.get(pendingThreadID);
       if (realizedThreadID && threadInfos[realizedThreadID]) {
         return threadInfos[realizedThreadID];
       }
 
       const updatedThread = searching
         ? createPendingThread({
             viewerID,
             threadType: pendingThreadType(userInfoInputArray.length),
             members: [loggedInUserInfo, ...userInfoInputArray],
           })
         : baseThreadInfo;
 
       return updatedThread;
     },
     [baseThreadInfo, threadInfos, loggedInUserInfo, pendingToRealizedThreadIDs],
   );
 }
 
 type ThreadTypeParentRequirement = 'optional' | 'required' | 'disabled';
 
 function getThreadTypeParentRequirement(
   threadType: ThreadType,
 ): ThreadTypeParentRequirement {
   if (
     threadType === threadTypes.COMMUNITY_OPEN_SUBTHREAD ||
     threadType === threadTypes.COMMUNITY_OPEN_ANNOUNCEMENT_SUBTHREAD ||
     //threadType === threadTypes.COMMUNITY_SECRET_SUBTHREAD ||
     threadType === threadTypes.COMMUNITY_SECRET_ANNOUNCEMENT_SUBTHREAD ||
     threadType === threadTypes.SIDEBAR
   ) {
     return 'required';
   } else if (
     threadType === threadTypes.COMMUNITY_ROOT ||
     threadType === threadTypes.COMMUNITY_ANNOUNCEMENT_ROOT ||
     threadType === threadTypes.GENESIS ||
     threadType === threadTypes.GENESIS_PERSONAL ||
     threadType === threadTypes.GENESIS_PRIVATE
   ) {
     return 'disabled';
   } else {
     return 'optional';
   }
 }
 
 function checkIfDefaultMembersAreVoiced(threadInfo: ThreadInfo): boolean {
   const defaultRoleID = Object.keys(threadInfo.roles).find(roleID =>
     roleIsDefaultRole(threadInfo.roles[roleID]),
   );
   invariant(
     defaultRoleID !== undefined,
     'all threads should have a default role',
   );
   const defaultRole = threadInfo.roles[defaultRoleID];
   const defaultRolePermissions =
     decodeMinimallyEncodedRoleInfo(defaultRole).permissions;
 
   return !!defaultRolePermissions[threadPermissions.VOICED];
 }
 
 const draftKeySuffix = '/message_composer';
 
 function draftKeyFromThreadID(threadID: string): string {
   return `${threadID}${draftKeySuffix}`;
 }
 
 function getContainingThreadID(
   parentThreadInfo:
     | ?ServerThreadInfo
     | LegacyRawThreadInfo
     | RawThreadInfo
     | ThreadInfo,
   threadType: ThreadType,
 ): ?string {
   if (!parentThreadInfo) {
     return null;
   }
   if (threadType === threadTypes.SIDEBAR) {
     return parentThreadInfo.id;
   }
   if (!parentThreadInfo.containingThreadID) {
     return parentThreadInfo.id;
   }
   return parentThreadInfo.containingThreadID;
 }
 
 function getCommunity(
   parentThreadInfo:
     | ?ServerThreadInfo
     | LegacyRawThreadInfo
     | RawThreadInfo
     | ThreadInfo,
 ): ?string {
   if (!parentThreadInfo) {
     return null;
   }
   const { id, community, type } = parentThreadInfo;
   if (community !== null && community !== undefined) {
     return community;
   }
   if (threadTypeIsCommunityRoot(type)) {
     return id;
   }
   return null;
 }
 
 function getThreadListSearchResults(
   chatListData: $ReadOnlyArray<ChatThreadItem>,
   searchText: string,
   threadFilter: ThreadInfo => boolean,
   threadSearchResults: $ReadOnlySet<string>,
   usersSearchResults: $ReadOnlyArray<GlobalAccountUserInfo>,
   loggedInUserInfo: ?LoggedInUserInfo,
 ): $ReadOnlyArray<ChatThreadItem> {
   if (!searchText) {
     return chatListData.filter(
       item =>
         threadIsTopLevel(item.threadInfo) && threadFilter(item.threadInfo),
     );
   }
 
   const privateThreads = [];
   const personalThreads = [];
   const otherThreads = [];
   for (const item of chatListData) {
     if (!threadSearchResults.has(item.threadInfo.id)) {
       continue;
     }
     if (item.threadInfo.type === threadTypes.GENESIS_PRIVATE) {
       privateThreads.push({ ...item, sidebars: [] });
     } else if (item.threadInfo.type === threadTypes.GENESIS_PERSONAL) {
       personalThreads.push({ ...item, sidebars: [] });
     } else {
       otherThreads.push({ ...item, sidebars: [] });
     }
   }
 
   const chatItems: ChatThreadItem[] = [
     ...privateThreads,
     ...personalThreads,
     ...otherThreads,
   ];
   if (loggedInUserInfo) {
     chatItems.push(
       ...usersSearchResults.map(user =>
         createPendingThreadItem(loggedInUserInfo, user),
       ),
     );
   }
   return chatItems;
 }
 
 function reorderThreadSearchResults<T: RawThreadInfo | ThreadInfo>(
   threadInfos: $ReadOnlyArray<T>,
   threadSearchResults: $ReadOnlyArray<string>,
 ): T[] {
   const privateThreads = [];
   const personalThreads = [];
   const otherThreads = [];
   const threadSearchResultsSet = new Set(threadSearchResults);
   for (const threadInfo of threadInfos) {
     if (!threadSearchResultsSet.has(threadInfo.id)) {
       continue;
     }
     if (threadInfo.type === threadTypes.GENESIS_PRIVATE) {
       privateThreads.push(threadInfo);
     } else if (threadInfo.type === threadTypes.GENESIS_PERSONAL) {
       personalThreads.push(threadInfo);
     } else {
       otherThreads.push(threadInfo);
     }
   }
 
   return [...privateThreads, ...personalThreads, ...otherThreads];
 }
 
 function useAvailableThreadMemberActions(
   memberInfo: RelativeMemberInfo,
   threadInfo: ThreadInfo,
   canEdit: ?boolean = true,
 ): $ReadOnlyArray<'change_role' | 'remove_user'> {
   const canRemoveMembers = useThreadHasPermission(
     threadInfo,
     threadPermissions.REMOVE_MEMBERS,
   );
   const canChangeRoles = useThreadHasPermission(
     threadInfo,
     threadPermissions.CHANGE_ROLE,
   );
 
   return React.useMemo(() => {
     const { role } = memberInfo;
     if (!canEdit || !role) {
       return [];
     }
 
     const result = [];
 
     if (
       canChangeRoles &&
       memberInfo.username &&
       threadHasAdminRole(threadInfo)
     ) {
       result.push('change_role');
     }
 
     if (
       canRemoveMembers &&
       !memberInfo.isViewer &&
       (canChangeRoles || roleIsDefaultRole(threadInfo.roles[role]))
     ) {
       result.push('remove_user');
     }
 
     return result;
   }, [canChangeRoles, canEdit, canRemoveMembers, memberInfo, threadInfo]);
 }
 
 function patchThreadInfoToIncludeMentionedMembersOfParent(
   threadInfo: ThreadInfo,
   parentThreadInfo: ThreadInfo,
   messageText: string,
   viewerID: string,
 ): ThreadInfo {
   const members: UserIDAndUsername[] = threadInfo.members
     .map(({ id, username }) =>
       username ? ({ id, username }: UserIDAndUsername) : null,
     )
     .filter(Boolean);
   const mentionedNewMembers = extractNewMentionedParentMembers(
     messageText,
     threadInfo,
     parentThreadInfo,
   );
   if (mentionedNewMembers.length === 0) {
     return threadInfo;
   }
   members.push(...mentionedNewMembers);
   return createPendingThread({
     viewerID,
     threadType: threadTypes.SIDEBAR,
     members,
     parentThreadInfo,
     threadColor: threadInfo.color,
     name: threadInfo.name,
     sourceMessageID: threadInfo.sourceMessageID,
   });
 }
 
 function threadInfoInsideCommunity(
   threadInfo: RawThreadInfo | ThreadInfo,
   communityID: string,
 ): boolean {
   return threadInfo.community === communityID || threadInfo.id === communityID;
 }
 
 type RoleAndMemberCount = {
   [roleName: string]: number,
 };
 
 function useRoleMemberCountsForCommunity(
   threadInfo: ThreadInfo,
 ): RoleAndMemberCount {
   return React.useMemo(() => {
     const roleIDsToNames: { [string]: string } = {};
 
     Object.keys(threadInfo.roles).forEach(roleID => {
       roleIDsToNames[roleID] = threadInfo.roles[roleID].name;
     });
 
     const roleNamesToMemberCount: RoleAndMemberCount = {};
 
     threadInfo.members.forEach(({ role: roleID }) => {
       invariant(roleID, 'Community member should have a role');
       const roleName = roleIDsToNames[roleID];
 
       roleNamesToMemberCount[roleName] =
         (roleNamesToMemberCount[roleName] ?? 0) + 1;
     });
 
     // For all community roles with no members, add them to the list with 0
     Object.keys(roleIDsToNames).forEach(roleName => {
       if (roleNamesToMemberCount[roleIDsToNames[roleName]] === undefined) {
         roleNamesToMemberCount[roleIDsToNames[roleName]] = 0;
       }
     });
 
     return roleNamesToMemberCount;
   }, [threadInfo.members, threadInfo.roles]);
 }
 
 function useRoleNamesToSpecialRole(threadInfo: ThreadInfo): {
   +[roleName: string]: ?SpecialRole,
 } {
   return React.useMemo(() => {
     const roleNamesToSpecialRole: { [roleName: string]: ?SpecialRole } = {};
     values(threadInfo.roles).forEach(role => {
       if (roleNamesToSpecialRole[role.name] !== undefined) {
         return;
       }
       if (roleIsDefaultRole(role)) {
         roleNamesToSpecialRole[role.name] = specialRoles.DEFAULT_ROLE;
       } else if (roleIsAdminRole(role)) {
         roleNamesToSpecialRole[role.name] = specialRoles.ADMIN_ROLE;
       } else {
         roleNamesToSpecialRole[role.name] = null;
       }
     });
     return roleNamesToSpecialRole;
   }, [threadInfo.roles]);
 }
 
 type RoleUserSurfacedPermissions = {
   +[roleName: string]: $ReadOnlySet<UserSurfacedPermission>,
 };
 // Iterates through the existing roles in the community and 'reverse maps'
 // the set of permission literals for each role to user-facing permission enums
 // to help pre-populate the permission checkboxes when editing roles.
 function useRoleUserSurfacedPermissions(
   threadInfo: ThreadInfo,
 ): RoleUserSurfacedPermissions {
   return React.useMemo(() => {
     const roleNamesToPermissions: { [string]: Set<UserSurfacedPermission> } =
       {};
 
     Object.keys(threadInfo.roles).forEach(roleID => {
       const roleName = threadInfo.roles[roleID].name;
       const rolePermissions = Object.keys(
         decodeMinimallyEncodedRoleInfo(threadInfo.roles[roleID]).permissions,
       );
 
       const setOfUserSurfacedPermissions = new Set<UserSurfacedPermission>();
 
       rolePermissions.forEach(rolePermission => {
         const userSurfacedPermission = Object.keys(
           configurableCommunityPermissions,
         ).find(key =>
           configurableCommunityPermissions[key].has(rolePermission),
         );
 
         if (userSurfacedPermission) {
           setOfUserSurfacedPermissions.add(userSurfacedPermission);
         }
       });
       roleNamesToPermissions[roleName] = setOfUserSurfacedPermissions;
     });
 
     return roleNamesToPermissions;
   }, [threadInfo.roles]);
 }
 
 function communityOrThreadNoun(threadInfo: RawThreadInfo | ThreadInfo): string {
   return threadTypeIsCommunityRoot(threadInfo.type)
     ? 'community'
     : threadNoun(threadInfo.type, threadInfo.parentThreadID);
 }
 
 function getThreadsToDeleteText(
   threadInfo: RawThreadInfo | ThreadInfo,
 ): string {
   return `${
     threadTypeIsCommunityRoot(threadInfo.type)
       ? 'Subchannels and threads'
       : 'Threads'
   } within this ${communityOrThreadNoun(threadInfo)}`;
 }
 
 function useUserProfileThreadInfo(userInfo: ?UserInfo): ?UserProfileThreadInfo {
   const userID = userInfo?.id;
   const username = userInfo?.username;
 
   const loggedInUserInfo = useLoggedInUserInfo();
   const isViewerProfile = loggedInUserInfo?.id === userID;
 
   const privateThreadInfosSelector = threadInfosSelectorForThreadType(
     threadTypes.GENESIS_PRIVATE,
   );
   const privateThreadInfos = useSelector(privateThreadInfosSelector);
 
   const personalThreadInfosSelector = threadInfosSelectorForThreadType(
     threadTypes.GENESIS_PERSONAL,
   );
 
   const personalThreadInfos = useSelector(personalThreadInfosSelector);
 
   const usersWithPersonalThread = useSelector(usersWithPersonalThreadSelector);
 
   return React.useMemo(() => {
     if (!loggedInUserInfo || !userID || !username) {
       return null;
     }
 
     if (isViewerProfile) {
       const privateThreadInfo: ?ThreadInfo = privateThreadInfos[0];
 
       return privateThreadInfo ? { threadInfo: privateThreadInfo } : null;
     }
 
     if (usersWithPersonalThread.has(userID)) {
       const personalThreadInfo: ?ThreadInfo = personalThreadInfos.find(
         threadInfo =>
           userID === getSingleOtherUser(threadInfo, loggedInUserInfo.id),
       );
 
       return personalThreadInfo ? { threadInfo: personalThreadInfo } : null;
     }
 
     const pendingPersonalThreadInfo = createPendingPersonalThread(
       loggedInUserInfo,
       userID,
       username,
     );
 
     return pendingPersonalThreadInfo;
   }, [
     isViewerProfile,
     loggedInUserInfo,
     personalThreadInfos,
     privateThreadInfos,
     userID,
     username,
     usersWithPersonalThread,
   ]);
 }
 
 function assertAllThreadInfosAreLegacy(rawThreadInfos: MixedRawThreadInfos): {
   [id: string]: LegacyRawThreadInfo,
 } {
   return Object.fromEntries(
     Object.entries(rawThreadInfos).map(([id, rawThreadInfo]) => {
       invariant(
         !rawThreadInfo.minimallyEncoded,
         `rawThreadInfos shouldn't be minimallyEncoded`,
       );
       return [id, rawThreadInfo];
     }),
   );
 }
 
 function useOnScreenEntryEditableThreadInfos(): $ReadOnlyArray<ThreadInfo> {
   const visibleThreadInfos = useSelector(onScreenThreadInfos);
   const editableVisibleThreadInfos = useThreadsWithPermission(
     visibleThreadInfos,
     threadPermissions.EDIT_ENTRIES,
   );
   return editableVisibleThreadInfos;
 }
 
 export {
   threadHasPermission,
   useCommunityRootMembersToRole,
   useThreadHasPermission,
   viewerIsMember,
   threadInChatList,
   useIsThreadInChatList,
   useThreadsInChatList,
   threadIsTopLevel,
   threadIsChannel,
   threadIsSidebar,
   threadInBackgroundChatList,
   threadInHomeChatList,
   threadIsInHome,
   threadInFilterList,
   userIsMember,
   threadActualMembers,
   threadOtherMembers,
   threadIsGroupChat,
   threadIsPending,
   threadIsPendingSidebar,
   getSingleOtherUser,
   getPendingThreadID,
   parsePendingThreadID,
   createPendingThread,
   extractNewMentionedParentMembers,
   pendingThreadType,
   filterOutDisabledPermissions,
   threadFrozenDueToBlock,
   useThreadFrozenDueToViewerBlock,
   rawThreadInfoFromServerThreadInfo,
   threadUIName,
   threadInfoFromRawThreadInfo,
   threadTypeDescriptions,
   memberHasAdminPowers,
   roleIsDefaultRole,
   roleIsAdminRole,
   threadHasAdminRole,
   identifyInvalidatedThreads,
   permissionsDisabledByBlock,
   emptyItemText,
   threadNoun,
   threadLabel,
   useExistingThreadInfoFinder,
   getThreadTypeParentRequirement,
   checkIfDefaultMembersAreVoiced,
   draftKeySuffix,
   draftKeyFromThreadID,
   threadTypeCanBePending,
   getContainingThreadID,
   getCommunity,
   getThreadListSearchResults,
   reorderThreadSearchResults,
   useAvailableThreadMemberActions,
   threadMembersWithoutAddedAdmin,
   patchThreadInfoToIncludeMentionedMembersOfParent,
   threadInfoInsideCommunity,
   useRoleMemberCountsForCommunity,
   useRoleNamesToSpecialRole,
   useRoleUserSurfacedPermissions,
   getThreadsToDeleteText,
   useUserProfileThreadInfo,
   assertAllThreadInfosAreLegacy,
   useOnScreenEntryEditableThreadInfos,
   extractMentionedMembers,
 };
diff --git a/lib/shared/updates/delete-account-spec.js b/lib/shared/updates/delete-account-spec.js
index e4cb8628e..9ec2bd85f 100644
--- a/lib/shared/updates/delete-account-spec.js
+++ b/lib/shared/updates/delete-account-spec.js
@@ -1,103 +1,119 @@
 // @flow
 
 import t from 'tcomb';
 
 import type { UpdateSpec } from './update-spec.js';
 import type { RawThreadInfos } from '../../types/thread-types.js';
 import { updateTypes } from '../../types/update-types-enum.js';
 import type {
   AccountDeletionRawUpdateInfo,
   AccountDeletionUpdateData,
   AccountDeletionUpdateInfo,
 } from '../../types/update-types.js';
 import type { UserInfos } from '../../types/user-types.js';
 import { tNumber, tShape, tUserID } from '../../utils/validation-utils.js';
 
 export const deleteAccountSpec: UpdateSpec<
   AccountDeletionUpdateInfo,
   AccountDeletionRawUpdateInfo,
   AccountDeletionUpdateData,
 > = Object.freeze({
   generateOpsForThreadUpdates(
     storeThreadInfos: RawThreadInfos,
     update: AccountDeletionUpdateInfo,
   ) {
     const operations = [];
     for (const threadID in storeThreadInfos) {
       const threadInfo = storeThreadInfos[threadID];
-      const newMembers = threadInfo.members.filter(
-        member => member.id !== update.deletedUserID,
-      );
-      if (newMembers.length < threadInfo.members.length) {
-        const updatedThread = {
-          ...threadInfo,
-          members: newMembers,
-        };
+
+      let replacedThreadInfo;
+      if (threadInfo.thick) {
+        const newMembers = threadInfo.members.filter(
+          member => member.id !== update.deletedUserID,
+        );
+        if (newMembers.length < threadInfo.members.length) {
+          replacedThreadInfo = {
+            ...threadInfo,
+            members: newMembers,
+          };
+        }
+      } else {
+        const newMembers = threadInfo.members.filter(
+          member => member.id !== update.deletedUserID,
+        );
+        if (newMembers.length < threadInfo.members.length) {
+          replacedThreadInfo = {
+            ...threadInfo,
+            members: newMembers,
+          };
+        }
+      }
+      if (replacedThreadInfo) {
         operations.push({
           type: 'replace',
           payload: {
-            id: threadID,
-            threadInfo: updatedThread,
+            id: threadInfo.id,
+            threadInfo: replacedThreadInfo,
           },
         });
       }
     }
     return operations;
   },
   reduceUserInfos(state: UserInfos, update: AccountDeletionUpdateInfo) {
     const { deletedUserID } = update;
     if (!state[deletedUserID]) {
       return state;
     }
     const { [deletedUserID]: deleted, ...rest } = state;
     return rest;
   },
   rawUpdateInfoFromRow(row: Object) {
     const content = JSON.parse(row.content);
     return {
       type: updateTypes.DELETE_ACCOUNT,
       id: row.id.toString(),
       time: row.time,
       deletedUserID: content.deletedUserID,
     };
   },
   updateContentForServerDB(data: AccountDeletionUpdateData) {
     return JSON.stringify({ deletedUserID: data.deletedUserID });
   },
   rawInfoFromData(data: AccountDeletionUpdateData, id: string) {
     return {
       type: updateTypes.DELETE_ACCOUNT,
       id,
       time: data.time,
       deletedUserID: data.deletedUserID,
     };
   },
   updateInfoFromRawInfo(info: AccountDeletionRawUpdateInfo) {
     return {
       type: updateTypes.DELETE_ACCOUNT,
       id: info.id,
       time: info.time,
       deletedUserID: info.deletedUserID,
     };
   },
   deleteCondition: new Set([
     updateTypes.DELETE_ACCOUNT,
     updateTypes.UPDATE_USER,
   ]),
   keyForUpdateData(data: AccountDeletionUpdateData) {
     return data.deletedUserID;
   },
   keyForUpdateInfo(info: AccountDeletionUpdateInfo) {
     return info.deletedUserID;
   },
   typesOfReplacedUpdatesForMatchingKey: 'all_types',
   generateOpsForUserInfoUpdates(update: AccountDeletionUpdateInfo) {
     return [{ type: 'remove_users', payload: { ids: [update.deletedUserID] } }];
   },
   infoValidator: tShape<AccountDeletionUpdateInfo>({
     type: tNumber(updateTypes.DELETE_ACCOUNT),
     id: t.String,
     time: t.Number,
     deletedUserID: tUserID,
   }),
 });
diff --git a/lib/types/minimally-encoded-thread-permissions-types.js b/lib/types/minimally-encoded-thread-permissions-types.js
index d191aec4a..e2c346f49 100644
--- a/lib/types/minimally-encoded-thread-permissions-types.js
+++ b/lib/types/minimally-encoded-thread-permissions-types.js
@@ -1,239 +1,296 @@
 // @flow
 
 import invariant from 'invariant';
 import _mapValues from 'lodash/fp/mapValues.js';
 
 import type { ClientAvatar } from './avatar-types.js';
+import type { ThreadPermissionsInfo } from './thread-permission-types.js';
 import type { ThreadType } from './thread-types-enum.js';
 import type {
   LegacyMemberInfo,
   LegacyRawThreadInfo,
+  LegacyThinRawThreadInfo,
+  LegacyThickRawThreadInfo,
   ClientLegacyRoleInfo,
   LegacyThreadCurrentUserInfo,
+  ThickMemberInfo,
 } from './thread-types.js';
 import {
   decodeThreadRolePermissionsBitmaskArray,
   permissionsToBitmaskHex,
   threadPermissionsFromBitmaskHex,
   threadRolePermissionsBlobToBitmaskArray,
 } from '../permissions/minimally-encoded-thread-permissions.js';
 import type { SpecialRole } from '../permissions/special-roles.js';
 import { specialRoles } from '../permissions/special-roles.js';
 import { roleIsAdminRole, roleIsDefaultRole } from '../shared/thread-utils.js';
 import type { ThreadEntity } from '../utils/entity-text.js';
 
 type RoleInfoBase = $ReadOnly<{
   +id: string,
   +name: string,
   +minimallyEncoded: true,
   +permissions: $ReadOnlyArray<string>,
 }>;
 
 export type RoleInfo = $ReadOnly<{
   ...RoleInfoBase,
   +specialRole?: ?SpecialRole,
 }>;
 
 const minimallyEncodeRoleInfo = (roleInfo: ClientLegacyRoleInfo): RoleInfo => {
   invariant(
     !('minimallyEncoded' in roleInfo),
     'roleInfo is already minimally encoded.',
   );
   let specialRole: ?SpecialRole;
   if (roleIsDefaultRole(roleInfo)) {
     specialRole = specialRoles.DEFAULT_ROLE;
   } else if (roleIsAdminRole(roleInfo)) {
     specialRole = specialRoles.ADMIN_ROLE;
   }
   const { isDefault, ...rest } = roleInfo;
   return {
     ...rest,
     minimallyEncoded: true,
     permissions: threadRolePermissionsBlobToBitmaskArray(roleInfo.permissions),
     specialRole,
   };
 };
 
 const decodeMinimallyEncodedRoleInfo = (
   minimallyEncodedRoleInfo: RoleInfo,
 ): ClientLegacyRoleInfo => {
   const { minimallyEncoded, specialRole, ...rest } = minimallyEncodedRoleInfo;
   return {
     ...rest,
     permissions: decodeThreadRolePermissionsBitmaskArray(
       minimallyEncodedRoleInfo.permissions,
     ),
     isDefault: roleIsDefaultRole(minimallyEncodedRoleInfo),
   };
 };
 
 export type ThreadCurrentUserInfo = $ReadOnly<{
   ...LegacyThreadCurrentUserInfo,
   +minimallyEncoded: true,
   +permissions: string,
 }>;
 
 const minimallyEncodeThreadCurrentUserInfo = (
   threadCurrentUserInfo: LegacyThreadCurrentUserInfo,
 ): ThreadCurrentUserInfo => {
   invariant(
     !('minimallyEncoded' in threadCurrentUserInfo),
     'threadCurrentUserInfo is already minimally encoded.',
   );
   return {
     ...threadCurrentUserInfo,
     minimallyEncoded: true,
     permissions: permissionsToBitmaskHex(threadCurrentUserInfo.permissions),
   };
 };
 
 const decodeMinimallyEncodedThreadCurrentUserInfo = (
   minimallyEncodedThreadCurrentUserInfo: ThreadCurrentUserInfo,
 ): LegacyThreadCurrentUserInfo => {
   const { minimallyEncoded, ...rest } = minimallyEncodedThreadCurrentUserInfo;
   return {
     ...rest,
     permissions: threadPermissionsFromBitmaskHex(
       minimallyEncodedThreadCurrentUserInfo.permissions,
     ),
   };
 };
 
 export type MemberInfoWithPermissions = $ReadOnly<{
   ...LegacyMemberInfo,
   +minimallyEncoded: true,
   +permissions: string,
 }>;
 
 export type MemberInfoSansPermissions = $Diff<
   MemberInfoWithPermissions,
   { +permissions: string },
 >;
 
 function stripPermissionsFromMemberInfo(
   memberInfo: MemberInfoWithPermissions,
 ): MemberInfoSansPermissions {
   const { permissions, ...rest } = memberInfo;
   return rest;
 }
 
-const minimallyEncodeMemberInfo = (
-  memberInfo: LegacyMemberInfo,
-): MemberInfoWithPermissions => {
+export type MinimallyEncodedThickMemberInfo = $ReadOnly<{
+  ...ThickMemberInfo,
+  +minimallyEncoded: true,
+  +permissions: string,
+}>;
+
+const minimallyEncodeMemberInfo = <T: LegacyMemberInfo | ThickMemberInfo>(
+  memberInfo: T,
+): $ReadOnly<{
+  ...T,
+  +minimallyEncoded: true,
+  +permissions: string,
+}> => {
   invariant(
     !('minimallyEncoded' in memberInfo),
     'memberInfo is already minimally encoded.',
   );
   return {
     ...memberInfo,
     minimallyEncoded: true,
     permissions: permissionsToBitmaskHex(memberInfo.permissions),
   };
 };
 
-const decodeMinimallyEncodedMemberInfo = (
-  minimallyEncodedMemberInfo: MemberInfoWithPermissions,
-): LegacyMemberInfo => {
+const decodeMinimallyEncodedMemberInfo = <
+  T: MemberInfoWithPermissions | MinimallyEncodedThickMemberInfo,
+>(
+  minimallyEncodedMemberInfo: T,
+): $ReadOnly<{
+  ...$Diff<
+    T,
+    {
+      +minimallyEncoded: true,
+      +permissions: string,
+    },
+  >,
+  +permissions: ThreadPermissionsInfo,
+}> => {
   const { minimallyEncoded, ...rest } = minimallyEncodedMemberInfo;
   return {
     ...rest,
     permissions: threadPermissionsFromBitmaskHex(
       minimallyEncodedMemberInfo.permissions,
     ),
   };
 };
 
-export type RelativeMemberInfo = {
-  +id: string,
-  +role: ?string,
-  +isSender: boolean,
+export type ThinRawThreadInfo = $ReadOnly<{
+  ...LegacyThinRawThreadInfo,
   +minimallyEncoded: true,
-  +username: ?string,
-  +isViewer: boolean,
-};
+  +members: $ReadOnlyArray<MemberInfoWithPermissions>,
+  +roles: { +[id: string]: RoleInfo },
+  +currentUser: ThreadCurrentUserInfo,
+}>;
 
-export type RawThreadInfo = $ReadOnly<{
-  ...LegacyRawThreadInfo,
+export type ThickRawThreadInfo = $ReadOnly<{
+  ...LegacyThickRawThreadInfo,
   +minimallyEncoded: true,
-  +members: $ReadOnlyArray<MemberInfoWithPermissions>,
+  +members: $ReadOnlyArray<MinimallyEncodedThickMemberInfo>,
   +roles: { +[id: string]: RoleInfo },
   +currentUser: ThreadCurrentUserInfo,
 }>;
 
+export type RawThreadInfo = ThinRawThreadInfo | ThickRawThreadInfo;
+
 const minimallyEncodeRawThreadInfo = (
   rawThreadInfo: LegacyRawThreadInfo,
 ): RawThreadInfo => {
   invariant(
     !('minimallyEncoded' in rawThreadInfo),
     'rawThreadInfo is already minimally encoded.',
   );
-  const { members, roles, currentUser, ...rest } = rawThreadInfo;
-  return {
-    ...rest,
-    minimallyEncoded: true,
-    members: members.map(minimallyEncodeMemberInfo),
-    roles: _mapValues(minimallyEncodeRoleInfo)(roles),
-    currentUser: minimallyEncodeThreadCurrentUserInfo(currentUser),
-  };
+  if (rawThreadInfo.thick) {
+    const { members, roles, currentUser, ...rest } = rawThreadInfo;
+    return {
+      ...rest,
+      minimallyEncoded: true,
+      members: members.map(minimallyEncodeMemberInfo),
+      roles: _mapValues(minimallyEncodeRoleInfo)(roles),
+      currentUser: minimallyEncodeThreadCurrentUserInfo(currentUser),
+    };
+  } else {
+    const { members, roles, currentUser, ...rest } = rawThreadInfo;
+    return {
+      ...rest,
+      minimallyEncoded: true,
+      members: members.map(minimallyEncodeMemberInfo),
+      roles: _mapValues(minimallyEncodeRoleInfo)(roles),
+      currentUser: minimallyEncodeThreadCurrentUserInfo(currentUser),
+    };
+  }
 };
 
 const decodeMinimallyEncodedRawThreadInfo = (
   minimallyEncodedRawThreadInfo: RawThreadInfo,
 ): LegacyRawThreadInfo => {
-  const { minimallyEncoded, members, roles, currentUser, ...rest } =
-    minimallyEncodedRawThreadInfo;
-  return {
-    ...rest,
-    members: members.map(decodeMinimallyEncodedMemberInfo),
-    roles: _mapValues(decodeMinimallyEncodedRoleInfo)(roles),
-    currentUser: decodeMinimallyEncodedThreadCurrentUserInfo(currentUser),
-  };
+  if (minimallyEncodedRawThreadInfo.thick) {
+    const { minimallyEncoded, members, roles, currentUser, ...rest } =
+      minimallyEncodedRawThreadInfo;
+    return {
+      ...rest,
+      members: members.map(decodeMinimallyEncodedMemberInfo),
+      roles: _mapValues(decodeMinimallyEncodedRoleInfo)(roles),
+      currentUser: decodeMinimallyEncodedThreadCurrentUserInfo(currentUser),
+    };
+  } else {
+    const { minimallyEncoded, members, roles, currentUser, ...rest } =
+      minimallyEncodedRawThreadInfo;
+    return {
+      ...rest,
+      members: members.map(decodeMinimallyEncodedMemberInfo),
+      roles: _mapValues(decodeMinimallyEncodedRoleInfo)(roles),
+      currentUser: decodeMinimallyEncodedThreadCurrentUserInfo(currentUser),
+    };
+  }
 };
 
 export type RoleInfoWithoutSpecialRole = $ReadOnly<{
   ...RoleInfoBase,
   +isDefault?: boolean,
 }>;
 
 export type RawThreadInfoWithoutSpecialRole = $ReadOnly<{
   ...RawThreadInfo,
   +roles: { +[id: string]: RoleInfoWithoutSpecialRole },
 }>;
 
+export type RelativeMemberInfo = {
+  +id: string,
+  +role: ?string,
+  +isSender: boolean,
+  +minimallyEncoded: true,
+  +username: ?string,
+  +isViewer: boolean,
+};
+
 export type ThreadInfo = $ReadOnly<{
   +minimallyEncoded: true,
   +id: string,
   +type: ThreadType,
   +name: ?string,
   +uiName: string | ThreadEntity,
   +avatar?: ?ClientAvatar,
   +description: ?string,
   +color: string, // hex, without "#" or "0x"
   +creationTime: number, // millisecond timestamp
   +parentThreadID: ?string,
   +containingThreadID: ?string,
   +community: ?string,
   +members: $ReadOnlyArray<RelativeMemberInfo>,
   +roles: { +[id: string]: RoleInfo },
   +currentUser: ThreadCurrentUserInfo,
   +sourceMessageID?: string,
   +repliesCount: number,
   +pinnedCount?: number,
 }>;
 
 export type ResolvedThreadInfo = $ReadOnly<{
   ...ThreadInfo,
   +uiName: string,
 }>;
 
 export {
   minimallyEncodeRoleInfo,
   decodeMinimallyEncodedRoleInfo,
   minimallyEncodeThreadCurrentUserInfo,
   decodeMinimallyEncodedThreadCurrentUserInfo,
   stripPermissionsFromMemberInfo,
   minimallyEncodeMemberInfo,
   decodeMinimallyEncodedMemberInfo,
   minimallyEncodeRawThreadInfo,
   decodeMinimallyEncodedRawThreadInfo,
 };
diff --git a/lib/types/thread-types.js b/lib/types/thread-types.js
index 988c0092f..1b7aad3aa 100644
--- a/lib/types/thread-types.js
+++ b/lib/types/thread-types.js
@@ -1,428 +1,466 @@
 // @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,
 } 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, threadTypeValidator } from './thread-types-enum.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 LegacyRawThreadInfo = {
+export type LegacyThinRawThreadInfo = {
   +id: string,
-  +type: ThreadType,
+  +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 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: ThreadType,
   +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,
 };
 export type ClientThreadJoinRequest = {
   +threadID: string,
   +calendarQuery: CalendarQuery,
   +inviteLinkSecret?: string,
 };
 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,
 };
diff --git a/lib/utils/thread-ops-utils.js b/lib/utils/thread-ops-utils.js
index 36ac5faab..2385f204d 100644
--- a/lib/utils/thread-ops-utils.js
+++ b/lib/utils/thread-ops-utils.js
@@ -1,139 +1,169 @@
 // @flow
 
 import invariant from 'invariant';
 
 import {
   memberInfoWithPermissionsValidator,
   persistedRoleInfoValidator,
   threadCurrentUserInfoValidator,
 } from '../permissions/minimally-encoded-raw-thread-info-validators.js';
 import type {
-  MemberInfoWithPermissions,
   RawThreadInfo,
   RoleInfo,
 } from '../types/minimally-encoded-thread-permissions-types.js';
 import {
   decodeMinimallyEncodedRawThreadInfo,
   minimallyEncodeMemberInfo,
   minimallyEncodeRoleInfo,
   minimallyEncodeThreadCurrentUserInfo,
 } from '../types/minimally-encoded-thread-permissions-types.js';
-import { assertThreadType } from '../types/thread-types-enum.js';
+import {
+  assertThreadType,
+  threadTypeIsThick,
+  assertThinThreadType,
+  assertThickThreadType,
+} from '../types/thread-types-enum.js';
 import {
   type ClientDBThreadInfo,
   legacyMemberInfoValidator,
   type LegacyRawThreadInfo,
   clientLegacyRoleInfoValidator,
   legacyThreadCurrentUserInfoValidator,
 } from '../types/thread-types.js';
 
 function convertRawThreadInfoToClientDBThreadInfo(
   rawThreadInfo: LegacyRawThreadInfo | RawThreadInfo,
 ): ClientDBThreadInfo {
-  const { minimallyEncoded, ...rest } = rawThreadInfo;
+  const { minimallyEncoded, thick, ...rest } = rawThreadInfo;
   return {
     ...rest,
     creationTime: rawThreadInfo.creationTime.toString(),
     members: JSON.stringify(rawThreadInfo.members),
     roles: JSON.stringify(rawThreadInfo.roles),
     currentUser: JSON.stringify(rawThreadInfo.currentUser),
     avatar: rawThreadInfo.avatar ? JSON.stringify(rawThreadInfo.avatar) : null,
   };
 }
 
 function convertClientDBThreadInfoToRawThreadInfo(
   clientDBThreadInfo: ClientDBThreadInfo,
 ): RawThreadInfo {
   // 1. Validate and potentially minimally encode `rawMembers`.
   const rawMembers = JSON.parse(clientDBThreadInfo.members);
-  const minimallyEncodedMembers: $ReadOnlyArray<MemberInfoWithPermissions> =
-    rawMembers.map(rawMember => {
-      invariant(
-        memberInfoWithPermissionsValidator.is(rawMember) ||
-          legacyMemberInfoValidator.is(rawMember),
-        'rawMember must be valid [MinimallyEncoded/Legacy]MemberInfo',
-      );
-      return rawMember.minimallyEncoded
-        ? rawMember
-        : minimallyEncodeMemberInfo(rawMember);
-    });
+  const minimallyEncodedMembers = rawMembers.map(rawMember => {
+    invariant(
+      // TODO these must be updated to accept new client-only change
+      //      that subscription field may be present
+      memberInfoWithPermissionsValidator.is(rawMember) ||
+        legacyMemberInfoValidator.is(rawMember),
+      'rawMember must be valid [MinimallyEncoded/Legacy]MemberInfo',
+    );
+    return rawMember.minimallyEncoded
+      ? rawMember
+      : minimallyEncodeMemberInfo(rawMember);
+  });
 
   // 2. Validate and potentially minimally encode `rawRoles`.
   const rawRoles = JSON.parse(clientDBThreadInfo.roles);
   const minimallyEncodedRoles: { +[id: string]: RoleInfo } = Object.keys(
     rawRoles,
   ).reduce((acc: { [string]: RoleInfo }, roleID: string) => {
     const roleInfo = rawRoles[roleID];
     invariant(
       persistedRoleInfoValidator.is(roleInfo) ||
         clientLegacyRoleInfoValidator.is(roleInfo),
       'rawRole must be valid [MinimallyEncoded/Legacy]RoleInfo',
     );
     acc[roleID] = roleInfo.minimallyEncoded
       ? roleInfo
       : minimallyEncodeRoleInfo(roleInfo);
     return acc;
   }, {});
 
   // 3. Validate and potentially minimally encode `rawCurrentUser`.
   const rawCurrentUser = JSON.parse(clientDBThreadInfo.currentUser);
   invariant(
     threadCurrentUserInfoValidator.is(rawCurrentUser) ||
       legacyThreadCurrentUserInfoValidator.is(rawCurrentUser),
     'rawCurrentUser must be valid [MinimallyEncoded]ThreadCurrentUserInfo',
   );
   const minimallyEncodedCurrentUser = rawCurrentUser.minimallyEncoded
     ? rawCurrentUser
     : minimallyEncodeThreadCurrentUserInfo(rawCurrentUser);
 
-  let rawThreadInfo: RawThreadInfo = {
-    minimallyEncoded: true,
-    id: clientDBThreadInfo.id,
-    type: assertThreadType(clientDBThreadInfo.type),
-    name: clientDBThreadInfo.name,
-    description: clientDBThreadInfo.description,
-    color: clientDBThreadInfo.color,
-    creationTime: Number(clientDBThreadInfo.creationTime),
-    parentThreadID: clientDBThreadInfo.parentThreadID,
-    containingThreadID: clientDBThreadInfo.containingThreadID,
-    community: clientDBThreadInfo.community,
-    members: minimallyEncodedMembers,
-    roles: minimallyEncodedRoles,
-    currentUser: minimallyEncodedCurrentUser,
-    repliesCount: clientDBThreadInfo.repliesCount,
-    pinnedCount: clientDBThreadInfo.pinnedCount,
-  };
+  let rawThreadInfo: RawThreadInfo;
+  const threadType = assertThreadType(clientDBThreadInfo.type);
+  if (threadTypeIsThick(threadType)) {
+    const thickThreadType = assertThickThreadType(threadType);
+    rawThreadInfo = {
+      minimallyEncoded: true,
+      thick: true,
+      id: clientDBThreadInfo.id,
+      type: thickThreadType,
+      name: clientDBThreadInfo.name,
+      description: clientDBThreadInfo.description,
+      color: clientDBThreadInfo.color,
+      creationTime: Number(clientDBThreadInfo.creationTime),
+      parentThreadID: clientDBThreadInfo.parentThreadID,
+      containingThreadID: clientDBThreadInfo.containingThreadID,
+      community: clientDBThreadInfo.community,
+      members: minimallyEncodedMembers,
+      roles: minimallyEncodedRoles,
+      currentUser: minimallyEncodedCurrentUser,
+      repliesCount: clientDBThreadInfo.repliesCount,
+      pinnedCount: clientDBThreadInfo.pinnedCount,
+    };
+  } else {
+    const thinThreadType = assertThinThreadType(threadType);
+    rawThreadInfo = {
+      minimallyEncoded: true,
+      id: clientDBThreadInfo.id,
+      type: thinThreadType,
+      name: clientDBThreadInfo.name,
+      description: clientDBThreadInfo.description,
+      color: clientDBThreadInfo.color,
+      creationTime: Number(clientDBThreadInfo.creationTime),
+      parentThreadID: clientDBThreadInfo.parentThreadID,
+      containingThreadID: clientDBThreadInfo.containingThreadID,
+      community: clientDBThreadInfo.community,
+      members: minimallyEncodedMembers,
+      roles: minimallyEncodedRoles,
+      currentUser: minimallyEncodedCurrentUser,
+      repliesCount: clientDBThreadInfo.repliesCount,
+      pinnedCount: clientDBThreadInfo.pinnedCount,
+    };
+  }
 
   if (clientDBThreadInfo.sourceMessageID) {
     rawThreadInfo = {
       ...rawThreadInfo,
       sourceMessageID: clientDBThreadInfo.sourceMessageID,
     };
   }
 
   if (clientDBThreadInfo.avatar) {
     rawThreadInfo = {
       ...rawThreadInfo,
       avatar: JSON.parse(clientDBThreadInfo.avatar),
     };
   }
 
   return rawThreadInfo;
 }
 
 // WARNING: Do not consume or delete this function!
 // This function is being left in the codebase **SOLELY** to ensure that
 // previous `native` redux migrations continue to behave as expected.
 function deprecatedConvertClientDBThreadInfoToRawThreadInfo(
   clientDBThreadInfo: ClientDBThreadInfo,
 ): LegacyRawThreadInfo {
   const minimallyEncoded =
     convertClientDBThreadInfoToRawThreadInfo(clientDBThreadInfo);
   return decodeMinimallyEncodedRawThreadInfo(minimallyEncoded);
 }
 
 export {
   convertRawThreadInfoToClientDBThreadInfo,
   convertClientDBThreadInfoToRawThreadInfo,
   deprecatedConvertClientDBThreadInfoToRawThreadInfo,
 };
diff --git a/native/redux/edit-thread-permission-migration.js b/native/redux/edit-thread-permission-migration.js
index 97d05bfbf..9942912a1 100644
--- a/native/redux/edit-thread-permission-migration.js
+++ b/native/redux/edit-thread-permission-migration.js
@@ -1,96 +1,109 @@
 // @flow
 
 import { threadTypes } from 'lib/types/thread-types-enum.js';
 import type {
   LegacyMemberInfo,
   LegacyRawThreadInfo,
   ClientLegacyRoleInfo,
   LegacyRawThreadInfos,
   LegacyThreadCurrentUserInfo,
+  ThickMemberInfo,
 } from 'lib/types/thread-types.js';
 
 function addDetailedThreadEditPermissionsToUser<
-  T: LegacyMemberInfo | LegacyThreadCurrentUserInfo,
+  T: LegacyMemberInfo | LegacyThreadCurrentUserInfo | ThickMemberInfo,
 >(threadInfo: LegacyRawThreadInfo, member: T, threadID: string): T {
   let newPermissions = null;
   if (threadInfo.type === threadTypes.GENESIS_PRIVATE) {
     newPermissions = {
       ...member.permissions,
       edit_thread_color: { value: true, source: threadID },
       edit_thread_description: { value: true, source: threadID },
     };
   } else if (member.permissions['edit_thread']) {
     newPermissions = {
       ...member.permissions,
       edit_thread_color: member.permissions['edit_thread'],
       edit_thread_description: member.permissions['edit_thread'],
     };
   }
 
   return newPermissions
     ? {
         ...member,
         permissions: newPermissions,
       }
     : member;
 }
 
 function addDetailedThreadEditPermissionsToRole(
   role: ClientLegacyRoleInfo,
   threadType: number,
 ): ClientLegacyRoleInfo {
   let updatedPermissions = null;
   if (role.permissions['edit_thread']) {
     updatedPermissions = {
       ...role.permissions,
       edit_thread_color: role.permissions['edit_thread'],
       edit_thread_description: role.permissions['edit_thread'],
     };
   } else if (threadType === threadTypes.GENESIS_PRIVATE) {
     updatedPermissions = {
       ...role.permissions,
       edit_thread_color: true,
       edit_thread_description: true,
     };
   }
   return updatedPermissions
     ? { ...role, permissions: updatedPermissions }
     : role;
 }
 
 function migrateThreadStoreForEditThreadPermissions(threadInfos: {
   +[id: string]: LegacyRawThreadInfo,
 }): LegacyRawThreadInfos {
   const newThreadInfos: { [string]: LegacyRawThreadInfo } = {};
   for (const threadID in threadInfos) {
     const threadInfo: LegacyRawThreadInfo = threadInfos[threadID];
-    const updatedMembers = threadInfo.members.map(member =>
-      addDetailedThreadEditPermissionsToUser(threadInfo, member, threadID),
-    );
-
     const updatedCurrentUser = addDetailedThreadEditPermissionsToUser(
       threadInfo,
       threadInfo.currentUser,
       threadID,
     );
 
     const updatedRoles: { [string]: ClientLegacyRoleInfo } = {};
     for (const roleID in threadInfo.roles) {
       updatedRoles[roleID] = addDetailedThreadEditPermissionsToRole(
         threadInfo.roles[roleID],
         threadInfo.type,
       );
     }
 
-    const newThreadInfo = {
-      ...threadInfo,
-      members: updatedMembers,
-      currentUser: updatedCurrentUser,
-      roles: updatedRoles,
-    };
-    newThreadInfos[threadID] = newThreadInfo;
+    if (threadInfo.thick) {
+      const updatedMembers = threadInfo.members.map(member =>
+        addDetailedThreadEditPermissionsToUser(threadInfo, member, threadID),
+      );
+      const newThreadInfo = {
+        ...threadInfo,
+        members: updatedMembers,
+        currentUser: updatedCurrentUser,
+        roles: updatedRoles,
+      };
+      newThreadInfos[threadID] = newThreadInfo;
+    } else {
+      const updatedMembers = threadInfo.members.map(member =>
+        addDetailedThreadEditPermissionsToUser(threadInfo, member, threadID),
+      );
+      const newThreadInfo = {
+        ...threadInfo,
+        members: updatedMembers,
+        currentUser: updatedCurrentUser,
+        roles: updatedRoles,
+      };
+      newThreadInfos[threadID] = newThreadInfo;
+    }
   }
   return newThreadInfos;
 }
 
 export { migrateThreadStoreForEditThreadPermissions };
diff --git a/native/redux/manage-pins-permission-migration.js b/native/redux/manage-pins-permission-migration.js
index 5d5115513..705e71e0a 100644
--- a/native/redux/manage-pins-permission-migration.js
+++ b/native/redux/manage-pins-permission-migration.js
@@ -1,93 +1,109 @@
 // @flow
 
 import type {
   LegacyRawThreadInfo,
   LegacyMemberInfo,
   LegacyThreadCurrentUserInfo,
   ClientLegacyRoleInfo,
   LegacyRawThreadInfos,
+  ThickMemberInfo,
 } from 'lib/types/thread-types.js';
 
 type ThreadStoreThreadInfos = LegacyRawThreadInfos;
 
 const adminRoleName = 'Admins';
 
 function addManagePinsThreadPermissionToUser<
-  TargetMemberInfo: LegacyMemberInfo | LegacyThreadCurrentUserInfo,
+  TargetMemberInfo:
+    | LegacyMemberInfo
+    | LegacyThreadCurrentUserInfo
+    | ThickMemberInfo,
 >(
   threadInfo: LegacyRawThreadInfo,
   member: TargetMemberInfo,
   threadID: string,
 ): TargetMemberInfo {
   const isAdmin =
     member.role && threadInfo.roles[member.role].name === adminRoleName;
   let newPermissionsForMember;
   if (isAdmin) {
     newPermissionsForMember = {
       ...member.permissions,
       manage_pins: { value: true, source: threadID },
     };
   }
 
   return newPermissionsForMember
     ? {
         ...member,
         permissions: newPermissionsForMember,
       }
     : member;
 }
 
 function addManagePinsThreadPermissionToRole(
   role: ClientLegacyRoleInfo,
 ): ClientLegacyRoleInfo {
   const isAdminRole = role.name === adminRoleName;
   let updatedPermissions;
 
   if (isAdminRole) {
     updatedPermissions = {
       ...role.permissions,
       manage_pins: true,
       descendant_manage_pins: true,
     };
   }
 
   return updatedPermissions
     ? { ...role, permissions: updatedPermissions }
     : role;
 }
 
 function persistMigrationForManagePinsThreadPermission(
   threadInfos: ThreadStoreThreadInfos,
 ): ThreadStoreThreadInfos {
   const newThreadInfos: { [string]: LegacyRawThreadInfo } = {};
   for (const threadID in threadInfos) {
     const threadInfo: LegacyRawThreadInfo = threadInfos[threadID];
-    const updatedMembers = threadInfo.members.map(member =>
-      addManagePinsThreadPermissionToUser(threadInfo, member, threadID),
-    );
-
     const updatedCurrentUser = addManagePinsThreadPermissionToUser(
       threadInfo,
       threadInfo.currentUser,
       threadID,
     );
 
     const updatedRoles: { [string]: ClientLegacyRoleInfo } = {};
     for (const roleID in threadInfo.roles) {
       updatedRoles[roleID] = addManagePinsThreadPermissionToRole(
         threadInfo.roles[roleID],
       );
     }
 
-    const updatedThreadInfo = {
-      ...threadInfo,
-      members: updatedMembers,
-      currentUser: updatedCurrentUser,
-      roles: updatedRoles,
-    };
-    newThreadInfos[threadID] = updatedThreadInfo;
+    if (threadInfo.thick) {
+      const updatedMembers = threadInfo.members.map(member =>
+        addManagePinsThreadPermissionToUser(threadInfo, member, threadID),
+      );
+      const updatedThreadInfo = {
+        ...threadInfo,
+        members: updatedMembers,
+        currentUser: updatedCurrentUser,
+        roles: updatedRoles,
+      };
+      newThreadInfos[threadID] = updatedThreadInfo;
+    } else {
+      const updatedMembers = threadInfo.members.map(member =>
+        addManagePinsThreadPermissionToUser(threadInfo, member, threadID),
+      );
+      const updatedThreadInfo = {
+        ...threadInfo,
+        members: updatedMembers,
+        currentUser: updatedCurrentUser,
+        roles: updatedRoles,
+      };
+      newThreadInfos[threadID] = updatedThreadInfo;
+    }
   }
   return newThreadInfos;
 }
 
 export { persistMigrationForManagePinsThreadPermission };