diff --git a/native/redux/redux-setup.js b/native/redux/redux-setup.js
index f547d9793..4a08e36e5 100644
--- a/native/redux/redux-setup.js
+++ b/native/redux/redux-setup.js
@@ -1,438 +1,407 @@
 // @flow
 
 import { AppState as NativeAppState, Alert } from 'react-native';
 import { createStore, applyMiddleware, type Store, compose } from 'redux';
 import { persistStore, persistReducer } from 'redux-persist';
 import thunk from 'redux-thunk';
 
 import { setClientDBStoreActionType } from 'lib/actions/client-db-store-actions.js';
 import { siweAuthActionTypes } from 'lib/actions/siwe-actions.js';
 import {
   logOutActionTypes,
   deleteAccountActionTypes,
   logInActionTypes,
   keyserverAuthActionTypes,
   deleteKeyserverAccountActionTypes,
 } from 'lib/actions/user-actions.js';
 import { setNewSessionActionType } from 'lib/keyserver-conn/keyserver-conn-types.js';
 import type { ThreadStoreOperation } from 'lib/ops/thread-store-ops.js';
 import { threadStoreOpsHandlers } from 'lib/ops/thread-store-ops.js';
 import { reduceLoadingStatuses } from 'lib/reducers/loading-reducer.js';
 import baseReducer from 'lib/reducers/master-reducer.js';
 import {
   invalidSessionDowngrade,
   invalidSessionRecovery,
 } from 'lib/shared/session-utils.js';
 import { isStaff } from 'lib/shared/staff-utils.js';
 import type { Dispatch, BaseAction } from 'lib/types/redux-types.js';
 import { rehydrateActionType } from 'lib/types/redux-types.js';
 import type { SetSessionPayload } from 'lib/types/session-types.js';
 import { reduxLoggerMiddleware } from 'lib/utils/action-logger.js';
 import { ashoatKeyserverID } from 'lib/utils/validation-utils.js';
 
 import {
   updateDimensionsActiveType,
   updateConnectivityActiveType,
   updateDeviceCameraInfoActionType,
   updateDeviceOrientationActionType,
   backgroundActionTypes,
   setReduxStateActionType,
   setStoreLoadedActionType,
   type Action,
   setLocalSettingsActionType,
 } from './action-types.js';
 import { defaultState } from './default-state.js';
 import { remoteReduxDevServerConfig } from './dev-tools.js';
 import { persistConfig, setPersistor } from './persist.js';
 import { onStateDifference } from './redux-debug-utils.js';
 import { processDBStoreOperations } from './redux-utils.js';
 import type { AppState } from './state-types.js';
 import { getGlobalNavContext } from '../navigation/icky-global.js';
 import { activeMessageListSelector } from '../navigation/nav-selectors.js';
 import reactotron from '../reactotron.js';
 import { AppOutOfDateAlertDetails } from '../utils/alert-messages.js';
 import { isStaffRelease } from '../utils/staff-utils.js';
 import { getDevServerHostname } from '../utils/url-utils.js';
 
 function reducer(state: AppState = defaultState, action: Action) {
   if (action.type === setReduxStateActionType) {
     return action.payload.state;
   }
 
   // We want to alert staff/developers if there's a difference between the keys
   // we expect to see REHYDRATED and the keys that are actually REHYDRATED.
   // Context: https://linear.app/comm/issue/ENG-2127/
   if (
     action.type === rehydrateActionType &&
     (__DEV__ ||
       isStaffRelease ||
       (state.currentUserInfo &&
         state.currentUserInfo.id &&
         isStaff(state.currentUserInfo.id)))
   ) {
     // 1. Construct set of keys expected to be REHYDRATED
     const defaultKeys: $ReadOnlyArray<string> = Object.keys(defaultState);
     const expectedKeys = defaultKeys.filter(
       each => !persistConfig.blacklist.includes(each),
     );
     const expectedKeysSet = new Set(expectedKeys);
 
     // 2. Construct set of keys actually REHYDRATED
     const rehydratedKeys: $ReadOnlyArray<string> = Object.keys(
       action.payload ?? {},
     );
     const rehydratedKeysSet = new Set(rehydratedKeys);
 
     // 3. Determine the difference between the two sets
     const expectedKeysNotRehydrated = expectedKeys.filter(
       each => !rehydratedKeysSet.has(each),
     );
     const rehydratedKeysNotExpected = rehydratedKeys.filter(
       each => !expectedKeysSet.has(each),
     );
 
     // 4. Display alerts with the differences between the two sets
     if (expectedKeysNotRehydrated.length > 0) {
       Alert.alert(
         `EXPECTED KEYS NOT REHYDRATED: ${JSON.stringify(
           expectedKeysNotRehydrated,
         )}`,
       );
     }
     if (rehydratedKeysNotExpected.length > 0) {
       Alert.alert(
         `REHYDRATED KEYS NOT EXPECTED: ${JSON.stringify(
           rehydratedKeysNotExpected,
         )}`,
       );
     }
   }
 
   if (
     (action.type === setNewSessionActionType &&
       invalidSessionDowngrade(
         state,
         action.payload.sessionChange.currentUserInfo,
         action.payload.preRequestUserState,
         action.payload.keyserverID,
       )) ||
     (action.type === logOutActionTypes.success &&
       invalidSessionDowngrade(
         state,
         action.payload.currentUserInfo,
         action.payload.preRequestUserState,
         ashoatKeyserverID,
       )) ||
     (action.type === deleteKeyserverAccountActionTypes.success &&
       invalidSessionDowngrade(
         state,
         action.payload.currentUserInfo,
         action.payload.preRequestUserState,
         ashoatKeyserverID,
       )) ||
     (action.type === deleteAccountActionTypes.success &&
       invalidSessionDowngrade(
         state,
         action.payload.currentUserInfo,
         action.payload.preRequestUserState,
         ashoatKeyserverID,
       ))
   ) {
     return {
       ...state,
       loadingStatuses: reduceLoadingStatuses(state.loadingStatuses, action),
     };
   }
   if (
     (action.type === setNewSessionActionType &&
       action.payload.sessionChange.currentUserInfo &&
       invalidSessionRecovery(
         state,
         action.payload.sessionChange.currentUserInfo,
         action.payload.logInActionSource,
       )) ||
     ((action.type === logInActionTypes.success ||
       action.type === siweAuthActionTypes.success) &&
       invalidSessionRecovery(
         state,
         action.payload.currentUserInfo,
         action.payload.logInActionSource,
       )) ||
     (action.type === keyserverAuthActionTypes.success &&
       invalidSessionRecovery(
         state,
         action.payload.preRequestUserInfo,
         action.payload.logInActionSource,
       ))
   ) {
     return state;
   }
 
   if (action.type === updateDimensionsActiveType) {
     return {
       ...state,
       dimensions: {
         ...state.dimensions,
         ...action.payload,
       },
     };
   } else if (action.type === updateConnectivityActiveType) {
     return {
       ...state,
       connectivity: action.payload,
     };
   } else if (action.type === updateDeviceCameraInfoActionType) {
     return {
       ...state,
       deviceCameraInfo: {
         ...state.deviceCameraInfo,
         ...action.payload,
       },
     };
   } else if (action.type === updateDeviceOrientationActionType) {
     return {
       ...state,
       deviceOrientation: action.payload,
     };
   } else if (action.type === setLocalSettingsActionType) {
     return {
       ...state,
       localSettings: { ...state.localSettings, ...action.payload },
     };
   } else if (
     action.type === logOutActionTypes.started ||
     action.type === logOutActionTypes.success ||
     action.type === deleteAccountActionTypes.success
   ) {
     state = {
       ...state,
       localSettings: {
         isBackupEnabled: false,
       },
     };
   }
 
   if (action.type === setNewSessionActionType) {
     sessionInvalidationAlert(action.payload);
   }
   if (action.type === setStoreLoadedActionType) {
     return {
       ...state,
       storeLoaded: true,
     };
   }
   if (action.type === setClientDBStoreActionType) {
     state = {
       ...state,
       storeLoaded: true,
     };
     const currentLoggedInUserID = state.currentUserInfo?.anonymous
       ? undefined
       : state.currentUserInfo?.id;
     const actionCurrentLoggedInUserID = action.payload.currentUserID;
     if (
       !currentLoggedInUserID ||
       !actionCurrentLoggedInUserID ||
       actionCurrentLoggedInUserID !== currentLoggedInUserID
     ) {
       // If user is logged out now, was logged out at the time action was
       // dispatched or their ID changed between action dispatch and a
       // call to reducer we ignore the SQLite data since it is not valid
       return state;
     }
   }
 
   const baseReducerResult = baseReducer(
     state,
     (action: BaseAction),
     onStateDifference,
   );
   state = baseReducerResult.state;
 
   const { storeOperations } = baseReducerResult;
   const {
     draftStoreOperations,
     threadStoreOperations,
     messageStoreOperations,
     reportStoreOperations,
     userStoreOperations,
   } = storeOperations;
 
   const fixUnreadActiveThreadResult = fixUnreadActiveThread(state, action);
   state = fixUnreadActiveThreadResult.state;
 
   const threadStoreOperationsWithUnreadFix = [
     ...threadStoreOperations,
     ...fixUnreadActiveThreadResult.threadStoreOperations,
   ];
 
   void processDBStoreOperations({
     draftStoreOperations,
     messageStoreOperations,
     threadStoreOperations: threadStoreOperationsWithUnreadFix,
     reportStoreOperations,
     userStoreOperations,
   });
 
   return state;
 }
 
 function sessionInvalidationAlert(payload: SetSessionPayload) {
   if (
     !payload.sessionChange.cookieInvalidated ||
     !payload.preRequestUserState ||
     !payload.preRequestUserState.currentUserInfo ||
     payload.preRequestUserState.currentUserInfo.anonymous
   ) {
     return;
   }
   if (payload.error === 'client_version_unsupported') {
     Alert.alert(
       AppOutOfDateAlertDetails.title,
       AppOutOfDateAlertDetails.message,
       [{ text: 'OK' }],
       {
         cancelable: true,
       },
     );
   } else {
     Alert.alert(
       'Session invalidated',
       'We’re sorry, but your session was invalidated by the server. ' +
         'Please log in again.',
       [{ text: 'OK' }],
       { cancelable: true },
     );
   }
 }
 
 // Makes sure a currently focused thread is never unread. Note that we consider
 // a backgrounded NativeAppState to actually be active if it last changed to
 // inactive more than 10 seconds ago. This is because there is a delay when
 // NativeAppState is updating in response to a foreground, and actions don't get
 // processed more than 10 seconds after a backgrounding anyways. However we
 // don't consider this for action types that can be expected to happen while the
 // app is backgrounded.
 type FixUnreadActiveThreadResult = {
   +state: AppState,
   +threadStoreOperations: $ReadOnlyArray<ThreadStoreOperation>,
 };
 
 function fixUnreadActiveThread(
   state: AppState,
   action: *,
 ): FixUnreadActiveThreadResult {
   const navContext = getGlobalNavContext();
   const activeThread = activeMessageListSelector(navContext);
   if (
     !activeThread ||
     !state.threadStore.threadInfos[activeThread]?.currentUser.unread ||
     (NativeAppState.currentState !== 'active' &&
       (appLastBecameInactive + 10000 >= Date.now() ||
         backgroundActionTypes.has(action.type)))
   ) {
     return { state, threadStoreOperations: [] };
   }
 
   const activeThreadInfo = state.threadStore.threadInfos[activeThread];
-  // TODO (atul): Try to get rid of this ridiculous branching.
-  if (activeThreadInfo.minimallyEncoded) {
-    const updatedActiveThreadInfo = {
-      ...activeThreadInfo,
-      currentUser: {
-        ...activeThreadInfo.currentUser,
-        unread: false,
+  const updatedActiveThreadInfo = {
+    ...activeThreadInfo,
+    currentUser: {
+      ...activeThreadInfo.currentUser,
+      unread: false,
+    },
+  };
+
+  const threadStoreOperations = [
+    {
+      type: 'replace',
+      payload: {
+        id: activeThread,
+        threadInfo: updatedActiveThreadInfo,
       },
-    };
-
-    const threadStoreOperations = [
-      {
-        type: 'replace',
-        payload: {
-          id: activeThread,
-          threadInfo: updatedActiveThreadInfo,
-        },
-      },
-    ];
-
-    const updatedThreadStore = threadStoreOpsHandlers.processStoreOperations(
-      state.threadStore,
-      threadStoreOperations,
-    );
-
-    return {
-      state: { ...state, threadStore: updatedThreadStore },
-      threadStoreOperations,
-    };
-  } else {
-    const updatedActiveThreadInfo = {
-      ...activeThreadInfo,
-      currentUser: {
-        ...activeThreadInfo.currentUser,
-        unread: false,
-      },
-    };
-
-    const threadStoreOperations = [
-      {
-        type: 'replace',
-        payload: {
-          id: activeThread,
-          threadInfo: updatedActiveThreadInfo,
-        },
-      },
-    ];
+    },
+  ];
 
-    const updatedThreadStore = threadStoreOpsHandlers.processStoreOperations(
-      state.threadStore,
-      threadStoreOperations,
-    );
+  const updatedThreadStore = threadStoreOpsHandlers.processStoreOperations(
+    state.threadStore,
+    threadStoreOperations,
+  );
 
-    return {
-      state: { ...state, threadStore: updatedThreadStore },
-      threadStoreOperations,
-    };
-  }
+  return {
+    state: { ...state, threadStore: updatedThreadStore },
+    threadStoreOperations,
+  };
 }
 
 let appLastBecameInactive = 0;
 
 function appBecameInactive() {
   appLastBecameInactive = Date.now();
 }
 
 const middleware = applyMiddleware(thunk, reduxLoggerMiddleware);
 
 let composeFunc = compose;
 if (__DEV__ && global.HermesInternal) {
   const { composeWithDevTools } = require('remote-redux-devtools/src/index.js');
   composeFunc = composeWithDevTools({
     name: 'Redux',
     hostname: getDevServerHostname(),
     ...remoteReduxDevServerConfig,
   });
 } else if (global.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__) {
   composeFunc = global.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__({
     name: 'Redux',
   });
 }
 
 let enhancers;
 if (reactotron) {
   enhancers = composeFunc(middleware, reactotron.createEnhancer());
 } else {
   enhancers = composeFunc(middleware);
 }
 
 const store: Store<AppState, *> = createStore(
   persistReducer(persistConfig, reducer),
   defaultState,
   enhancers,
 );
 const persistor = persistStore(store);
 setPersistor(persistor);
 
 const unsafeDispatch: any = store.dispatch;
 const dispatch: Dispatch = unsafeDispatch;
 
 export { store, dispatch, appBecameInactive };
diff --git a/web/redux/redux-setup.js b/web/redux/redux-setup.js
index 0a0e17950..20e070077 100644
--- a/web/redux/redux-setup.js
+++ b/web/redux/redux-setup.js
@@ -1,389 +1,372 @@
 // @flow
 
 import invariant from 'invariant';
 import type { PersistState } from 'redux-persist/es/types.js';
 
 import {
   logOutActionTypes,
   deleteKeyserverAccountActionTypes,
 } from 'lib/actions/user-actions.js';
 import { setNewSessionActionType } from 'lib/keyserver-conn/keyserver-conn-types.js';
 import {
   type ThreadStoreOperation,
   threadStoreOpsHandlers,
 } from 'lib/ops/thread-store-ops.js';
 import { reduceLoadingStatuses } from 'lib/reducers/loading-reducer.js';
 import baseReducer from 'lib/reducers/master-reducer.js';
 import { mostRecentlyReadThreadSelector } from 'lib/selectors/thread-selectors.js';
 import { isLoggedIn } from 'lib/selectors/user-selectors.js';
 import { invalidSessionDowngrade } from 'lib/shared/session-utils.js';
 import type { CryptoStore } from 'lib/types/crypto-types.js';
 import type { DraftStore } from 'lib/types/draft-types.js';
 import type { EnabledApps } from 'lib/types/enabled-apps.js';
 import type { EntryStore, CalendarQuery } from 'lib/types/entry-types.js';
 import { type CalendarFilter } from 'lib/types/filter-types.js';
 import type { IntegrityStore } from 'lib/types/integrity-types.js';
 import type { KeyserverStore } from 'lib/types/keyserver-types.js';
 import type { LifecycleState } from 'lib/types/lifecycle-state-types.js';
 import type { InviteLinksStore } from 'lib/types/link-types.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import type { MessageStore } from 'lib/types/message-types.js';
 import type { UserPolicies } from 'lib/types/policy-types.js';
 import type { BaseAction } from 'lib/types/redux-types.js';
 import type { ReportStore } from 'lib/types/report-types.js';
 import type { StoreOperations } from 'lib/types/store-ops-types.js';
 import type { GlobalThemeInfo } from 'lib/types/theme-types.js';
 import type { ThreadActivityStore } from 'lib/types/thread-activity-types';
 import type { ThreadStore } from 'lib/types/thread-types.js';
 import type { CurrentUserInfo, UserStore } from 'lib/types/user-types.js';
 import type { NotifPermissionAlertInfo } from 'lib/utils/push-alerts.js';
 import { ashoatKeyserverID } from 'lib/utils/validation-utils.js';
 
 import {
   updateWindowActiveActionType,
   updateNavInfoActionType,
   updateWindowDimensionsActionType,
   setInitialReduxState,
 } from './action-types.js';
 import { reduceCommunityPickerStore } from './community-picker-reducer.js';
 import { reduceCryptoStore, setCryptoStore } from './crypto-store-reducer.js';
 import reduceNavInfo from './nav-reducer.js';
 import { onStateDifference } from './redux-debug-utils.js';
 import { getVisibility } from './visibility.js';
 import { processDBStoreOperations } from '../database/utils/store.js';
 import { activeThreadSelector } from '../selectors/nav-selectors.js';
 import { type NavInfo } from '../types/nav-types.js';
 import type { InitialReduxState } from '../types/redux-types.js';
 
 export type WindowDimensions = { width: number, height: number };
 
 export type CommunityPickerStore = {
   +chat: ?string,
   +calendar: ?string,
 };
 
 export type AppState = {
   +navInfo: NavInfo,
   +currentUserInfo: ?CurrentUserInfo,
   +draftStore: DraftStore,
   +entryStore: EntryStore,
   +threadStore: ThreadStore,
   +userStore: UserStore,
   +messageStore: MessageStore,
   +loadingStatuses: { [key: string]: { [idx: number]: LoadingStatus } },
   +calendarFilters: $ReadOnlyArray<CalendarFilter>,
   +communityPickerStore: CommunityPickerStore,
   +windowDimensions: WindowDimensions,
   +notifPermissionAlertInfo: NotifPermissionAlertInfo,
   +actualizedCalendarQuery: CalendarQuery,
   +watchedThreadIDs: $ReadOnlyArray<string>,
   +lifecycleState: LifecycleState,
   +enabledApps: EnabledApps,
   +reportStore: ReportStore,
   +nextLocalID: number,
   +dataLoaded: boolean,
   +windowActive: boolean,
   +userPolicies: UserPolicies,
   +cryptoStore: ?CryptoStore,
   +pushApiPublicKey: ?string,
   +_persist: ?PersistState,
   +commServicesAccessToken: ?string,
   +inviteLinksStore: InviteLinksStore,
   +keyserverStore: KeyserverStore,
   +threadActivityStore: ThreadActivityStore,
   +initialStateLoaded: boolean,
   +integrityStore: IntegrityStore,
   +globalThemeInfo: GlobalThemeInfo,
   +customServer: ?string,
 };
 
 export type Action =
   | BaseAction
   | { type: 'UPDATE_NAV_INFO', payload: Partial<NavInfo> }
   | {
       type: 'UPDATE_WINDOW_DIMENSIONS',
       payload: WindowDimensions,
     }
   | {
       type: 'UPDATE_WINDOW_ACTIVE',
       payload: boolean,
     }
   | { +type: 'SET_CRYPTO_STORE', payload: CryptoStore }
   | { +type: 'SET_INITIAL_REDUX_STATE', payload: InitialReduxState };
 
 export function reducer(oldState: AppState | void, action: Action): AppState {
   invariant(oldState, 'should be set');
   let state = oldState;
   let storeOperations: StoreOperations = {
     draftStoreOperations: [],
     threadStoreOperations: [],
     messageStoreOperations: [],
     reportStoreOperations: [],
     userStoreOperations: [],
   };
 
   if (action.type === setInitialReduxState) {
     const { userInfos, keyserverInfos, ...rest } = action.payload;
     const newKeyserverInfos = { ...state.keyserverStore.keyserverInfos };
     for (const keyserverID in keyserverInfos) {
       newKeyserverInfos[keyserverID] = {
         ...newKeyserverInfos[keyserverID],
         ...keyserverInfos[keyserverID],
       };
     }
     return validateStateAndProcessDBOperations(
       oldState,
       {
         ...state,
         ...rest,
         userStore: { userInfos },
         keyserverStore: {
           ...state.keyserverStore,
           keyserverInfos: newKeyserverInfos,
         },
         initialStateLoaded: true,
       },
       storeOperations,
     );
   } else if (action.type === updateWindowDimensionsActionType) {
     return validateStateAndProcessDBOperations(
       oldState,
       {
         ...state,
         windowDimensions: action.payload,
       },
       storeOperations,
     );
   } else if (action.type === updateWindowActiveActionType) {
     return validateStateAndProcessDBOperations(
       oldState,
       {
         ...state,
         windowActive: action.payload,
       },
       storeOperations,
     );
   } else if (action.type === setNewSessionActionType) {
     const { keyserverID, sessionChange } = action.payload;
     if (!state.keyserverStore.keyserverInfos[keyserverID]) {
       if (sessionChange.cookie?.startsWith('user=')) {
         console.log(
           'received sessionChange with user cookie, ' +
             `but keyserver ${keyserverID} is not in KeyserverStore!`,
         );
       }
       return state;
     }
 
     if (
       invalidSessionDowngrade(
         oldState,
         sessionChange.currentUserInfo,
         action.payload.preRequestUserState,
         keyserverID,
       )
     ) {
       return {
         ...oldState,
         loadingStatuses: reduceLoadingStatuses(state.loadingStatuses, action),
       };
     }
 
     state = {
       ...state,
       keyserverStore: {
         ...state.keyserverStore,
         keyserverInfos: {
           ...state.keyserverStore.keyserverInfos,
           [keyserverID]: {
             ...state.keyserverStore.keyserverInfos[keyserverID],
             sessionID: sessionChange.sessionID,
           },
         },
       },
     };
   } else if (
     (action.type === logOutActionTypes.success &&
       invalidSessionDowngrade(
         oldState,
         action.payload.currentUserInfo,
         action.payload.preRequestUserState,
         ashoatKeyserverID,
       )) ||
     (action.type === deleteKeyserverAccountActionTypes.success &&
       invalidSessionDowngrade(
         oldState,
         action.payload.currentUserInfo,
         action.payload.preRequestUserState,
         ashoatKeyserverID,
       ))
   ) {
     return {
       ...oldState,
       loadingStatuses: reduceLoadingStatuses(state.loadingStatuses, action),
     };
   }
 
   if (
     action.type !== updateNavInfoActionType &&
     action.type !== setCryptoStore
   ) {
     const baseReducerResult = baseReducer(state, action, onStateDifference);
     state = baseReducerResult.state;
     storeOperations = baseReducerResult.storeOperations;
   }
 
   const communityPickerStore = reduceCommunityPickerStore(
     state.communityPickerStore,
     action,
   );
 
   state = {
     ...state,
     navInfo: reduceNavInfo(
       state.navInfo,
       action,
       state.threadStore.threadInfos,
     ),
     cryptoStore: reduceCryptoStore(state.cryptoStore, action),
     communityPickerStore,
   };
 
   return validateStateAndProcessDBOperations(oldState, state, storeOperations);
 }
 
 function validateStateAndProcessDBOperations(
   oldState: AppState,
   state: AppState,
   storeOperations: StoreOperations,
 ): AppState {
   const updateActiveThreadOps: ThreadStoreOperation[] = [];
   if (
     (state.navInfo.activeChatThreadID &&
       !state.navInfo.pendingThread &&
       !state.threadStore.threadInfos[state.navInfo.activeChatThreadID]) ||
     (!state.navInfo.activeChatThreadID && isLoggedIn(state))
   ) {
     // Makes sure the active thread always exists
     state = {
       ...state,
       navInfo: {
         ...state.navInfo,
         activeChatThreadID: mostRecentlyReadThreadSelector(state),
       },
     };
   }
 
   const activeThread = activeThreadSelector(state);
   if (
     activeThread &&
     !state.navInfo.pendingThread &&
     state.threadStore.threadInfos[activeThread].currentUser.unread &&
     getVisibility().hidden()
   ) {
     console.warn(
       `thread ${activeThread} is active and unread, ` +
         'but visibilityjs reports the window is not visible',
     );
   }
   if (
     activeThread &&
     !state.navInfo.pendingThread &&
     state.threadStore.threadInfos[activeThread].currentUser.unread &&
     typeof document !== 'undefined' &&
     document &&
     'hasFocus' in document &&
     !document.hasFocus()
   ) {
     console.warn(
       `thread ${activeThread} is active and unread, ` +
         'but document.hasFocus() is false',
     );
   }
   if (
     activeThread &&
     !getVisibility().hidden() &&
     typeof document !== 'undefined' &&
     document &&
     'hasFocus' in document &&
     document.hasFocus() &&
     !state.navInfo.pendingThread &&
     state.threadStore.threadInfos[activeThread].currentUser.unread
   ) {
     // Makes sure a currently focused thread is never unread
     const activeThreadInfo = state.threadStore.threadInfos[activeThread];
-    // TODO (atul): Try to get rid of this ridiculous branching.
-    if (activeThreadInfo.minimallyEncoded) {
-      updateActiveThreadOps.push({
-        type: 'replace',
-        payload: {
-          id: activeThread,
-          threadInfo: {
-            ...activeThreadInfo,
-            currentUser: {
-              ...activeThreadInfo.currentUser,
-              unread: false,
-            },
+    updateActiveThreadOps.push({
+      type: 'replace',
+      payload: {
+        id: activeThread,
+        threadInfo: {
+          ...activeThreadInfo,
+          currentUser: {
+            ...activeThreadInfo.currentUser,
+            unread: false,
           },
         },
-      });
-    } else {
-      updateActiveThreadOps.push({
-        type: 'replace',
-        payload: {
-          id: activeThread,
-          threadInfo: {
-            ...activeThreadInfo,
-            currentUser: {
-              ...activeThreadInfo.currentUser,
-              unread: false,
-            },
-          },
-        },
-      });
-    }
+      },
+    });
   }
 
   const oldActiveThread = activeThreadSelector(oldState);
   if (
     activeThread &&
     oldActiveThread !== activeThread &&
     state.messageStore.threads[activeThread]
   ) {
     const now = Date.now();
     state = {
       ...state,
       threadActivityStore: {
         ...state.threadActivityStore,
         [(activeThread: string)]: {
           ...state.threadActivityStore[activeThread],
           lastNavigatedTo: now,
         },
       },
     };
   }
 
   if (updateActiveThreadOps.length > 0) {
     state = {
       ...state,
       threadStore: threadStoreOpsHandlers.processStoreOperations(
         state.threadStore,
         updateActiveThreadOps,
       ),
     };
     storeOperations = {
       ...storeOperations,
       threadStoreOperations: [
         ...storeOperations.threadStoreOperations,
         ...updateActiveThreadOps,
       ],
     };
   }
 
   void processDBStoreOperations(
     storeOperations,
     state.currentUserInfo?.id ?? null,
   );
 
   return state;
 }