diff --git a/keyserver/src/responders/redux-state-responders.js b/keyserver/src/responders/redux-state-responders.js
index 3aa4e1424..abe497316 100644
--- a/keyserver/src/responders/redux-state-responders.js
+++ b/keyserver/src/responders/redux-state-responders.js
@@ -1,376 +1,376 @@
 // @flow
 
 import _keyBy from 'lodash/fp/keyBy.js';
 import t, { type TInterface } from 'tcomb';
 
 import { baseLegalPolicies } from 'lib/facts/policies.js';
-import { mixedRawThreadInfoValidator } from 'lib/permissions/minimally-encoded-thread-permissions-validators.js';
+import { mixedRawThreadInfoValidator } from 'lib/permissions/minimally-encoded-raw-thread-info-validators.js';
 import { daysToEntriesFromEntryInfos } from 'lib/reducers/entry-reducer.js';
 import { freshMessageStore } from 'lib/reducers/message-reducer.js';
 import { mostRecentlyReadThread } from 'lib/selectors/thread-selectors.js';
 import { mostRecentMessageTimestamp } from 'lib/shared/message-utils.js';
 import {
   threadHasPermission,
   threadIsPending,
   parsePendingThreadID,
   createPendingThread,
 } from 'lib/shared/thread-utils.js';
 import { canUseDatabaseOnWeb } from 'lib/shared/web-database.js';
 import { entryStoreValidator } from 'lib/types/entry-types.js';
 import { defaultCalendarFilters } from 'lib/types/filter-types.js';
 import {
   inviteLinksStoreValidator,
   type CommunityLinks,
 } from 'lib/types/link-types.js';
 import {
   defaultNumberPerThread,
   messageStoreValidator,
   type MessageStore,
 } from 'lib/types/message-types.js';
 import { webNavInfoValidator } from 'lib/types/nav-types.js';
 import type {
   WebInitialKeyserverInfo,
   ServerWebInitialReduxStateResponse,
 } from 'lib/types/redux-types.js';
 import { threadPermissions } from 'lib/types/thread-permission-types.js';
 import { threadTypes } from 'lib/types/thread-types-enum.js';
 import { type ThreadStore } from 'lib/types/thread-types.js';
 import {
   currentUserInfoValidator,
   userInfosValidator,
   type GlobalAccountUserInfo,
 } from 'lib/types/user-types.js';
 import { currentDateInTimeZone } from 'lib/utils/date-utils.js';
 import { ServerError } from 'lib/utils/errors.js';
 import { promiseAll } from 'lib/utils/promises.js';
 import { urlInfoValidator } from 'lib/utils/url-utils.js';
 import { tShape, ashoatKeyserverID, tID } from 'lib/utils/validation-utils.js';
 import type {
   InitialReduxStateRequest,
   ExcludedData,
 } from 'web/types/redux-types.js';
 import { navInfoFromURL } from 'web/url-utils.js';
 
 import { fetchEntryInfos } from '../fetchers/entry-fetchers.js';
 import { fetchPrimaryInviteLinks } from '../fetchers/link-fetchers.js';
 import { fetchMessageInfos } from '../fetchers/message-fetchers.js';
 import { hasAnyNotAcknowledgedPolicies } from '../fetchers/policy-acknowledgment-fetchers.js';
 import { fetchThreadInfos } from '../fetchers/thread-fetchers.js';
 import {
   fetchCurrentUserInfo,
   fetchKnownUserInfos,
   fetchUserInfos,
 } from '../fetchers/user-fetchers.js';
 import { getWebPushConfig } from '../push/providers.js';
 import { setNewSession } from '../session/cookies.js';
 import { Viewer } from '../session/viewer.js';
 
 const excludedDataValidator: TInterface<ExcludedData> = tShape<ExcludedData>({
   threadStore: t.maybe(t.Bool),
 });
 
 export const initialReduxStateRequestValidator: TInterface<InitialReduxStateRequest> =
   tShape<InitialReduxStateRequest>({
     urlInfo: urlInfoValidator,
     excludedData: excludedDataValidator,
     clientUpdatesCurrentAsOf: t.Number,
   });
 
 const initialKeyserverInfoValidator = tShape<WebInitialKeyserverInfo>({
   sessionID: t.maybe(t.String),
   updatesCurrentAsOf: t.Number,
 });
 
 export const threadStoreValidator: TInterface<ThreadStore> =
   tShape<ThreadStore>({
     threadInfos: t.dict(tID, mixedRawThreadInfoValidator),
   });
 
 export const initialReduxStateValidator: TInterface<ServerWebInitialReduxStateResponse> =
   tShape<ServerWebInitialReduxStateResponse>({
     navInfo: webNavInfoValidator,
     currentUserInfo: currentUserInfoValidator,
     entryStore: entryStoreValidator,
     threadStore: threadStoreValidator,
     userInfos: userInfosValidator,
     messageStore: messageStoreValidator,
     pushApiPublicKey: t.maybe(t.String),
     commServicesAccessToken: t.Nil,
     inviteLinksStore: inviteLinksStoreValidator,
     keyserverInfo: initialKeyserverInfoValidator,
   });
 
 async function getInitialReduxStateResponder(
   viewer: Viewer,
   request: InitialReduxStateRequest,
 ): Promise<ServerWebInitialReduxStateResponse> {
   const { urlInfo, excludedData, clientUpdatesCurrentAsOf } = request;
   const useDatabase = viewer.loggedIn && canUseDatabaseOnWeb(viewer.userID);
 
   const hasNotAcknowledgedPoliciesPromise = hasAnyNotAcknowledgedPolicies(
     viewer.id,
     baseLegalPolicies,
   );
 
   const initialNavInfoPromise = (async () => {
     try {
       let backupInfo = {
         now: currentDateInTimeZone(viewer.timeZone),
       };
       // Some user ids in selectedUserList might not exist in the userInfos
       // (e.g. they were included in the results of the user search endpoint)
       // Because of that we keep their userInfos inside the navInfo.
       if (urlInfo.selectedUserList) {
         const fetchedUserInfos = await fetchUserInfos(urlInfo.selectedUserList);
         const userInfos: { [string]: GlobalAccountUserInfo } = {};
         for (const userID in fetchedUserInfos) {
           const userInfo = fetchedUserInfos[userID];
           if (userInfo.username) {
             userInfos[userID] = {
               ...userInfo,
               username: userInfo.username,
             };
           }
         }
         backupInfo = { userInfos, ...backupInfo };
       }
       return navInfoFromURL(urlInfo, backupInfo);
     } catch (e) {
       throw new ServerError(e.message);
     }
   })();
 
   const calendarQueryPromise = (async () => {
     const initialNavInfo = await initialNavInfoPromise;
     return {
       startDate: initialNavInfo.startDate,
       endDate: initialNavInfo.endDate,
       filters: defaultCalendarFilters,
     };
   })();
   const messageSelectionCriteria = { joinedThreads: true };
   const serverUpdatesCurrentAsOf =
     useDatabase && clientUpdatesCurrentAsOf
       ? clientUpdatesCurrentAsOf
       : Date.now();
 
   const threadInfoPromise = fetchThreadInfos(viewer);
   const messageInfoPromise = fetchMessageInfos(
     viewer,
     messageSelectionCriteria,
     defaultNumberPerThread,
   );
   const entryInfoPromise = (async () => {
     const calendarQuery = await calendarQueryPromise;
     return await fetchEntryInfos(viewer, [calendarQuery]);
   })();
   const currentUserInfoPromise = fetchCurrentUserInfo(viewer);
   const userInfoPromise = fetchKnownUserInfos(viewer);
 
   const sessionIDPromise = (async () => {
     const calendarQuery = await calendarQueryPromise;
     if (viewer.loggedIn) {
       await setNewSession(viewer, calendarQuery, serverUpdatesCurrentAsOf);
     }
     return viewer.sessionID;
   })();
 
   const threadStorePromise = (async () => {
     if (excludedData.threadStore && useDatabase) {
       return { threadInfos: {} };
     }
     const [{ threadInfos }, hasNotAcknowledgedPolicies] = await Promise.all([
       threadInfoPromise,
       hasNotAcknowledgedPoliciesPromise,
     ]);
     return { threadInfos: hasNotAcknowledgedPolicies ? {} : threadInfos };
   })();
   const messageStorePromise: Promise<MessageStore> = (async () => {
     const [
       { threadInfos },
       { rawMessageInfos, truncationStatuses },
       hasNotAcknowledgedPolicies,
     ] = await Promise.all([
       threadInfoPromise,
       messageInfoPromise,
       hasNotAcknowledgedPoliciesPromise,
     ]);
     if (hasNotAcknowledgedPolicies) {
       return {
         messages: {},
         threads: {},
         local: {},
         currentAsOf: { [ashoatKeyserverID]: 0 },
       };
     }
     const { messageStore: freshStore } = freshMessageStore(
       rawMessageInfos,
       truncationStatuses,
       {
         [ashoatKeyserverID]: mostRecentMessageTimestamp(
           rawMessageInfos,
           serverUpdatesCurrentAsOf,
         ),
       },
       threadInfos,
     );
     return freshStore;
   })();
   const entryStorePromise = (async () => {
     const [{ rawEntryInfos }, hasNotAcknowledgedPolicies] = await Promise.all([
       entryInfoPromise,
       hasNotAcknowledgedPoliciesPromise,
     ]);
     if (hasNotAcknowledgedPolicies) {
       return {
         entryInfos: {},
         daysToEntries: {},
         lastUserInteractionCalendar: 0,
       };
     }
     return {
       entryInfos: _keyBy('id')(rawEntryInfos),
       daysToEntries: daysToEntriesFromEntryInfos(rawEntryInfos),
       lastUserInteractionCalendar: serverUpdatesCurrentAsOf,
     };
   })();
   const userInfosPromise = (async () => {
     const [userInfos, hasNotAcknowledgedPolicies] = await Promise.all([
       userInfoPromise,
       hasNotAcknowledgedPoliciesPromise,
     ]);
     return hasNotAcknowledgedPolicies ? {} : userInfos;
   })();
 
   const navInfoPromise = (async () => {
     const [
       { threadInfos },
       messageStore,
       currentUserInfo,
       userInfos,
       finalNavInfo,
     ] = await Promise.all([
       threadInfoPromise,
       messageStorePromise,
       currentUserInfoPromise,
       userInfosPromise,
       initialNavInfoPromise,
     ]);
 
     const requestedActiveChatThreadID = finalNavInfo.activeChatThreadID;
     if (
       requestedActiveChatThreadID &&
       !threadIsPending(requestedActiveChatThreadID) &&
       !threadHasPermission(
         threadInfos[requestedActiveChatThreadID],
         threadPermissions.VISIBLE,
       )
     ) {
       finalNavInfo.activeChatThreadID = null;
     }
 
     if (!finalNavInfo.activeChatThreadID) {
       const mostRecentThread = mostRecentlyReadThread(
         messageStore,
         threadInfos,
       );
       if (mostRecentThread) {
         finalNavInfo.activeChatThreadID = mostRecentThread;
       }
     }
 
     const curActiveChatThreadID = finalNavInfo.activeChatThreadID;
     if (
       curActiveChatThreadID &&
       threadIsPending(curActiveChatThreadID) &&
       finalNavInfo.pendingThread?.id !== curActiveChatThreadID
     ) {
       const pendingThreadData = parsePendingThreadID(curActiveChatThreadID);
       if (
         pendingThreadData &&
         pendingThreadData.threadType !== threadTypes.SIDEBAR &&
         currentUserInfo.id
       ) {
         const members = [...pendingThreadData.memberIDs, currentUserInfo.id]
           .map(id => {
             const userInfo = userInfos[id];
             if (!userInfo || !userInfo.username) {
               return undefined;
             }
             const { username } = userInfo;
             return { id, username };
           })
           .filter(Boolean);
         const newPendingThread = createPendingThread({
           viewerID: currentUserInfo.id,
           threadType: pendingThreadData.threadType,
           members,
         });
         finalNavInfo.activeChatThreadID = newPendingThread.id;
         finalNavInfo.pendingThread = newPendingThread;
       }
     }
 
     return finalNavInfo;
   })();
   const currentAsOfPromise = (async () => {
     const hasNotAcknowledgedPolicies = await hasNotAcknowledgedPoliciesPromise;
     return hasNotAcknowledgedPolicies ? 0 : serverUpdatesCurrentAsOf;
   })();
 
   const pushApiPublicKeyPromise: Promise<?string> = (async () => {
     const pushConfig = await getWebPushConfig();
     if (!pushConfig) {
       if (process.env.NODE_ENV !== 'development') {
         console.warn('keyserver/secrets/web_push_config.json should exist');
       }
       return null;
     }
     return pushConfig.publicKey;
   })();
 
   const inviteLinksStorePromise = (async () => {
     const primaryInviteLinks = await fetchPrimaryInviteLinks(viewer);
     const links: { [string]: CommunityLinks } = {};
     for (const link of primaryInviteLinks) {
       if (link.primary) {
         links[link.communityID] = {
           primaryLink: link,
         };
       }
     }
     return {
       links,
     };
   })();
 
   const keyserverInfoPromise = (async () => {
     const { sessionID, updatesCurrentAsOf } = await promiseAll({
       sessionID: sessionIDPromise,
       updatesCurrentAsOf: currentAsOfPromise,
     });
 
     return {
       sessionID,
       updatesCurrentAsOf,
     };
   })();
 
   const initialReduxState: ServerWebInitialReduxStateResponse =
     await promiseAll({
       navInfo: navInfoPromise,
       currentUserInfo: currentUserInfoPromise,
       entryStore: entryStorePromise,
       threadStore: threadStorePromise,
       userInfos: userInfosPromise,
       messageStore: messageStorePromise,
       pushApiPublicKey: pushApiPublicKeyPromise,
       commServicesAccessToken: null,
       inviteLinksStore: inviteLinksStorePromise,
       keyserverInfo: keyserverInfoPromise,
     });
 
   return initialReduxState;
 }
 
 export { getInitialReduxStateResponder };
diff --git a/keyserver/src/responders/thread-responders.js b/keyserver/src/responders/thread-responders.js
index 467905d04..1871069e3 100644
--- a/keyserver/src/responders/thread-responders.js
+++ b/keyserver/src/responders/thread-responders.js
@@ -1,339 +1,339 @@
 // @flow
 
 import t from 'tcomb';
 import type { TInterface, TUnion } from 'tcomb';
 
-import { mixedRawThreadInfoValidator } from 'lib/permissions/minimally-encoded-thread-permissions-validators.js';
+import { mixedRawThreadInfoValidator } from 'lib/permissions/minimally-encoded-raw-thread-info-validators.js';
 import { mediaValidator } from 'lib/types/media-types.js';
 import {
   rawMessageInfoValidator,
   messageTruncationStatusesValidator,
 } from 'lib/types/message-types.js';
 import { userSurfacedPermissionValidator } from 'lib/types/thread-permission-types.js';
 import { threadTypes } from 'lib/types/thread-types-enum.js';
 import {
   type ThreadDeletionRequest,
   type RoleChangeRequest,
   type ChangeThreadSettingsResult,
   type RemoveMembersRequest,
   type LeaveThreadRequest,
   type LeaveThreadResult,
   type UpdateThreadRequest,
   type ServerNewThreadRequest,
   type NewThreadResponse,
   type ServerThreadJoinRequest,
   type ThreadJoinResult,
   type ThreadFetchMediaResult,
   type ThreadFetchMediaRequest,
   type ToggleMessagePinRequest,
   type ToggleMessagePinResult,
   type RoleModificationRequest,
   type RoleModificationResult,
   type RoleDeletionRequest,
   type RoleDeletionResult,
 } from 'lib/types/thread-types.js';
 import { serverUpdateInfoValidator } from 'lib/types/update-types.js';
 import { userInfosValidator } from 'lib/types/user-types.js';
 import { updateUserAvatarRequestValidator } from 'lib/utils/avatar-utils.js';
 import { values } from 'lib/utils/objects.js';
 import {
   tShape,
   tNumEnum,
   tColor,
   tPassword,
   tID,
 } from 'lib/utils/validation-utils.js';
 
 import {
   entryQueryInputValidator,
   verifyCalendarQueryThreadIDs,
 } from './entry-responders.js';
 import { modifyRole } from '../creators/role-creator.js';
 import { createThread } from '../creators/thread-creator.js';
 import { deleteRole } from '../deleters/role-deleters.js';
 import { deleteThread } from '../deleters/thread-deleters.js';
 import { fetchMediaForThread } from '../fetchers/upload-fetchers.js';
 import type { Viewer } from '../session/viewer.js';
 import {
   updateRole,
   removeMembers,
   leaveThread,
   updateThread,
   joinThread,
   toggleMessagePinForThread,
 } from '../updaters/thread-updaters.js';
 
 export const threadDeletionRequestInputValidator: TInterface<ThreadDeletionRequest> =
   tShape<ThreadDeletionRequest>({
     threadID: tID,
     accountPassword: t.maybe(tPassword),
   });
 
 export const leaveThreadResultValidator: TInterface<LeaveThreadResult> =
   tShape<LeaveThreadResult>({
     updatesResult: tShape({
       newUpdates: t.list(serverUpdateInfoValidator),
     }),
   });
 
 async function threadDeletionResponder(
   viewer: Viewer,
   request: ThreadDeletionRequest,
 ): Promise<LeaveThreadResult> {
   return await deleteThread(viewer, request);
 }
 
 export const roleChangeRequestInputValidator: TInterface<RoleChangeRequest> =
   tShape<RoleChangeRequest>({
     threadID: tID,
     memberIDs: t.list(t.String),
     role: t.refinement(tID, str => {
       if (str.indexOf('|') !== -1) {
         str = str.split('|')[1];
       }
       const int = parseInt(str, 10);
       return String(int) === str && int > 0;
     }),
   });
 
 export const changeThreadSettingsResultValidator: TInterface<ChangeThreadSettingsResult> =
   tShape<ChangeThreadSettingsResult>({
     newMessageInfos: t.list(rawMessageInfoValidator),
     updatesResult: tShape({
       newUpdates: t.list(serverUpdateInfoValidator),
     }),
   });
 
 async function roleUpdateResponder(
   viewer: Viewer,
   request: RoleChangeRequest,
 ): Promise<ChangeThreadSettingsResult> {
   return await updateRole(viewer, request);
 }
 
 export const removeMembersRequestInputValidator: TInterface<RemoveMembersRequest> =
   tShape<RemoveMembersRequest>({
     threadID: tID,
     memberIDs: t.list(t.String),
   });
 
 async function memberRemovalResponder(
   viewer: Viewer,
   request: RemoveMembersRequest,
 ): Promise<ChangeThreadSettingsResult> {
   return await removeMembers(viewer, request);
 }
 
 export const leaveThreadRequestInputValidator: TInterface<LeaveThreadRequest> =
   tShape<LeaveThreadRequest>({
     threadID: tID,
   });
 
 async function threadLeaveResponder(
   viewer: Viewer,
   request: LeaveThreadRequest,
 ): Promise<LeaveThreadResult> {
   return await leaveThread(viewer, request);
 }
 
 export const updateThreadRequestInputValidator: TInterface<UpdateThreadRequest> =
   tShape<UpdateThreadRequest>({
     threadID: tID,
     changes: tShape({
       type: t.maybe(tNumEnum(values(threadTypes))),
       name: t.maybe(t.String),
       description: t.maybe(t.String),
       color: t.maybe(tColor),
       parentThreadID: t.maybe(tID),
       newMemberIDs: t.maybe(t.list(t.String)),
       avatar: t.maybe(updateUserAvatarRequestValidator),
     }),
     accountPassword: t.maybe(tPassword),
   });
 
 async function threadUpdateResponder(
   viewer: Viewer,
   request: UpdateThreadRequest,
 ): Promise<ChangeThreadSettingsResult> {
   return await updateThread(viewer, request);
 }
 
 const threadRequestValidationShape = {
   name: t.maybe(t.String),
   description: t.maybe(t.String),
   color: t.maybe(tColor),
   parentThreadID: t.maybe(tID),
   initialMemberIDs: t.maybe(t.list(t.String)),
   calendarQuery: t.maybe(entryQueryInputValidator),
 };
 const newThreadRequestInputValidator: TUnion<ServerNewThreadRequest> = t.union([
   tShape({
     type: tNumEnum([threadTypes.SIDEBAR]),
     sourceMessageID: tID,
     ...threadRequestValidationShape,
   }),
   tShape({
     type: tNumEnum([
       threadTypes.COMMUNITY_OPEN_SUBTHREAD,
       threadTypes.COMMUNITY_SECRET_SUBTHREAD,
       threadTypes.PERSONAL,
       threadTypes.LOCAL,
       threadTypes.COMMUNITY_ROOT,
       threadTypes.COMMUNITY_ANNOUNCEMENT_ROOT,
       threadTypes.COMMUNITY_OPEN_ANNOUNCEMENT_SUBTHREAD,
       threadTypes.COMMUNITY_SECRET_ANNOUNCEMENT_SUBTHREAD,
     ]),
     ...threadRequestValidationShape,
   }),
 ]);
 
 export const newThreadResponseValidator: TInterface<NewThreadResponse> =
   tShape<NewThreadResponse>({
     updatesResult: tShape({
       newUpdates: t.list(serverUpdateInfoValidator),
     }),
     newMessageInfos: t.list(rawMessageInfoValidator),
     userInfos: userInfosValidator,
     newThreadID: tID,
   });
 
 async function threadCreationResponder(
   viewer: Viewer,
   request: ServerNewThreadRequest,
 ): Promise<NewThreadResponse> {
   return await createThread(viewer, request, {
     silentlyFailMembers: request.type === threadTypes.SIDEBAR,
   });
 }
 
 export const joinThreadRequestInputValidator: TInterface<ServerThreadJoinRequest> =
   tShape<ServerThreadJoinRequest>({
     threadID: tID,
     calendarQuery: t.maybe(entryQueryInputValidator),
     inviteLinkSecret: t.maybe(t.String),
   });
 
 export const threadJoinResultValidator: TInterface<ThreadJoinResult> =
   tShape<ThreadJoinResult>({
     updatesResult: tShape({
       newUpdates: t.list(serverUpdateInfoValidator),
     }),
     rawMessageInfos: t.list(rawMessageInfoValidator),
     truncationStatuses: messageTruncationStatusesValidator,
     userInfos: userInfosValidator,
   });
 
 async function threadJoinResponder(
   viewer: Viewer,
   request: ServerThreadJoinRequest,
 ): Promise<ThreadJoinResult> {
   if (request.calendarQuery) {
     await verifyCalendarQueryThreadIDs(request.calendarQuery);
   }
 
   return await joinThread(viewer, request);
 }
 
 export const threadFetchMediaRequestInputValidator: TInterface<ThreadFetchMediaRequest> =
   tShape<ThreadFetchMediaRequest>({
     threadID: tID,
     limit: t.Number,
     offset: t.Number,
   });
 
 export const threadFetchMediaResultValidator: TInterface<ThreadFetchMediaResult> =
   tShape<ThreadFetchMediaResult>({ media: t.list(mediaValidator) });
 
 async function threadFetchMediaResponder(
   viewer: Viewer,
   request: ThreadFetchMediaRequest,
 ): Promise<ThreadFetchMediaResult> {
   return await fetchMediaForThread(viewer, request);
 }
 
 export const toggleMessagePinRequestInputValidator: TInterface<ToggleMessagePinRequest> =
   tShape<ToggleMessagePinRequest>({
     messageID: tID,
     action: t.enums.of(['pin', 'unpin']),
   });
 
 export const toggleMessagePinResultValidator: TInterface<ToggleMessagePinResult> =
   tShape<ToggleMessagePinResult>({
     newMessageInfos: t.list(rawMessageInfoValidator),
     threadID: tID,
   });
 
 async function toggleMessagePinResponder(
   viewer: Viewer,
   request: ToggleMessagePinRequest,
 ): Promise<ToggleMessagePinResult> {
   return await toggleMessagePinForThread(viewer, request);
 }
 
 export const roleModificationRequestInputValidator: TUnion<RoleModificationRequest> =
   t.union([
     tShape({
       community: tID,
       name: t.String,
       permissions: t.list(userSurfacedPermissionValidator),
       action: t.enums.of(['create_role']),
     }),
     tShape({
       community: tID,
       existingRoleID: tID,
       name: t.String,
       permissions: t.list(userSurfacedPermissionValidator),
       action: t.enums.of(['edit_role']),
     }),
   ]);
 
 export const roleModificationResultValidator: TInterface<RoleModificationResult> =
   tShape<RoleModificationResult>({
     threadInfo: t.maybe(mixedRawThreadInfoValidator),
     updatesResult: tShape({
       newUpdates: t.list(serverUpdateInfoValidator),
     }),
   });
 
 async function roleModificationResponder(
   viewer: Viewer,
   request: RoleModificationRequest,
 ): Promise<RoleModificationResult> {
   return await modifyRole(viewer, request);
 }
 
 export const roleDeletionRequestInputValidator: TInterface<RoleDeletionRequest> =
   tShape<RoleDeletionRequest>({
     community: tID,
     roleID: tID,
   });
 
 export const roleDeletionResultValidator: TInterface<RoleDeletionResult> =
   tShape<RoleDeletionResult>({
     threadInfo: t.maybe(mixedRawThreadInfoValidator),
     updatesResult: tShape({
       newUpdates: t.list(serverUpdateInfoValidator),
     }),
   });
 
 async function roleDeletionResponder(
   viewer: Viewer,
   request: RoleDeletionRequest,
 ): Promise<RoleDeletionResult> {
   return await deleteRole(viewer, request);
 }
 
 export {
   threadDeletionResponder,
   roleUpdateResponder,
   memberRemovalResponder,
   threadLeaveResponder,
   threadUpdateResponder,
   threadCreationResponder,
   threadJoinResponder,
   threadFetchMediaResponder,
   newThreadRequestInputValidator,
   toggleMessagePinResponder,
   roleModificationResponder,
   roleDeletionResponder,
 };
diff --git a/keyserver/src/responders/user-responders.js b/keyserver/src/responders/user-responders.js
index c8cc0e22a..1ddcd846c 100644
--- a/keyserver/src/responders/user-responders.js
+++ b/keyserver/src/responders/user-responders.js
@@ -1,940 +1,940 @@
 // @flow
 
 import type { Utility as OlmUtility } from '@commapp/olm';
 import invariant from 'invariant';
 import { getRustAPI } from 'rust-node-addon';
 import { ErrorTypes, SiweMessage } from 'siwe';
 import t, { type TInterface, type TUnion, type TEnums } from 'tcomb';
 import bcrypt from 'twin-bcrypt';
 
 import {
   baseLegalPolicies,
   policies,
   policyTypeValidator,
 } from 'lib/facts/policies.js';
-import { mixedRawThreadInfoValidator } from 'lib/permissions/minimally-encoded-thread-permissions-validators.js';
+import { mixedRawThreadInfoValidator } from 'lib/permissions/minimally-encoded-raw-thread-info-validators.js';
 import { hasMinCodeVersion } from 'lib/shared/version-utils.js';
 import type {
   KeyserverAuthRequest,
   ResetPasswordRequest,
   LogOutResponse,
   RegisterResponse,
   RegisterRequest,
   ServerLogInResponse,
   LogInRequest,
   UpdatePasswordRequest,
   UpdateUserSettingsRequest,
   PolicyAcknowledgmentRequest,
   ClaimUsernameResponse,
 } from 'lib/types/account-types';
 import {
   userSettingsTypes,
   notificationTypeValues,
   logInActionSources,
 } from 'lib/types/account-types.js';
 import {
   type ClientAvatar,
   clientAvatarValidator,
   type UpdateUserAvatarResponse,
   type UpdateUserAvatarRequest,
 } from 'lib/types/avatar-types.js';
 import type {
   ReservedUsernameMessage,
   IdentityKeysBlob,
   SignedIdentityKeysBlob,
 } from 'lib/types/crypto-types.js';
 import type { DeviceType } from 'lib/types/device-types';
 import {
   type CalendarQuery,
   rawEntryInfoValidator,
   type FetchEntryInfosBase,
 } from 'lib/types/entry-types.js';
 import {
   defaultNumberPerThread,
   rawMessageInfoValidator,
   messageTruncationStatusesValidator,
 } from 'lib/types/message-types.js';
 import type {
   SIWEAuthRequest,
   SIWEMessage,
   SIWESocialProof,
 } from 'lib/types/siwe-types.js';
 import {
   type SubscriptionUpdateRequest,
   type SubscriptionUpdateResponse,
   threadSubscriptionValidator,
 } from 'lib/types/subscription-types.js';
 import { createUpdatesResultValidator } from 'lib/types/update-types.js';
 import {
   type PasswordUpdate,
   loggedOutUserInfoValidator,
   loggedInUserInfoValidator,
   userInfoValidator,
 } from 'lib/types/user-types.js';
 import {
   identityKeysBlobValidator,
   signedIdentityKeysBlobValidator,
 } from 'lib/utils/crypto-utils.js';
 import { ServerError } from 'lib/utils/errors.js';
 import { values } from 'lib/utils/objects.js';
 import {
   getPublicKeyFromSIWEStatement,
   isValidSIWEMessage,
   isValidSIWEStatementWithPublicKey,
   primaryIdentityPublicKeyRegex,
 } from 'lib/utils/siwe-utils.js';
 import {
   tShape,
   tPlatformDetails,
   tPassword,
   tEmail,
   tOldValidUsername,
   tRegex,
   tID,
 } from 'lib/utils/validation-utils.js';
 
 import {
   entryQueryInputValidator,
   newEntryQueryInputValidator,
   normalizeCalendarQuery,
   verifyCalendarQueryThreadIDs,
 } from './entry-responders.js';
 import {
   processOLMAccountCreation,
   createAccount,
   processSIWEAccountCreation,
 } from '../creators/account-creator.js';
 import {
   createOlmSession,
   persistFreshOlmSession,
   createAndPersistOlmSession,
 } from '../creators/olm-session-creator.js';
 import { dbQuery, SQL } from '../database/database.js';
 import { deleteAccount } from '../deleters/account-deleters.js';
 import { deleteCookie } from '../deleters/cookie-deleters.js';
 import { checkAndInvalidateSIWENonceEntry } from '../deleters/siwe-nonce-deleters.js';
 import { fetchEntryInfos } from '../fetchers/entry-fetchers.js';
 import { fetchMessageInfos } from '../fetchers/message-fetchers.js';
 import { fetchNotAcknowledgedPolicies } from '../fetchers/policy-acknowledgment-fetchers.js';
 import { fetchThreadInfos } from '../fetchers/thread-fetchers.js';
 import {
   fetchKnownUserInfos,
   fetchLoggedInUserInfo,
   fetchUserIDForEthereumAddress,
   fetchUsername,
 } from '../fetchers/user-fetchers.js';
 import {
   createNewAnonymousCookie,
   createNewUserCookie,
   setNewSession,
 } from '../session/cookies.js';
 import type { Viewer } from '../session/viewer.js';
 import {
   accountUpdater,
   checkAndSendVerificationEmail,
   checkAndSendPasswordResetEmail,
   updatePassword,
   updateUserSettings,
   updateUserAvatar,
 } from '../updaters/account-updaters.js';
 import { fetchOlmAccount } from '../updaters/olm-account-updater.js';
 import { userSubscriptionUpdater } from '../updaters/user-subscription-updaters.js';
 import { viewerAcknowledgmentUpdater } from '../updaters/viewer-acknowledgment-updater.js';
 import { verifyUserLoggedIn } from '../user/login.js';
 import { getOlmUtility, getContentSigningKey } from '../utils/olm-utils.js';
 
 export const subscriptionUpdateRequestInputValidator: TInterface<SubscriptionUpdateRequest> =
   tShape<SubscriptionUpdateRequest>({
     threadID: tID,
     updatedFields: tShape({
       pushNotifs: t.maybe(t.Boolean),
       home: t.maybe(t.Boolean),
     }),
   });
 
 export const subscriptionUpdateResponseValidator: TInterface<SubscriptionUpdateResponse> =
   tShape<SubscriptionUpdateResponse>({
     threadSubscription: threadSubscriptionValidator,
   });
 
 async function userSubscriptionUpdateResponder(
   viewer: Viewer,
   request: SubscriptionUpdateRequest,
 ): Promise<SubscriptionUpdateResponse> {
   const threadSubscription = await userSubscriptionUpdater(viewer, request);
   return {
     threadSubscription,
   };
 }
 
 export const accountUpdateInputValidator: TInterface<PasswordUpdate> =
   tShape<PasswordUpdate>({
     updatedFields: tShape({
       email: t.maybe(tEmail),
       password: t.maybe(tPassword),
     }),
     currentPassword: tPassword,
   });
 
 async function passwordUpdateResponder(
   viewer: Viewer,
   request: PasswordUpdate,
 ): Promise<void> {
   await accountUpdater(viewer, request);
 }
 
 async function sendVerificationEmailResponder(viewer: Viewer): Promise<void> {
   await checkAndSendVerificationEmail(viewer);
 }
 
 export const resetPasswordRequestInputValidator: TInterface<ResetPasswordRequest> =
   tShape<ResetPasswordRequest>({
     usernameOrEmail: t.union([tEmail, tOldValidUsername]),
   });
 
 async function sendPasswordResetEmailResponder(
   viewer: Viewer,
   request: ResetPasswordRequest,
 ): Promise<void> {
   await checkAndSendPasswordResetEmail(request);
 }
 
 export const logOutResponseValidator: TInterface<LogOutResponse> =
   tShape<LogOutResponse>({
     currentUserInfo: loggedOutUserInfoValidator,
   });
 
 async function logOutResponder(viewer: Viewer): Promise<LogOutResponse> {
   if (viewer.loggedIn) {
     const [anonymousViewerData] = await Promise.all([
       createNewAnonymousCookie({
         platformDetails: viewer.platformDetails,
         deviceToken: viewer.deviceToken,
       }),
       deleteCookie(viewer.cookieID),
     ]);
     viewer.setNewCookie(anonymousViewerData);
   }
   return {
     currentUserInfo: {
       anonymous: true,
     },
   };
 }
 
 async function accountDeletionResponder(
   viewer: Viewer,
 ): Promise<LogOutResponse> {
   const result = await deleteAccount(viewer);
   invariant(result, 'deleteAccount should return result if handed request');
   return result;
 }
 
 type OldDeviceTokenUpdateRequest = {
   +deviceType?: ?DeviceType,
   +deviceToken: string,
 };
 const deviceTokenUpdateRequestInputValidator =
   tShape<OldDeviceTokenUpdateRequest>({
     deviceType: t.maybe(t.enums.of(['ios', 'android'])),
     deviceToken: t.String,
   });
 
 export const registerRequestInputValidator: TInterface<RegisterRequest> =
   tShape<RegisterRequest>({
     username: t.String,
     email: t.maybe(tEmail),
     password: tPassword,
     calendarQuery: t.maybe(newEntryQueryInputValidator),
     deviceTokenUpdateRequest: t.maybe(deviceTokenUpdateRequestInputValidator),
     platformDetails: tPlatformDetails,
     // We include `primaryIdentityPublicKey` to avoid breaking
     // old clients, but we no longer do anything with it.
     primaryIdentityPublicKey: t.maybe(tRegex(primaryIdentityPublicKeyRegex)),
     signedIdentityKeysBlob: t.maybe(signedIdentityKeysBlobValidator),
     initialNotificationsEncryptedMessage: t.maybe(t.String),
   });
 
 export const registerResponseValidator: TInterface<RegisterResponse> =
   tShape<RegisterResponse>({
     id: t.String,
     rawMessageInfos: t.list(rawMessageInfoValidator),
     currentUserInfo: loggedInUserInfoValidator,
     cookieChange: tShape({
       threadInfos: t.dict(tID, mixedRawThreadInfoValidator),
       userInfos: t.list(userInfoValidator),
     }),
   });
 
 async function accountCreationResponder(
   viewer: Viewer,
   request: RegisterRequest,
 ): Promise<RegisterResponse> {
   const { signedIdentityKeysBlob } = request;
   if (signedIdentityKeysBlob) {
     const identityKeys: IdentityKeysBlob = JSON.parse(
       signedIdentityKeysBlob.payload,
     );
     if (!identityKeysBlobValidator.is(identityKeys)) {
       throw new ServerError('invalid_identity_keys_blob');
     }
 
     const olmUtil: OlmUtility = getOlmUtility();
     try {
       olmUtil.ed25519_verify(
         identityKeys.primaryIdentityPublicKeys.ed25519,
         signedIdentityKeysBlob.payload,
         signedIdentityKeysBlob.signature,
       );
     } catch (e) {
       throw new ServerError('invalid_signature');
     }
   }
   return await createAccount(viewer, request);
 }
 
 type ProcessSuccessfulLoginParams = {
   +viewer: Viewer,
   +input: any,
   +userID: string,
   +calendarQuery: ?CalendarQuery,
   +socialProof?: ?SIWESocialProof,
   +signedIdentityKeysBlob?: ?SignedIdentityKeysBlob,
   +initialNotificationsEncryptedMessage?: string,
   +pickledContentOlmSession?: string,
   +cookieHasBeenSet?: boolean,
 };
 
 async function processSuccessfulLogin(
   params: ProcessSuccessfulLoginParams,
 ): Promise<ServerLogInResponse> {
   const {
     viewer,
     input,
     userID,
     calendarQuery,
     socialProof,
     signedIdentityKeysBlob,
     initialNotificationsEncryptedMessage,
     pickledContentOlmSession,
     cookieHasBeenSet,
   } = params;
 
   const request: LogInRequest = input;
   const newServerTime = Date.now();
   const deviceToken = request.deviceTokenUpdateRequest
     ? request.deviceTokenUpdateRequest.deviceToken
     : viewer.deviceToken;
   const setNewCookiePromise = (async () => {
     if (cookieHasBeenSet) {
       return;
     }
     const [userViewerData] = await Promise.all([
       createNewUserCookie(userID, {
         platformDetails: request.platformDetails,
         deviceToken,
         socialProof,
         signedIdentityKeysBlob,
       }),
       deleteCookie(viewer.cookieID),
     ]);
     viewer.setNewCookie(userViewerData);
   })();
   const [notAcknowledgedPolicies] = await Promise.all([
     fetchNotAcknowledgedPolicies(userID, baseLegalPolicies),
     setNewCookiePromise,
   ]);
 
   if (
     notAcknowledgedPolicies.length &&
     hasMinCodeVersion(viewer.platformDetails, { native: 181 })
   ) {
     const currentUserInfo = await fetchLoggedInUserInfo(viewer);
     return {
       notAcknowledgedPolicies,
       currentUserInfo: currentUserInfo,
       rawMessageInfos: [],
       truncationStatuses: {},
       userInfos: [],
       rawEntryInfos: [],
       serverTime: 0,
       cookieChange: {
         threadInfos: {},
         userInfos: [],
       },
     };
   }
 
   if (calendarQuery) {
     await setNewSession(viewer, calendarQuery, newServerTime);
   }
   const olmNotifSessionPromise = (async () => {
     if (
       viewer.cookieID &&
       initialNotificationsEncryptedMessage &&
       signedIdentityKeysBlob
     ) {
       await createAndPersistOlmSession(
         initialNotificationsEncryptedMessage,
         'notifications',
         viewer.cookieID,
       );
     }
   })();
   // `pickledContentOlmSession` is created in `keyserverAuthResponder(...)` in
   // order to authenticate the user. Here, we simply persist the session if it
   // exists.
   const olmContentSessionPromise = (async () => {
     if (viewer.cookieID && pickledContentOlmSession) {
       await persistFreshOlmSession(
         pickledContentOlmSession,
         'content',
         viewer.cookieID,
       );
     }
   })();
 
   const threadCursors: { [string]: null } = {};
   for (const watchedThreadID of request.watchedIDs) {
     threadCursors[watchedThreadID] = null;
   }
   const messageSelectionCriteria = { threadCursors, joinedThreads: true };
 
   const entriesPromise: Promise<?FetchEntryInfosBase> = (async () => {
     if (!calendarQuery) {
       return undefined;
     }
     return await fetchEntryInfos(viewer, [calendarQuery]);
   })();
 
   const [
     threadsResult,
     messagesResult,
     entriesResult,
     userInfos,
     currentUserInfo,
   ] = await Promise.all([
     fetchThreadInfos(viewer),
     fetchMessageInfos(viewer, messageSelectionCriteria, defaultNumberPerThread),
     entriesPromise,
     fetchKnownUserInfos(viewer),
     fetchLoggedInUserInfo(viewer),
     olmNotifSessionPromise,
     olmContentSessionPromise,
   ]);
 
   const rawEntryInfos = entriesResult ? entriesResult.rawEntryInfos : null;
   const response: ServerLogInResponse = {
     currentUserInfo,
     rawMessageInfos: messagesResult.rawMessageInfos,
     truncationStatuses: messagesResult.truncationStatuses,
     serverTime: newServerTime,
     userInfos: values(userInfos),
     cookieChange: {
       threadInfos: threadsResult.threadInfos,
       userInfos: [],
     },
   };
   if (rawEntryInfos) {
     return {
       ...response,
       rawEntryInfos,
     };
   }
   return response;
 }
 
 export const logInRequestInputValidator: TInterface<LogInRequest> =
   tShape<LogInRequest>({
     username: t.maybe(t.String),
     usernameOrEmail: t.maybe(t.union([tEmail, tOldValidUsername])),
     password: tPassword,
     watchedIDs: t.list(tID),
     calendarQuery: t.maybe(entryQueryInputValidator),
     deviceTokenUpdateRequest: t.maybe(deviceTokenUpdateRequestInputValidator),
     platformDetails: tPlatformDetails,
     source: t.maybe(t.enums.of(values(logInActionSources))),
     // We include `primaryIdentityPublicKey` to avoid breaking
     // old clients, but we no longer do anything with it.
     primaryIdentityPublicKey: t.maybe(tRegex(primaryIdentityPublicKeyRegex)),
     signedIdentityKeysBlob: t.maybe(signedIdentityKeysBlobValidator),
     initialNotificationsEncryptedMessage: t.maybe(t.String),
   });
 
 export const logInResponseValidator: TInterface<ServerLogInResponse> =
   tShape<ServerLogInResponse>({
     currentUserInfo: loggedInUserInfoValidator,
     rawMessageInfos: t.list(rawMessageInfoValidator),
     truncationStatuses: messageTruncationStatusesValidator,
     userInfos: t.list(userInfoValidator),
     rawEntryInfos: t.maybe(t.list(rawEntryInfoValidator)),
     serverTime: t.Number,
     cookieChange: tShape({
       threadInfos: t.dict(tID, mixedRawThreadInfoValidator),
       userInfos: t.list(userInfoValidator),
     }),
     notAcknowledgedPolicies: t.maybe(t.list<TEnums>(policyTypeValidator)),
   });
 
 async function logInResponder(
   viewer: Viewer,
   request: LogInRequest,
 ): Promise<ServerLogInResponse> {
   let identityKeys: ?IdentityKeysBlob;
   const { signedIdentityKeysBlob, initialNotificationsEncryptedMessage } =
     request;
   if (signedIdentityKeysBlob) {
     identityKeys = JSON.parse(signedIdentityKeysBlob.payload);
 
     const olmUtil: OlmUtility = getOlmUtility();
     try {
       olmUtil.ed25519_verify(
         identityKeys.primaryIdentityPublicKeys.ed25519,
         signedIdentityKeysBlob.payload,
         signedIdentityKeysBlob.signature,
       );
     } catch (e) {
       throw new ServerError('invalid_signature');
     }
   }
 
   const calendarQuery = request.calendarQuery
     ? normalizeCalendarQuery(request.calendarQuery)
     : null;
   const verifyCalendarQueryThreadIDsPromise = (async () => {
     if (calendarQuery) {
       await verifyCalendarQueryThreadIDs(calendarQuery);
     }
   })();
 
   const username = request.username ?? request.usernameOrEmail;
   if (!username) {
     if (hasMinCodeVersion(viewer.platformDetails, { native: 150 })) {
       throw new ServerError('invalid_credentials');
     } else {
       throw new ServerError('invalid_parameters');
     }
   }
   const userQuery = SQL`
     SELECT id, hash, username
     FROM users
     WHERE LCASE(username) = LCASE(${username})
   `;
   const userQueryPromise = dbQuery(userQuery);
   const [[userResult]] = await Promise.all([
     userQueryPromise,
     verifyCalendarQueryThreadIDsPromise,
   ]);
 
   if (userResult.length === 0) {
     if (hasMinCodeVersion(viewer.platformDetails, { native: 150 })) {
       throw new ServerError('invalid_credentials');
     } else {
       throw new ServerError('invalid_parameters');
     }
   }
 
   const userRow = userResult[0];
 
   if (!userRow.hash || !bcrypt.compareSync(request.password, userRow.hash)) {
     throw new ServerError('invalid_credentials');
   }
 
   const id = userRow.id.toString();
 
   return await processSuccessfulLogin({
     viewer,
     input: request,
     userID: id,
     calendarQuery,
     signedIdentityKeysBlob,
     initialNotificationsEncryptedMessage,
   });
 }
 
 export const siweAuthRequestInputValidator: TInterface<SIWEAuthRequest> =
   tShape<SIWEAuthRequest>({
     signature: t.String,
     message: t.String,
     calendarQuery: entryQueryInputValidator,
     deviceTokenUpdateRequest: t.maybe(deviceTokenUpdateRequestInputValidator),
     platformDetails: tPlatformDetails,
     watchedIDs: t.list(tID),
     signedIdentityKeysBlob: t.maybe(signedIdentityKeysBlobValidator),
     initialNotificationsEncryptedMessage: t.maybe(t.String),
     doNotRegister: t.maybe(t.Boolean),
   });
 
 async function siweAuthResponder(
   viewer: Viewer,
   request: SIWEAuthRequest,
 ): Promise<ServerLogInResponse> {
   const {
     message,
     signature,
     deviceTokenUpdateRequest,
     platformDetails,
     signedIdentityKeysBlob,
     initialNotificationsEncryptedMessage,
     doNotRegister,
   } = request;
   const calendarQuery = normalizeCalendarQuery(request.calendarQuery);
 
   // 1. Ensure that `message` is a well formed Comm SIWE Auth message.
   const siweMessage: SIWEMessage = new SiweMessage(message);
   if (!isValidSIWEMessage(siweMessage)) {
     throw new ServerError('invalid_parameters');
   }
 
   // 2. Check if there's already a user for this ETH address.
   const existingUserID = await fetchUserIDForEthereumAddress(
     siweMessage.address,
   );
   if (!existingUserID && doNotRegister) {
     throw new ServerError('account_does_not_exist');
   }
 
   // 3. Ensure that the `nonce` exists in the `siwe_nonces` table
   //    AND hasn't expired. If those conditions are met, delete the entry to
   //    ensure that the same `nonce` can't be re-used in a future request.
   const wasNonceCheckedAndInvalidated = await checkAndInvalidateSIWENonceEntry(
     siweMessage.nonce,
   );
   if (!wasNonceCheckedAndInvalidated) {
     throw new ServerError('invalid_parameters');
   }
 
   // 4. Validate SIWEMessage signature and handle possible errors.
   try {
     await siweMessage.validate(signature);
   } catch (error) {
     if (error === ErrorTypes.EXPIRED_MESSAGE) {
       // Thrown when the `expirationTime` is present and in the past.
       throw new ServerError('expired_message');
     } else if (error === ErrorTypes.INVALID_SIGNATURE) {
       // Thrown when the `validate()` function can't verify the message.
       throw new ServerError('invalid_signature');
     } else if (error === ErrorTypes.MALFORMED_SESSION) {
       // Thrown when some required field is missing.
       throw new ServerError('malformed_session');
     } else {
       throw new ServerError('unknown_error');
     }
   }
 
   // 5. Pull `primaryIdentityPublicKey` out from SIWEMessage `statement`.
   //    We expect it to be included for BOTH native and web clients.
   const { statement } = siweMessage;
   const primaryIdentityPublicKey =
     statement && isValidSIWEStatementWithPublicKey(statement)
       ? getPublicKeyFromSIWEStatement(statement)
       : null;
   if (!primaryIdentityPublicKey) {
     throw new ServerError('invalid_siwe_statement_public_key');
   }
 
   // 6. Verify `signedIdentityKeysBlob.payload` with included `signature`
   //    if `signedIdentityKeysBlob` was included in the `SIWEAuthRequest`.
   let identityKeys: ?IdentityKeysBlob;
   if (signedIdentityKeysBlob) {
     identityKeys = JSON.parse(signedIdentityKeysBlob.payload);
     if (!identityKeysBlobValidator.is(identityKeys)) {
       throw new ServerError('invalid_identity_keys_blob');
     }
 
     const olmUtil: OlmUtility = getOlmUtility();
     try {
       olmUtil.ed25519_verify(
         identityKeys.primaryIdentityPublicKeys.ed25519,
         signedIdentityKeysBlob.payload,
         signedIdentityKeysBlob.signature,
       );
     } catch (e) {
       throw new ServerError('invalid_signature');
     }
   }
 
   // 7. Ensure that `primaryIdentityPublicKeys.ed25519` matches SIWE
   //    statement `primaryIdentityPublicKey` if `identityKeys` exists.
   if (
     identityKeys &&
     identityKeys.primaryIdentityPublicKeys.ed25519 !== primaryIdentityPublicKey
   ) {
     throw new ServerError('primary_public_key_mismatch');
   }
 
   // 8. Construct `SIWESocialProof` object with the stringified
   //    SIWEMessage and the corresponding signature.
   const socialProof: SIWESocialProof = {
     siweMessage: siweMessage.toMessage(),
     siweMessageSignature: signature,
   };
 
   // 9. Create account with call to `processSIWEAccountCreation(...)`
   //    if address does not correspond to an existing user.
   let userID = existingUserID;
   if (!userID) {
     const siweAccountCreationRequest = {
       address: siweMessage.address,
       calendarQuery,
       deviceTokenUpdateRequest,
       platformDetails,
       socialProof,
     };
     userID = await processSIWEAccountCreation(
       viewer,
       siweAccountCreationRequest,
     );
   }
 
   // 10. Complete login with call to `processSuccessfulLogin(...)`.
   return await processSuccessfulLogin({
     viewer,
     input: request,
     userID,
     calendarQuery,
     socialProof,
     signedIdentityKeysBlob,
     initialNotificationsEncryptedMessage,
   });
 }
 
 export const keyserverAuthRequestInputValidator: TInterface<KeyserverAuthRequest> =
   tShape<KeyserverAuthRequest>({
     userID: t.String,
     deviceID: t.String,
     calendarQuery: entryQueryInputValidator,
     deviceTokenUpdateRequest: t.maybe(deviceTokenUpdateRequestInputValidator),
     platformDetails: tPlatformDetails,
     watchedIDs: t.list(tID),
     initialContentEncryptedMessage: t.String,
     initialNotificationsEncryptedMessage: t.String,
     doNotRegister: t.Boolean,
     source: t.maybe(t.enums.of(values(logInActionSources))),
   });
 
 async function keyserverAuthResponder(
   viewer: Viewer,
   request: KeyserverAuthRequest,
 ): Promise<ServerLogInResponse> {
   const {
     userID,
     deviceID,
     deviceTokenUpdateRequest,
     platformDetails,
     initialContentEncryptedMessage,
     initialNotificationsEncryptedMessage,
     doNotRegister,
   } = request;
   const calendarQuery = normalizeCalendarQuery(request.calendarQuery);
 
   // 1. Check if there's already a user for this userID. Simultaneously, get
   //    info for identity service auth.
   const [existingUsername, authDeviceID, identityInfo, rustAPI] =
     await Promise.all([
       fetchUsername(userID),
       getContentSigningKey(),
       verifyUserLoggedIn(),
       getRustAPI(),
     ]);
   if (!existingUsername && doNotRegister) {
     throw new ServerError('account_does_not_exist');
   }
   if (!identityInfo) {
     throw new ServerError('account_not_registered_on_identity_service');
   }
 
   // 2. Get user's keys from identity service.
   let inboundKeysForUser;
   try {
     inboundKeysForUser = await rustAPI.getInboundKeysForUserDevice(
       identityInfo.userId,
       authDeviceID,
       identityInfo.accessToken,
       userID,
       deviceID,
     );
   } catch (e) {
     throw new ServerError('failed_to_retrieve_inbound_keys');
   }
 
   const username = inboundKeysForUser.username
     ? inboundKeysForUser.username
     : inboundKeysForUser.walletAddress;
 
   if (!username) {
     throw new ServerError('user_identifier_missing');
   }
 
   const identityKeys: IdentityKeysBlob = JSON.parse(inboundKeysForUser.payload);
   if (!identityKeysBlobValidator.is(identityKeys)) {
     throw new ServerError('invalid_identity_keys_blob');
   }
 
   // 3. Create content olm session. (The notif session is not required for auth
   //    and will be created later in `processSuccessfulLogin(...)`.)
   const pickledContentOlmSessionPromise = createOlmSession(
     initialContentEncryptedMessage,
     'content',
     identityKeys.primaryIdentityPublicKeys.curve25519,
   );
 
   // 4. Create account with call to `processOLMAccountCreation(...)`
   //    if username does not correspond to an existing user. If we successfully
   //    create a new account, we set `cookieHasBeenSet` to true to avoid
   //    creating a new cookie again in `processSuccessfulLogin`.
   const signedIdentityKeysBlob: SignedIdentityKeysBlob = {
     payload: inboundKeysForUser.payload,
     signature: inboundKeysForUser.payloadSignature,
   };
   const olmAccountCreationPromise = (async () => {
     if (existingUsername) {
       return;
     }
     const olmAccountCreationRequest = {
       userID,
       username: username,
       walletAddress: inboundKeysForUser.walletAddress,
       signedIdentityKeysBlob,
       calendarQuery,
       deviceTokenUpdateRequest,
       platformDetails,
     };
     await processOLMAccountCreation(viewer, olmAccountCreationRequest);
   })();
 
   const [pickledContentOlmSession] = await Promise.all([
     pickledContentOlmSessionPromise,
     olmAccountCreationPromise,
   ]);
 
   // 5. Complete login with call to `processSuccessfulLogin(...)`.
   return await processSuccessfulLogin({
     viewer,
     input: request,
     userID,
     calendarQuery,
     signedIdentityKeysBlob,
     initialNotificationsEncryptedMessage,
     pickledContentOlmSession,
     cookieHasBeenSet: !existingUsername,
   });
 }
 
 export const updatePasswordRequestInputValidator: TInterface<UpdatePasswordRequest> =
   tShape<UpdatePasswordRequest>({
     code: t.String,
     password: tPassword,
     watchedIDs: t.list(tID),
     calendarQuery: t.maybe(entryQueryInputValidator),
     deviceTokenUpdateRequest: t.maybe(deviceTokenUpdateRequestInputValidator),
     platformDetails: tPlatformDetails,
   });
 
 async function oldPasswordUpdateResponder(
   viewer: Viewer,
   request: UpdatePasswordRequest,
 ): Promise<ServerLogInResponse> {
   if (request.calendarQuery) {
     request.calendarQuery = normalizeCalendarQuery(request.calendarQuery);
   }
   return await updatePassword(viewer, request);
 }
 
 export const updateUserSettingsInputValidator: TInterface<UpdateUserSettingsRequest> =
   tShape<UpdateUserSettingsRequest>({
     name: t.irreducible(
       userSettingsTypes.DEFAULT_NOTIFICATIONS,
       x => x === userSettingsTypes.DEFAULT_NOTIFICATIONS,
     ),
     data: t.enums.of(notificationTypeValues),
   });
 
 async function updateUserSettingsResponder(
   viewer: Viewer,
   request: UpdateUserSettingsRequest,
 ): Promise<void> {
   await updateUserSettings(viewer, request);
 }
 
 export const policyAcknowledgmentRequestInputValidator: TInterface<PolicyAcknowledgmentRequest> =
   tShape<PolicyAcknowledgmentRequest>({
     policy: t.maybe(t.enums.of(policies)),
   });
 
 async function policyAcknowledgmentResponder(
   viewer: Viewer,
   request: PolicyAcknowledgmentRequest,
 ): Promise<void> {
   await viewerAcknowledgmentUpdater(viewer, request.policy);
 }
 
 export const updateUserAvatarResponseValidator: TInterface<UpdateUserAvatarResponse> =
   tShape<UpdateUserAvatarResponse>({
     updates: createUpdatesResultValidator,
   });
 
 export const updateUserAvatarResponderValidator: TUnion<
   ?ClientAvatar | UpdateUserAvatarResponse,
 > = t.union([
   t.maybe(clientAvatarValidator),
   updateUserAvatarResponseValidator,
 ]);
 
 async function updateUserAvatarResponder(
   viewer: Viewer,
   request: UpdateUserAvatarRequest,
 ): Promise<?ClientAvatar | UpdateUserAvatarResponse> {
   return await updateUserAvatar(viewer, request);
 }
 
 export const claimUsernameResponseValidator: TInterface<ClaimUsernameResponse> =
   tShape<ClaimUsernameResponse>({
     message: t.String,
     signature: t.String,
   });
 
 async function claimUsernameResponder(
   viewer: Viewer,
 ): Promise<ClaimUsernameResponse> {
   const [username, accountInfo] = await Promise.all([
     fetchUsername(viewer.userID),
     fetchOlmAccount('content'),
   ]);
 
   if (!username) {
     throw new ServerError('invalid_credentials');
   }
 
   const issuedAt = new Date().toISOString();
   const reservedUsernameMessage: ReservedUsernameMessage = {
     statement: 'This user is the owner of the following username and user ID',
     payload: {
       username,
       userID: viewer.userID,
     },
     issuedAt,
   };
   const message = JSON.stringify(reservedUsernameMessage);
   const signature = accountInfo.account.sign(message);
 
   return { message, signature };
 }
 
 export {
   userSubscriptionUpdateResponder,
   passwordUpdateResponder,
   sendVerificationEmailResponder,
   sendPasswordResetEmailResponder,
   logOutResponder,
   accountDeletionResponder,
   accountCreationResponder,
   logInResponder,
   siweAuthResponder,
   oldPasswordUpdateResponder,
   updateUserSettingsResponder,
   policyAcknowledgmentResponder,
   updateUserAvatarResponder,
   claimUsernameResponder,
   keyserverAuthResponder,
 };
diff --git a/keyserver/src/shared/state-sync/threads-state-sync-spec.js b/keyserver/src/shared/state-sync/threads-state-sync-spec.js
index 2db9bb3ee..1ee243059 100644
--- a/keyserver/src/shared/state-sync/threads-state-sync-spec.js
+++ b/keyserver/src/shared/state-sync/threads-state-sync-spec.js
@@ -1,50 +1,50 @@
 // @flow
 
-import { mixedRawThreadInfoValidator } from 'lib/permissions/minimally-encoded-thread-permissions-validators.js';
+import { mixedRawThreadInfoValidator } from 'lib/permissions/minimally-encoded-raw-thread-info-validators.js';
 import { threadsStateSyncSpec as libSpec } from 'lib/shared/state-sync/threads-state-sync-spec.js';
 import type { RawThreadInfo } from 'lib/types/minimally-encoded-thread-permissions-types.js';
 import type { ClientThreadInconsistencyReportCreationRequest } from 'lib/types/report-types.js';
 import {
   type MixedRawThreadInfos,
   type LegacyRawThreadInfo,
 } from 'lib/types/thread-types.js';
 import { hash, combineUnorderedHashes, values } from 'lib/utils/objects.js';
 
 import type { ServerStateSyncSpec } from './state-sync-spec.js';
 import { fetchThreadInfos } from '../../fetchers/thread-fetchers.js';
 import type { Viewer } from '../../session/viewer.js';
 import { validateOutput } from '../../utils/validation-utils.js';
 
 export const threadsStateSyncSpec: ServerStateSyncSpec<
   MixedRawThreadInfos,
   MixedRawThreadInfos,
   LegacyRawThreadInfo | RawThreadInfo,
   $ReadOnlyArray<ClientThreadInconsistencyReportCreationRequest>,
 > = Object.freeze({
   fetch,
   async fetchFullSocketSyncPayload(viewer: Viewer) {
     const result = await fetchThreadInfos(viewer);
     return result.threadInfos;
   },
   async fetchServerInfosHash(viewer: Viewer, ids?: $ReadOnlySet<string>) {
     const infos = await fetch(viewer, ids);
     return getServerInfosHash(infos);
   },
   getServerInfosHash,
   getServerInfoHash,
   ...libSpec,
 });
 
 async function fetch(viewer: Viewer, ids?: $ReadOnlySet<string>) {
   const filter = ids ? { threadIDs: ids } : undefined;
   const result = await fetchThreadInfos(viewer, filter);
   return result.threadInfos;
 }
 
 function getServerInfosHash(infos: MixedRawThreadInfos) {
   return combineUnorderedHashes(values(infos).map(getServerInfoHash));
 }
 
 function getServerInfoHash(info: LegacyRawThreadInfo | RawThreadInfo) {
   return hash(validateOutput(null, mixedRawThreadInfoValidator, info));
 }
diff --git a/lib/permissions/minimally-encoded-thread-permissions-validators.js b/lib/permissions/minimally-encoded-raw-thread-info-validators.js
similarity index 51%
copy from lib/permissions/minimally-encoded-thread-permissions-validators.js
copy to lib/permissions/minimally-encoded-raw-thread-info-validators.js
index ad7a49670..7d9361f39 100644
--- a/lib/permissions/minimally-encoded-thread-permissions-validators.js
+++ b/lib/permissions/minimally-encoded-raw-thread-info-validators.js
@@ -1,99 +1,64 @@
 // @flow
 
 import t, { type TInterface, type TUnion } from 'tcomb';
 
 import {
   tHexEncodedPermissionsBitmask,
   tHexEncodedRolePermission,
 } from './minimally-encoded-thread-permissions.js';
 import { specialRoleValidator } from './special-roles.js';
-import { clientAvatarValidator } from '../types/avatar-types.js';
 import type {
   MemberInfo,
   ThreadCurrentUserInfo,
   RawThreadInfo,
-  RelativeMemberInfo,
   RoleInfo,
-  ThreadInfo,
 } from '../types/minimally-encoded-thread-permissions-types.js';
-import { threadTypeValidator } from '../types/thread-types-enum.js';
 import {
+  type LegacyRawThreadInfo,
   legacyMemberInfoValidator,
   legacyRawThreadInfoValidator,
   legacyRoleInfoValidator,
   legacyThreadCurrentUserInfoValidator,
 } from '../types/thread-types.js';
-import type { LegacyRawThreadInfo } from '../types/thread-types.js';
-import { threadEntityValidator } from '../utils/entity-text.js';
 import { tBool, tID, tShape } from '../utils/validation-utils.js';
 
-const roleInfoValidator: TInterface<RoleInfo> = tShape<RoleInfo>({
-  ...legacyRoleInfoValidator.meta.props,
-  minimallyEncoded: tBool(true),
-  permissions: t.list(tHexEncodedRolePermission),
-  specialRole: t.maybe(specialRoleValidator),
-});
-
 const threadCurrentUserInfoValidator: TInterface<ThreadCurrentUserInfo> =
   tShape<ThreadCurrentUserInfo>({
     ...legacyThreadCurrentUserInfoValidator.meta.props,
     minimallyEncoded: tBool(true),
     permissions: tHexEncodedPermissionsBitmask,
   });
 
-const MemberInfoValidator: TInterface<MemberInfo> = tShape<MemberInfo>({
-  ...legacyMemberInfoValidator.meta.props,
+const roleInfoValidator: TInterface<RoleInfo> = tShape<RoleInfo>({
+  ...legacyRoleInfoValidator.meta.props,
   minimallyEncoded: tBool(true),
-  permissions: tHexEncodedPermissionsBitmask,
+  permissions: t.list(tHexEncodedRolePermission),
+  specialRole: t.maybe(specialRoleValidator),
 });
 
-const relativeMemberInfoValidator: TInterface<RelativeMemberInfo> =
-  tShape<RelativeMemberInfo>({
-    ...MemberInfoValidator.meta.props,
-    username: t.maybe(t.String),
-    isViewer: t.Boolean,
-  });
-
-const threadInfoValidator: TInterface<ThreadInfo> = tShape<ThreadInfo>({
+const memberInfoValidator: TInterface<MemberInfo> = tShape<MemberInfo>({
+  ...legacyMemberInfoValidator.meta.props,
   minimallyEncoded: tBool(true),
-  id: tID,
-  type: threadTypeValidator,
-  name: t.maybe(t.String),
-  uiName: t.union([t.String, threadEntityValidator]),
-  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(relativeMemberInfoValidator),
-  roles: t.dict(tID, roleInfoValidator),
-  currentUser: threadCurrentUserInfoValidator,
-  sourceMessageID: t.maybe(tID),
-  repliesCount: t.Number,
-  pinnedCount: t.maybe(t.Number),
+  permissions: tHexEncodedPermissionsBitmask,
 });
 
 const rawThreadInfoValidator: TInterface<RawThreadInfo> = tShape<RawThreadInfo>(
   {
     ...legacyRawThreadInfoValidator.meta.props,
     minimallyEncoded: tBool(true),
-    members: t.list(MemberInfoValidator),
+    members: t.list(memberInfoValidator),
     roles: t.dict(tID, roleInfoValidator),
     currentUser: threadCurrentUserInfoValidator,
   },
 );
 
-export const mixedRawThreadInfoValidator: TUnion<
-  LegacyRawThreadInfo | RawThreadInfo,
-> = t.union([legacyRawThreadInfoValidator, rawThreadInfoValidator]);
+const mixedRawThreadInfoValidator: TUnion<LegacyRawThreadInfo | RawThreadInfo> =
+  t.union([legacyRawThreadInfoValidator, rawThreadInfoValidator]);
 
 export {
+  memberInfoValidator,
   roleInfoValidator,
   threadCurrentUserInfoValidator,
-  MemberInfoValidator,
-  relativeMemberInfoValidator,
-  threadInfoValidator,
   rawThreadInfoValidator,
+  mixedRawThreadInfoValidator,
 };
diff --git a/lib/permissions/minimally-encoded-thread-permissions-validators.js b/lib/permissions/minimally-encoded-thread-permissions-validators.js
index ad7a49670..0f051d651 100644
--- a/lib/permissions/minimally-encoded-thread-permissions-validators.js
+++ b/lib/permissions/minimally-encoded-thread-permissions-validators.js
@@ -1,99 +1,47 @@
 // @flow
 
-import t, { type TInterface, type TUnion } from 'tcomb';
+import t, { type TInterface } from 'tcomb';
 
 import {
-  tHexEncodedPermissionsBitmask,
-  tHexEncodedRolePermission,
-} from './minimally-encoded-thread-permissions.js';
-import { specialRoleValidator } from './special-roles.js';
+  roleInfoValidator,
+  threadCurrentUserInfoValidator,
+  memberInfoValidator,
+} from './minimally-encoded-raw-thread-info-validators.js';
 import { clientAvatarValidator } from '../types/avatar-types.js';
 import type {
-  MemberInfo,
-  ThreadCurrentUserInfo,
-  RawThreadInfo,
   RelativeMemberInfo,
-  RoleInfo,
   ThreadInfo,
 } from '../types/minimally-encoded-thread-permissions-types.js';
 import { threadTypeValidator } from '../types/thread-types-enum.js';
-import {
-  legacyMemberInfoValidator,
-  legacyRawThreadInfoValidator,
-  legacyRoleInfoValidator,
-  legacyThreadCurrentUserInfoValidator,
-} from '../types/thread-types.js';
-import type { LegacyRawThreadInfo } from '../types/thread-types.js';
 import { threadEntityValidator } from '../utils/entity-text.js';
 import { tBool, tID, tShape } from '../utils/validation-utils.js';
 
-const roleInfoValidator: TInterface<RoleInfo> = tShape<RoleInfo>({
-  ...legacyRoleInfoValidator.meta.props,
-  minimallyEncoded: tBool(true),
-  permissions: t.list(tHexEncodedRolePermission),
-  specialRole: t.maybe(specialRoleValidator),
-});
-
-const threadCurrentUserInfoValidator: TInterface<ThreadCurrentUserInfo> =
-  tShape<ThreadCurrentUserInfo>({
-    ...legacyThreadCurrentUserInfoValidator.meta.props,
-    minimallyEncoded: tBool(true),
-    permissions: tHexEncodedPermissionsBitmask,
-  });
-
-const MemberInfoValidator: TInterface<MemberInfo> = tShape<MemberInfo>({
-  ...legacyMemberInfoValidator.meta.props,
-  minimallyEncoded: tBool(true),
-  permissions: tHexEncodedPermissionsBitmask,
-});
-
 const relativeMemberInfoValidator: TInterface<RelativeMemberInfo> =
   tShape<RelativeMemberInfo>({
-    ...MemberInfoValidator.meta.props,
+    ...memberInfoValidator.meta.props,
     username: t.maybe(t.String),
     isViewer: t.Boolean,
   });
 
 const threadInfoValidator: TInterface<ThreadInfo> = tShape<ThreadInfo>({
   minimallyEncoded: tBool(true),
   id: tID,
   type: threadTypeValidator,
   name: t.maybe(t.String),
   uiName: t.union([t.String, threadEntityValidator]),
   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(relativeMemberInfoValidator),
   roles: t.dict(tID, roleInfoValidator),
   currentUser: threadCurrentUserInfoValidator,
   sourceMessageID: t.maybe(tID),
   repliesCount: t.Number,
   pinnedCount: t.maybe(t.Number),
 });
 
-const rawThreadInfoValidator: TInterface<RawThreadInfo> = tShape<RawThreadInfo>(
-  {
-    ...legacyRawThreadInfoValidator.meta.props,
-    minimallyEncoded: tBool(true),
-    members: t.list(MemberInfoValidator),
-    roles: t.dict(tID, roleInfoValidator),
-    currentUser: threadCurrentUserInfoValidator,
-  },
-);
-
-export const mixedRawThreadInfoValidator: TUnion<
-  LegacyRawThreadInfo | RawThreadInfo,
-> = t.union([legacyRawThreadInfoValidator, rawThreadInfoValidator]);
-
-export {
-  roleInfoValidator,
-  threadCurrentUserInfoValidator,
-  MemberInfoValidator,
-  relativeMemberInfoValidator,
-  threadInfoValidator,
-  rawThreadInfoValidator,
-};
+export { relativeMemberInfoValidator, threadInfoValidator };
diff --git a/lib/permissions/minimally-encoded-thread-permissions.test.js b/lib/permissions/minimally-encoded-thread-permissions.test.js
index 526930066..e4f89c4ec 100644
--- a/lib/permissions/minimally-encoded-thread-permissions.test.js
+++ b/lib/permissions/minimally-encoded-thread-permissions.test.js
@@ -1,638 +1,638 @@
 // @flow
 
+import {
+  memberInfoValidator,
+  rawThreadInfoValidator,
+  roleInfoValidator,
+  threadCurrentUserInfoValidator,
+} from './minimally-encoded-raw-thread-info-validators.js';
 import {
   exampleMinimallyEncodedRawThreadInfoA,
   exampleRawThreadInfoA,
   expectedDecodedExampleRawThreadInfoA,
 } from './minimally-encoded-thread-permissions-test-data.js';
-import {
-  MemberInfoValidator,
-  rawThreadInfoValidator,
-  roleInfoValidator,
-  threadCurrentUserInfoValidator,
-} from './minimally-encoded-thread-permissions-validators.js';
 import {
   decodeRolePermissionBitmask,
   decodeThreadRolePermissionsBitmaskArray,
   hasPermission,
   permissionsToBitmaskHex,
   rolePermissionToBitmaskHex,
   threadPermissionsFromBitmaskHex,
   threadRolePermissionsBlobToBitmaskArray,
 } from './minimally-encoded-thread-permissions.js';
 import {
   minimallyEncodeRawThreadInfo,
   decodeMinimallyEncodedRawThreadInfo,
   minimallyEncodeThreadCurrentUserInfo,
 } from '../types/minimally-encoded-thread-permissions-types.js';
 import type { ThreadRolePermissionsBlob } from '../types/thread-permission-types.js';
 import type { LegacyThreadCurrentUserInfo } from '../types/thread-types.js';
 
 const permissions = {
   know_of: { value: true, source: '1' },
   visible: { value: true, source: '1' },
   voiced: { value: true, source: '1' },
   edit_entries: { value: true, source: '1' },
   edit_thread: { value: true, source: '1' },
   edit_thread_description: { value: true, source: '1' },
   edit_thread_color: { value: true, source: '1' },
   delete_thread: { value: true, source: '1' },
   create_subthreads: { value: true, source: '1' },
   create_sidebars: { value: true, source: '1' },
   join_thread: { value: false, source: null },
   edit_permissions: { value: false, source: null },
   add_members: { value: true, source: '1' },
   remove_members: { value: true, source: '1' },
   change_role: { value: true, source: '1' },
   leave_thread: { value: false, source: null },
   react_to_message: { value: true, source: '1' },
   edit_message: { value: true, source: '1' },
   edit_thread_avatar: { value: false, source: null },
   manage_pins: { value: false, source: null },
   manage_invite_links: { value: false, source: null },
   voiced_in_announcement_channels: { value: false, source: null },
 };
 
 describe('minimallyEncodedThreadPermissions', () => {
   it('should encode ThreadPermissionsInfo as bitmask', () => {
     const permissionsBitmask = permissionsToBitmaskHex(permissions);
     expect(permissionsBitmask).toBe('373ff');
     expect(hasPermission(permissionsBitmask, 'know_of')).toBe(true);
     expect(hasPermission(permissionsBitmask, 'visible')).toBe(true);
     expect(hasPermission(permissionsBitmask, 'voiced')).toBe(true);
     expect(hasPermission(permissionsBitmask, 'edit_entries')).toBe(true);
     expect(hasPermission(permissionsBitmask, 'edit_thread')).toBe(true);
     expect(hasPermission(permissionsBitmask, 'edit_thread_description')).toBe(
       true,
     );
     expect(hasPermission(permissionsBitmask, 'edit_thread_color')).toBe(true);
     expect(hasPermission(permissionsBitmask, 'delete_thread')).toBe(true);
     expect(hasPermission(permissionsBitmask, 'create_subthreads')).toBe(true);
     expect(hasPermission(permissionsBitmask, 'create_sidebars')).toBe(true);
     expect(hasPermission(permissionsBitmask, 'join_thread')).toBe(false);
     expect(hasPermission(permissionsBitmask, 'edit_permissions')).toBe(false);
     expect(hasPermission(permissionsBitmask, 'remove_members')).toBe(true);
     expect(hasPermission(permissionsBitmask, 'change_role')).toBe(true);
     expect(hasPermission(permissionsBitmask, 'leave_thread')).toBe(false);
     expect(hasPermission(permissionsBitmask, 'react_to_message')).toBe(true);
     expect(hasPermission(permissionsBitmask, 'edit_message')).toBe(true);
   });
 });
 
 describe('hasPermission', () => {
   const permissionsSansKnowOf = {
     know_of: { value: false, source: null },
     visible: { value: true, source: '1' },
   };
   const permissionsSansKnowOfBitmask = permissionsToBitmaskHex(
     permissionsSansKnowOf,
   );
   it('should fail check if know_of is false even if permission specified in request is true', () => {
     expect(hasPermission(permissionsSansKnowOfBitmask, 'visible')).toBe(false);
   });
 
   const permissionsWithKnowOf = {
     know_of: { value: true, source: '1' },
     visible: { value: true, source: '1' },
   };
   const permissionsWithKnowOfBitmask = permissionsToBitmaskHex(
     permissionsWithKnowOf,
   );
   it('should succeed permission check if know_of is true', () => {
     expect(hasPermission(permissionsWithKnowOfBitmask, 'visible')).toBe(true);
   });
 });
 
 describe('threadPermissionsFromBitmaskHex', () => {
   const expectedDecodedThreadPermissions = {
     know_of: { value: true, source: 'null' },
     visible: { value: true, source: 'null' },
     voiced: { value: true, source: 'null' },
     edit_entries: { value: true, source: 'null' },
     edit_thread: { value: true, source: 'null' },
     edit_thread_description: { value: true, source: 'null' },
     edit_thread_color: { value: true, source: 'null' },
     delete_thread: { value: true, source: 'null' },
     create_subthreads: { value: true, source: 'null' },
     create_sidebars: { value: true, source: 'null' },
     join_thread: { value: false, source: null },
     edit_permissions: { value: false, source: null },
     add_members: { value: true, source: 'null' },
     remove_members: { value: true, source: 'null' },
     change_role: { value: true, source: 'null' },
     leave_thread: { value: false, source: null },
     react_to_message: { value: true, source: 'null' },
     edit_message: { value: true, source: 'null' },
     edit_thread_avatar: { value: false, source: null },
     manage_pins: { value: false, source: null },
     manage_invite_links: { value: false, source: null },
     voiced_in_announcement_channels: { value: false, source: null },
   };
 
   it('should decode ThreadPermissionsInfo from bitmask', () => {
     const permissionsBitmask = permissionsToBitmaskHex(permissions);
     const decodedThreadPermissions =
       threadPermissionsFromBitmaskHex(permissionsBitmask);
 
     expect(decodedThreadPermissions).toStrictEqual(
       expectedDecodedThreadPermissions,
     );
   });
 
   it('should decode bitmask strings under 3 characters', () => {
     // We know that '3' in hex is 0b0011. Given that permissions are encoded
     // from least significant bit (LSB) to most significant bit (MSB), we would
     // except this to mean that only the first two permissions listed in
     // `baseRolePermissionEncoding` are `true`. Which is the case.
     const decodedThreadPermissions = threadPermissionsFromBitmaskHex('3');
     expect(decodedThreadPermissions).toStrictEqual({
       know_of: { value: true, source: 'null' },
       visible: { value: true, source: 'null' },
       voiced: { value: false, source: null },
       edit_entries: { value: false, source: null },
       edit_thread: { value: false, source: null },
       edit_thread_description: { value: false, source: null },
       edit_thread_color: { value: false, source: null },
       delete_thread: { value: false, source: null },
       create_subthreads: { value: false, source: null },
       create_sidebars: { value: false, source: null },
       join_thread: { value: false, source: null },
       edit_permissions: { value: false, source: null },
       add_members: { value: false, source: null },
       remove_members: { value: false, source: null },
       change_role: { value: false, source: null },
       leave_thread: { value: false, source: null },
       react_to_message: { value: false, source: null },
       edit_message: { value: false, source: null },
       edit_thread_avatar: { value: false, source: null },
       manage_pins: { value: false, source: null },
       manage_invite_links: { value: false, source: null },
       voiced_in_announcement_channels: { value: false, source: null },
     });
   });
 });
 
 describe('rolePermissionToBitmaskHex', () => {
   it('should encode `child_opentoplevel_visible` successfully', () => {
     expect(rolePermissionToBitmaskHex('child_opentoplevel_visible')).toBe(
       '01b',
     );
   });
 
   it('should encode `child_opentoplevel_know_of` successfully', () => {
     expect(rolePermissionToBitmaskHex('child_opentoplevel_know_of')).toBe(
       '00b',
     );
   });
 
   it('should encode `child_toplevel_visible` successfully', () => {
     expect(rolePermissionToBitmaskHex('child_toplevel_visible')).toBe('01a');
   });
 
   it('should encode `child_toplevel_know_of` successfully', () => {
     expect(rolePermissionToBitmaskHex('child_toplevel_know_of')).toBe('00a');
   });
 
   it('should encode `child_opentoplevel_join_thread` successfully', () => {
     expect(rolePermissionToBitmaskHex('child_opentoplevel_join_thread')).toBe(
       '0ab',
     );
   });
 
   it('should encode `child_visible` successfully', () => {
     expect(rolePermissionToBitmaskHex('child_visible')).toBe('018');
   });
 
   it('should encode `child_know_of` successfully', () => {
     expect(rolePermissionToBitmaskHex('child_know_of')).toBe('008');
   });
 });
 
 describe('decodeRolePermissionBitmask', () => {
   it('should decode `01b` to `child_opentoplevel_visible` successfully', () => {
     expect(decodeRolePermissionBitmask('01b')).toBe(
       'child_opentoplevel_visible',
     );
   });
 
   it('should decode `00b` to `child_opentoplevel_know_of` successfully', () => {
     expect(decodeRolePermissionBitmask('00b')).toBe(
       'child_opentoplevel_know_of',
     );
   });
 
   it('should decode `01a` to `child_toplevel_visible` successfully', () => {
     expect(decodeRolePermissionBitmask('01a')).toBe('child_toplevel_visible');
   });
 
   it('should decode `00a` to `child_toplevel_know_of` successfully', () => {
     expect(decodeRolePermissionBitmask('00a')).toBe('child_toplevel_know_of');
   });
 
   it('should decode `0ab` to `child_opentoplevel_join_thread` successfully', () => {
     expect(decodeRolePermissionBitmask('0ab')).toBe(
       'child_opentoplevel_join_thread',
     );
   });
 
   it('should decode `018` to `child_visible` successfully', () => {
     expect(decodeRolePermissionBitmask('018')).toBe('child_visible');
   });
 
   it('should decode `008` to `child_know_of` successfully', () => {
     expect(decodeRolePermissionBitmask('008')).toBe('child_know_of');
   });
 });
 
 const threadRolePermissionsBlob: ThreadRolePermissionsBlob = {
   add_members: true,
   child_open_join_thread: true,
   create_sidebars: true,
   create_subthreads: true,
   descendant_open_know_of: true,
   descendant_open_visible: true,
   descendant_opentoplevel_join_thread: true,
   edit_entries: true,
   edit_message: true,
   edit_permissions: true,
   edit_thread: true,
   edit_thread_avatar: true,
   edit_thread_color: true,
   edit_thread_description: true,
   know_of: true,
   leave_thread: true,
   react_to_message: true,
   remove_members: true,
   visible: true,
   voiced: true,
   open_know_of: true,
   open_visible: true,
   opentoplevel_join_thread: true,
   toplevel_know_of: true,
   toplevel_visible: true,
   opentoplevel_know_of: true,
   opentoplevel_visible: true,
   child_know_of: true,
   child_visible: true,
   child_opentoplevel_join_thread: true,
   child_toplevel_know_of: true,
   child_toplevel_visible: true,
   child_opentoplevel_know_of: true,
   child_opentoplevel_visible: true,
 };
 
 const threadRolePermissionsBitmaskArray = [
   '0c0',
   '0a9',
   '090',
   '080',
   '005',
   '015',
   '0a7',
   '030',
   '110',
   '0b0',
   '040',
   '120',
   '060',
   '050',
   '000',
   '0f0',
   '100',
   '0d0',
   '010',
   '020',
   '001',
   '011',
   '0a3',
   '002',
   '012',
   '003',
   '013',
   '008',
   '018',
   '0ab',
   '00a',
   '01a',
   '00b',
   '01b',
 ];
 
 describe('threadRolePermissionsBlobToBitmaskArray', () => {
   it('should encode threadRolePermissionsBlob as bitmask array', () => {
     const arr = threadRolePermissionsBlobToBitmaskArray(
       threadRolePermissionsBlob,
     );
     expect(arr).toEqual(threadRolePermissionsBitmaskArray);
   });
 });
 
 describe('decodeThreadRolePermissionsBitmaskArray', () => {
   it('should decode threadRolePermissionsBitmaskArray', () => {
     expect(
       decodeThreadRolePermissionsBitmaskArray(
         threadRolePermissionsBitmaskArray,
       ),
     ).toEqual(threadRolePermissionsBlob);
   });
 });
 
 describe('minimallyEncodedRoleInfoValidator', () => {
   it('should validate correctly formed MinimallyEncodedRoleInfo', () => {
     expect(
       roleInfoValidator.is({
         minimallyEncoded: true,
         id: 'roleID',
         name: 'roleName',
         permissions: ['abc', 'def'],
         isDefault: true,
       }),
     ).toBe(true);
   });
 
   it('should NOT validate malformed MinimallyEncodedRoleInfo', () => {
     expect(
       roleInfoValidator.is({
         id: 1234,
         name: 'roleName',
         permissions: ['abc', 'def'],
         isDefault: true,
       }),
     ).toBe(false);
 
     expect(
       roleInfoValidator.is({
         id: 'roleID',
         name: 'roleName',
         permissions: ['hello a02 test', 'def'],
         isDefault: true,
       }),
     ).toBe(false);
 
     expect(
       roleInfoValidator.is({
         id: 'roleID',
         name: 'roleName',
         permissions: [123, 456],
         isDefault: true,
       }),
     ).toBe(false);
 
     expect(
       roleInfoValidator.is({
         id: 'roleID',
         name: 'roleName',
         permissions: ['ZZZ', 'YYY'],
         isDefault: true,
       }),
     ).toBe(false);
 
     expect(
       roleInfoValidator.is({
         id: 'roleID',
         name: 'roleName',
         permissions: ['AAAAA', 'YYY'],
         isDefault: true,
       }),
     ).toBe(false);
   });
 });
 
 describe('minimallyEncodedThreadCurrentUserInfoValidator', () => {
   it('should validate correctly formed MinimallyEncodedThreadCurrentUserInfo', () => {
     expect(
       threadCurrentUserInfoValidator.is({
         minimallyEncoded: true,
         permissions: '100',
         subscription: { home: true, pushNotifs: true },
       }),
     ).toBe(true);
     expect(
       threadCurrentUserInfoValidator.is({
         minimallyEncoded: true,
         permissions: 'ABCDEFABCDEFABCD',
         subscription: { home: true, pushNotifs: true },
       }),
     ).toBe(true);
   });
 
   it('should NOT validate malformed MinimallyEncodedThreadCurrentUserInfo', () => {
     expect(
       threadCurrentUserInfoValidator.is({
         minimallyEncoded: true,
         permissions: 'INVALID',
         subscription: { home: true, pushNotifs: true },
       }),
     ).toBe(false);
 
     expect(
       threadCurrentUserInfoValidator.is({
         minimallyEncoded: true,
         permissions: 'ABCDEF  hello  ABCDEFABCD',
         subscription: { home: true, pushNotifs: true },
       }),
     ).toBe(false);
 
     expect(
       threadCurrentUserInfoValidator.is({
         minimallyEncoded: true,
         permissions: 100,
         subscription: { home: true, pushNotifs: true },
       }),
     ).toBe(false);
   });
 });
 
 describe('minimallyEncodedMemberInfoValidator', () => {
   it('should validate correctly formed MinimallyEncodedMemberInfo', () => {
     expect(
-      MemberInfoValidator.is({
+      memberInfoValidator.is({
         minimallyEncoded: true,
         id: 'memberID',
         permissions: 'ABCDEF',
         isSender: true,
       }),
     ).toBe(true);
 
     expect(
-      MemberInfoValidator.is({
+      memberInfoValidator.is({
         minimallyEncoded: true,
         id: 'memberID',
         permissions: '01b',
         isSender: false,
       }),
     ).toBe(true);
   });
 
   it('should NOT validate malformed MinimallyEncodedMemberInfo', () => {
     expect(
-      MemberInfoValidator.is({
+      memberInfoValidator.is({
         minimallyEncoded: true,
         id: 'memberID',
         permissions: 'INVALID',
         isSender: false,
       }),
     ).toBe(false);
 
     expect(
-      MemberInfoValidator.is({
+      memberInfoValidator.is({
         minimallyEncoded: true,
         id: 'memberID',
         permissions: 100,
         isSender: false,
       }),
     ).toBe(false);
   });
 });
 
 describe('minimallyEncodedRawThreadInfoValidator', () => {
   it('should validate correctly formed MinimallyEncodedRawThreadInfo', () => {
     expect(
       rawThreadInfoValidator.is(exampleMinimallyEncodedRawThreadInfoA),
     ).toBe(true);
   });
 });
 
 describe('minimallyEncodeRawThreadInfo', () => {
   it('should correctly encode RawThreadInfo', () => {
     expect(
       rawThreadInfoValidator.is(
         minimallyEncodeRawThreadInfo(exampleRawThreadInfoA),
       ),
     ).toBe(true);
   });
 });
 
 describe('decodeMinimallyEncodedRawThreadInfo', () => {
   it('should correctly decode minimallyEncodedRawThreadInfo', () => {
     expect(
       decodeMinimallyEncodedRawThreadInfo(
         minimallyEncodeRawThreadInfo(exampleRawThreadInfoA),
       ),
     ).toStrictEqual(expectedDecodedExampleRawThreadInfoA);
   });
 });
 
 const threadCurrentUserInfo: LegacyThreadCurrentUserInfo = {
   role: '256|83795',
   permissions: {
     know_of: {
       value: true,
       source: '256|1',
     },
     visible: {
       value: true,
       source: '256|1',
     },
     voiced: {
       value: false,
       source: null,
     },
     edit_entries: {
       value: false,
       source: null,
     },
     edit_thread: {
       value: false,
       source: null,
     },
     edit_thread_description: {
       value: false,
       source: null,
     },
     edit_thread_color: {
       value: false,
       source: null,
     },
     delete_thread: {
       value: false,
       source: null,
     },
     create_subthreads: {
       value: false,
       source: null,
     },
     create_sidebars: {
       value: false,
       source: null,
     },
     join_thread: {
       value: false,
       source: null,
     },
     edit_permissions: {
       value: false,
       source: null,
     },
     add_members: {
       value: false,
       source: null,
     },
     remove_members: {
       value: false,
       source: null,
     },
     change_role: {
       value: false,
       source: null,
     },
     leave_thread: {
       value: false,
       source: null,
     },
     react_to_message: {
       value: false,
       source: null,
     },
     edit_message: {
       value: false,
       source: null,
     },
     edit_thread_avatar: {
       value: false,
       source: null,
     },
     manage_pins: {
       value: false,
       source: null,
     },
     manage_invite_links: {
       value: false,
       source: null,
     },
     voiced_in_announcement_channels: {
       value: false,
       source: null,
     },
   },
   subscription: {
     home: true,
     pushNotifs: true,
   },
   unread: true,
 };
 describe('minimallyEncodeThreadCurrentUserInfo', () => {
   it('should correctly encode threadCurrentUserInfo ONCE', () => {
     const minimallyEncoded = minimallyEncodeThreadCurrentUserInfo(
       threadCurrentUserInfo,
     );
     expect(minimallyEncoded.permissions).toBe('3');
   });
 
   it('should throw when attempting to minimally encode threadCurrentUserInfo twice', () => {
     const minimallyEncoded = minimallyEncodeThreadCurrentUserInfo(
       threadCurrentUserInfo,
     );
     expect(minimallyEncoded.permissions).toBe('3');
     expect(() =>
       // `MinimallyEncodedThreadCurrentUser` should never be passed
       // to `minimallyEncodeThreadCurrentUserInfo`. We're intentionally
       // bypassing Flow to simulate a scenario where malformed input is
       // passed to minimallyEncodeThreadCurrentUserInfo to ensure that the
       // `invariant` throws the expected error.
 
       // $FlowExpectedError
       minimallyEncodeThreadCurrentUserInfo(minimallyEncoded),
     ).toThrow('threadCurrentUserInfo is already minimally encoded.');
   });
 });
diff --git a/lib/shared/updates/join-thread-spec.js b/lib/shared/updates/join-thread-spec.js
index 7b221bffb..17659a2fe 100644
--- a/lib/shared/updates/join-thread-spec.js
+++ b/lib/shared/updates/join-thread-spec.js
@@ -1,181 +1,181 @@
 // @flow
 
 import invariant from 'invariant';
 import _isEqual from 'lodash/fp/isEqual.js';
 import t from 'tcomb';
 
 import type { UpdateInfoFromRawInfoParams, UpdateSpec } from './update-spec.js';
-import { mixedRawThreadInfoValidator } from '../../permissions/minimally-encoded-thread-permissions-validators.js';
+import { mixedRawThreadInfoValidator } from '../../permissions/minimally-encoded-raw-thread-info-validators.js';
 import {
   type RawEntryInfo,
   rawEntryInfoValidator,
 } from '../../types/entry-types.js';
 import type {
   RawMessageInfo,
   MessageTruncationStatuses,
 } from '../../types/message-types.js';
 import {
   messageTruncationStatusValidator,
   rawMessageInfoValidator,
 } from '../../types/message-types.js';
 import type { RawThreadInfos } from '../../types/thread-types.js';
 import { updateTypes } from '../../types/update-types-enum.js';
 import type {
   ThreadJoinUpdateInfo,
   ThreadJoinRawUpdateInfo,
   ThreadJoinUpdateData,
 } from '../../types/update-types.js';
 import { tNumber, tShape } from '../../utils/validation-utils.js';
 import { combineTruncationStatuses } from '../message-utils.js';
 import { threadInFilterList } from '../thread-utils.js';
 
 export const joinThreadSpec: UpdateSpec<
   ThreadJoinUpdateInfo,
   ThreadJoinRawUpdateInfo,
   ThreadJoinUpdateData,
 > = Object.freeze({
   generateOpsForThreadUpdates(
     storeThreadInfos: RawThreadInfos,
     update: ThreadJoinUpdateInfo,
   ) {
     if (_isEqual(storeThreadInfos[update.threadInfo.id])(update.threadInfo)) {
       return null;
     }
     invariant(
       update.threadInfo.minimallyEncoded,
       'update threadInfo must be minimallyEncoded',
     );
     return [
       {
         type: 'replace',
         payload: {
           id: update.threadInfo.id,
           threadInfo: update.threadInfo,
         },
       },
     ];
   },
   mergeEntryInfos(
     entryIDs: Set<string>,
     mergedEntryInfos: Array<RawEntryInfo>,
     update: ThreadJoinUpdateInfo,
   ) {
     for (const entryInfo of update.rawEntryInfos) {
       const entryID = entryInfo.id;
       if (!entryID || entryIDs.has(entryID)) {
         continue;
       }
       mergedEntryInfos.push(entryInfo);
       entryIDs.add(entryID);
     }
   },
   reduceCalendarThreadFilters(
     filteredThreadIDs: $ReadOnlySet<string>,
     update: ThreadJoinUpdateInfo,
   ) {
     if (
       !threadInFilterList(update.threadInfo) ||
       filteredThreadIDs.has(update.threadInfo.id)
     ) {
       return filteredThreadIDs;
     }
     return new Set([...filteredThreadIDs, update.threadInfo.id]);
   },
   getRawMessageInfos(update: ThreadJoinUpdateInfo) {
     return update.rawMessageInfos;
   },
   mergeMessageInfosAndTruncationStatuses(
     messageIDs: Set<string>,
     messageInfos: Array<RawMessageInfo>,
     truncationStatuses: MessageTruncationStatuses,
     update: ThreadJoinUpdateInfo,
   ) {
     for (const messageInfo of update.rawMessageInfos) {
       const messageID = messageInfo.id;
       if (!messageID || messageIDs.has(messageID)) {
         continue;
       }
       messageInfos.push(messageInfo);
       messageIDs.add(messageID);
     }
 
     truncationStatuses[update.threadInfo.id] = combineTruncationStatuses(
       update.truncationStatus,
       truncationStatuses[update.threadInfo.id],
     );
   },
   rawUpdateInfoFromRow(row: Object) {
     const { threadID } = JSON.parse(row.content);
     return {
       type: updateTypes.JOIN_THREAD,
       id: row.id.toString(),
       time: row.time,
       threadID,
     };
   },
   updateContentForServerDB(data: ThreadJoinUpdateData) {
     const { threadID } = data;
     return JSON.stringify({ threadID });
   },
   entitiesToFetch(update: ThreadJoinRawUpdateInfo) {
     return {
       threadID: update.threadID,
       detailedThreadID: update.threadID,
     };
   },
   rawInfoFromData(data: ThreadJoinUpdateData, id: string) {
     return {
       type: updateTypes.JOIN_THREAD,
       id,
       time: data.time,
       threadID: data.threadID,
     };
   },
   updateInfoFromRawInfo(
     info: ThreadJoinRawUpdateInfo,
     params: UpdateInfoFromRawInfoParams,
   ) {
     const { data, rawEntryInfosByThreadID, rawMessageInfosByThreadID } = params;
     const { threadInfos, calendarResult, messageInfosResult } = data;
     const threadInfo = threadInfos[info.threadID];
     if (!threadInfo) {
       console.warn(
         "failed to hydrate updateTypes.JOIN_THREAD because we couldn't " +
           `fetch RawThreadInfo for ${info.threadID}`,
       );
       return null;
     }
 
     invariant(calendarResult, 'should be set');
     const rawEntryInfos = rawEntryInfosByThreadID[info.threadID] ?? [];
     invariant(messageInfosResult, 'should be set');
     const rawMessageInfos = rawMessageInfosByThreadID[info.threadID] ?? [];
 
     return {
       type: updateTypes.JOIN_THREAD,
       id: info.id,
       time: info.time,
       threadInfo,
       rawMessageInfos,
       truncationStatus: messageInfosResult.truncationStatuses[info.threadID],
       rawEntryInfos,
     };
   },
   deleteCondition: 'all_types',
   keyForUpdateData(data: ThreadJoinUpdateData) {
     return data.threadID;
   },
   keyForUpdateInfo(info: ThreadJoinUpdateInfo) {
     return info.threadInfo.id;
   },
   typesOfReplacedUpdatesForMatchingKey: 'all_types',
   infoValidator: tShape<ThreadJoinUpdateInfo>({
     type: tNumber(updateTypes.JOIN_THREAD),
     id: t.String,
     time: t.Number,
     threadInfo: mixedRawThreadInfoValidator,
     rawMessageInfos: t.list(rawMessageInfoValidator),
     truncationStatus: messageTruncationStatusValidator,
     rawEntryInfos: t.list(rawEntryInfoValidator),
   }),
 });
diff --git a/lib/shared/updates/update-thread-spec.js b/lib/shared/updates/update-thread-spec.js
index 3bd25faaf..0f40b681c 100644
--- a/lib/shared/updates/update-thread-spec.js
+++ b/lib/shared/updates/update-thread-spec.js
@@ -1,122 +1,122 @@
 // @flow
 
 import invariant from 'invariant';
 import _isEqual from 'lodash/fp/isEqual.js';
 import t from 'tcomb';
 
 import type { UpdateInfoFromRawInfoParams, UpdateSpec } from './update-spec.js';
-import { mixedRawThreadInfoValidator } from '../../permissions/minimally-encoded-thread-permissions-validators.js';
+import { mixedRawThreadInfoValidator } from '../../permissions/minimally-encoded-raw-thread-info-validators.js';
 import type { RawThreadInfos } from '../../types/thread-types.js';
 import { updateTypes } from '../../types/update-types-enum.js';
 import type {
   ThreadUpdateInfo,
   ThreadRawUpdateInfo,
   ThreadUpdateData,
 } from '../../types/update-types.js';
 import { tNumber, tShape } from '../../utils/validation-utils.js';
 import { threadInFilterList } from '../thread-utils.js';
 
 export const updateThreadSpec: UpdateSpec<
   ThreadUpdateInfo,
   ThreadRawUpdateInfo,
   ThreadUpdateData,
 > = Object.freeze({
   generateOpsForThreadUpdates(
     storeThreadInfos: RawThreadInfos,
     update: ThreadUpdateInfo,
   ) {
     if (_isEqual(storeThreadInfos[update.threadInfo.id])(update.threadInfo)) {
       return null;
     }
     invariant(
       update.threadInfo.minimallyEncoded,
       'update threadInfo must be minimallyEncoded',
     );
     return [
       {
         type: 'replace',
         payload: {
           id: update.threadInfo.id,
           threadInfo: update.threadInfo,
         },
       },
     ];
   },
   reduceCalendarThreadFilters(
     filteredThreadIDs: $ReadOnlySet<string>,
     update: ThreadUpdateInfo,
   ) {
     if (
       threadInFilterList(update.threadInfo) ||
       !filteredThreadIDs.has(update.threadInfo.id)
     ) {
       return filteredThreadIDs;
     }
     return new Set(
       [...filteredThreadIDs].filter(id => id !== update.threadInfo.id),
     );
   },
   rawUpdateInfoFromRow(row: Object) {
     const { threadID } = JSON.parse(row.content);
     return {
       type: updateTypes.UPDATE_THREAD,
       id: row.id.toString(),
       time: row.time,
       threadID,
     };
   },
   updateContentForServerDB(data: ThreadUpdateData) {
     return JSON.stringify({ threadID: data.threadID });
   },
   entitiesToFetch(update: ThreadRawUpdateInfo) {
     return {
       threadID: update.threadID,
     };
   },
   rawInfoFromData(data: ThreadUpdateData, id: string) {
     return {
       type: updateTypes.UPDATE_THREAD,
       id,
       time: data.time,
       threadID: data.threadID,
     };
   },
   updateInfoFromRawInfo(
     info: ThreadRawUpdateInfo,
     params: UpdateInfoFromRawInfoParams,
   ) {
     const threadInfo = params.data.threadInfos[info.threadID];
     if (!threadInfo) {
       console.warn(
         "failed to hydrate updateTypes.UPDATE_THREAD because we couldn't " +
           `fetch RawThreadInfo for ${info.threadID}`,
       );
       return null;
     }
     return {
       type: updateTypes.UPDATE_THREAD,
       id: info.id,
       time: info.time,
       threadInfo,
     };
   },
   deleteCondition: new Set([
     updateTypes.UPDATE_THREAD,
     updateTypes.UPDATE_THREAD_READ_STATUS,
   ]),
   keyForUpdateData(data: ThreadUpdateData) {
     return data.threadID;
   },
   keyForUpdateInfo(info: ThreadUpdateInfo) {
     return info.threadInfo.id;
   },
   typesOfReplacedUpdatesForMatchingKey: new Set([
     updateTypes.UPDATE_THREAD_READ_STATUS,
   ]),
   infoValidator: tShape<ThreadUpdateInfo>({
     type: tNumber(updateTypes.UPDATE_THREAD),
     id: t.String,
     time: t.Number,
     threadInfo: mixedRawThreadInfoValidator,
   }),
 });
diff --git a/lib/types/request-types.js b/lib/types/request-types.js
index 28a2d1693..969dbf906 100644
--- a/lib/types/request-types.js
+++ b/lib/types/request-types.js
@@ -1,311 +1,311 @@
 // @flow
 
 import invariant from 'invariant';
 import t, { type TUnion, type TInterface } from 'tcomb';
 
 import { type ActivityUpdate } from './activity-types.js';
 import type { SignedIdentityKeysBlob } from './crypto-types.js';
 import { signedIdentityKeysBlobValidator } from './crypto-types.js';
 import type { Platform, PlatformDetails } from './device-types.js';
 import {
   type RawEntryInfo,
   type CalendarQuery,
   rawEntryInfoValidator,
 } from './entry-types.js';
 import type { RawThreadInfo } from './minimally-encoded-thread-permissions-types';
 import type {
   ThreadInconsistencyReportShape,
   EntryInconsistencyReportShape,
   ClientThreadInconsistencyReportShape,
   ClientEntryInconsistencyReportShape,
 } from './report-types.js';
 import type { LegacyRawThreadInfo } from './thread-types.js';
 import {
   type CurrentUserInfo,
   currentUserInfoValidator,
   type AccountUserInfo,
   accountUserInfoValidator,
 } from './user-types.js';
-import { mixedRawThreadInfoValidator } from '../permissions/minimally-encoded-thread-permissions-validators.js';
+import { mixedRawThreadInfoValidator } from '../permissions/minimally-encoded-raw-thread-info-validators.js';
 import { tNumber, tShape, tID } from '../utils/validation-utils.js';
 
 // "Server requests" are requests for information that the server delivers to
 // clients. Clients then respond to those requests with a "client response".
 export const serverRequestTypes = Object.freeze({
   PLATFORM: 0,
   //DEVICE_TOKEN: 1,            (DEPRECATED)
   THREAD_INCONSISTENCY: 2,
   PLATFORM_DETAILS: 3,
   //INITIAL_ACTIVITY_UPDATE: 4, (DEPRECATED)
   ENTRY_INCONSISTENCY: 5,
   CHECK_STATE: 6,
   INITIAL_ACTIVITY_UPDATES: 7,
   MORE_ONE_TIME_KEYS: 8,
   SIGNED_IDENTITY_KEYS_BLOB: 9,
   INITIAL_NOTIFICATIONS_ENCRYPTED_MESSAGE: 10,
 });
 type ServerRequestType = $Values<typeof serverRequestTypes>;
 export function assertServerRequestType(
   serverRequestType: number,
 ): ServerRequestType {
   invariant(
     serverRequestType === 0 ||
       serverRequestType === 2 ||
       serverRequestType === 3 ||
       serverRequestType === 5 ||
       serverRequestType === 6 ||
       serverRequestType === 7 ||
       serverRequestType === 8 ||
       serverRequestType === 9 ||
       serverRequestType === 10,
     'number is not ServerRequestType enum',
   );
   return serverRequestType;
 }
 
 type PlatformServerRequest = {
   +type: 0,
 };
 const platformServerRequestValidator = tShape<PlatformServerRequest>({
   type: tNumber(serverRequestTypes.PLATFORM),
 });
 type PlatformClientResponse = {
   +type: 0,
   +platform: Platform,
 };
 
 export type ThreadInconsistencyClientResponse = {
   ...ThreadInconsistencyReportShape,
   +type: 2,
 };
 
 type PlatformDetailsServerRequest = {
   type: 3,
 };
 const platformDetailsServerRequestValidator =
   tShape<PlatformDetailsServerRequest>({
     type: tNumber(serverRequestTypes.PLATFORM_DETAILS),
   });
 
 type PlatformDetailsClientResponse = {
   type: 3,
   platformDetails: PlatformDetails,
 };
 
 export type EntryInconsistencyClientResponse = {
   type: 5,
   ...EntryInconsistencyReportShape,
 };
 
 type FailUnmentioned = Partial<{
   +threadInfos: boolean,
   +entryInfos: boolean,
   +userInfos: boolean,
 }>;
 
 type StateChanges = Partial<{
   +rawThreadInfos: LegacyRawThreadInfo[] | RawThreadInfo[],
   +rawEntryInfos: RawEntryInfo[],
   +currentUserInfo: CurrentUserInfo,
   +userInfos: AccountUserInfo[],
   +deleteThreadIDs: string[],
   +deleteEntryIDs: string[],
   +deleteUserInfoIDs: string[],
 }>;
 
 export type ServerCheckStateServerRequest = {
   +type: 6,
   +hashesToCheck: { +[key: string]: number },
   +failUnmentioned?: FailUnmentioned,
   +stateChanges?: StateChanges,
 };
 const serverCheckStateServerRequestValidator =
   tShape<ServerCheckStateServerRequest>({
     type: tNumber(serverRequestTypes.CHECK_STATE),
     hashesToCheck: t.dict(t.String, t.Number),
     failUnmentioned: t.maybe(
       tShape<FailUnmentioned>({
         threadInfos: t.maybe(t.Boolean),
         entryInfos: t.maybe(t.Boolean),
         userInfos: t.maybe(t.Boolean),
       }),
     ),
     stateChanges: t.maybe(
       tShape<StateChanges>({
         rawThreadInfos: t.maybe(t.list(mixedRawThreadInfoValidator)),
         rawEntryInfos: t.maybe(t.list(rawEntryInfoValidator)),
         currentUserInfo: t.maybe(currentUserInfoValidator),
         userInfos: t.maybe(t.list(accountUserInfoValidator)),
         deleteThreadIDs: t.maybe(t.list(tID)),
         deleteEntryIDs: t.maybe(t.list(tID)),
         deleteUserInfoIDs: t.maybe(t.list(t.String)),
       }),
     ),
   });
 
 type CheckStateClientResponse = {
   +type: 6,
   +hashResults: { +[key: string]: boolean },
 };
 
 type InitialActivityUpdatesClientResponse = {
   +type: 7,
   +activityUpdates: $ReadOnlyArray<ActivityUpdate>,
 };
 
 type MoreOneTimeKeysServerRequest = {
   +type: 8,
 };
 const moreOneTimeKeysServerRequestValidator =
   tShape<MoreOneTimeKeysServerRequest>({
     type: tNumber(serverRequestTypes.MORE_ONE_TIME_KEYS),
   });
 
 type MoreOneTimeKeysClientResponse = {
   +type: 8,
   +keys: $ReadOnlyArray<string>,
 };
 
 type SignedIdentityKeysBlobServerRequest = {
   +type: 9,
 };
 const signedIdentityKeysBlobServerRequestValidator =
   tShape<SignedIdentityKeysBlobServerRequest>({
     type: tNumber(serverRequestTypes.SIGNED_IDENTITY_KEYS_BLOB),
   });
 
 type SignedIdentityKeysBlobClientResponse = {
   +type: 9,
   +signedIdentityKeysBlob: SignedIdentityKeysBlob,
 };
 
 type InitialNotificationsEncryptedMessageServerRequest = {
   +type: 10,
 };
 const initialNotificationsEncryptedMessageServerRequestValidator =
   tShape<InitialNotificationsEncryptedMessageServerRequest>({
     type: tNumber(serverRequestTypes.INITIAL_NOTIFICATIONS_ENCRYPTED_MESSAGE),
   });
 
 type InitialNotificationsEncryptedMessageClientResponse = {
   +type: 10,
   +initialNotificationsEncryptedMessage: string,
 };
 
 export type ServerServerRequest =
   | PlatformServerRequest
   | PlatformDetailsServerRequest
   | ServerCheckStateServerRequest
   | MoreOneTimeKeysServerRequest
   | SignedIdentityKeysBlobServerRequest
   | InitialNotificationsEncryptedMessageServerRequest;
 export const serverServerRequestValidator: TUnion<ServerServerRequest> =
   t.union([
     platformServerRequestValidator,
     platformDetailsServerRequestValidator,
     serverCheckStateServerRequestValidator,
     moreOneTimeKeysServerRequestValidator,
     signedIdentityKeysBlobServerRequestValidator,
     initialNotificationsEncryptedMessageServerRequestValidator,
   ]);
 
 export type ClientResponse =
   | PlatformClientResponse
   | ThreadInconsistencyClientResponse
   | PlatformDetailsClientResponse
   | EntryInconsistencyClientResponse
   | CheckStateClientResponse
   | InitialActivityUpdatesClientResponse
   | MoreOneTimeKeysClientResponse
   | SignedIdentityKeysBlobClientResponse
   | InitialNotificationsEncryptedMessageClientResponse;
 
 export type ClientCheckStateServerRequest = {
   +type: 6,
   +hashesToCheck: { +[key: string]: number },
   +failUnmentioned?: Partial<{
     +threadInfos: boolean,
     +entryInfos: boolean,
     +userInfos: boolean,
   }>,
   +stateChanges?: Partial<{
     +rawThreadInfos: RawThreadInfo[],
     +rawEntryInfos: RawEntryInfo[],
     +currentUserInfo: CurrentUserInfo,
     +userInfos: AccountUserInfo[],
     +deleteThreadIDs: string[],
     +deleteEntryIDs: string[],
     +deleteUserInfoIDs: string[],
   }>,
 };
 export type ClientServerRequest =
   | PlatformServerRequest
   | PlatformDetailsServerRequest
   | ClientCheckStateServerRequest
   | MoreOneTimeKeysServerRequest
   | SignedIdentityKeysBlobServerRequest
   | InitialNotificationsEncryptedMessageServerRequest;
 
 // This is just the client variant of ClientResponse. The server needs to handle
 // multiple client versions so the type supports old versions of certain client
 // responses, but the client variant only need to support the latest version.
 type ClientThreadInconsistencyClientResponse = {
   ...ClientThreadInconsistencyReportShape,
   +type: 2,
 };
 type ClientEntryInconsistencyClientResponse = {
   +type: 5,
   ...ClientEntryInconsistencyReportShape,
 };
 export type ClientClientResponse =
   | PlatformClientResponse
   | ClientThreadInconsistencyClientResponse
   | PlatformDetailsClientResponse
   | ClientEntryInconsistencyClientResponse
   | CheckStateClientResponse
   | InitialActivityUpdatesClientResponse
   | MoreOneTimeKeysClientResponse
   | SignedIdentityKeysBlobClientResponse
   | InitialNotificationsEncryptedMessageClientResponse;
 
 export type ClientInconsistencyResponse =
   | ClientThreadInconsistencyClientResponse
   | ClientEntryInconsistencyClientResponse;
 
 export const processServerRequestsActionType = 'PROCESS_SERVER_REQUESTS';
 export type ProcessServerRequestsPayload = {
   +serverRequests: $ReadOnlyArray<ClientServerRequest>,
   +calendarQuery: CalendarQuery,
 };
 export type ProcessServerRequestAction = {
   +type: 'PROCESS_SERVER_REQUESTS',
   +payload: ProcessServerRequestsPayload,
 };
 
 export type GetSessionPublicKeysArgs = {
   +session: string,
 };
 
 export type OlmSessionInitializationInfo = {
   +prekey: string,
   +prekeySignature: string,
   +oneTimeKey: string,
 };
 export const olmSessionInitializationInfoValidator: TInterface<OlmSessionInitializationInfo> =
   tShape<OlmSessionInitializationInfo>({
     prekey: t.String,
     prekeySignature: t.String,
     oneTimeKey: t.String,
   });
 
 export type GetOlmSessionInitializationDataResponse = {
   +signedIdentityKeysBlob: SignedIdentityKeysBlob,
   +contentInitializationInfo: OlmSessionInitializationInfo,
   +notifInitializationInfo: OlmSessionInitializationInfo,
 };
 export const getOlmSessionInitializationDataResponseValidator: TInterface<GetOlmSessionInitializationDataResponse> =
   tShape({
     signedIdentityKeysBlob: signedIdentityKeysBlobValidator,
     contentInitializationInfo: olmSessionInitializationInfoValidator,
     notifInitializationInfo: olmSessionInitializationInfoValidator,
   });
diff --git a/lib/types/socket-types.js b/lib/types/socket-types.js
index c651ec060..76fd95c7d 100644
--- a/lib/types/socket-types.js
+++ b/lib/types/socket-types.js
@@ -1,546 +1,546 @@
 // @flow
 
 import invariant from 'invariant';
 import t, { type TInterface, type TUnion } from 'tcomb';
 
 import {
   type ActivityUpdate,
   activityUpdateValidator,
   type UpdateActivityResult,
   updateActivityResultValidator,
 } from './activity-types.js';
 import {
   type CompressedData,
   compressedDataValidator,
 } from './compression-types.js';
 import type { APIRequest } from './endpoints.js';
 import {
   type RawEntryInfo,
   rawEntryInfoValidator,
   type CalendarQuery,
 } from './entry-types.js';
 import {
   type MessagesResponse,
   messagesResponseValidator,
   type NewMessagesPayload,
   newMessagesPayloadValidator,
 } from './message-types.js';
 import {
   type ServerServerRequest,
   serverServerRequestValidator,
   type ClientServerRequest,
   type ClientResponse,
   type ClientClientResponse,
 } from './request-types.js';
 import type { SessionState, SessionIdentification } from './session-types.js';
 import type { MixedRawThreadInfos, RawThreadInfos } from './thread-types.js';
 import {
   type ClientUpdatesResult,
   type ClientUpdatesResultWithUserInfos,
   type ServerUpdatesResult,
   serverUpdatesResultValidator,
   type ServerUpdatesResultWithUserInfos,
   serverUpdatesResultWithUserInfosValidator,
 } from './update-types.js';
 import {
   type UserInfo,
   userInfoValidator,
   type CurrentUserInfo,
   currentUserInfoValidator,
   type LoggedOutUserInfo,
   loggedOutUserInfoValidator,
 } from './user-types.js';
-import { mixedRawThreadInfoValidator } from '../permissions/minimally-encoded-thread-permissions-validators.js';
+import { mixedRawThreadInfoValidator } from '../permissions/minimally-encoded-raw-thread-info-validators.js';
 import { tShape, tNumber, tID } from '../utils/validation-utils.js';
 
 // The types of messages that the client sends across the socket
 export const clientSocketMessageTypes = Object.freeze({
   INITIAL: 0,
   RESPONSES: 1,
   //ACTIVITY_UPDATES: 2, (DEPRECATED)
   PING: 3,
   ACK_UPDATES: 4,
   API_REQUEST: 5,
 });
 export type ClientSocketMessageType = $Values<typeof clientSocketMessageTypes>;
 export function assertClientSocketMessageType(
   ourClientSocketMessageType: number,
 ): ClientSocketMessageType {
   invariant(
     ourClientSocketMessageType === 0 ||
       ourClientSocketMessageType === 1 ||
       ourClientSocketMessageType === 3 ||
       ourClientSocketMessageType === 4 ||
       ourClientSocketMessageType === 5,
     'number is not ClientSocketMessageType enum',
   );
   return ourClientSocketMessageType;
 }
 
 export type InitialClientSocketMessage = {
   +type: 0,
   +id: number,
   +payload: {
     +sessionIdentification: SessionIdentification,
     +sessionState: SessionState,
     +clientResponses: $ReadOnlyArray<ClientResponse>,
   },
 };
 export type ResponsesClientSocketMessage = {
   +type: 1,
   +id: number,
   +payload: {
     +clientResponses: $ReadOnlyArray<ClientResponse>,
   },
 };
 export type PingClientSocketMessage = {
   +type: 3,
   +id: number,
 };
 export type AckUpdatesClientSocketMessage = {
   +type: 4,
   +id: number,
   +payload: {
     +currentAsOf: number,
   },
 };
 export type APIRequestClientSocketMessage = {
   +type: 5,
   +id: number,
   +payload: APIRequest,
 };
 export type ClientSocketMessage =
   | InitialClientSocketMessage
   | ResponsesClientSocketMessage
   | PingClientSocketMessage
   | AckUpdatesClientSocketMessage
   | APIRequestClientSocketMessage;
 
 export type ClientInitialClientSocketMessage = {
   +type: 0,
   +id: number,
   +payload: {
     +sessionIdentification: SessionIdentification,
     +sessionState: SessionState,
     +clientResponses: $ReadOnlyArray<ClientClientResponse>,
   },
 };
 export type ClientResponsesClientSocketMessage = {
   +type: 1,
   +id: number,
   +payload: {
     +clientResponses: $ReadOnlyArray<ClientClientResponse>,
   },
 };
 export type ClientClientSocketMessage =
   | ClientInitialClientSocketMessage
   | ClientResponsesClientSocketMessage
   | PingClientSocketMessage
   | AckUpdatesClientSocketMessage
   | APIRequestClientSocketMessage;
 export type ClientSocketMessageWithoutID = $Diff<
   ClientClientSocketMessage,
   { id: number },
 >;
 
 // The types of messages that the server sends across the socket
 export const serverSocketMessageTypes = Object.freeze({
   STATE_SYNC: 0,
   REQUESTS: 1,
   ERROR: 2,
   AUTH_ERROR: 3,
   ACTIVITY_UPDATE_RESPONSE: 4,
   PONG: 5,
   UPDATES: 6,
   MESSAGES: 7,
   API_RESPONSE: 8,
   COMPRESSED_MESSAGE: 9,
 });
 export type ServerSocketMessageType = $Values<typeof serverSocketMessageTypes>;
 export function assertServerSocketMessageType(
   ourServerSocketMessageType: number,
 ): ServerSocketMessageType {
   invariant(
     ourServerSocketMessageType === 0 ||
       ourServerSocketMessageType === 1 ||
       ourServerSocketMessageType === 2 ||
       ourServerSocketMessageType === 3 ||
       ourServerSocketMessageType === 4 ||
       ourServerSocketMessageType === 5 ||
       ourServerSocketMessageType === 6 ||
       ourServerSocketMessageType === 7 ||
       ourServerSocketMessageType === 8 ||
       ourServerSocketMessageType === 9,
     'number is not ServerSocketMessageType enum',
   );
   return ourServerSocketMessageType;
 }
 
 export const stateSyncPayloadTypes = Object.freeze({
   FULL: 0,
   INCREMENTAL: 1,
 });
 
 export const fullStateSyncActionType = 'FULL_STATE_SYNC';
 export type BaseFullStateSync = {
   +messagesResult: MessagesResponse,
   +rawEntryInfos: $ReadOnlyArray<RawEntryInfo>,
   +userInfos: $ReadOnlyArray<UserInfo>,
   +updatesCurrentAsOf: number,
 };
 const baseFullStateSyncValidator = tShape<BaseFullStateSync>({
   messagesResult: messagesResponseValidator,
   rawEntryInfos: t.list(rawEntryInfoValidator),
   userInfos: t.list(userInfoValidator),
   updatesCurrentAsOf: t.Number,
 });
 
 export type ClientFullStateSync = $ReadOnly<{
   ...BaseFullStateSync,
   +threadInfos: RawThreadInfos,
   +currentUserInfo: CurrentUserInfo,
 }>;
 export type StateSyncFullActionPayload = $ReadOnly<{
   ...ClientFullStateSync,
   +calendarQuery: CalendarQuery,
   +keyserverID: string,
 }>;
 export type ClientStateSyncFullSocketPayload = $ReadOnly<{
   ...ClientFullStateSync,
   +type: 0,
   // Included iff client is using sessionIdentifierTypes.BODY_SESSION_ID
   +sessionID?: string,
 }>;
 
 export type ServerFullStateSync = $ReadOnly<{
   ...BaseFullStateSync,
   +threadInfos: MixedRawThreadInfos,
   +currentUserInfo: CurrentUserInfo,
 }>;
 const serverFullStateSyncValidator = tShape<ServerFullStateSync>({
   ...baseFullStateSyncValidator.meta.props,
   threadInfos: t.dict(tID, mixedRawThreadInfoValidator),
   currentUserInfo: currentUserInfoValidator,
 });
 
 export type ServerStateSyncFullSocketPayload = {
   ...ServerFullStateSync,
   +type: 0,
   // Included iff client is using sessionIdentifierTypes.BODY_SESSION_ID
   +sessionID?: string,
 };
 const serverStateSyncFullSocketPayloadValidator =
   tShape<ServerStateSyncFullSocketPayload>({
     ...serverFullStateSyncValidator.meta.props,
     type: tNumber(stateSyncPayloadTypes.FULL),
     sessionID: t.maybe(t.String),
   });
 
 export const incrementalStateSyncActionType = 'INCREMENTAL_STATE_SYNC';
 export type BaseIncrementalStateSync = {
   +messagesResult: MessagesResponse,
   +deltaEntryInfos: $ReadOnlyArray<RawEntryInfo>,
   +deletedEntryIDs: $ReadOnlyArray<string>,
   +userInfos: $ReadOnlyArray<UserInfo>,
 };
 const baseIncrementalStateSyncValidator = tShape<BaseIncrementalStateSync>({
   messagesResult: messagesResponseValidator,
   deltaEntryInfos: t.list(rawEntryInfoValidator),
   deletedEntryIDs: t.list(tID),
   userInfos: t.list(userInfoValidator),
 });
 
 export type ClientIncrementalStateSync = {
   ...BaseIncrementalStateSync,
   +updatesResult: ClientUpdatesResult,
 };
 export type StateSyncIncrementalActionPayload = {
   ...ClientIncrementalStateSync,
   +calendarQuery: CalendarQuery,
   +keyserverID: string,
 };
 type ClientStateSyncIncrementalSocketPayload = {
   +type: 1,
   ...ClientIncrementalStateSync,
 };
 
 export type ServerIncrementalStateSync = {
   ...BaseIncrementalStateSync,
   +updatesResult: ServerUpdatesResult,
 };
 const serverIncrementalStateSyncValidator = tShape<ServerIncrementalStateSync>({
   ...baseIncrementalStateSyncValidator.meta.props,
   updatesResult: serverUpdatesResultValidator,
 });
 
 type ServerStateSyncIncrementalSocketPayload = {
   +type: 1,
   ...ServerIncrementalStateSync,
 };
 const serverStateSyncIncrementalSocketPayloadValidator =
   tShape<ServerStateSyncIncrementalSocketPayload>({
     type: tNumber(stateSyncPayloadTypes.INCREMENTAL),
     ...serverIncrementalStateSyncValidator.meta.props,
   });
 
 export type ClientStateSyncSocketPayload =
   | ClientStateSyncFullSocketPayload
   | ClientStateSyncIncrementalSocketPayload;
 export type ServerStateSyncSocketPayload =
   | ServerStateSyncFullSocketPayload
   | ServerStateSyncIncrementalSocketPayload;
 const serverStateSyncSocketPayloadValidator = t.union([
   serverStateSyncFullSocketPayloadValidator,
   serverStateSyncIncrementalSocketPayloadValidator,
 ]);
 
 export type ServerStateSyncServerSocketMessage = {
   +type: 0,
   +responseTo: number,
   +payload: ServerStateSyncSocketPayload,
 };
 export const serverStateSyncServerSocketMessageValidator: TInterface<ServerStateSyncServerSocketMessage> =
   tShape<ServerStateSyncServerSocketMessage>({
     type: tNumber(serverSocketMessageTypes.STATE_SYNC),
     responseTo: t.Number,
     payload: serverStateSyncSocketPayloadValidator,
   });
 
 type ServerRequestsServerSocketMessagePayload = {
   +serverRequests: $ReadOnlyArray<ServerServerRequest>,
 };
 export type ServerRequestsServerSocketMessage = {
   +type: 1,
   +responseTo?: number,
   +payload: ServerRequestsServerSocketMessagePayload,
 };
 export const serverRequestsServerSocketMessageValidator: TInterface<ServerRequestsServerSocketMessage> =
   tShape<ServerRequestsServerSocketMessage>({
     type: tNumber(serverSocketMessageTypes.REQUESTS),
     responseTo: t.maybe(t.Number),
     payload: tShape<ServerRequestsServerSocketMessagePayload>({
       serverRequests: t.list(serverServerRequestValidator),
     }),
   });
 
 export type ErrorServerSocketMessage = {
   type: 2,
   responseTo?: number,
   message: string,
   payload?: Object,
 };
 export const errorServerSocketMessageValidator: TInterface<ErrorServerSocketMessage> =
   tShape<ErrorServerSocketMessage>({
     type: tNumber(serverSocketMessageTypes.ERROR),
     responseTo: t.maybe(t.Number),
     message: t.String,
     payload: t.maybe(t.Object),
   });
 
 type SessionChange = {
   +cookie: string,
   +currentUserInfo: LoggedOutUserInfo,
 };
 
 export type AuthErrorServerSocketMessage = {
   +type: 3,
   +responseTo: number,
   +message: string,
   +sessionChange: SessionChange,
 };
 export const authErrorServerSocketMessageValidator: TInterface<AuthErrorServerSocketMessage> =
   tShape<AuthErrorServerSocketMessage>({
     type: tNumber(serverSocketMessageTypes.AUTH_ERROR),
     responseTo: t.Number,
     message: t.String,
     sessionChange: t.maybe(
       tShape<SessionChange>({
         cookie: t.String,
         currentUserInfo: loggedOutUserInfoValidator,
       }),
     ),
   });
 
 export type ActivityUpdateResponseServerSocketMessage = {
   +type: 4,
   +responseTo: number,
   +payload: UpdateActivityResult,
 };
 export const activityUpdateResponseServerSocketMessageValidator: TInterface<ActivityUpdateResponseServerSocketMessage> =
   tShape<ActivityUpdateResponseServerSocketMessage>({
     type: tNumber(serverSocketMessageTypes.ACTIVITY_UPDATE_RESPONSE),
     responseTo: t.Number,
     payload: updateActivityResultValidator,
   });
 
 export type PongServerSocketMessage = {
   +type: 5,
   +responseTo: number,
 };
 export const pongServerSocketMessageValidator: TInterface<PongServerSocketMessage> =
   tShape<PongServerSocketMessage>({
     type: tNumber(serverSocketMessageTypes.PONG),
     responseTo: t.Number,
   });
 
 export type ServerUpdatesServerSocketMessage = {
   +type: 6,
   +payload: ServerUpdatesResultWithUserInfos,
 };
 export const serverUpdatesServerSocketMessageValidator: TInterface<ServerUpdatesServerSocketMessage> =
   tShape<ServerUpdatesServerSocketMessage>({
     type: tNumber(serverSocketMessageTypes.UPDATES),
     payload: serverUpdatesResultWithUserInfosValidator,
   });
 
 export type MessagesServerSocketMessage = {
   +type: 7,
   +payload: NewMessagesPayload,
 };
 export const messagesServerSocketMessageValidator: TInterface<MessagesServerSocketMessage> =
   tShape<MessagesServerSocketMessage>({
     type: tNumber(serverSocketMessageTypes.MESSAGES),
     payload: newMessagesPayloadValidator,
   });
 
 export type APIResponseServerSocketMessage = {
   +type: 8,
   +responseTo: number,
   +payload?: Object,
 };
 export const apiResponseServerSocketMessageValidator: TInterface<APIResponseServerSocketMessage> =
   tShape<APIResponseServerSocketMessage>({
     type: tNumber(serverSocketMessageTypes.API_RESPONSE),
     responseTo: t.Number,
     payload: t.maybe(t.Object),
   });
 
 export type CompressedMessageServerSocketMessage = {
   +type: 9,
   +payload: CompressedData,
 };
 export const compressedMessageServerSocketMessageValidator: TInterface<CompressedMessageServerSocketMessage> =
   tShape<CompressedMessageServerSocketMessage>({
     type: tNumber(serverSocketMessageTypes.COMPRESSED_MESSAGE),
     payload: compressedDataValidator,
   });
 
 export type ServerServerSocketMessage =
   | ServerStateSyncServerSocketMessage
   | ServerRequestsServerSocketMessage
   | ErrorServerSocketMessage
   | AuthErrorServerSocketMessage
   | ActivityUpdateResponseServerSocketMessage
   | PongServerSocketMessage
   | ServerUpdatesServerSocketMessage
   | MessagesServerSocketMessage
   | APIResponseServerSocketMessage
   | CompressedMessageServerSocketMessage;
 export const serverServerSocketMessageValidator: TUnion<ServerServerSocketMessage> =
   t.union([
     serverStateSyncServerSocketMessageValidator,
     serverRequestsServerSocketMessageValidator,
     errorServerSocketMessageValidator,
     authErrorServerSocketMessageValidator,
     activityUpdateResponseServerSocketMessageValidator,
     pongServerSocketMessageValidator,
     serverUpdatesServerSocketMessageValidator,
     messagesServerSocketMessageValidator,
     apiResponseServerSocketMessageValidator,
     compressedMessageServerSocketMessageValidator,
   ]);
 
 export type ClientRequestsServerSocketMessage = {
   +type: 1,
   +responseTo?: number,
   +payload: {
     +serverRequests: $ReadOnlyArray<ClientServerRequest>,
   },
 };
 export type ClientStateSyncServerSocketMessage = {
   +type: 0,
   +responseTo: number,
   +payload: ClientStateSyncSocketPayload,
 };
 export type ClientUpdatesServerSocketMessage = {
   +type: 6,
   +payload: ClientUpdatesResultWithUserInfos,
 };
 export type ClientServerSocketMessage =
   | ClientStateSyncServerSocketMessage
   | ClientRequestsServerSocketMessage
   | ErrorServerSocketMessage
   | AuthErrorServerSocketMessage
   | ActivityUpdateResponseServerSocketMessage
   | PongServerSocketMessage
   | ClientUpdatesServerSocketMessage
   | MessagesServerSocketMessage
   | APIResponseServerSocketMessage
   | CompressedMessageServerSocketMessage;
 
 export type SocketListener = (message: ClientServerSocketMessage) => void;
 
 export type ConnectionStatus =
   | 'connecting'
   | 'connected'
   | 'reconnecting'
   | 'disconnecting'
   | 'forcedDisconnecting'
   | 'disconnected';
 
 export type ConnectionIssue =
   | 'policy_acknowledgement_socket_crash_loop'
   | 'not_logged_in_error';
 
 export type ConnectionInfo = {
   +status: ConnectionStatus,
   +queuedActivityUpdates: $ReadOnlyArray<ActivityUpdate>,
   +lateResponses: $ReadOnlyArray<number>,
   +unreachable: boolean,
   +connectionIssue: ?ConnectionIssue,
   // When this is flipped to true, a session recovery is attempted
   // This can happen when the keyserver invalidates the session
   +sessionRecoveryInProgress: boolean,
 };
 export const connectionInfoValidator: TInterface<ConnectionInfo> =
   tShape<ConnectionInfo>({
     status: t.enums.of([
       'connecting',
       'connected',
       'reconnecting',
       'disconnecting',
       'forcedDisconnecting',
       'disconnected',
     ]),
     queuedActivityUpdates: t.list(activityUpdateValidator),
     lateResponses: t.list(t.Number),
     unreachable: t.Boolean,
     connectionIssue: t.maybe(
       t.enums.of([
         'policy_acknowledgement_socket_crash_loop',
         'not_logged_in_error',
       ]),
     ),
     sessionRecoveryInProgress: t.Boolean,
   });
 export const defaultConnectionInfo: ConnectionInfo = {
   status: 'connecting',
   queuedActivityUpdates: [],
   lateResponses: [],
   unreachable: false,
   connectionIssue: null,
   sessionRecoveryInProgress: false,
 };
 
 export type OneTimeKeyGenerator = (inc: number) => string;
 
 export type GRPCStream = {
   readyState: number,
   onopen: (ev: any) => mixed,
   onmessage: (ev: MessageEvent) => mixed,
   onclose: (ev: CloseEvent) => mixed,
   close(code?: number, reason?: string): void,
   send(data: string | Blob | ArrayBuffer | $ArrayBufferView): void,
 };
 
 export type CommTransportLayer = GRPCStream | WebSocket;
diff --git a/lib/utils/thread-ops-utils.js b/lib/utils/thread-ops-utils.js
index 1a89c19c0..b02422560 100644
--- a/lib/utils/thread-ops-utils.js
+++ b/lib/utils/thread-ops-utils.js
@@ -1,139 +1,139 @@
 // @flow
 
 import invariant from 'invariant';
 
 import {
-  MemberInfoValidator,
+  memberInfoValidator,
   roleInfoValidator,
   threadCurrentUserInfoValidator,
-} from '../permissions/minimally-encoded-thread-permissions-validators.js';
+} from '../permissions/minimally-encoded-raw-thread-info-validators.js';
 import type {
   MemberInfo,
   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 {
   type ClientDBThreadInfo,
   legacyMemberInfoValidator,
   type LegacyRawThreadInfo,
   legacyRoleInfoValidator,
   legacyThreadCurrentUserInfoValidator,
 } from '../types/thread-types.js';
 
 function convertRawThreadInfoToClientDBThreadInfo(
   rawThreadInfo: LegacyRawThreadInfo | RawThreadInfo,
 ): ClientDBThreadInfo {
   const { minimallyEncoded, ...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<MemberInfo> = rawMembers.map(
     rawMember => {
       invariant(
-        MemberInfoValidator.is(rawMember) ||
+        memberInfoValidator.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(
       roleInfoValidator.is(roleInfo) || legacyRoleInfoValidator.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,
   };
 
   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,
 };