diff --git a/keyserver/src/responders/activity-responders.js b/keyserver/src/responders/activity-responders.js
index 20908e336..42758d7d2 100644
--- a/keyserver/src/responders/activity-responders.js
+++ b/keyserver/src/responders/activity-responders.js
@@ -1,68 +1,76 @@
 // @flow
 
 import t from 'tcomb';
 import type { TList } from 'tcomb';
 
 import {
   type UpdateActivityResult,
   type UpdateActivityRequest,
   type SetThreadUnreadStatusRequest,
   type SetThreadUnreadStatusResult,
   type ActivityUpdate,
   setThreadUnreadStatusResult,
   updateActivityResultValidator,
 } from 'lib/types/activity-types.js';
 import { tShape, tID } from 'lib/utils/validation-utils.js';
 
 import type { Viewer } from '../session/viewer.js';
 import {
   activityUpdater,
   setThreadUnreadStatus,
 } from '../updaters/activity-updaters.js';
 import { validateInput, validateOutput } from '../utils/validation-utils.js';
 
 const activityUpdatesInputValidator: TList<Array<ActivityUpdate>> = t.list(
   tShape({
     focus: t.Bool,
     threadID: tID,
     latestMessage: t.maybe(tID),
   }),
 );
 
 const inputValidator = tShape<UpdateActivityRequest>({
   updates: activityUpdatesInputValidator,
 });
 
 async function updateActivityResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<UpdateActivityResult> {
   const request = await validateInput(viewer, inputValidator, input);
   const result = await activityUpdater(viewer, request);
-  return validateOutput(viewer, updateActivityResultValidator, result);
+  return validateOutput(
+    viewer.platformDetails,
+    updateActivityResultValidator,
+    result,
+  );
 }
 
 const setThreadUnreadStatusValidator = tShape<SetThreadUnreadStatusRequest>({
   threadID: tID,
   unread: t.Bool,
   latestMessage: t.maybe(tID),
 });
 async function threadSetUnreadStatusResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<SetThreadUnreadStatusResult> {
   const request = await validateInput(
     viewer,
     setThreadUnreadStatusValidator,
     input,
   );
 
   const result = await setThreadUnreadStatus(viewer, request);
-  return validateOutput(viewer, setThreadUnreadStatusResult, result);
+  return validateOutput(
+    viewer.platformDetails,
+    setThreadUnreadStatusResult,
+    result,
+  );
 }
 
 export {
   activityUpdatesInputValidator,
   updateActivityResponder,
   threadSetUnreadStatusResponder,
 };
diff --git a/keyserver/src/responders/entry-responders.js b/keyserver/src/responders/entry-responders.js
index 35efe6264..270758f73 100644
--- a/keyserver/src/responders/entry-responders.js
+++ b/keyserver/src/responders/entry-responders.js
@@ -1,341 +1,365 @@
 // @flow
 
 import t from 'tcomb';
 import type { TInterface } from 'tcomb';
 
 import { filteredThreadIDs } from 'lib/selectors/calendar-filter-selectors.js';
 import {
   type CalendarQuery,
   type SaveEntryRequest,
   type CreateEntryRequest,
   type DeleteEntryRequest,
   type DeleteEntryResponse,
   type RestoreEntryRequest,
   type RestoreEntryResponse,
   type FetchEntryInfosResponse,
   type DeltaEntryInfosResult,
   type SaveEntryResponse,
   rawEntryInfoValidator,
 } from 'lib/types/entry-types.js';
 import {
   type CalendarFilter,
   calendarThreadFilterTypes,
 } from 'lib/types/filter-types.js';
 import {
   type FetchEntryRevisionInfosResult,
   type FetchEntryRevisionInfosRequest,
   historyRevisionInfoValidator,
 } from 'lib/types/history-types.js';
 import { rawMessageInfoValidator } from 'lib/types/message-types.js';
 import { serverCreateUpdatesResponseValidator } from 'lib/types/update-types.js';
 import { accountUserInfoValidator } from 'lib/types/user-types.js';
 import { ServerError } from 'lib/utils/errors.js';
 import { tString, tShape, tDate, tID } from 'lib/utils/validation-utils.js';
 
 import createEntry from '../creators/entry-creator.js';
 import { deleteEntry, restoreEntry } from '../deleters/entry-deleters.js';
 import {
   fetchEntryInfos,
   fetchEntryRevisionInfo,
   fetchEntriesForSession,
 } from '../fetchers/entry-fetchers.js';
 import { verifyThreadIDs } from '../fetchers/thread-fetchers.js';
 import type { Viewer } from '../session/viewer.js';
 import {
   updateEntry,
   compareNewCalendarQuery,
 } from '../updaters/entry-updaters.js';
 import { commitSessionUpdate } from '../updaters/session-updaters.js';
 import { validateInput, validateOutput } from '../utils/validation-utils.js';
 
 type EntryQueryInput = {
   +startDate: string,
   +endDate: string,
   +navID?: ?string,
   +includeDeleted?: ?boolean,
   +filters?: ?$ReadOnlyArray<CalendarFilter>,
 };
 const entryQueryInputValidator: TInterface<EntryQueryInput> = tShape({
   navID: t.maybe(t.String),
   startDate: tDate,
   endDate: tDate,
   includeDeleted: t.maybe(t.Boolean),
   filters: t.maybe(
     t.list(
       t.union([
         tShape({
           type: tString(calendarThreadFilterTypes.NOT_DELETED),
         }),
         tShape({
           type: tString(calendarThreadFilterTypes.THREAD_LIST),
           threadIDs: t.list(tID),
         }),
       ]),
     ),
   ),
 });
 
 const newEntryQueryInputValidator: TInterface<CalendarQuery> = tShape({
   startDate: tDate,
   endDate: tDate,
   filters: t.list(
     t.union([
       tShape({
         type: tString(calendarThreadFilterTypes.NOT_DELETED),
       }),
       tShape({
         type: tString(calendarThreadFilterTypes.THREAD_LIST),
         threadIDs: t.list(tID),
       }),
     ]),
   ),
 });
 
 function normalizeCalendarQuery(input: any): CalendarQuery {
   if (input.filters) {
     return {
       startDate: input.startDate,
       endDate: input.endDate,
       filters: input.filters,
     };
   }
   const filters = [];
   if (!input.includeDeleted) {
     filters.push({ type: calendarThreadFilterTypes.NOT_DELETED });
   }
   if (input.navID !== 'home') {
     filters.push({
       type: calendarThreadFilterTypes.THREAD_LIST,
       threadIDs: [input.navID],
     });
   }
   return {
     startDate: input.startDate,
     endDate: input.endDate,
     filters,
   };
 }
 
 async function verifyCalendarQueryThreadIDs(
   request: CalendarQuery,
 ): Promise<void> {
   const threadIDsToFilterTo = filteredThreadIDs(request.filters);
   if (threadIDsToFilterTo && threadIDsToFilterTo.size > 0) {
     const verifiedThreadIDs = await verifyThreadIDs([...threadIDsToFilterTo]);
     if (verifiedThreadIDs.length !== threadIDsToFilterTo.size) {
       throw new ServerError('invalid_parameters');
     }
   }
 }
 
 export const fetchEntryInfosResponseValidator: TInterface<FetchEntryInfosResponse> =
   tShape<FetchEntryInfosResponse>({
     rawEntryInfos: t.list(rawEntryInfoValidator),
     userInfos: t.dict(t.String, accountUserInfoValidator),
   });
 
 async function entryFetchResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<FetchEntryInfosResponse> {
   const inputQuery = await validateInput(
     viewer,
     entryQueryInputValidator,
     input,
   );
   const request = normalizeCalendarQuery(inputQuery);
 
   await verifyCalendarQueryThreadIDs(request);
 
   const response = await fetchEntryInfos(viewer, [request]);
-  return validateOutput(viewer, fetchEntryInfosResponseValidator, {
-    ...response,
-    userInfos: {},
-  });
+  return validateOutput(
+    viewer.platformDetails,
+    fetchEntryInfosResponseValidator,
+    {
+      ...response,
+      userInfos: {},
+    },
+  );
 }
 
 const entryRevisionHistoryFetchInputValidator =
   tShape<FetchEntryRevisionInfosRequest>({
     id: tID,
   });
 
 export const fetchEntryRevisionInfosResultValidator: TInterface<FetchEntryRevisionInfosResult> =
   tShape<FetchEntryRevisionInfosResult>({
     result: t.list(historyRevisionInfoValidator),
   });
 
 async function entryRevisionFetchResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<FetchEntryRevisionInfosResult> {
   const request = await validateInput(
     viewer,
     entryRevisionHistoryFetchInputValidator,
     input,
   );
   const entryHistory = await fetchEntryRevisionInfo(viewer, request.id);
   const response = { result: entryHistory };
   return validateOutput(
-    viewer,
+    viewer.platformDetails,
     fetchEntryRevisionInfosResultValidator,
     response,
   );
 }
 
 const createEntryRequestInputValidator = tShape<CreateEntryRequest>({
   text: t.String,
   sessionID: t.maybe(t.String),
   timestamp: t.Number,
   date: tDate,
   threadID: tID,
   localID: t.maybe(t.String),
   calendarQuery: t.maybe(newEntryQueryInputValidator),
 });
 
 export const saveEntryResponseValidator: TInterface<SaveEntryResponse> =
   tShape<SaveEntryResponse>({
     entryID: tID,
     newMessageInfos: t.list(rawMessageInfoValidator),
     updatesResult: serverCreateUpdatesResponseValidator,
   });
 
 async function entryCreationResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<SaveEntryResponse> {
   const request = await validateInput(
     viewer,
     createEntryRequestInputValidator,
     input,
   );
   const response = await createEntry(viewer, request);
-  return validateOutput(viewer, saveEntryResponseValidator, response);
+  return validateOutput(
+    viewer.platformDetails,
+    saveEntryResponseValidator,
+    response,
+  );
 }
 
 const saveEntryRequestInputValidator = tShape<SaveEntryRequest>({
   entryID: tID,
   text: t.String,
   prevText: t.String,
   sessionID: t.maybe(t.String),
   timestamp: t.Number,
   calendarQuery: t.maybe(newEntryQueryInputValidator),
 });
 
 async function entryUpdateResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<SaveEntryResponse> {
   const request = await validateInput(
     viewer,
     saveEntryRequestInputValidator,
     input,
   );
   const response = await updateEntry(viewer, request);
-  return validateOutput(viewer, saveEntryResponseValidator, response);
+  return validateOutput(
+    viewer.platformDetails,
+    saveEntryResponseValidator,
+    response,
+  );
 }
 
 const deleteEntryRequestInputValidator = tShape<DeleteEntryRequest>({
   entryID: tID,
   prevText: t.String,
   sessionID: t.maybe(t.String),
   timestamp: t.Number,
   calendarQuery: t.maybe(newEntryQueryInputValidator),
 });
 
 export const deleteEntryResponseValidator: TInterface<DeleteEntryResponse> =
   tShape<DeleteEntryResponse>({
     newMessageInfos: t.list(rawMessageInfoValidator),
     threadID: tID,
     updatesResult: serverCreateUpdatesResponseValidator,
   });
 
 async function entryDeletionResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<DeleteEntryResponse> {
   const request = await validateInput(
     viewer,
     deleteEntryRequestInputValidator,
     input,
   );
   const response = await deleteEntry(viewer, request);
-  return validateOutput(viewer, deleteEntryResponseValidator, response);
+  return validateOutput(
+    viewer.platformDetails,
+    deleteEntryResponseValidator,
+    response,
+  );
 }
 
 const restoreEntryRequestInputValidator = tShape<RestoreEntryRequest>({
   entryID: tID,
   sessionID: t.maybe(t.String),
   timestamp: t.Number,
   calendarQuery: t.maybe(newEntryQueryInputValidator),
 });
 
 export const restoreEntryResponseValidator: TInterface<RestoreEntryResponse> =
   tShape<RestoreEntryResponse>({
     newMessageInfos: t.list(rawMessageInfoValidator),
     updatesResult: serverCreateUpdatesResponseValidator,
   });
 
 async function entryRestorationResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<RestoreEntryResponse> {
   const request = await validateInput(
     viewer,
     restoreEntryRequestInputValidator,
     input,
   );
   const response = await restoreEntry(viewer, request);
-  return validateOutput(viewer, restoreEntryResponseValidator, response);
+  return validateOutput(
+    viewer.platformDetails,
+    restoreEntryResponseValidator,
+    response,
+  );
 }
 
 export const deltaEntryInfosResultValidator: TInterface<DeltaEntryInfosResult> =
   tShape<DeltaEntryInfosResult>({
     rawEntryInfos: t.list(rawEntryInfoValidator),
     deletedEntryIDs: t.list(tID),
     userInfos: t.list(accountUserInfoValidator),
   });
 
 async function calendarQueryUpdateResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<DeltaEntryInfosResult> {
   const request = await validateInput(
     viewer,
     newEntryQueryInputValidator,
     input,
   );
 
   await verifyCalendarQueryThreadIDs(request);
   if (!viewer.loggedIn) {
     throw new ServerError('not_logged_in');
   }
 
   const { difference, oldCalendarQuery, sessionUpdate } =
     compareNewCalendarQuery(viewer, request);
 
   const [response] = await Promise.all([
     fetchEntriesForSession(viewer, difference, oldCalendarQuery),
     commitSessionUpdate(viewer, sessionUpdate),
   ]);
 
-  return validateOutput(viewer, deltaEntryInfosResultValidator, {
-    rawEntryInfos: response.rawEntryInfos,
-    deletedEntryIDs: response.deletedEntryIDs,
-    // Old clients expect userInfos object
-    userInfos: [],
-  });
+  return validateOutput(
+    viewer.platformDetails,
+    deltaEntryInfosResultValidator,
+    {
+      rawEntryInfos: response.rawEntryInfos,
+      deletedEntryIDs: response.deletedEntryIDs,
+      // Old clients expect userInfos object
+      userInfos: [],
+    },
+  );
 }
 
 export {
   entryQueryInputValidator,
   newEntryQueryInputValidator,
   normalizeCalendarQuery,
   verifyCalendarQueryThreadIDs,
   entryFetchResponder,
   entryRevisionFetchResponder,
   entryCreationResponder,
   entryUpdateResponder,
   entryDeletionResponder,
   entryRestorationResponder,
   calendarQueryUpdateResponder,
 };
diff --git a/keyserver/src/responders/keys-responders.js b/keyserver/src/responders/keys-responders.js
index 11d493b42..cecec72a2 100644
--- a/keyserver/src/responders/keys-responders.js
+++ b/keyserver/src/responders/keys-responders.js
@@ -1,44 +1,44 @@
 // @flow
 
 import t, { type TUnion } from 'tcomb';
 
 import type { GetSessionPublicKeysArgs } from 'lib/types/request-types.js';
 import {
   type SessionPublicKeys,
   sessionPublicKeysValidator,
 } from 'lib/types/session-types.js';
 import { tShape, tNull } from 'lib/utils/validation-utils.js';
 
 import { fetchSessionPublicKeys } from '../fetchers/key-fetchers.js';
 import type { Viewer } from '../session/viewer.js';
 import { validateInput, validateOutput } from '../utils/validation-utils.js';
 
 const getSessionPublicKeysInputValidator = tShape<GetSessionPublicKeysArgs>({
   session: t.String,
 });
 
 type GetSessionPublicKeysResponse = SessionPublicKeys | null;
 export const getSessionPublicKeysResponseValidator: TUnion<GetSessionPublicKeysResponse> =
   t.union([sessionPublicKeysValidator, tNull]);
 
 async function getSessionPublicKeysResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<GetSessionPublicKeysResponse> {
   if (!viewer.loggedIn) {
     return null;
   }
   const request = await validateInput(
     viewer,
     getSessionPublicKeysInputValidator,
     input,
   );
   const response = await fetchSessionPublicKeys(request.session);
   return validateOutput(
-    viewer,
+    viewer.platformDetails,
     getSessionPublicKeysResponseValidator,
     response,
   );
 }
 
 export { getSessionPublicKeysResponder };
diff --git a/keyserver/src/responders/message-report-responder.js b/keyserver/src/responders/message-report-responder.js
index bbd9f474c..11fa8f0cf 100644
--- a/keyserver/src/responders/message-report-responder.js
+++ b/keyserver/src/responders/message-report-responder.js
@@ -1,39 +1,43 @@
 // @flow
 
 import type { TInterface } from 'tcomb';
 
 import {
   type MessageReportCreationRequest,
   type MessageReportCreationResult,
 } from 'lib/types/message-report-types.js';
 import { rawMessageInfoValidator } from 'lib/types/message-types.js';
 import { tShape, tID } from 'lib/utils/validation-utils.js';
 
 import createMessageReport from '../creators/message-report-creator.js';
 import type { Viewer } from '../session/viewer.js';
 import { validateInput, validateOutput } from '../utils/validation-utils.js';
 
 const messageReportCreationRequestInputValidator =
   tShape<MessageReportCreationRequest>({
     messageID: tID,
   });
 
 export const messageReportCreationResultValidator: TInterface<MessageReportCreationResult> =
   tShape<MessageReportCreationResult>({ messageInfo: rawMessageInfoValidator });
 
 async function messageReportCreationResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<MessageReportCreationResult> {
   const request = await validateInput(
     viewer,
     messageReportCreationRequestInputValidator,
     input,
   );
 
   const rawMessageInfos = await createMessageReport(viewer, request);
   const result = { messageInfo: rawMessageInfos[0] };
-  return validateOutput(viewer, messageReportCreationResultValidator, result);
+  return validateOutput(
+    viewer.platformDetails,
+    messageReportCreationResultValidator,
+    result,
+  );
 }
 
 export { messageReportCreationResponder };
diff --git a/keyserver/src/responders/message-responders.js b/keyserver/src/responders/message-responders.js
index ef639297c..dcecacf72 100644
--- a/keyserver/src/responders/message-responders.js
+++ b/keyserver/src/responders/message-responders.js
@@ -1,462 +1,486 @@
 // @flow
 
 import invariant from 'invariant';
 import t, { type TInterface } from 'tcomb';
 
 import { onlyOneEmojiRegex } from 'lib/shared/emojis.js';
 import {
   createMediaMessageData,
   trimMessage,
 } from 'lib/shared/message-utils.js';
 import { relationshipBlockedInEitherDirection } from 'lib/shared/relationship-utils.js';
 import type { Media } from 'lib/types/media-types.js';
 import { messageTypes } from 'lib/types/message-types-enum.js';
 import {
   type SendTextMessageRequest,
   type SendMultimediaMessageRequest,
   type SendReactionMessageRequest,
   type SendEditMessageRequest,
   type FetchMessageInfosResponse,
   type FetchMessageInfosRequest,
   defaultNumberPerThread,
   type SendMessageResponse,
   type SendEditMessageResponse,
   type FetchPinnedMessagesRequest,
   type FetchPinnedMessagesResult,
   messageTruncationStatusesValidator,
   rawMessageInfoValidator,
 } from 'lib/types/message-types.js';
 import type { EditMessageData } from 'lib/types/messages/edit.js';
 import type { ReactionMessageData } from 'lib/types/messages/reaction.js';
 import type { TextMessageData } from 'lib/types/messages/text.js';
 import { threadPermissions } from 'lib/types/thread-permission-types.js';
 import { userInfosValidator } from 'lib/types/user-types.js';
 import { ServerError } from 'lib/utils/errors.js';
 import { values } from 'lib/utils/objects.js';
 import {
   tRegex,
   tShape,
   tMediaMessageMedia,
   tID,
 } from 'lib/utils/validation-utils.js';
 
 import createMessages from '../creators/message-creator.js';
 import { SQL } from '../database/database.js';
 import {
   fetchMessageInfos,
   fetchMessageInfoForLocalID,
   fetchMessageInfoByID,
   fetchThreadMessagesCount,
   fetchPinnedMessageInfos,
 } from '../fetchers/message-fetchers.js';
 import { fetchServerThreadInfos } from '../fetchers/thread-fetchers.js';
 import { checkThreadPermission } from '../fetchers/thread-permission-fetchers.js';
 import {
   fetchImages,
   fetchMediaFromMediaMessageContent,
 } from '../fetchers/upload-fetchers.js';
 import { fetchKnownUserInfos } from '../fetchers/user-fetchers.js';
 import type { Viewer } from '../session/viewer.js';
 import {
   assignImages,
   assignMessageContainerToMedia,
 } from '../updaters/upload-updaters.js';
 import { validateInput, validateOutput } from '../utils/validation-utils.js';
 
 const sendTextMessageRequestInputValidator = tShape<SendTextMessageRequest>({
   threadID: tID,
   localID: t.maybe(t.String),
   text: t.String,
   sidebarCreation: t.maybe(t.Boolean),
 });
 
 export const sendMessageResponseValidator: TInterface<SendMessageResponse> =
   tShape<SendMessageResponse>({ newMessageInfo: rawMessageInfoValidator });
 
 async function textMessageCreationResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<SendMessageResponse> {
   const request = await validateInput(
     viewer,
     sendTextMessageRequestInputValidator,
     input,
   );
 
   const { threadID, localID, text: rawText, sidebarCreation } = request;
   const text = trimMessage(rawText);
   if (!text) {
     throw new ServerError('invalid_parameters');
   }
 
   const hasPermission = await checkThreadPermission(
     viewer,
     threadID,
     threadPermissions.VOICED,
   );
   if (!hasPermission) {
     throw new ServerError('invalid_parameters');
   }
 
   let messageData: TextMessageData = {
     type: messageTypes.TEXT,
     threadID,
     creatorID: viewer.id,
     time: Date.now(),
     text,
   };
   if (localID) {
     messageData = { ...messageData, localID };
   }
   if (sidebarCreation) {
     const numMessages = await fetchThreadMessagesCount(threadID);
     if (numMessages === 2) {
       // sidebarCreation is set below to prevent double notifs from a sidebar
       // creation. We expect precisely two messages to appear before a
       // sidebarCreation: a SIDEBAR_SOURCE and a CREATE_SIDEBAR. If two users
       // attempt to create a sidebar at the same time, then both clients will
       // attempt to set sidebarCreation here, but we only want to suppress
       // notifs for the client that won the race.
       messageData = { ...messageData, sidebarCreation };
     }
   }
   const rawMessageInfos = await createMessages(viewer, [messageData]);
 
   const response = { newMessageInfo: rawMessageInfos[0] };
-  return validateOutput(viewer, sendMessageResponseValidator, response);
+  return validateOutput(
+    viewer.platformDetails,
+    sendMessageResponseValidator,
+    response,
+  );
 }
 
 const fetchMessageInfosRequestInputValidator = tShape<FetchMessageInfosRequest>(
   {
     cursors: t.dict(tID, t.maybe(tID)),
     numberPerThread: t.maybe(t.Number),
   },
 );
 
 export const fetchMessageInfosResponseValidator: TInterface<FetchMessageInfosResponse> =
   tShape<FetchMessageInfosResponse>({
     rawMessageInfos: t.list(rawMessageInfoValidator),
     truncationStatuses: messageTruncationStatusesValidator,
     userInfos: userInfosValidator,
   });
 
 async function messageFetchResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<FetchMessageInfosResponse> {
   const request = await validateInput(
     viewer,
     fetchMessageInfosRequestInputValidator,
     input,
   );
   const response = await fetchMessageInfos(
     viewer,
     { threadCursors: request.cursors },
     request.numberPerThread ? request.numberPerThread : defaultNumberPerThread,
   );
-  return validateOutput(viewer, fetchMessageInfosResponseValidator, {
-    ...response,
-    userInfos: {},
-  });
+  return validateOutput(
+    viewer.platformDetails,
+    fetchMessageInfosResponseValidator,
+    {
+      ...response,
+      userInfos: {},
+    },
+  );
 }
 
 const sendMultimediaMessageRequestInputValidator =
   t.union<SendMultimediaMessageRequest>([
     // This option is only used for messageTypes.IMAGES
     tShape({
       threadID: tID,
       localID: t.String,
       sidebarCreation: t.maybe(t.Boolean),
       mediaIDs: t.list(tID),
     }),
     tShape({
       threadID: tID,
       localID: t.String,
       sidebarCreation: t.maybe(t.Boolean),
       mediaMessageContents: t.list(tMediaMessageMedia),
     }),
   ]);
 async function multimediaMessageCreationResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<SendMessageResponse> {
   const request = await validateInput(
     viewer,
     sendMultimediaMessageRequestInputValidator,
     input,
   );
 
   if (
     (request.mediaIDs && request.mediaIDs.length === 0) ||
     (request.mediaMessageContents && request.mediaMessageContents.length === 0)
   ) {
     throw new ServerError('invalid_parameters');
   }
 
   const { threadID, localID, sidebarCreation } = request;
   const hasPermission = await checkThreadPermission(
     viewer,
     threadID,
     threadPermissions.VOICED,
   );
   if (!hasPermission) {
     throw new ServerError('invalid_parameters');
   }
 
   const existingMessageInfoPromise = fetchMessageInfoForLocalID(
     viewer,
     localID,
   );
   const mediaPromise: Promise<$ReadOnlyArray<Media>> = request.mediaIDs
     ? fetchImages(viewer, request.mediaIDs)
     : fetchMediaFromMediaMessageContent(viewer, request.mediaMessageContents);
 
   const [existingMessageInfo, media] = await Promise.all([
     existingMessageInfoPromise,
     mediaPromise,
   ]);
 
   if (media.length === 0 && !existingMessageInfo) {
     throw new ServerError('invalid_parameters');
   }
 
   // We use the MULTIMEDIA type for encrypted photos
   const containsEncryptedMedia = media.some(
     m => m.type === 'encrypted_photo' || m.type === 'encrypted_video',
   );
   const messageData = createMediaMessageData(
     {
       localID,
       threadID,
       creatorID: viewer.id,
       media,
       sidebarCreation,
     },
     { forceMultimediaMessageType: containsEncryptedMedia },
   );
   const [newMessageInfo] = await createMessages(viewer, [messageData]);
   const { id } = newMessageInfo;
   invariant(
     id !== null && id !== undefined,
     'serverID should be set in createMessages result',
   );
 
   if (request.mediaIDs) {
     await assignImages(viewer, request.mediaIDs, id, threadID);
   } else {
     await assignMessageContainerToMedia(
       viewer,
       request.mediaMessageContents,
       id,
       threadID,
     );
   }
 
   const response = { newMessageInfo };
-  return validateOutput(viewer, sendMessageResponseValidator, response);
+  return validateOutput(
+    viewer.platformDetails,
+    sendMessageResponseValidator,
+    response,
+  );
 }
 
 const sendReactionMessageRequestInputValidator =
   tShape<SendReactionMessageRequest>({
     threadID: tID,
     localID: t.maybe(t.String),
     targetMessageID: tID,
     reaction: tRegex(onlyOneEmojiRegex),
     action: t.enums.of(['add_reaction', 'remove_reaction']),
   });
 async function reactionMessageCreationResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<SendMessageResponse> {
   const request = await validateInput(
     viewer,
     sendReactionMessageRequestInputValidator,
     input,
   );
 
   const { threadID, localID, targetMessageID, reaction, action } = request;
 
   if (!targetMessageID || !reaction) {
     throw new ServerError('invalid_parameters');
   }
 
   const targetMessageInfo = await fetchMessageInfoByID(viewer, targetMessageID);
 
   if (!targetMessageInfo || !targetMessageInfo.id) {
     throw new ServerError('invalid_parameters');
   }
 
   const [serverThreadInfos, hasPermission, targetMessageUserInfos] =
     await Promise.all([
       fetchServerThreadInfos(SQL`t.id = ${threadID}`),
       checkThreadPermission(
         viewer,
         threadID,
         threadPermissions.REACT_TO_MESSAGE,
       ),
       fetchKnownUserInfos(viewer, [targetMessageInfo.creatorID]),
     ]);
 
   const targetMessageThreadInfo = serverThreadInfos.threadInfos[threadID];
   if (targetMessageThreadInfo.sourceMessageID === targetMessageID) {
     throw new ServerError('invalid_parameters');
   }
 
   const targetMessageCreator =
     targetMessageUserInfos[targetMessageInfo.creatorID];
 
   const targetMessageCreatorRelationship =
     targetMessageCreator?.relationshipStatus;
 
   const creatorRelationshipHasBlock =
     targetMessageCreatorRelationship &&
     relationshipBlockedInEitherDirection(targetMessageCreatorRelationship);
 
   if (!hasPermission || creatorRelationshipHasBlock) {
     throw new ServerError('invalid_parameters');
   }
 
   let messageData: ReactionMessageData = {
     type: messageTypes.REACTION,
     threadID,
     creatorID: viewer.id,
     time: Date.now(),
     targetMessageID,
     reaction,
     action,
   };
   if (localID) {
     messageData = { ...messageData, localID };
   }
 
   const rawMessageInfos = await createMessages(viewer, [messageData]);
 
   const response = { newMessageInfo: rawMessageInfos[0] };
-  return validateOutput(viewer, sendMessageResponseValidator, response);
+  return validateOutput(
+    viewer.platformDetails,
+    sendMessageResponseValidator,
+    response,
+  );
 }
 
 const editMessageRequestInputValidator = tShape<SendEditMessageRequest>({
   targetMessageID: tID,
   text: t.String,
 });
 
 export const sendEditMessageResponseValidator: TInterface<SendEditMessageResponse> =
   tShape<SendEditMessageResponse>({
     newMessageInfos: t.list(rawMessageInfoValidator),
   });
 
 async function editMessageCreationResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<SendEditMessageResponse> {
   const request = await validateInput(
     viewer,
     editMessageRequestInputValidator,
     input,
   );
 
   const { targetMessageID, text: rawText } = request;
   const text = trimMessage(rawText);
   if (!targetMessageID || !text) {
     throw new ServerError('invalid_parameters');
   }
 
   const targetMessageInfo = await fetchMessageInfoByID(viewer, targetMessageID);
   if (!targetMessageInfo || !targetMessageInfo.id) {
     throw new ServerError('invalid_parameters');
   }
 
   if (targetMessageInfo.type !== messageTypes.TEXT) {
     throw new ServerError('invalid_parameters');
   }
 
   const { threadID } = targetMessageInfo;
 
   const [serverThreadInfos, hasPermission, rawSidebarThreadInfos] =
     await Promise.all([
       fetchServerThreadInfos(SQL`t.id = ${threadID}`),
       checkThreadPermission(viewer, threadID, threadPermissions.EDIT_MESSAGE),
       fetchServerThreadInfos(
         SQL`t.parent_thread_id = ${threadID} AND t.source_message = ${targetMessageID}`,
       ),
     ]);
 
   const targetMessageThreadInfo = serverThreadInfos.threadInfos[threadID];
   if (targetMessageThreadInfo.sourceMessageID === targetMessageID) {
     // We are editing first message of the sidebar
     // If client wants to do that it sends id of the sourceMessage instead
     throw new ServerError('invalid_parameters');
   }
 
   if (!hasPermission) {
     throw new ServerError('invalid_parameters');
   }
 
   if (targetMessageInfo.creatorID !== viewer.id) {
     throw new ServerError('invalid_parameters');
   }
 
   const time = Date.now();
   const messagesData = [];
   let messageData: EditMessageData = {
     type: messageTypes.EDIT_MESSAGE,
     threadID,
     creatorID: viewer.id,
     time,
     targetMessageID,
     text,
   };
   messagesData.push(messageData);
 
   const sidebarThreadValues = values(rawSidebarThreadInfos.threadInfos);
   for (const sidebarThreadValue of sidebarThreadValues) {
     if (sidebarThreadValue && sidebarThreadValue.id) {
       messageData = {
         type: messageTypes.EDIT_MESSAGE,
         threadID: sidebarThreadValue.id,
         creatorID: viewer.id,
         time,
         targetMessageID,
         text: text,
       };
       messagesData.push(messageData);
     }
   }
 
   const newMessageInfos = await createMessages(viewer, messagesData);
 
   const response = { newMessageInfos };
-  return validateOutput(viewer, sendEditMessageResponseValidator, response);
+  return validateOutput(
+    viewer.platformDetails,
+    sendEditMessageResponseValidator,
+    response,
+  );
 }
 
 const fetchPinnedMessagesResponderInputValidator =
   tShape<FetchPinnedMessagesRequest>({
     threadID: tID,
   });
 
 export const fetchPinnedMessagesResultValidator: TInterface<FetchPinnedMessagesResult> =
   tShape<FetchPinnedMessagesResult>({
     pinnedMessages: t.list(rawMessageInfoValidator),
   });
 
 async function fetchPinnedMessagesResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<FetchPinnedMessagesResult> {
   const request = await validateInput(
     viewer,
     fetchPinnedMessagesResponderInputValidator,
     input,
   );
   const response = await fetchPinnedMessageInfos(viewer, request);
-  return validateOutput(viewer, fetchPinnedMessagesResultValidator, response);
+  return validateOutput(
+    viewer.platformDetails,
+    fetchPinnedMessagesResultValidator,
+    response,
+  );
 }
 
 export {
   textMessageCreationResponder,
   messageFetchResponder,
   multimediaMessageCreationResponder,
   reactionMessageCreationResponder,
   editMessageCreationResponder,
   fetchPinnedMessagesResponder,
 };
diff --git a/keyserver/src/responders/relationship-responders.js b/keyserver/src/responders/relationship-responders.js
index fe4fcf516..87a48c16d 100644
--- a/keyserver/src/responders/relationship-responders.js
+++ b/keyserver/src/responders/relationship-responders.js
@@ -1,41 +1,45 @@
 // @flow
 
 import t, { type TInterface } from 'tcomb';
 
 import {
   type RelationshipRequest,
   type RelationshipErrors,
   relationshipActionsList,
 } from 'lib/types/relationship-types.js';
 import { tShape } from 'lib/utils/validation-utils.js';
 
 import type { Viewer } from '../session/viewer.js';
 import { updateRelationships } from '../updaters/relationship-updaters.js';
 import { validateInput, validateOutput } from '../utils/validation-utils.js';
 
 const updateRelationshipInputValidator = tShape<RelationshipRequest>({
   action: t.enums.of(relationshipActionsList, 'relationship action'),
   userIDs: t.list(t.String),
 });
 
 export const relationshipErrorsValidator: TInterface<RelationshipErrors> =
   tShape<RelationshipErrors>({
     invalid_user: t.maybe(t.list(t.String)),
     already_friends: t.maybe(t.list(t.String)),
     user_blocked: t.maybe(t.list(t.String)),
   });
 
 async function updateRelationshipsResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<RelationshipErrors> {
   const request = await validateInput(
     viewer,
     updateRelationshipInputValidator,
     input,
   );
   const response = await updateRelationships(viewer, request);
-  return validateOutput(viewer, relationshipErrorsValidator, response);
+  return validateOutput(
+    viewer.platformDetails,
+    relationshipErrorsValidator,
+    response,
+  );
 }
 
 export { updateRelationshipsResponder };
diff --git a/keyserver/src/responders/report-responders.js b/keyserver/src/responders/report-responders.js
index a320f3d4c..e67cb739e 100644
--- a/keyserver/src/responders/report-responders.js
+++ b/keyserver/src/responders/report-responders.js
@@ -1,265 +1,269 @@
 // @flow
 
 import type { $Response, $Request } from 'express';
 import t from 'tcomb';
 import type { TInterface, TStructProps } from 'tcomb';
 
 import {
   type ReportCreationResponse,
   type ReportCreationRequest,
   type FetchErrorReportInfosResponse,
   type FetchErrorReportInfosRequest,
   type ThreadInconsistencyReportShape,
   type EntryInconsistencyReportShape,
   reportTypes,
   reportInfoValidator,
 } from 'lib/types/report-types.js';
 import { userInfoValidator } from 'lib/types/user-types.js';
 import { ServerError } from 'lib/utils/errors.js';
 import {
   tShape,
   tPlatform,
   tPlatformDetails,
 } from 'lib/utils/validation-utils.js';
 
 import { newEntryQueryInputValidator } from './entry-responders.js';
 import createReport from '../creators/report-creator.js';
 import {
   fetchErrorReportInfos,
   fetchReduxToolsImport,
 } from '../fetchers/report-fetchers.js';
 import type { Viewer } from '../session/viewer.js';
 import { validateInput, validateOutput } from '../utils/validation-utils.js';
 
 const tActionSummary = tShape({
   type: t.String,
   time: t.Number,
   summary: t.String,
 });
 const threadInconsistencyReportValidatorShape: TStructProps<ThreadInconsistencyReportShape> =
   {
     platformDetails: tPlatformDetails,
     beforeAction: t.Object,
     action: t.Object,
     pollResult: t.maybe(t.Object),
     pushResult: t.Object,
     lastActionTypes: t.maybe(t.list(t.String)),
     lastActions: t.maybe(t.list(tActionSummary)),
     time: t.maybe(t.Number),
   };
 const entryInconsistencyReportValidatorShape: TStructProps<EntryInconsistencyReportShape> =
   {
     platformDetails: tPlatformDetails,
     beforeAction: t.Object,
     action: t.Object,
     calendarQuery: newEntryQueryInputValidator,
     pollResult: t.maybe(t.Object),
     pushResult: t.Object,
     lastActionTypes: t.maybe(t.list(t.String)),
     lastActions: t.maybe(t.list(tActionSummary)),
     time: t.Number,
   };
 const userInconsistencyReportValidatorShape = {
   platformDetails: tPlatformDetails,
   action: t.Object,
   beforeStateCheck: t.Object,
   afterStateCheck: t.Object,
   lastActions: t.list(tActionSummary),
   time: t.Number,
 };
 
 const threadInconsistencyReportCreationRequest = tShape({
   ...threadInconsistencyReportValidatorShape,
   type: t.irreducible(
     'reportTypes.THREAD_INCONSISTENCY',
     x => x === reportTypes.THREAD_INCONSISTENCY,
   ),
 });
 
 const entryInconsistencyReportCreationRquest = tShape({
   ...entryInconsistencyReportValidatorShape,
   type: t.irreducible(
     'reportTypes.ENTRY_INCONSISTENCY',
     x => x === reportTypes.ENTRY_INCONSISTENCY,
   ),
 });
 
 const mediaMissionReportCreationRequest = tShape({
   type: t.irreducible(
     'reportTypes.MEDIA_MISSION',
     x => x === reportTypes.MEDIA_MISSION,
   ),
   platformDetails: tPlatformDetails,
   time: t.Number,
   mediaMission: t.Object,
   uploadServerID: t.maybe(t.String),
   uploadLocalID: t.maybe(t.String),
   mediaLocalID: t.maybe(t.String),
   messageServerID: t.maybe(t.String),
   messageLocalID: t.maybe(t.String),
 });
 
 const userInconsistencyReportCreationRequest = tShape({
   ...userInconsistencyReportValidatorShape,
   type: t.irreducible(
     'reportTypes.USER_INCONSISTENCY',
     x => x === reportTypes.USER_INCONSISTENCY,
   ),
 });
 
 const reportCreationRequestInputValidator = t.union<ReportCreationRequest>([
   tShape({
     type: t.maybe(
       t.irreducible('reportTypes.ERROR', x => x === reportTypes.ERROR),
     ),
     platformDetails: t.maybe(tPlatformDetails),
     deviceType: t.maybe(tPlatform),
     codeVersion: t.maybe(t.Number),
     stateVersion: t.maybe(t.Number),
     errors: t.list(
       tShape({
         errorMessage: t.String,
         stack: t.maybe(t.String),
         componentStack: t.maybe(t.String),
       }),
     ),
     preloadedState: t.Object,
     currentState: t.Object,
     actions: t.list(t.union([t.Object, t.String])),
   }),
   threadInconsistencyReportCreationRequest,
   entryInconsistencyReportCreationRquest,
   mediaMissionReportCreationRequest,
   userInconsistencyReportCreationRequest,
 ]);
 
 export const reportCreationResponseValidator: TInterface<ReportCreationResponse> =
   tShape<ReportCreationResponse>({ id: t.String });
 
 async function reportCreationResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<ReportCreationResponse> {
   let request = await validateInput(
     viewer,
     reportCreationRequestInputValidator,
     input,
   );
   if (request.type === null || request.type === undefined) {
     request.type = reportTypes.ERROR;
   }
   if (!request.platformDetails && request.deviceType) {
     const { deviceType, codeVersion, stateVersion, ...rest } = request;
     request = {
       ...rest,
       platformDetails: { platform: deviceType, codeVersion, stateVersion },
     };
   }
   const response = await createReport(viewer, request);
   if (!response) {
     throw new ServerError('ignored_report');
   }
-  return validateOutput(viewer, reportCreationResponseValidator, response);
+  return validateOutput(
+    viewer.platformDetails,
+    reportCreationResponseValidator,
+    response,
+  );
 }
 
 const reportMultiCreationRequestInputValidator =
   tShape<ReportMultiCreationRequest>({
     reports: t.list(
       t.union([
         tShape({
           type: t.irreducible(
             'reportTypes.ERROR',
             x => x === reportTypes.ERROR,
           ),
           platformDetails: tPlatformDetails,
           errors: t.list(
             tShape({
               errorMessage: t.String,
               stack: t.maybe(t.String),
               componentStack: t.maybe(t.String),
             }),
           ),
           preloadedState: t.Object,
           currentState: t.Object,
           actions: t.list(t.union([t.Object, t.String])),
         }),
         threadInconsistencyReportCreationRequest,
         entryInconsistencyReportCreationRquest,
         mediaMissionReportCreationRequest,
         userInconsistencyReportCreationRequest,
       ]),
     ),
   });
 
 type ReportMultiCreationRequest = {
   reports: $ReadOnlyArray<ReportCreationRequest>,
 };
 async function reportMultiCreationResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<void> {
   const request = await validateInput(
     viewer,
     reportMultiCreationRequestInputValidator,
     input,
   );
   await Promise.all(
     request.reports.map(reportCreationRequest =>
       createReport(viewer, reportCreationRequest),
     ),
   );
 }
 
 const fetchErrorReportInfosRequestInputValidator =
   tShape<FetchErrorReportInfosRequest>({
     cursor: t.maybe(t.String),
   });
 
 export const fetchErrorReportInfosResponseValidator: TInterface<FetchErrorReportInfosResponse> =
   tShape<FetchErrorReportInfosResponse>({
     reports: t.list(reportInfoValidator),
     userInfos: t.list(userInfoValidator),
   });
 
 async function errorReportFetchInfosResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<FetchErrorReportInfosResponse> {
   const request = await validateInput(
     viewer,
     fetchErrorReportInfosRequestInputValidator,
     input,
   );
   const response = await fetchErrorReportInfos(viewer, request);
   return validateOutput(
-    viewer,
+    viewer.platformDetails,
     fetchErrorReportInfosResponseValidator,
     response,
   );
 }
 
 async function errorReportDownloadResponder(
   viewer: Viewer,
   req: $Request,
   res: $Response,
 ): Promise<void> {
   const id = req.params.reportID;
   if (!id) {
     throw new ServerError('invalid_parameters');
   }
   const result = await fetchReduxToolsImport(viewer, id);
   res.set('Content-Disposition', `attachment; filename=report-${id}.json`);
   res.json({
     preloadedState: JSON.stringify(result.preloadedState),
     payload: JSON.stringify(result.payload),
   });
 }
 
 export {
   threadInconsistencyReportValidatorShape,
   entryInconsistencyReportValidatorShape,
   reportCreationResponder,
   reportMultiCreationResponder,
   errorReportFetchInfosResponder,
   errorReportDownloadResponder,
 };
diff --git a/keyserver/src/responders/search-responders.js b/keyserver/src/responders/search-responders.js
index dffe0bdda..10189dbcc 100644
--- a/keyserver/src/responders/search-responders.js
+++ b/keyserver/src/responders/search-responders.js
@@ -1,39 +1,43 @@
 // @flow
 
 import t, { type TInterface } from 'tcomb';
 
 import type {
   UserSearchRequest,
   UserSearchResult,
 } from 'lib/types/search-types.js';
 import { globalAccountUserInfoValidator } from 'lib/types/user-types.js';
 import { tShape } from 'lib/utils/validation-utils.js';
 
 import { searchForUsers } from '../search/users.js';
 import type { Viewer } from '../session/viewer.js';
 import { validateInput, validateOutput } from '../utils/validation-utils.js';
 
 const userSearchRequestInputValidator = tShape<UserSearchRequest>({
   prefix: t.maybe(t.String),
 });
 
 export const userSearchResultValidator: TInterface<UserSearchResult> =
   tShape<UserSearchResult>({
     userInfos: t.list(globalAccountUserInfoValidator),
   });
 
 async function userSearchResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<UserSearchResult> {
   const request = await validateInput(
     viewer,
     userSearchRequestInputValidator,
     input,
   );
   const searchResults = await searchForUsers(request);
   const result = { userInfos: searchResults };
-  return validateOutput(viewer, userSearchResultValidator, result);
+  return validateOutput(
+    viewer.platformDetails,
+    userSearchResultValidator,
+    result,
+  );
 }
 
 export { userSearchResponder };
diff --git a/keyserver/src/responders/thread-responders.js b/keyserver/src/responders/thread-responders.js
index e57a04504..0c64d8b56 100644
--- a/keyserver/src/responders/thread-responders.js
+++ b/keyserver/src/responders/thread-responders.js
@@ -1,332 +1,368 @@
 // @flow
 
 import t from 'tcomb';
 import type { TInterface, TUnion } from 'tcomb';
 
 import { rawEntryInfoValidator } from 'lib/types/entry-types.js';
 import { mediaValidator } from 'lib/types/media-types.js';
 import {
   rawMessageInfoValidator,
   messageTruncationStatusesValidator,
 } from 'lib/types/message-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,
   rawThreadInfoValidator,
 } 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 { createThread } from '../creators/thread-creator.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';
 import { validateInput, validateOutput } from '../utils/validation-utils.js';
 
 const threadDeletionRequestInputValidator = tShape<ThreadDeletionRequest>({
   threadID: tID,
   accountPassword: t.maybe(tPassword),
 });
 
 export const leaveThreadResultValidator: TInterface<LeaveThreadResult> =
   tShape<LeaveThreadResult>({
     threadInfos: t.maybe(t.dict(tID, rawThreadInfoValidator)),
     updatesResult: tShape({
       newUpdates: t.list(serverUpdateInfoValidator),
     }),
   });
 
 async function threadDeletionResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<LeaveThreadResult> {
   const request = await validateInput(
     viewer,
     threadDeletionRequestInputValidator,
     input,
   );
   const result = await deleteThread(viewer, request);
-  return validateOutput(viewer, leaveThreadResultValidator, result);
+  return validateOutput(
+    viewer.platformDetails,
+    leaveThreadResultValidator,
+    result,
+  );
 }
 
 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),
     threadInfo: t.maybe(rawThreadInfoValidator),
     threadInfos: t.maybe(t.dict(tID, rawThreadInfoValidator)),
     updatesResult: tShape({
       newUpdates: t.list(serverUpdateInfoValidator),
     }),
   });
 
 async function roleUpdateResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<ChangeThreadSettingsResult> {
   const request = await validateInput(
     viewer,
     roleChangeRequestInputValidator,
     input,
   );
   const result = await updateRole(viewer, request);
-  return validateOutput(viewer, changeThreadSettingsResultValidator, result);
+  return validateOutput(
+    viewer.platformDetails,
+    changeThreadSettingsResultValidator,
+    result,
+  );
 }
 
 const removeMembersRequestInputValidator = tShape<RemoveMembersRequest>({
   threadID: tID,
   memberIDs: t.list(t.String),
 });
 
 async function memberRemovalResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<ChangeThreadSettingsResult> {
   const request = await validateInput(
     viewer,
     removeMembersRequestInputValidator,
     input,
   );
   const result = await removeMembers(viewer, request);
-  return validateOutput(viewer, changeThreadSettingsResultValidator, result);
+  return validateOutput(
+    viewer.platformDetails,
+    changeThreadSettingsResultValidator,
+    result,
+  );
 }
 
 const leaveThreadRequestInputValidator = tShape<LeaveThreadRequest>({
   threadID: tID,
 });
 
 async function threadLeaveResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<LeaveThreadResult> {
   const request = await validateInput(
     viewer,
     leaveThreadRequestInputValidator,
     input,
   );
   const result = await leaveThread(viewer, request);
-  return validateOutput(viewer, leaveThreadResultValidator, result);
+  return validateOutput(
+    viewer.platformDetails,
+    leaveThreadResultValidator,
+    result,
+  );
 }
 
 const updateThreadRequestInputValidator = 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,
   input: mixed,
 ): Promise<ChangeThreadSettingsResult> {
   const request = await validateInput(
     viewer,
     updateThreadRequestInputValidator,
     input,
   );
   const result = await updateThread(viewer, request);
-  return validateOutput(viewer, changeThreadSettingsResultValidator, result);
+  return validateOutput(
+    viewer.platformDetails,
+    changeThreadSettingsResultValidator,
+    result,
+  );
 }
 
 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,
     ]),
     ...threadRequestValidationShape,
   }),
 ]);
 
 export const newThreadResponseValidator: TInterface<NewThreadResponse> =
   tShape<NewThreadResponse>({
     updatesResult: tShape({
       newUpdates: t.list(serverUpdateInfoValidator),
     }),
     newMessageInfos: t.list(rawMessageInfoValidator),
     newThreadInfo: t.maybe(rawThreadInfoValidator),
     userInfos: userInfosValidator,
     newThreadID: t.maybe(tID),
   });
 
 async function threadCreationResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<NewThreadResponse> {
   const request = await validateInput(
     viewer,
     newThreadRequestInputValidator,
     input,
   );
 
   const result = await createThread(viewer, request, {
     silentlyFailMembers: request.type === threadTypes.SIDEBAR,
   });
-  return validateOutput(viewer, newThreadResponseValidator, result);
+  return validateOutput(
+    viewer.platformDetails,
+    newThreadResponseValidator,
+    result,
+  );
 }
 
 const joinThreadRequestInputValidator = tShape<ServerThreadJoinRequest>({
   threadID: tID,
   calendarQuery: t.maybe(entryQueryInputValidator),
   inviteLinkSecret: t.maybe(t.String),
 });
 
 export const threadJoinResultValidator: TInterface<ThreadJoinResult> =
   tShape<ThreadJoinResult>({
     threadInfos: t.maybe(t.dict(tID, rawThreadInfoValidator)),
     updatesResult: tShape({
       newUpdates: t.list(serverUpdateInfoValidator),
     }),
     rawMessageInfos: t.list(rawMessageInfoValidator),
     truncationStatuses: messageTruncationStatusesValidator,
     userInfos: userInfosValidator,
     rawEntryInfos: t.maybe(t.list(rawEntryInfoValidator)),
   });
 
 async function threadJoinResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<ThreadJoinResult> {
   const request = await validateInput(
     viewer,
     joinThreadRequestInputValidator,
     input,
   );
 
   if (request.calendarQuery) {
     await verifyCalendarQueryThreadIDs(request.calendarQuery);
   }
 
   const result = await joinThread(viewer, request);
-  return validateOutput(viewer, threadJoinResultValidator, result);
+  return validateOutput(
+    viewer.platformDetails,
+    threadJoinResultValidator,
+    result,
+  );
 }
 
 const threadFetchMediaRequestInputValidator = 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,
   input: mixed,
 ): Promise<ThreadFetchMediaResult> {
   const request = await validateInput(
     viewer,
     threadFetchMediaRequestInputValidator,
     input,
   );
   const result = await fetchMediaForThread(viewer, request);
-  return validateOutput(viewer, threadFetchMediaResultValidator, result);
+  return validateOutput(
+    viewer.platformDetails,
+    threadFetchMediaResultValidator,
+    result,
+  );
 }
 
 const toggleMessagePinRequestInputValidator = 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,
   input: mixed,
 ): Promise<ToggleMessagePinResult> {
   const request = await validateInput(
     viewer,
     toggleMessagePinRequestInputValidator,
     input,
   );
   const result = await toggleMessagePinForThread(viewer, request);
-  return validateOutput(viewer, toggleMessagePinResultValidator, result);
+  return validateOutput(
+    viewer.platformDetails,
+    toggleMessagePinResultValidator,
+    result,
+  );
 }
 
 export {
   threadDeletionResponder,
   roleUpdateResponder,
   memberRemovalResponder,
   threadLeaveResponder,
   threadUpdateResponder,
   threadCreationResponder,
   threadJoinResponder,
   threadFetchMediaResponder,
   newThreadRequestInputValidator,
   toggleMessagePinResponder,
 };
diff --git a/keyserver/src/responders/user-responders.js b/keyserver/src/responders/user-responders.js
index d4389fb79..0de1188b4 100644
--- a/keyserver/src/responders/user-responders.js
+++ b/keyserver/src/responders/user-responders.js
@@ -1,774 +1,806 @@
 // @flow
 
 import type { Utility as OlmUtility } from '@commapp/olm';
 import invariant from 'invariant';
 import { ErrorTypes, SiweMessage } from 'siwe';
 import t, { type TInterface } from 'tcomb';
 import bcrypt from 'twin-bcrypt';
 
 import {
   baseLegalPolicies,
   policies,
   policyTypeValidator,
 } from 'lib/facts/policies.js';
 import { hasMinCodeVersion } from 'lib/shared/version-utils.js';
 import type {
   ResetPasswordRequest,
   LogOutResponse,
   DeleteAccountRequest,
   RegisterResponse,
   RegisterRequest,
   LogInResponse,
   LogInRequest,
   UpdatePasswordRequest,
   UpdateUserSettingsRequest,
   PolicyAcknowledgmentRequest,
 } from 'lib/types/account-types.js';
 import {
   userSettingsTypes,
   notificationTypeValues,
   logInActionSources,
 } from 'lib/types/account-types.js';
 import {
   type ClientAvatar,
   clientAvatarValidator,
   type UpdateUserAvatarResponse,
 } from 'lib/types/avatar-types.js';
 import type {
   IdentityKeysBlob,
   SignedIdentityKeysBlob,
 } from 'lib/types/crypto-types.js';
 import {
   type CalendarQuery,
   rawEntryInfoValidator,
 } 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 { rawThreadInfoValidator } from 'lib/types/thread-types.js';
 import { createUpdatesResultValidator } from 'lib/types/update-types.js';
 import {
   type PasswordUpdate,
   loggedOutUserInfoValidator,
   loggedInUserInfoValidator,
   oldLoggedInUserInfoValidator,
   userInfoValidator,
 } from 'lib/types/user-types.js';
 import { updateUserAvatarRequestValidator } from 'lib/utils/avatar-utils.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 { promiseAll } from 'lib/utils/promises.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 {
   createAccount,
   processSIWEAccountCreation,
 } from '../creators/account-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,
 } from '../fetchers/user-fetchers.js';
 import {
   createNewAnonymousCookie,
   createNewUserCookie,
   setNewSession,
 } from '../session/cookies.js';
 import { verifyClientSupported } from '../session/version.js';
 import type { Viewer } from '../session/viewer.js';
 import {
   accountUpdater,
   checkAndSendVerificationEmail,
   checkAndSendPasswordResetEmail,
   updatePassword,
   updateUserSettings,
   updateUserAvatar,
 } from '../updaters/account-updaters.js';
 import { userSubscriptionUpdater } from '../updaters/user-subscription-updaters.js';
 import { viewerAcknowledgmentUpdater } from '../updaters/viewer-acknowledgment-updater.js';
 import { getOlmUtility } from '../utils/olm-utils.js';
 import { validateInput, validateOutput } from '../utils/validation-utils.js';
 
 const subscriptionUpdateRequestInputValidator =
   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,
   input: mixed,
 ): Promise<SubscriptionUpdateResponse> {
   const request = await validateInput(
     viewer,
     subscriptionUpdateRequestInputValidator,
     input,
   );
   const threadSubscription = await userSubscriptionUpdater(viewer, request);
-  return validateOutput(viewer, subscriptionUpdateResponseValidator, {
-    threadSubscription,
-  });
+  return validateOutput(
+    viewer.platformDetails,
+    subscriptionUpdateResponseValidator,
+    {
+      threadSubscription,
+    },
+  );
 }
 
 const accountUpdateInputValidator = tShape<PasswordUpdate>({
   updatedFields: tShape({
     email: t.maybe(tEmail),
     password: t.maybe(tPassword),
   }),
   currentPassword: tPassword,
 });
 
 async function passwordUpdateResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<void> {
   const request = await validateInput(
     viewer,
     accountUpdateInputValidator,
     input,
   );
   await accountUpdater(viewer, request);
 }
 
 async function sendVerificationEmailResponder(viewer: Viewer): Promise<void> {
   if (!viewer.isSocket) {
     await verifyClientSupported(viewer, viewer.platformDetails);
   }
   await checkAndSendVerificationEmail(viewer);
 }
 
 const resetPasswordRequestInputValidator = tShape<ResetPasswordRequest>({
   usernameOrEmail: t.union([tEmail, tOldValidUsername]),
 });
 
 async function sendPasswordResetEmailResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<void> {
   const request = await validateInput(
     viewer,
     resetPasswordRequestInputValidator,
     input,
   );
   await checkAndSendPasswordResetEmail(request);
 }
 
 export const logOutResponseValidator: TInterface<LogOutResponse> =
   tShape<LogOutResponse>({
     currentUserInfo: loggedOutUserInfoValidator,
   });
 
 async function logOutResponder(viewer: Viewer): Promise<LogOutResponse> {
   if (!viewer.isSocket) {
     await verifyClientSupported(viewer, viewer.platformDetails);
   }
   if (viewer.loggedIn) {
     const [anonymousViewerData] = await Promise.all([
       createNewAnonymousCookie({
         platformDetails: viewer.platformDetails,
         deviceToken: viewer.deviceToken,
       }),
       deleteCookie(viewer.cookieID),
     ]);
     viewer.setNewCookie(anonymousViewerData);
   }
   const response = {
     currentUserInfo: {
       id: viewer.id,
       anonymous: true,
     },
   };
-  return validateOutput(viewer, logOutResponseValidator, response);
+  return validateOutput(
+    viewer.platformDetails,
+    logOutResponseValidator,
+    response,
+  );
 }
 
 const deleteAccountRequestInputValidator = tShape<DeleteAccountRequest>({
   password: t.maybe(tPassword),
 });
 
 async function accountDeletionResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<LogOutResponse> {
   const request = await validateInput(
     viewer,
     deleteAccountRequestInputValidator,
     input,
   );
   const result = await deleteAccount(viewer, request);
   invariant(result, 'deleteAccount should return result if handed request');
-  return validateOutput(viewer, logOutResponseValidator, result);
+  return validateOutput(
+    viewer.platformDetails,
+    logOutResponseValidator,
+    result,
+  );
 }
 
 const deviceTokenUpdateRequestInputValidator = tShape({
   deviceType: t.maybe(t.enums.of(['ios', 'android'])),
   deviceToken: t.String,
 });
 
 const registerRequestInputValidator = 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),
 });
 
 export const registerResponseValidator: TInterface<RegisterResponse> =
   tShape<RegisterResponse>({
     id: t.String,
     rawMessageInfos: t.list(rawMessageInfoValidator),
     currentUserInfo: t.union([
       oldLoggedInUserInfoValidator,
       loggedInUserInfoValidator,
     ]),
     cookieChange: tShape({
       threadInfos: t.dict(t.String, rawThreadInfoValidator),
       userInfos: t.list(userInfoValidator),
     }),
   });
 
 async function accountCreationResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<RegisterResponse> {
   const request = await validateInput(
     viewer,
     registerRequestInputValidator,
     input,
   );
   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');
     }
   }
   const response = await createAccount(viewer, request);
-  return validateOutput(viewer, registerResponseValidator, response);
+  return validateOutput(
+    viewer.platformDetails,
+    registerResponseValidator,
+    response,
+  );
 }
 
 type ProcessSuccessfulLoginParams = {
   +viewer: Viewer,
   +input: any,
   +userID: string,
   +calendarQuery: ?CalendarQuery,
   +socialProof?: ?SIWESocialProof,
   +signedIdentityKeysBlob?: ?SignedIdentityKeysBlob,
 };
 
 async function processSuccessfulLogin(
   params: ProcessSuccessfulLoginParams,
 ): Promise<LogInResponse> {
   const {
     viewer,
     input,
     userID,
     calendarQuery,
     socialProof,
     signedIdentityKeysBlob,
   } = params;
 
   const request: LogInRequest = input;
   const newServerTime = Date.now();
   const deviceToken = request.deviceTokenUpdateRequest
     ? request.deviceTokenUpdateRequest.deviceToken
     : viewer.deviceToken;
   const [userViewerData, notAcknowledgedPolicies] = await Promise.all([
     createNewUserCookie(userID, {
       platformDetails: request.platformDetails,
       deviceToken,
       socialProof,
       signedIdentityKeysBlob,
     }),
     fetchNotAcknowledgedPolicies(userID, baseLegalPolicies),
     deleteCookie(viewer.cookieID),
   ]);
   viewer.setNewCookie(userViewerData);
 
   if (
     notAcknowledgedPolicies.length &&
     hasMinCodeVersion(viewer.platformDetails, 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 threadCursors = {};
   for (const watchedThreadID of request.watchedIDs) {
     threadCursors[watchedThreadID] = null;
   }
   const messageSelectionCriteria = { threadCursors, joinedThreads: true };
 
   const [
     threadsResult,
     messagesResult,
     entriesResult,
     userInfos,
     currentUserInfo,
   ] = await Promise.all([
     fetchThreadInfos(viewer),
     fetchMessageInfos(viewer, messageSelectionCriteria, defaultNumberPerThread),
     calendarQuery ? fetchEntryInfos(viewer, [calendarQuery]) : undefined,
     fetchKnownUserInfos(viewer),
     fetchLoggedInUserInfo(viewer),
   ]);
 
   const rawEntryInfos = entriesResult ? entriesResult.rawEntryInfos : null;
   const response: LogInResponse = {
     currentUserInfo,
     rawMessageInfos: messagesResult.rawMessageInfos,
     truncationStatuses: messagesResult.truncationStatuses,
     serverTime: newServerTime,
     userInfos: values(userInfos),
     cookieChange: {
       threadInfos: threadsResult.threadInfos,
       userInfos: [],
     },
   };
   if (rawEntryInfos) {
     return {
       ...response,
       rawEntryInfos,
     };
   }
   return response;
 }
 
 const logInRequestInputValidator = 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),
 });
 
 export const logInResponseValidator: TInterface<LogInResponse> =
   tShape<LogInResponse>({
     currentUserInfo: t.union([
       loggedInUserInfoValidator,
       oldLoggedInUserInfoValidator,
     ]),
     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, rawThreadInfoValidator),
       userInfos: t.list(userInfoValidator),
     }),
     notAcknowledgedPolicies: t.maybe(t.list(policyTypeValidator)),
   });
 
 async function logInResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<LogInResponse> {
   const request = await validateInput(
     viewer,
     logInRequestInputValidator,
     input,
   );
 
   let identityKeys: ?IdentityKeysBlob;
   const { signedIdentityKeysBlob } = 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 promises = {};
   if (calendarQuery) {
     promises.verifyCalendarQueryThreadIDs =
       verifyCalendarQueryThreadIDs(calendarQuery);
   }
   const username = request.username ?? request.usernameOrEmail;
   if (!username) {
     if (hasMinCodeVersion(viewer.platformDetails, 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})
   `;
   promises.userQuery = dbQuery(userQuery);
   const {
     userQuery: [userResult],
   } = await promiseAll(promises);
 
   if (userResult.length === 0) {
     if (hasMinCodeVersion(viewer.platformDetails, 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();
 
   const response = await processSuccessfulLogin({
     viewer,
     input,
     userID: id,
     calendarQuery,
     signedIdentityKeysBlob,
   });
-  return validateOutput(viewer, logInResponseValidator, response);
+  return validateOutput(
+    viewer.platformDetails,
+    logInResponseValidator,
+    response,
+  );
 }
 
 const siweAuthRequestInputValidator = tShape<SIWEAuthRequest>({
   signature: t.String,
   message: t.String,
   calendarQuery: entryQueryInputValidator,
   deviceTokenUpdateRequest: t.maybe(deviceTokenUpdateRequestInputValidator),
   platformDetails: tPlatformDetails,
   watchedIDs: t.list(tID),
   signedIdentityKeysBlob: t.maybe(signedIdentityKeysBlobValidator),
 });
 
 async function siweAuthResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<LogInResponse> {
   const request = await validateInput(
     viewer,
     siweAuthRequestInputValidator,
     input,
   );
 
   const {
     message,
     signature,
     deviceTokenUpdateRequest,
     platformDetails,
     signedIdentityKeysBlob,
   } = 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. 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');
   }
 
   // 3. 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');
     }
   }
 
   // 4. 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');
   }
 
   // 5. 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');
     }
   }
 
   // 6. Ensure that `primaryIdentityPublicKeys.ed25519` matches SIWE
   //    statement `primaryIdentityPublicKey` if `identityKeys` exists.
   if (
     identityKeys &&
     identityKeys.primaryIdentityPublicKeys.ed25519 !== primaryIdentityPublicKey
   ) {
     throw new ServerError('primary_public_key_mismatch');
   }
 
   // 7. Construct `SIWESocialProof` object with the stringified
   //    SIWEMessage and the corresponding signature.
   const socialProof: SIWESocialProof = {
     siweMessage: siweMessage.toMessage(),
     siweMessageSignature: signature,
   };
 
   // 8. Create account with call to `processSIWEAccountCreation(...)`
   //    if address does not correspond to an existing user.
   let userID = await fetchUserIDForEthereumAddress(siweMessage.address);
   if (!userID) {
     const siweAccountCreationRequest = {
       address: siweMessage.address,
       calendarQuery,
       deviceTokenUpdateRequest,
       platformDetails,
       socialProof,
     };
     userID = await processSIWEAccountCreation(
       viewer,
       siweAccountCreationRequest,
     );
   }
 
   // 9. Complete login with call to `processSuccessfulLogin(...)`.
   const response = await processSuccessfulLogin({
     viewer,
     input,
     userID,
     calendarQuery,
     socialProof,
     signedIdentityKeysBlob,
   });
-  return validateOutput(viewer, logInResponseValidator, response);
+  return validateOutput(
+    viewer.platformDetails,
+    logInResponseValidator,
+    response,
+  );
 }
 
 const updatePasswordRequestInputValidator = 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,
   input: mixed,
 ): Promise<LogInResponse> {
   const request = await validateInput(
     viewer,
     updatePasswordRequestInputValidator,
     input,
   );
 
   if (request.calendarQuery) {
     request.calendarQuery = normalizeCalendarQuery(request.calendarQuery);
   }
   const response = await updatePassword(viewer, request);
-  return validateOutput(viewer, logInResponseValidator, response);
+  return validateOutput(
+    viewer.platformDetails,
+    logInResponseValidator,
+    response,
+  );
 }
 
 const updateUserSettingsInputValidator = tShape<UpdateUserSettingsRequest>({
   name: t.irreducible(
     userSettingsTypes.DEFAULT_NOTIFICATIONS,
     x => x === userSettingsTypes.DEFAULT_NOTIFICATIONS,
   ),
   data: t.enums.of(notificationTypeValues),
 });
 
 async function updateUserSettingsResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<void> {
   const request = await validateInput(
     viewer,
     updateUserSettingsInputValidator,
     input,
   );
   await updateUserSettings(viewer, request);
 }
 
 const policyAcknowledgmentRequestInputValidator =
   tShape<PolicyAcknowledgmentRequest>({
     policy: t.maybe(t.enums.of(policies)),
   });
 
 async function policyAcknowledgmentResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<void> {
   const request = await validateInput(
     viewer,
     policyAcknowledgmentRequestInputValidator,
     input,
   );
   await viewerAcknowledgmentUpdater(viewer, request.policy);
 }
 
 export const updateUserAvatarResponseValidator: TInterface<UpdateUserAvatarResponse> =
   tShape<UpdateUserAvatarResponse>({
     updates: createUpdatesResultValidator,
   });
 
 const updateUserAvatarResponderValidator = t.union([
   t.maybe(clientAvatarValidator),
   updateUserAvatarResponseValidator,
 ]);
 
 async function updateUserAvatarResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<?ClientAvatar | UpdateUserAvatarResponse> {
   const request = await validateInput(
     viewer,
     updateUserAvatarRequestValidator,
     input,
   );
   const result = await updateUserAvatar(viewer, request);
-  return validateOutput(viewer, updateUserAvatarResponderValidator, result);
+  return validateOutput(
+    viewer.platformDetails,
+    updateUserAvatarResponderValidator,
+    result,
+  );
 }
 
 export {
   userSubscriptionUpdateResponder,
   passwordUpdateResponder,
   sendVerificationEmailResponder,
   sendPasswordResetEmailResponder,
   logOutResponder,
   accountDeletionResponder,
   accountCreationResponder,
   logInResponder,
   siweAuthResponder,
   oldPasswordUpdateResponder,
   updateUserSettingsResponder,
   policyAcknowledgmentResponder,
   updateUserAvatarResponder,
 };
diff --git a/keyserver/src/responders/website-responders.js b/keyserver/src/responders/website-responders.js
index a0c9fa41b..c819bd7aa 100644
--- a/keyserver/src/responders/website-responders.js
+++ b/keyserver/src/responders/website-responders.js
@@ -1,734 +1,734 @@
 // @flow
 
 import html from 'common-tags/lib/html/index.js';
 import { detect as detectBrowser } from 'detect-browser';
 import type { $Response, $Request } from 'express';
 import fs from 'fs';
 import _isEqual from 'lodash/fp/isEqual.js';
 import _keyBy from 'lodash/fp/keyBy.js';
 import * as React from 'react';
 // eslint-disable-next-line import/extensions
 import ReactDOMServer from 'react-dom/server';
 import t from 'tcomb';
 import { promisify } from 'util';
 
 import { baseLegalPolicies } from 'lib/facts/policies.js';
 import stores from 'lib/facts/stores.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 { defaultWebEnabledApps } from 'lib/types/enabled-apps.js';
 import { entryStoreValidator } from 'lib/types/entry-types.js';
 import { defaultCalendarFilters } from 'lib/types/filter-types.js';
 import {
   defaultNumberPerThread,
   messageStoreValidator,
 } from 'lib/types/message-types.js';
 import { defaultEnabledReports } from 'lib/types/report-types.js';
 import { defaultConnectionInfo } from 'lib/types/socket-types.js';
 import { threadPermissions } from 'lib/types/thread-permission-types.js';
 import { threadTypes } from 'lib/types/thread-types-enum.js';
 import { threadStoreValidator } from 'lib/types/thread-types.js';
 import {
   currentUserInfoValidator,
   userInfosValidator,
 } 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 { defaultNotifPermissionAlertInfo } from 'lib/utils/push-alerts.js';
 import { tBool, tNumber, tShape, tString } from 'lib/utils/validation-utils.js';
 import getTitle from 'web/title/getTitle.js';
 import { navInfoValidator } from 'web/types/nav-types.js';
 import { navInfoFromURL } from 'web/url-utils.js';
 
 import { fetchEntryInfos } from '../fetchers/entry-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,
 } from '../fetchers/user-fetchers.js';
 import { getWebPushConfig } from '../push/providers.js';
 import { setNewSession } from '../session/cookies.js';
 import { Viewer } from '../session/viewer.js';
 import { streamJSON, waitForStream } from '../utils/json-stream.js';
 import { getAppURLFactsFromRequestURL } from '../utils/urls.js';
 import { validateOutput } from '../utils/validation-utils.js';
 
 const { renderToNodeStream } = ReactDOMServer;
 
 const access = promisify(fs.access);
 const readFile = promisify(fs.readFile);
 
 const googleFontsURL =
   'https://fonts.googleapis.com/css2?family=IBM+Plex+Sans:wght@400;500;600&family=Inter:wght@400;500;600&display=swap';
 const localFontsURL = 'fonts/local-fonts.css';
 async function getFontsURL() {
   try {
     await access(localFontsURL);
     return localFontsURL;
   } catch {
     return googleFontsURL;
   }
 }
 
 type AssetInfo = {
   +jsURL: string,
   +fontsURL: string,
   +cssInclude: string,
   +olmFilename: string,
   +sqljsFilename: string,
   +opaqueURL: string,
 };
 let assetInfo: ?AssetInfo = null;
 async function getAssetInfo() {
   if (assetInfo) {
     return assetInfo;
   }
   if (process.env.NODE_ENV === 'development') {
     const fontsURL = await getFontsURL();
     assetInfo = {
       jsURL: 'http://localhost:8080/dev.build.js',
       fontsURL,
       cssInclude: '',
       olmFilename: '',
       sqljsFilename: '',
       opaqueURL: 'http://localhost:8080/opaque-ke.wasm',
     };
     return assetInfo;
   }
   try {
     const manifestString = await readFile('../web/dist/manifest.json', 'utf8');
     const manifest = JSON.parse(manifestString);
     const webworkersManifestString = await readFile(
       '../web/dist/webworkers/manifest.json',
       'utf8',
     );
     const webworkersManifest = JSON.parse(webworkersManifestString);
     assetInfo = {
       jsURL: `compiled/${manifest['browser.js']}`,
       fontsURL: googleFontsURL,
       cssInclude: html`
         <link
           rel="stylesheet"
           type="text/css"
           href="compiled/${manifest['browser.css']}"
         />
       `,
       olmFilename: manifest['olm.wasm'],
       sqljsFilename: webworkersManifest['sql-wasm.wasm'],
       opaqueURL: `compiled/${manifest['comm_opaque2_wasm_bg.wasm']}`,
     };
     return assetInfo;
   } catch {
     throw new Error(
       'Could not load manifest.json for web build. ' +
         'Did you forget to run `yarn dev` in the web folder?',
     );
   }
 }
 
 let webpackCompiledRootComponent: ?React.ComponentType<{}> = null;
 async function getWebpackCompiledRootComponentForSSR() {
   if (webpackCompiledRootComponent) {
     return webpackCompiledRootComponent;
   }
   try {
     // $FlowFixMe web/dist doesn't always exist
     const webpackBuild = await import('web/dist/app.build.cjs');
     webpackCompiledRootComponent = webpackBuild.app.default;
     return webpackCompiledRootComponent;
   } catch {
     throw new Error(
       'Could not load app.build.cjs. ' +
         'Did you forget to run `yarn dev` in the web folder?',
     );
   }
 }
 
 const initialReduxStateValidator = tShape({
   navInfo: navInfoValidator,
   deviceID: t.Nil,
   currentUserInfo: currentUserInfoValidator,
   draftStore: t.irreducible('default draftStore', _isEqual({ drafts: {} })),
   sessionID: t.maybe(t.String),
   entryStore: entryStoreValidator,
   threadStore: threadStoreValidator,
   userStore: tShape({
     userInfos: userInfosValidator,
     inconsistencyReports: t.irreducible(
       'default inconsistencyReports',
       _isEqual([]),
     ),
   }),
   messageStore: messageStoreValidator,
   updatesCurrentAsOf: t.Number,
   loadingStatuses: t.irreducible('default loadingStatuses', _isEqual({})),
   calendarFilters: t.irreducible(
     'defaultCalendarFilters',
     _isEqual(defaultCalendarFilters),
   ),
   urlPrefix: tString(''),
   windowDimensions: t.irreducible(
     'default windowDimensions',
     _isEqual({ width: 0, height: 0 }),
   ),
   baseHref: t.String,
   notifPermissionAlertInfo: t.irreducible(
     'default notifPermissionAlertInfo',
     _isEqual(defaultNotifPermissionAlertInfo),
   ),
   connection: tShape({
     status: tString('connecting'),
     queuedActivityUpdates: t.irreducible(
       'default queuedActivityUpdates',
       _isEqual([]),
     ),
     actualizedCalendarQuery: tShape({
       startDate: t.String,
       endDate: t.String,
       filters: t.irreducible(
         'default filters',
         _isEqual(defaultCalendarFilters),
       ),
     }),
     lateResponses: t.irreducible('default lateResponses', _isEqual([])),
     showDisconnectedBar: tBool(false),
   }),
   watchedThreadIDs: t.irreducible('default watchedThreadIDs', _isEqual([])),
   lifecycleState: tString('active'),
   enabledApps: t.irreducible(
     'defaultWebEnabledApps',
     _isEqual(defaultWebEnabledApps),
   ),
   reportStore: t.irreducible(
     'default reportStore',
     _isEqual({
       enabledReports: defaultEnabledReports,
       queuedReports: [],
     }),
   ),
   nextLocalID: tNumber(0),
   cookie: t.Nil,
   deviceToken: t.Nil,
   dataLoaded: t.Boolean,
   windowActive: tBool(true),
   userPolicies: t.irreducible('default userPolicies', _isEqual({})),
   cryptoStore: t.irreducible(
     'default cryptoStore',
     _isEqual({
       primaryIdentityKeys: null,
       notificationIdentityKeys: null,
     }),
   ),
   pushApiPublicKey: t.maybe(t.String),
   _persist: t.Nil,
   commServicesAccessToken: t.Nil,
 });
 
 async function websiteResponder(
   viewer: Viewer,
   req: $Request,
   res: $Response,
 ): Promise<void> {
   const appURLFacts = getAppURLFactsFromRequestURL(req.originalUrl);
   const { basePath, baseDomain } = appURLFacts;
   const baseURL = basePath.replace(/\/$/, '');
   const baseHref = baseDomain + baseURL;
 
   const loadingPromise = getWebpackCompiledRootComponentForSSR();
   const hasNotAcknowledgedPoliciesPromise = hasAnyNotAcknowledgedPolicies(
     viewer.id,
     baseLegalPolicies,
   );
 
   let initialNavInfo;
   try {
     initialNavInfo = navInfoFromURL(req.url, {
       now: currentDateInTimeZone(viewer.timeZone),
     });
   } catch (e) {
     throw new ServerError(e.message);
   }
 
   const calendarQuery = {
     startDate: initialNavInfo.startDate,
     endDate: initialNavInfo.endDate,
     filters: defaultCalendarFilters,
   };
   const messageSelectionCriteria = { joinedThreads: true };
   const initialTime = Date.now();
 
   const assetInfoPromise = getAssetInfo();
   const threadInfoPromise = fetchThreadInfos(viewer);
   const messageInfoPromise = fetchMessageInfos(
     viewer,
     messageSelectionCriteria,
     defaultNumberPerThread,
   );
   const entryInfoPromise = fetchEntryInfos(viewer, [calendarQuery]);
   const currentUserInfoPromise = fetchCurrentUserInfo(viewer);
   const userInfoPromise = fetchKnownUserInfos(viewer);
 
   const sessionIDPromise = (async () => {
     if (viewer.loggedIn) {
       await setNewSession(viewer, calendarQuery, initialTime);
     }
     return viewer.sessionID;
   })();
 
   const threadStorePromise = (async () => {
     const [{ threadInfos }, hasNotAcknowledgedPolicies] = await Promise.all([
       threadInfoPromise,
       hasNotAcknowledgedPoliciesPromise,
     ]);
     return { threadInfos: hasNotAcknowledgedPolicies ? {} : threadInfos };
   })();
   const messageStorePromise = (async () => {
     const [
       { threadInfos },
       { rawMessageInfos, truncationStatuses },
       hasNotAcknowledgedPolicies,
     ] = await Promise.all([
       threadInfoPromise,
       messageInfoPromise,
       hasNotAcknowledgedPoliciesPromise,
     ]);
     if (hasNotAcknowledgedPolicies) {
       return {
         messages: {},
         threads: {},
         local: {},
         currentAsOf: 0,
       };
     }
     const { messageStore: freshStore } = freshMessageStore(
       rawMessageInfos,
       truncationStatuses,
       mostRecentMessageTimestamp(rawMessageInfos, initialTime),
       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: initialTime,
     };
   })();
   const userStorePromise = (async () => {
     const [userInfos, hasNotAcknowledgedPolicies] = await Promise.all([
       userInfoPromise,
       hasNotAcknowledgedPoliciesPromise,
     ]);
     return {
       userInfos: hasNotAcknowledgedPolicies ? {} : userInfos,
       inconsistencyReports: [],
     };
   })();
 
   const navInfoPromise = (async () => {
     const [{ threadInfos }, messageStore, currentUserInfo, userStore] =
       await Promise.all([
         threadInfoPromise,
         messageStorePromise,
         currentUserInfoPromise,
         userStorePromise,
       ]);
     const finalNavInfo = initialNavInfo;
 
     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;
       }
     }
 
     if (
       finalNavInfo.activeChatThreadID &&
       threadIsPending(finalNavInfo.activeChatThreadID) &&
       finalNavInfo.pendingThread?.id !== finalNavInfo.activeChatThreadID
     ) {
       const pendingThreadData = parsePendingThreadID(
         finalNavInfo.activeChatThreadID,
       );
       if (
         pendingThreadData &&
         pendingThreadData.threadType !== threadTypes.SIDEBAR &&
         currentUserInfo.id
       ) {
         const { userInfos } = userStore;
         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 : initialTime;
   })();
 
   const pushApiPublicKeyPromise = (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 { jsURL, fontsURL, cssInclude, olmFilename, sqljsFilename, opaqueURL } =
     await assetInfoPromise;
 
   // prettier-ignore
   res.write(html`
     <!DOCTYPE html>
     <html lang="en">
       <head>
         <meta charset="utf-8" />
         <title>${getTitle(0)}</title>
         <base href="${basePath}" />
         <link rel="stylesheet" type="text/css" href="${fontsURL}" />
         ${cssInclude}
         <link
           rel="apple-touch-icon"
           sizes="180x180"
           href="apple-touch-icon.png"
         />
         <link
           rel="icon"
           type="image/png"
           sizes="32x32"
           href="favicon-32x32.png"
         />
         <link
           rel="icon"
           type="image/png"
           sizes="16x16"
           href="favicon-16x16.png"
         />
         <link rel="manifest" href="site.webmanifest" />
         <meta name="apple-mobile-web-app-title" content="Comm" />
         <meta name="application-name" content="Comm" />
         <meta name="msapplication-TileColor" content="#b91d47" />
         <meta name="theme-color" content="#b91d47" />
       </head>
       <body>
         <div id="react-root">
   `);
 
   const Loading = await loadingPromise;
   const reactStream = renderToNodeStream(<Loading />);
   reactStream.pipe(res, { end: false });
 
   await waitForStream(reactStream);
   res.write(html`
     </div>
     <script>
       var preloadedState =
   `);
 
   const initialReduxState = await promiseAll({
     navInfo: navInfoPromise,
     deviceID: null,
     currentUserInfo: currentUserInfoPromise,
     draftStore: { drafts: {} },
     sessionID: sessionIDPromise,
     entryStore: entryStorePromise,
     threadStore: threadStorePromise,
     userStore: userStorePromise,
     messageStore: messageStorePromise,
     updatesCurrentAsOf: currentAsOfPromise,
     loadingStatuses: {},
     calendarFilters: defaultCalendarFilters,
     // We can use paths local to the <base href> on web
     urlPrefix: '',
     windowDimensions: { width: 0, height: 0 },
     baseHref,
     notifPermissionAlertInfo: defaultNotifPermissionAlertInfo,
     connection: {
       ...defaultConnectionInfo(viewer.platform ?? 'web', viewer.timeZone),
       actualizedCalendarQuery: calendarQuery,
     },
     watchedThreadIDs: [],
     lifecycleState: 'active',
     enabledApps: defaultWebEnabledApps,
     reportStore: {
       enabledReports: defaultEnabledReports,
       queuedReports: [],
     },
     nextLocalID: 0,
     cookie: undefined,
     deviceToken: null,
     dataLoaded: viewer.loggedIn,
     windowActive: true,
     userPolicies: {},
     cryptoStore: {
       primaryIdentityKeys: null,
       notificationIdentityKeys: null,
     },
     pushApiPublicKey: pushApiPublicKeyPromise,
     _persist: null,
     commServicesAccessToken: null,
   });
   const validatedInitialReduxState = validateOutput(
-    viewer,
+    viewer.platformDetails,
     initialReduxStateValidator,
     initialReduxState,
   );
   const jsonStream = streamJSON(res, validatedInitialReduxState);
 
   await waitForStream(jsonStream);
   res.end(html`
     ;
           var baseURL = "${baseURL}";
           var olmFilename = "${olmFilename}";
           var sqljsFilename = "${sqljsFilename}";
           var opaqueURL = "${opaqueURL}";
         </script>
         <script src="${jsURL}"></script>
       </body>
     </html>
   `);
 }
 
 const inviteSecretRegex = /^[a-z0-9]+$/i;
 
 async function inviteResponder(req: $Request, res: $Response): Promise<void> {
   const { secret } = req.params;
   const userAgent = req.get('User-Agent');
   const detectionResult = detectBrowser(userAgent);
   if (detectionResult.os === 'Android OS') {
     const isSecretValid = inviteSecretRegex.test(secret);
     const referrer = isSecretValid
       ? `&referrer=${encodeURIComponent(`utm_source=invite/${secret}`)}`
       : '';
     const redirectUrl = `${stores.googlePlayUrl}${referrer}`;
     res.writeHead(301, {
       Location: redirectUrl,
     });
     res.end();
     return;
   }
   const fontsURL = await getFontsURL();
   res.end(html`
     <!DOCTYPE html>
     <html lang="en">
       <head>
         <meta charset="utf-8" />
         <title>Comm</title>
         <link rel="stylesheet" type="text/css" href="/${fontsURL}" />
         <style>
           * {
             -webkit-font-smoothing: antialiased;
             -moz-osx-font-smoothing: grayscale;
             box-sizing: border-box;
             padding: 0;
             margin: 0;
           }
 
           html {
             height: 100%;
             font-size: 112.5%;
           }
 
           body {
             font-family: 'Inter', -apple-system, 'Segoe UI', 'Roboto', 'Oxygen',
               'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
               ui-sans-serif;
             background: #0a0a0a url('/images/invite_link_background.png')
               no-repeat;
             background-size: cover;
             color: #ffffff;
             display: flex;
             flex-direction: column;
             justify-content: space-around;
             align-items: center;
             height: 100%;
             padding: 1.6rem;
             font-size: 1.8rem;
             line-height: 2.4rem;
             font-weight: 500;
           }
 
           section {
             display: flex;
             flex-direction: column;
             align-items: center;
             justify-content: space-between;
             width: 100%;
           }
 
           .card {
             width: 100%;
             padding: 3.2rem 1.6rem;
             gap: 4rem;
             background-color: #1f1f1f;
             border-radius: 1.6rem;
           }
 
           .buttons {
             gap: 1.2rem;
           }
 
           h1 {
             font-size: 3.6rem;
             line-height: 1.5;
             font-weight: 500;
             font-family: 'IBM Plex Sans', sans-serif;
           }
 
           p {
             text-align: center;
           }
 
           .separator {
             border: 1px solid #404040;
             width: 100%;
           }
 
           .button {
             all: unset;
             box-sizing: border-box;
             display: flex;
             justify-content: center;
             align-items: center;
             width: 100%;
             padding: 1.7rem;
             border-radius: 0.4rem;
             border: 1px solid transparent;
             background-color: #6d49ab;
             font-size: 1.6rem;
             line-height: 1.5;
           }
 
           .button.secondary {
             background-color: #1f1f1f;
             border-color: #ffffff;
           }
 
           .link {
             all: unset;
             box-sizing: border-box;
             display: flex;
             align-items: center;
           }
 
           .link-text {
             text-decoration-line: underline;
           }
 
           .logo-container {
             background-color: #0a0a0a;
             width: 4.2rem;
             height: 4.2rem;
             display: flex;
             justify-content: center;
             align-items: center;
             border-radius: 50%;
           }
 
           .logo {
             height: 2.6rem;
           }
 
           .arrow {
             width: 1.8rem;
             height: 1.8rem;
           }
         </style>
       </head>
       <body>
         <div></div>
         <section class="card">
           <section>
             <div class="logo-container">
               <img
                 src="/images/loading_logo.svg"
                 alt="Comm logo"
                 class="logo"
               />
             </div>
             <h1>Comm</h1>
           </section>
           <p>
             To join this community, download the Comm app and reopen this invite
             link
           </p>
           <div class="separator"></div>
           <section class="buttons">
             <a class="button" href="${stores.appStoreUrl}">Download Comm</a>
             <a class="button secondary" href="/invite/${secret}">
               Invite Link
             </a>
           </section>
         </section>
         <a class="link" href="https://comm.app/">
           <span class="link-text">Visit Comm’s website</span>
           <img
             src="/images/arrow_up_right.svg"
             alt="arrow up right"
             class="arrow"
           />
         </a>
       </body>
     </html>
   `);
 }
 
 export { websiteResponder, inviteResponder };
diff --git a/keyserver/src/socket/socket.js b/keyserver/src/socket/socket.js
index 0ab279a97..5dc0eb7f1 100644
--- a/keyserver/src/socket/socket.js
+++ b/keyserver/src/socket/socket.js
@@ -1,844 +1,844 @@
 // @flow
 
 import type { $Request } from 'express';
 import invariant from 'invariant';
 import _debounce from 'lodash/debounce.js';
 import t from 'tcomb';
 import type { TUnion } from 'tcomb';
 import WebSocket from 'ws';
 
 import { baseLegalPolicies } from 'lib/facts/policies.js';
 import { mostRecentMessageTimestamp } from 'lib/shared/message-utils.js';
 import {
   serverRequestSocketTimeout,
   serverResponseTimeout,
 } from 'lib/shared/timeouts.js';
 import { mostRecentUpdateTimestamp } from 'lib/shared/update-utils.js';
 import type { Shape } from 'lib/types/core.js';
 import { endpointIsSocketSafe } from 'lib/types/endpoints.js';
 import { defaultNumberPerThread } from 'lib/types/message-types.js';
 import { redisMessageTypes, type RedisMessage } from 'lib/types/redis-types.js';
 import { serverRequestTypes } from 'lib/types/request-types.js';
 import {
   cookieSources,
   sessionCheckFrequency,
   stateCheckInactivityActivationInterval,
 } from 'lib/types/session-types.js';
 import {
   type ClientSocketMessage,
   type InitialClientSocketMessage,
   type ResponsesClientSocketMessage,
   type ServerStateSyncFullSocketPayload,
   type ServerServerSocketMessage,
   type ErrorServerSocketMessage,
   type AuthErrorServerSocketMessage,
   type PingClientSocketMessage,
   type AckUpdatesClientSocketMessage,
   type APIRequestClientSocketMessage,
   clientSocketMessageTypes,
   stateSyncPayloadTypes,
   serverSocketMessageTypes,
   serverServerSocketMessageValidator,
 } from 'lib/types/socket-types.js';
 import { ServerError } from 'lib/utils/errors.js';
 import { values } from 'lib/utils/objects.js';
 import { promiseAll } from 'lib/utils/promises.js';
 import SequentialPromiseResolver from 'lib/utils/sequential-promise-resolver.js';
 import sleep from 'lib/utils/sleep.js';
 import { tShape, tCookie } from 'lib/utils/validation-utils.js';
 
 import { RedisSubscriber } from './redis.js';
 import {
   clientResponseInputValidator,
   processClientResponses,
   initializeSession,
   checkState,
 } from './session-utils.js';
 import { fetchUpdateInfosWithRawUpdateInfos } from '../creators/update-creator.js';
 import { deleteActivityForViewerSession } from '../deleters/activity-deleters.js';
 import { deleteCookie } from '../deleters/cookie-deleters.js';
 import { deleteUpdatesBeforeTimeTargetingSession } from '../deleters/update-deleters.js';
 import { jsonEndpoints } from '../endpoints.js';
 import { fetchEntryInfos } from '../fetchers/entry-fetchers.js';
 import {
   fetchMessageInfosSince,
   getMessageFetchResultFromRedisMessages,
 } from '../fetchers/message-fetchers.js';
 import { fetchThreadInfos } from '../fetchers/thread-fetchers.js';
 import { fetchUpdateInfos } from '../fetchers/update-fetchers.js';
 import {
   fetchCurrentUserInfo,
   fetchKnownUserInfos,
 } from '../fetchers/user-fetchers.js';
 import {
   newEntryQueryInputValidator,
   verifyCalendarQueryThreadIDs,
 } from '../responders/entry-responders.js';
 import { handleAsyncPromise } from '../responders/handlers.js';
 import {
   fetchViewerForSocket,
   extendCookieLifespan,
   createNewAnonymousCookie,
   isCookieMissingSignedIdentityKeysBlob,
 } from '../session/cookies.js';
 import { Viewer } from '../session/viewer.js';
 import { commitSessionUpdate } from '../updaters/session-updaters.js';
 import { assertSecureRequest } from '../utils/security-utils.js';
 import {
   checkInputValidator,
   checkClientSupported,
   policiesValidator,
   validateOutput,
 } from '../utils/validation-utils.js';
 
 const clientSocketMessageInputValidator: TUnion<ClientSocketMessage> = t.union([
   tShape({
     type: t.irreducible(
       'clientSocketMessageTypes.INITIAL',
       x => x === clientSocketMessageTypes.INITIAL,
     ),
     id: t.Number,
     payload: tShape({
       sessionIdentification: tShape({
         cookie: t.maybe(tCookie),
         sessionID: t.maybe(t.String),
       }),
       sessionState: tShape({
         calendarQuery: newEntryQueryInputValidator,
         messagesCurrentAsOf: t.Number,
         updatesCurrentAsOf: t.Number,
         watchedIDs: t.list(t.String),
       }),
       clientResponses: t.list(clientResponseInputValidator),
     }),
   }),
   tShape({
     type: t.irreducible(
       'clientSocketMessageTypes.RESPONSES',
       x => x === clientSocketMessageTypes.RESPONSES,
     ),
     id: t.Number,
     payload: tShape({
       clientResponses: t.list(clientResponseInputValidator),
     }),
   }),
   tShape({
     type: t.irreducible(
       'clientSocketMessageTypes.PING',
       x => x === clientSocketMessageTypes.PING,
     ),
     id: t.Number,
   }),
   tShape({
     type: t.irreducible(
       'clientSocketMessageTypes.ACK_UPDATES',
       x => x === clientSocketMessageTypes.ACK_UPDATES,
     ),
     id: t.Number,
     payload: tShape({
       currentAsOf: t.Number,
     }),
   }),
   tShape({
     type: t.irreducible(
       'clientSocketMessageTypes.API_REQUEST',
       x => x === clientSocketMessageTypes.API_REQUEST,
     ),
     id: t.Number,
     payload: tShape({
       endpoint: t.String,
       input: t.maybe(t.Object),
     }),
   }),
 ]);
 
 function onConnection(ws: WebSocket, req: $Request) {
   assertSecureRequest(req);
   new Socket(ws, req);
 }
 
 type StateCheckConditions = {
   activityRecentlyOccurred: boolean,
   stateCheckOngoing: boolean,
 };
 
 class Socket {
   ws: WebSocket;
   httpRequest: $Request;
   viewer: ?Viewer;
   redis: ?RedisSubscriber;
   redisPromiseResolver: SequentialPromiseResolver<ServerServerSocketMessage>;
 
   stateCheckConditions: StateCheckConditions = {
     activityRecentlyOccurred: true,
     stateCheckOngoing: false,
   };
   stateCheckTimeoutID: ?TimeoutID;
 
   constructor(ws: WebSocket, httpRequest: $Request) {
     this.ws = ws;
     this.httpRequest = httpRequest;
     ws.on('message', this.onMessage);
     ws.on('close', this.onClose);
     this.resetTimeout();
     this.redisPromiseResolver = new SequentialPromiseResolver(this.sendMessage);
   }
 
   onMessage = async (
     messageString: string | Buffer | ArrayBuffer | Array<Buffer>,
   ) => {
     invariant(typeof messageString === 'string', 'message should be string');
     let clientSocketMessage: ?ClientSocketMessage;
     try {
       this.resetTimeout();
       const messageObject = JSON.parse(messageString);
       clientSocketMessage = checkInputValidator(
         clientSocketMessageInputValidator,
         messageObject,
       );
       if (clientSocketMessage.type === clientSocketMessageTypes.INITIAL) {
         if (this.viewer) {
           // This indicates that the user sent multiple INITIAL messages.
           throw new ServerError('socket_already_initialized');
         }
         this.viewer = await fetchViewerForSocket(
           this.httpRequest,
           clientSocketMessage,
         );
         if (!this.viewer) {
           // This indicates that the cookie was invalid, but the client is using
           // cookieSources.HEADER and thus can't accept a new cookie over
           // WebSockets. See comment under catch block for socket_deauthorized.
           throw new ServerError('socket_deauthorized');
         }
       }
       const { viewer } = this;
       if (!viewer) {
         // This indicates a non-INITIAL message was sent by the client before
         // the INITIAL message.
         throw new ServerError('socket_uninitialized');
       }
       if (viewer.sessionChanged) {
         // This indicates that the cookie was invalid, and we've assigned a new
         // anonymous one.
         throw new ServerError('socket_deauthorized');
       }
       if (!viewer.loggedIn) {
         // This indicates that the specified cookie was an anonymous one.
         throw new ServerError('not_logged_in');
       }
       await checkClientSupported(
         viewer,
         clientSocketMessageInputValidator,
         clientSocketMessage,
       );
       await policiesValidator(viewer, baseLegalPolicies);
 
       const serverResponses = await this.handleClientSocketMessage(
         clientSocketMessage,
       );
       if (!this.redis) {
         this.redis = new RedisSubscriber(
           { userID: viewer.userID, sessionID: viewer.session },
           this.onRedisMessage,
         );
       }
       if (viewer.sessionChanged) {
         // This indicates that something has caused the session to change, which
         // shouldn't happen from inside a WebSocket since we can't handle cookie
         // invalidation.
         throw new ServerError('session_mutated_from_socket');
       }
       if (clientSocketMessage.type !== clientSocketMessageTypes.PING) {
         handleAsyncPromise(extendCookieLifespan(viewer.cookieID));
       }
       for (const response of serverResponses) {
         this.sendMessage(response);
       }
       if (clientSocketMessage.type === clientSocketMessageTypes.INITIAL) {
         this.onSuccessfulConnection();
       }
     } catch (error) {
       console.warn(error);
       if (!(error instanceof ServerError)) {
         const errorMessage: ErrorServerSocketMessage = {
           type: serverSocketMessageTypes.ERROR,
           message: error.message,
         };
         const responseTo = clientSocketMessage ? clientSocketMessage.id : null;
         if (responseTo !== null) {
           errorMessage.responseTo = responseTo;
         }
         this.markActivityOccurred();
         this.sendMessage(errorMessage);
         return;
       }
       invariant(clientSocketMessage, 'should be set');
       const responseTo = clientSocketMessage.id;
       if (error.message === 'socket_deauthorized') {
         const authErrorMessage: AuthErrorServerSocketMessage = {
           type: serverSocketMessageTypes.AUTH_ERROR,
           responseTo,
           message: error.message,
         };
         if (this.viewer) {
           // viewer should only be falsey for cookieSources.HEADER (web)
           // clients. Usually if the cookie is invalid we construct a new
           // anonymous Viewer with a new cookie, and then pass the cookie down
           // in the error. But we can't pass HTTP cookies in WebSocket messages.
           authErrorMessage.sessionChange = {
             cookie: this.viewer.cookiePairString,
             currentUserInfo: {
               id: this.viewer.cookieID,
               anonymous: true,
             },
           };
         }
         this.sendMessage(authErrorMessage);
         this.ws.close(4100, error.message);
         return;
       } else if (error.message === 'client_version_unsupported') {
         const { viewer } = this;
         invariant(viewer, 'should be set');
         const promises = {};
         promises.deleteCookie = deleteCookie(viewer.cookieID);
         if (viewer.cookieSource !== cookieSources.BODY) {
           promises.anonymousViewerData = createNewAnonymousCookie({
             platformDetails: error.platformDetails,
             deviceToken: viewer.deviceToken,
           });
         }
         const { anonymousViewerData } = await promiseAll(promises);
         const authErrorMessage: AuthErrorServerSocketMessage = {
           type: serverSocketMessageTypes.AUTH_ERROR,
           responseTo,
           message: error.message,
         };
         if (anonymousViewerData) {
           // It is normally not safe to pass the result of
           // createNewAnonymousCookie to the Viewer constructor. That is because
           // createNewAnonymousCookie leaves several fields of
           // AnonymousViewerData unset, and consequently Viewer will throw when
           // access is attempted. It is only safe here because we can guarantee
           // that only cookiePairString and cookieID are accessed on anonViewer
           // below.
           const anonViewer = new Viewer(anonymousViewerData);
           authErrorMessage.sessionChange = {
             cookie: anonViewer.cookiePairString,
             currentUserInfo: {
               id: anonViewer.cookieID,
               anonymous: true,
             },
           };
         }
         this.sendMessage(authErrorMessage);
         this.ws.close(4101, error.message);
         return;
       }
       if (error.payload) {
         this.sendMessage({
           type: serverSocketMessageTypes.ERROR,
           responseTo,
           message: error.message,
           payload: error.payload,
         });
       } else {
         this.sendMessage({
           type: serverSocketMessageTypes.ERROR,
           responseTo,
           message: error.message,
         });
       }
       if (error.message === 'not_logged_in') {
         this.ws.close(4102, error.message);
       } else if (error.message === 'session_mutated_from_socket') {
         this.ws.close(4103, error.message);
       } else {
         this.markActivityOccurred();
       }
     }
   };
 
   onClose = async () => {
     this.clearStateCheckTimeout();
     this.resetTimeout.cancel();
     this.debouncedAfterActivity.cancel();
     if (this.viewer && this.viewer.hasSessionInfo) {
       await deleteActivityForViewerSession(this.viewer);
     }
     if (this.redis) {
       this.redis.quit();
       this.redis = null;
     }
   };
 
   sendMessage = (message: ServerServerSocketMessage) => {
     invariant(
       this.ws.readyState > 0,
       "shouldn't send message until connection established",
     );
     if (this.ws.readyState === 1) {
       const { viewer } = this;
       const validatedMessage = validateOutput(
-        viewer,
+        viewer?.platformDetails,
         serverServerSocketMessageValidator,
         message,
       );
       this.ws.send(JSON.stringify(validatedMessage));
     }
   };
 
   async handleClientSocketMessage(
     message: ClientSocketMessage,
   ): Promise<ServerServerSocketMessage[]> {
     const resultPromise = (async () => {
       if (message.type === clientSocketMessageTypes.INITIAL) {
         this.markActivityOccurred();
         return await this.handleInitialClientSocketMessage(message);
       } else if (message.type === clientSocketMessageTypes.RESPONSES) {
         this.markActivityOccurred();
         return await this.handleResponsesClientSocketMessage(message);
       } else if (message.type === clientSocketMessageTypes.PING) {
         return this.handlePingClientSocketMessage(message);
       } else if (message.type === clientSocketMessageTypes.ACK_UPDATES) {
         this.markActivityOccurred();
         return await this.handleAckUpdatesClientSocketMessage(message);
       } else if (message.type === clientSocketMessageTypes.API_REQUEST) {
         this.markActivityOccurred();
         return await this.handleAPIRequestClientSocketMessage(message);
       }
       return [];
     })();
     const timeoutPromise = (async () => {
       await sleep(serverResponseTimeout);
       throw new ServerError('socket_response_timeout');
     })();
     return await Promise.race([resultPromise, timeoutPromise]);
   }
 
   async handleInitialClientSocketMessage(
     message: InitialClientSocketMessage,
   ): Promise<ServerServerSocketMessage[]> {
     const { viewer } = this;
     invariant(viewer, 'should be set');
 
     const responses = [];
 
     const { sessionState, clientResponses } = message.payload;
     const {
       calendarQuery,
       updatesCurrentAsOf: oldUpdatesCurrentAsOf,
       messagesCurrentAsOf: oldMessagesCurrentAsOf,
       watchedIDs,
     } = sessionState;
     await verifyCalendarQueryThreadIDs(calendarQuery);
 
     const sessionInitializationResult = await initializeSession(
       viewer,
       calendarQuery,
       oldUpdatesCurrentAsOf,
     );
 
     const threadCursors = {};
     for (const watchedThreadID of watchedIDs) {
       threadCursors[watchedThreadID] = null;
     }
     const messageSelectionCriteria = {
       threadCursors,
       joinedThreads: true,
       newerThan: oldMessagesCurrentAsOf,
     };
     const [fetchMessagesResult, { serverRequests, activityUpdateResult }] =
       await Promise.all([
         fetchMessageInfosSince(
           viewer,
           messageSelectionCriteria,
           defaultNumberPerThread,
         ),
         processClientResponses(viewer, clientResponses),
       ]);
     const messagesResult = {
       rawMessageInfos: fetchMessagesResult.rawMessageInfos,
       truncationStatuses: fetchMessagesResult.truncationStatuses,
       currentAsOf: mostRecentMessageTimestamp(
         fetchMessagesResult.rawMessageInfos,
         oldMessagesCurrentAsOf,
       ),
     };
 
     if (
       viewer.userAgent?.includes('Electron') &&
       viewer.platform === 'web' &&
       !serverRequests.find(
         request => request.type === serverRequestTypes.PLATFORM_DETAILS,
       )
     ) {
       serverRequests.push({ type: serverRequestTypes.PLATFORM_DETAILS });
     }
 
     const isCookieMissingSignedIdentityKeysBlobPromise =
       isCookieMissingSignedIdentityKeysBlob(viewer.cookieID);
 
     if (!sessionInitializationResult.sessionContinued) {
       const [threadsResult, entriesResult, currentUserInfo, knownUserInfos] =
         await Promise.all([
           fetchThreadInfos(viewer),
           fetchEntryInfos(viewer, [calendarQuery]),
           fetchCurrentUserInfo(viewer),
           fetchKnownUserInfos(viewer),
         ]);
       const payload: ServerStateSyncFullSocketPayload = {
         type: stateSyncPayloadTypes.FULL,
         messagesResult,
         threadInfos: threadsResult.threadInfos,
         currentUserInfo,
         rawEntryInfos: entriesResult.rawEntryInfos,
         userInfos: values(knownUserInfos),
         updatesCurrentAsOf: oldUpdatesCurrentAsOf,
       };
       if (viewer.sessionChanged) {
         // If initializeSession encounters,
         // sessionIdentifierTypes.BODY_SESSION_ID but the session
         // is unspecified or expired,
         // it will set a new sessionID and specify viewer.sessionChanged
         const { sessionID } = viewer;
         invariant(
           sessionID !== null && sessionID !== undefined,
           'should be set',
         );
         payload.sessionID = sessionID;
         viewer.sessionChanged = false;
       }
       responses.push({
         type: serverSocketMessageTypes.STATE_SYNC,
         responseTo: message.id,
         payload,
       });
     } else {
       const { sessionUpdate, deltaEntryInfoResult } =
         sessionInitializationResult;
 
       const promises = {};
       promises.deleteExpiredUpdates = deleteUpdatesBeforeTimeTargetingSession(
         viewer,
         oldUpdatesCurrentAsOf,
       );
       promises.fetchUpdateResult = fetchUpdateInfos(
         viewer,
         oldUpdatesCurrentAsOf,
         calendarQuery,
       );
       promises.sessionUpdate = commitSessionUpdate(viewer, sessionUpdate);
       const { fetchUpdateResult } = await promiseAll(promises);
 
       const { updateInfos, userInfos } = fetchUpdateResult;
       const newUpdatesCurrentAsOf = mostRecentUpdateTimestamp(
         [...updateInfos],
         oldUpdatesCurrentAsOf,
       );
       const updatesResult = {
         newUpdates: updateInfos,
         currentAsOf: newUpdatesCurrentAsOf,
       };
 
       responses.push({
         type: serverSocketMessageTypes.STATE_SYNC,
         responseTo: message.id,
         payload: {
           type: stateSyncPayloadTypes.INCREMENTAL,
           messagesResult,
           updatesResult,
           deltaEntryInfos: deltaEntryInfoResult.rawEntryInfos,
           deletedEntryIDs: deltaEntryInfoResult.deletedEntryIDs,
           userInfos: values(userInfos),
         },
       });
     }
 
     const signedIdentityKeysBlobMissing =
       await isCookieMissingSignedIdentityKeysBlobPromise;
 
     if (signedIdentityKeysBlobMissing) {
       serverRequests.push({
         type: serverRequestTypes.SIGNED_IDENTITY_KEYS_BLOB,
       });
     }
 
     if (serverRequests.length > 0 || clientResponses.length > 0) {
       // We send this message first since the STATE_SYNC triggers the client's
       // connection status to shift to "connected", and we want to make sure the
       // client responses are cleared from Redux before that happens
       responses.unshift({
         type: serverSocketMessageTypes.REQUESTS,
         responseTo: message.id,
         payload: { serverRequests },
       });
     }
 
     if (activityUpdateResult) {
       // Same reason for unshifting as above
       responses.unshift({
         type: serverSocketMessageTypes.ACTIVITY_UPDATE_RESPONSE,
         responseTo: message.id,
         payload: activityUpdateResult,
       });
     }
 
     return responses;
   }
 
   async handleResponsesClientSocketMessage(
     message: ResponsesClientSocketMessage,
   ): Promise<ServerServerSocketMessage[]> {
     const { viewer } = this;
     invariant(viewer, 'should be set');
 
     const { clientResponses } = message.payload;
     const { stateCheckStatus } = await processClientResponses(
       viewer,
       clientResponses,
     );
 
     const serverRequests = [];
     if (stateCheckStatus && stateCheckStatus.status !== 'state_check') {
       const { sessionUpdate, checkStateRequest } = await checkState(
         viewer,
         stateCheckStatus,
         viewer.calendarQuery,
       );
       if (sessionUpdate) {
         await commitSessionUpdate(viewer, sessionUpdate);
         this.setStateCheckConditions({ stateCheckOngoing: false });
       }
       if (checkStateRequest) {
         serverRequests.push(checkStateRequest);
       }
     }
 
     // We send a response message regardless of whether we have any requests,
     // since we need to ack the client's responses
     return [
       {
         type: serverSocketMessageTypes.REQUESTS,
         responseTo: message.id,
         payload: { serverRequests },
       },
     ];
   }
 
   handlePingClientSocketMessage(
     message: PingClientSocketMessage,
   ): ServerServerSocketMessage[] {
     return [
       {
         type: serverSocketMessageTypes.PONG,
         responseTo: message.id,
       },
     ];
   }
 
   async handleAckUpdatesClientSocketMessage(
     message: AckUpdatesClientSocketMessage,
   ): Promise<ServerServerSocketMessage[]> {
     const { viewer } = this;
     invariant(viewer, 'should be set');
     const { currentAsOf } = message.payload;
     await Promise.all([
       deleteUpdatesBeforeTimeTargetingSession(viewer, currentAsOf),
       commitSessionUpdate(viewer, { lastUpdate: currentAsOf }),
     ]);
     return [];
   }
 
   async handleAPIRequestClientSocketMessage(
     message: APIRequestClientSocketMessage,
   ): Promise<ServerServerSocketMessage[]> {
     if (!endpointIsSocketSafe(message.payload.endpoint)) {
       throw new ServerError('endpoint_unsafe_for_socket');
     }
     const { viewer } = this;
     invariant(viewer, 'should be set');
     const responder = jsonEndpoints[message.payload.endpoint];
     await policiesValidator(viewer, responder.requiredPolicies);
     const response = await responder.responder(viewer, message.payload.input);
     return [
       {
         type: serverSocketMessageTypes.API_RESPONSE,
         responseTo: message.id,
         payload: response,
       },
     ];
   }
 
   onRedisMessage = async (message: RedisMessage) => {
     try {
       await this.processRedisMessage(message);
     } catch (e) {
       console.warn(e);
     }
   };
 
   async processRedisMessage(message: RedisMessage) {
     if (message.type === redisMessageTypes.START_SUBSCRIPTION) {
       this.ws.terminate();
     } else if (message.type === redisMessageTypes.NEW_UPDATES) {
       const { viewer } = this;
       invariant(viewer, 'should be set');
       if (message.ignoreSession && message.ignoreSession === viewer.session) {
         return;
       }
       const rawUpdateInfos = message.updates;
       this.redisPromiseResolver.add(
         (async () => {
           const { updateInfos, userInfos } =
             await fetchUpdateInfosWithRawUpdateInfos(rawUpdateInfos, {
               viewer,
             });
           if (updateInfos.length === 0) {
             console.warn(
               'could not get any UpdateInfos from redisMessageTypes.NEW_UPDATES',
             );
             return null;
           }
           this.markActivityOccurred();
           return {
             type: serverSocketMessageTypes.UPDATES,
             payload: {
               updatesResult: {
                 currentAsOf: mostRecentUpdateTimestamp([...updateInfos], 0),
                 newUpdates: updateInfos,
               },
               userInfos: values(userInfos),
             },
           };
         })(),
       );
     } else if (message.type === redisMessageTypes.NEW_MESSAGES) {
       const { viewer } = this;
       invariant(viewer, 'should be set');
       const rawMessageInfos = message.messages;
       const messageFetchResult = getMessageFetchResultFromRedisMessages(
         viewer,
         rawMessageInfos,
       );
       if (messageFetchResult.rawMessageInfos.length === 0) {
         console.warn(
           'could not get any rawMessageInfos from ' +
             'redisMessageTypes.NEW_MESSAGES',
         );
         return;
       }
       this.redisPromiseResolver.add(
         (async () => {
           this.markActivityOccurred();
           return {
             type: serverSocketMessageTypes.MESSAGES,
             payload: {
               messagesResult: {
                 rawMessageInfos: messageFetchResult.rawMessageInfos,
                 truncationStatuses: messageFetchResult.truncationStatuses,
                 currentAsOf: mostRecentMessageTimestamp(
                   messageFetchResult.rawMessageInfos,
                   0,
                 ),
               },
             },
           };
         })(),
       );
     }
   }
 
   onSuccessfulConnection() {
     if (this.ws.readyState !== 1) {
       return;
     }
     this.handleStateCheckConditionsUpdate();
   }
 
   // The Socket will timeout by calling this.ws.terminate()
   // serverRequestSocketTimeout milliseconds after the last
   // time resetTimeout is called
   resetTimeout = _debounce(
     () => this.ws.terminate(),
     serverRequestSocketTimeout,
   );
 
   debouncedAfterActivity = _debounce(
     () => this.setStateCheckConditions({ activityRecentlyOccurred: false }),
     stateCheckInactivityActivationInterval,
   );
 
   markActivityOccurred = () => {
     if (this.ws.readyState !== 1) {
       return;
     }
     this.setStateCheckConditions({ activityRecentlyOccurred: true });
     this.debouncedAfterActivity();
   };
 
   clearStateCheckTimeout() {
     const { stateCheckTimeoutID } = this;
     if (stateCheckTimeoutID) {
       clearTimeout(stateCheckTimeoutID);
       this.stateCheckTimeoutID = null;
     }
   }
 
   setStateCheckConditions(newConditions: Shape<StateCheckConditions>) {
     this.stateCheckConditions = {
       ...this.stateCheckConditions,
       ...newConditions,
     };
     this.handleStateCheckConditionsUpdate();
   }
 
   get stateCheckCanStart() {
     return Object.values(this.stateCheckConditions).every(cond => !cond);
   }
 
   handleStateCheckConditionsUpdate() {
     if (!this.stateCheckCanStart) {
       this.clearStateCheckTimeout();
       return;
     }
     if (this.stateCheckTimeoutID) {
       return;
     }
     const { viewer } = this;
     if (!viewer) {
       return;
     }
     const timeUntilStateCheck =
       viewer.sessionLastValidated + sessionCheckFrequency - Date.now();
     if (timeUntilStateCheck <= 0) {
       this.initiateStateCheck();
     } else {
       this.stateCheckTimeoutID = setTimeout(
         this.initiateStateCheck,
         timeUntilStateCheck,
       );
     }
   }
 
   initiateStateCheck = async () => {
     this.setStateCheckConditions({ stateCheckOngoing: true });
 
     const { viewer } = this;
     invariant(viewer, 'should be set');
 
     const { checkStateRequest } = await checkState(
       viewer,
       { status: 'state_check' },
       viewer.calendarQuery,
     );
     invariant(checkStateRequest, 'should be set');
 
     this.sendMessage({
       type: serverSocketMessageTypes.REQUESTS,
       payload: { serverRequests: [checkStateRequest] },
     });
   };
 }
 
 export { onConnection };
diff --git a/keyserver/src/utils/validation-utils.js b/keyserver/src/utils/validation-utils.js
index d4b029520..17fc52650 100644
--- a/keyserver/src/utils/validation-utils.js
+++ b/keyserver/src/utils/validation-utils.js
@@ -1,343 +1,346 @@
 // @flow
 
 import _mapKeys from 'lodash/fp/mapKeys.js';
 import _mapValues from 'lodash/fp/mapValues.js';
 import type { TType, TInterface } from 'tcomb';
 
 import type { PolicyType } from 'lib/facts/policies.js';
-import { hasMinCodeVersion } from 'lib/shared/version-utils.js';
-import { isWebPlatform } from 'lib/types/device-types.js';
+import {
+  hasMinCodeVersion,
+  FUTURE_CODE_VERSION,
+} from 'lib/shared/version-utils.js';
+import { type PlatformDetails, isWebPlatform } from 'lib/types/device-types.js';
 import { ServerError } from 'lib/utils/errors.js';
 import {
   tCookie,
   tPassword,
   tPlatform,
   tPlatformDetails,
   assertWithValidator,
   tID,
 } from 'lib/utils/validation-utils.js';
 
 import { fetchNotAcknowledgedPolicies } from '../fetchers/policy-acknowledgment-fetchers.js';
 import { verifyClientSupported } from '../session/version.js';
 import type { Viewer } from '../session/viewer.js';
 
 const convertToNewIDSchema = false;
 const keyserverPrefixID = '256';
 
 async function validateInput<T>(
   viewer: Viewer,
   inputValidator: TType<T>,
   input: mixed,
 ): Promise<T> {
   if (!viewer.isSocket) {
     await checkClientSupported(viewer, inputValidator, input);
   }
   const convertedInput = checkInputValidator(inputValidator, input);
 
   if (
-    hasMinCodeVersion(viewer.platformDetails, 1000) &&
+    hasMinCodeVersion(viewer.platformDetails, FUTURE_CODE_VERSION) &&
     !isWebPlatform(viewer.platformDetails?.platform) &&
     convertToNewIDSchema
   ) {
     return convertClientIDsToServerIDs(
       keyserverPrefixID,
       inputValidator,
       convertedInput,
     );
   }
 
   return convertedInput;
 }
 
 function validateOutput<T>(
-  viewer: ?Viewer,
+  platformDetails: ?PlatformDetails,
   outputValidator: TType<T>,
   data: T,
 ): T {
   if (!outputValidator.is(data)) {
     console.trace(
       'Output validation failed, validator is:',
       outputValidator.displayName,
     );
     return data;
   }
 
   if (
-    hasMinCodeVersion(viewer?.platformDetails, 1000) &&
-    !isWebPlatform(viewer?.platformDetails?.platform) &&
+    hasMinCodeVersion(platformDetails, FUTURE_CODE_VERSION) &&
+    !isWebPlatform(platformDetails?.platform) &&
     convertToNewIDSchema
   ) {
     return convertServerIDsToClientIDs(
       keyserverPrefixID,
       outputValidator,
       data,
     );
   }
 
   return data;
 }
 
 function convertServerIDsToClientIDs<T>(
   serverPrefixID: string,
   outputValidator: TType<T>,
   data: T,
 ): T {
   const conversionFunction = id => {
     if (id.indexOf('|') !== -1) {
       console.warn(`Server id '${id}' already has a prefix`);
       return id;
     }
     return `${serverPrefixID}|${id}`;
   };
 
   return convertObject(outputValidator, data, [tID], conversionFunction);
 }
 
 function convertClientIDsToServerIDs<T>(
   serverPrefixID: string,
   outputValidator: TType<T>,
   data: T,
 ): T {
   const prefix = serverPrefixID + '|';
   const conversionFunction = id => {
     if (id.startsWith(prefix)) {
       return id.substr(prefix.length);
     }
 
     throw new ServerError('invalid_client_id_prefix');
   };
 
   return convertObject(outputValidator, data, [tID], conversionFunction);
 }
 
 function checkInputValidator<T>(inputValidator: TType<T>, input: mixed): T {
   if (inputValidator.is(input)) {
     return assertWithValidator(input, inputValidator);
   }
   const error = new ServerError('invalid_parameters');
   error.sanitizedInput = input ? sanitizeInput(inputValidator, input) : null;
   throw error;
 }
 
 async function checkClientSupported<T>(
   viewer: Viewer,
   inputValidator: ?TType<T>,
   input: T,
 ) {
   let platformDetails;
   if (inputValidator) {
     platformDetails = findFirstInputMatchingValidator(
       inputValidator,
       tPlatformDetails,
       input,
     );
   }
   if (!platformDetails && inputValidator) {
     const platform = findFirstInputMatchingValidator(
       inputValidator,
       tPlatform,
       input,
     );
     if (platform) {
       platformDetails = { platform };
     }
   }
   if (!platformDetails) {
     ({ platformDetails } = viewer);
   }
   await verifyClientSupported(viewer, platformDetails);
 }
 
 const redactedString = '********';
 const redactedTypes = [tPassword, tCookie];
 function sanitizeInput<T>(inputValidator: TType<T>, input: T): T {
   return convertObject(
     inputValidator,
     input,
     redactedTypes,
     () => redactedString,
   );
 }
 
 function findFirstInputMatchingValidator(
   wholeInputValidator: *,
   inputValidatorToMatch: *,
   input: *,
 ): any {
   if (!wholeInputValidator || input === null || input === undefined) {
     return null;
   }
   if (
     wholeInputValidator === inputValidatorToMatch &&
     wholeInputValidator.is(input)
   ) {
     return input;
   }
   if (wholeInputValidator.meta.kind === 'maybe') {
     return findFirstInputMatchingValidator(
       wholeInputValidator.meta.type,
       inputValidatorToMatch,
       input,
     );
   }
   if (
     wholeInputValidator.meta.kind === 'interface' &&
     typeof input === 'object'
   ) {
     for (const key in input) {
       const value = input[key];
       const validator = wholeInputValidator.meta.props[key];
       const innerResult = findFirstInputMatchingValidator(
         validator,
         inputValidatorToMatch,
         value,
       );
       if (innerResult) {
         return innerResult;
       }
     }
   }
   if (wholeInputValidator.meta.kind === 'union') {
     for (const validator of wholeInputValidator.meta.types) {
       if (validator.is(input)) {
         return findFirstInputMatchingValidator(
           validator,
           inputValidatorToMatch,
           input,
         );
       }
     }
   }
   if (wholeInputValidator.meta.kind === 'list' && Array.isArray(input)) {
     const validator = wholeInputValidator.meta.type;
     for (const value of input) {
       const innerResult = findFirstInputMatchingValidator(
         validator,
         inputValidatorToMatch,
         value,
       );
       if (innerResult) {
         return innerResult;
       }
     }
   }
   return null;
 }
 
 function convertObject<T, I>(
   validator: TType<I>,
   input: I,
   typesToConvert: $ReadOnlyArray<TType<T>>,
   conversionFunction: T => T,
 ): I {
   if (input === null || input === undefined) {
     return input;
   }
 
   // While they should be the same runtime object,
   // `TValidator` is `TType<T>` and `validator` is `TType<I>`.
   // Having them have different types allows us to use `assertWithValidator`
   // to change `input` flow type
   const TValidator = typesToConvert[typesToConvert.indexOf(validator)];
   if (TValidator && TValidator.is(input)) {
     const TInput = assertWithValidator(input, TValidator);
     const converted = conversionFunction(TInput);
     return assertWithValidator(converted, validator);
   }
 
   if (validator.meta.kind === 'maybe' || validator.meta.kind === 'subtype') {
     return convertObject(
       validator.meta.type,
       input,
       typesToConvert,
       conversionFunction,
     );
   }
   if (validator.meta.kind === 'interface' && typeof input === 'object') {
     const recastValidator: TInterface<typeof input> = (validator: any);
     const result = {};
     for (const key in input) {
       const innerValidator = recastValidator.meta.props[key];
       result[key] = convertObject(
         innerValidator,
         input[key],
         typesToConvert,
         conversionFunction,
       );
     }
     return assertWithValidator(result, recastValidator);
   }
   if (validator.meta.kind === 'union') {
     for (const innerValidator of validator.meta.types) {
       if (innerValidator.is(input)) {
         return convertObject(
           innerValidator,
           input,
           typesToConvert,
           conversionFunction,
         );
       }
     }
     return input;
   }
   if (validator.meta.kind === 'list' && Array.isArray(input)) {
     const innerValidator = validator.meta.type;
     return (input.map(value =>
       convertObject(innerValidator, value, typesToConvert, conversionFunction),
     ): any);
   }
   if (validator.meta.kind === 'dict' && typeof input === 'object') {
     const domainValidator = validator.meta.domain;
     const codomainValidator = validator.meta.codomain;
     if (typesToConvert.includes(domainValidator)) {
       input = _mapKeys(key => conversionFunction(key))(input);
     }
     return _mapValues(value =>
       convertObject(
         codomainValidator,
         value,
         typesToConvert,
         conversionFunction,
       ),
     )(input);
   }
 
   return input;
 }
 
 async function policiesValidator(
   viewer: Viewer,
   policies: $ReadOnlyArray<PolicyType>,
 ) {
   if (!policies.length) {
     return;
   }
   if (!hasMinCodeVersion(viewer.platformDetails, 181)) {
     return;
   }
 
   const notAcknowledgedPolicies = await fetchNotAcknowledgedPolicies(
     viewer.id,
     policies,
   );
 
   if (notAcknowledgedPolicies.length) {
     throw new ServerError('policies_not_accepted', {
       notAcknowledgedPolicies,
     });
   }
 }
 
 export {
   validateInput,
   validateOutput,
   checkInputValidator,
   redactedString,
   sanitizeInput,
   findFirstInputMatchingValidator,
   checkClientSupported,
   convertServerIDsToClientIDs,
   convertClientIDsToServerIDs,
   convertObject,
   policiesValidator,
 };