@ethora/chat-component-rn 26.7.8 → 26.7.10

package/src/networking/xmpp/flushLastViewedToPrivateStore.ts

@@ -1,22 +1,32 @@
 import { getChatsPrivateStoreRequest } from './getChatsPrivateStoreRequest.xmpp';
 import { setChatsPrivateStoreRequest } from './setChatsPrivateStoreRequest.xmpp';
+import {
+  getServerReadTimestamp,
+  isCorruptFutureReadMarker,
+  type ReadTimestampHeapState,
+} from '../../helpers/getServerReadTimestamp';
+import type { IMessage } from '../../types/types';
 
 interface RoomLike {
   jid: string;
   lastViewedTimestamp?: number;
   unreadMessages?: number;
+  // Needed to resolve a SERVER-timestamp read marker via
+  // getServerReadTimestamp instead of the device clock - see bug #38.
+  messages?: IMessage[];
 }
 
 interface FlushOpts {
   // When visibleRoomJID is set, treat it as "user just viewed everything
-  // up to now" and stamp it with Date.now() — even if its in-memory
-  // lastViewedTimestamp has not been updated yet.
+  // up to now" and stamp it with the newest server-acknowledged message
+  // timestamp for that room - even if its in-memory lastViewedTimestamp
+  // has not been updated yet.
   visibleRoomJID?: string | null;
-  // Explicit read boundary for the visible room, used INSTEAD of
-  // Date.now(). ChatRoom passes the timestamp of the newest message the
-  // user actually reached when they leave a room while scrolled up —
-  // without it, the Date.now() default writes "read everything" to the
-  // server and the messages they never scrolled down to come back as
+  // Explicit read boundary for the visible room, used INSTEAD of the
+  // newest-message fallback. ChatRoom passes the timestamp of the newest
+  // message the user actually reached when they leave a room while
+  // scrolled up - without it, the default writes "read everything" to
+  // the server and the messages they never scrolled down to come back as
   // read on the next login, even though the local count was correct.
   // Customer-reported #33 (server half).
   visibleRoomTs?: number | null;
@@ -24,6 +34,12 @@ interface FlushOpts {
   // (or the visible room). Used at logout time: rooms with outstanding
   // unread keep their old marker so the next login still surfaces them.
   onlyIfNoUnread?: boolean;
+  // Pending/failed-send state (store.getState().roomHeapSlice), combined
+  // with each room's `messages` to resolve the newest SERVER-acked
+  // message timestamp via getServerReadTimestamp. Passed in rather than
+  // read from the store here so this module stays a pure function of its
+  // arguments - existing jest coverage builds `rooms` by hand.
+  heapState?: ReadTimestampHeapState;
 }
 
 /**
@@ -33,8 +49,11 @@ interface FlushOpts {
  * each other's entries.
  *
  * Called on: tab change away from chat, AppState background/inactive,
- * and (with onlyIfNoUnread=true) logout. ChatRoom's own unmount path
- * still uses actionSetTimestampToPrivateStore for the single-room case.
+ * and (with onlyIfNoUnread=true) logout. ChatRoom's own unmount path also
+ * goes through this (via flushLastViewedToPrivateStoreStanza) for the
+ * single-room case - actionSetTimestampToPrivateStore is a separate,
+ * unconditional low-level write primitive kept for direct/external use
+ * and is not part of this merge path.
  */
 export async function flushLastViewedToPrivateStore(
   client: any,
@@ -42,7 +61,7 @@ export async function flushLastViewedToPrivateStore(
   opts: FlushOpts = {}
 ): Promise<boolean> {
   if (!client?.client) {return false;}
-  const { visibleRoomJID, visibleRoomTs, onlyIfNoUnread } = opts;
+  const { visibleRoomJID, visibleRoomTs, onlyIfNoUnread, heapState } = opts;
   const roomList = Object.values(rooms || {});
   if (roomList.length === 0) {return false;}
 
@@ -54,7 +73,6 @@ export async function flushLastViewedToPrivateStore(
   }
   if (!storeObj || typeof storeObj !== 'object') {storeObj = {};}
 
-  const nowMs = Date.now();
   let dirty = false;
 
   for (const room of roomList) {
@@ -62,27 +80,56 @@ export async function flushLastViewedToPrivateStore(
     const isVisible = !!visibleRoomJID && room.jid === visibleRoomJID;
     const hasUnread = Number(room.unreadMessages || 0) > 0;
 
-    // For the visible room, persist "now" — read state is driven by
-    // room visibility, not by a sentinel timestamp. The exception is an
-    // explicit `visibleRoomTs`: the caller knows the user only read up
-    // to a certain point (left the room while scrolled up), so stamping
-    // "now" here would mark genuinely-unread messages as read.
+    // Newest message this room actually has server-side proof of. Used
+    // both as the "read up to now" fallback for the visible room and as
+    // the yardstick for detecting a corrupt (future) stored marker below
+    // - never as a substitute for the device clock (bug #38: a device
+    // with a fast clock previously stamped Date.now() here, and once
+    // that future value reached the server the forward-only check a few
+    // lines down rejected every later correct write, forever).
+    const newestAckedMs = getServerReadTimestamp(room as any, heapState);
+
+    // For the visible room, persist "read up to the newest message we
+    // know the server has" - read state is driven by room visibility,
+    // not by a sentinel timestamp. The exception is an explicit
+    // `visibleRoomTs`: the caller knows the user only read up to a
+    // certain point (left the room while scrolled up), so stamping
+    // "everything" here would mark genuinely-unread messages as read.
     let ts: number | undefined;
     if (isVisible) {
       ts =
         typeof visibleRoomTs === 'number' && visibleRoomTs > 0
           ? visibleRoomTs
-          : nowMs;
+          : newestAckedMs || undefined;
     } else if (room.lastViewedTimestamp && room.lastViewedTimestamp > 0) {
       ts = room.lastViewedTimestamp;
     }
 
+    // Nothing to anchor a write to (no boundary, no existing marker, no
+    // known messages yet) - skip rather than write a device-clock guess.
     if (!ts) {continue;}
     if (onlyIfNoUnread && hasUnread && !isVisible) {continue;}
 
     const prev = storeObj[room.jid];
     const prevNum = prev != null ? Number(prev) : 0;
-    if (Number.isFinite(prevNum) && prevNum >= ts) {continue;}
+    // A currently-stored value that sits well past the newest message we
+    // know this room has is not "fresher" - it's a leftover future
+    // marker (bug #38). Forward-only logic normally protects a fresher
+    // read from being clobbered by a stale fetch, but applied to a
+    // corrupt future value it does the opposite: it permanently blocks
+    // the correct (smaller) value from ever landing. Detect that case
+    // and waive the forward-only check for it specifically; sane values
+    // keep the normal forward-only protection.
+    //
+    // "Well past the newest message we know about" is deliberately NOT
+    // sufficient on its own - see isCorruptFutureReadMarker. THIS device's
+    // copy of the room can simply be stale (history not synced yet this
+    // session), in which case a legitimate marker written by another
+    // device that HAS seen newer messages looks exactly like a corrupt
+    // one, and "healing" it here would push the server marker BACKWARDS
+    // and resurrect already-read messages on every device.
+    const prevLooksCorrupt = isCorruptFutureReadMarker(prevNum, newestAckedMs);
+    if (!prevLooksCorrupt && Number.isFinite(prevNum) && prevNum >= ts) {continue;}
     storeObj[room.jid] = String(ts);
     dirty = true;
   }

package/src/networking/xmppClient.ts

@@ -32,6 +32,10 @@ import {
   enqueueOutboundSend,
   flushOutboundSends,
 } from './outboundQueue';
+import {
+  getServerReadTimestamp,
+  isCorruptFutureReadMarker,
+} from '../helpers/getServerReadTimestamp';
 
 // Canonical production XMPP WSS endpoint (standard wss/443, no port suffix).
 const DEFAULT_DEV_SERVER = 'xmpp.chat.ethora.com';
@@ -1060,9 +1064,37 @@ export class XmppClient {
       // `getChatsPrivateStoreRequest` directly and intentionally skip this.
       if (markers && typeof markers === 'object') {
         const normalized: Record<string, number> = {};
+        const roomsState = store.getState().rooms?.rooms || {};
+        const heapState = store.getState().roomHeapSlice;
         for (const jid of Object.keys(markers as Record<string, unknown>)) {
           const n = Number((markers as Record<string, unknown>)[jid]);
-          if (jid && Number.isFinite(n) && n > 0) {normalized[jid] = n;}
+          if (!jid || !Number.isFinite(n) || n <= 0) {continue;}
+          // Defensive clamp (bug #38): a marker written while some
+          // device's clock was ahead can land in the future relative to
+          // the newest message the server actually has for this room.
+          // The redux merge (applyPrivateStoreMarkers) and the
+          // server-side merge (flushLastViewedToPrivateStore) both treat
+          // "newer" as "better", so an uncorrected future value would
+          // block every later correct write forever - useUnread() would
+          // report 0 for that room on every cold start. When we already
+          // know this room's messages locally, clamp an implausible
+          // marker down to the newest one we actually have instead of
+          // trusting the server value verbatim.
+          //
+          // "Implausible" needs BOTH "past the newest message we know
+          // about" AND "past real time" (isCorruptFutureReadMarker):
+          // this device's cache for a room is routinely stale, and
+          // clamping on staleness alone would drag a perfectly good
+          // marker written by another device backwards.
+          const room = roomsState[jid];
+          const newestKnownMs = room
+            ? getServerReadTimestamp(room, heapState)
+            : 0;
+          if (isCorruptFutureReadMarker(n, newestKnownMs)) {
+            normalized[jid] = newestKnownMs;
+          } else {
+            normalized[jid] = n;
+          }
         }
         if (Object.keys(normalized).length > 0) {
           store.dispatch(applyPrivateStoreMarkers(normalized));
@@ -1104,7 +1136,14 @@ export class XmppClient {
   ) {
     if (this.disableLastRead) {return false;}
     try {
-      return await flushLastViewedToPrivateStore(this, rooms, opts);
+      // Auto-inject the pending/failed-send heap so every caller gets
+      // getServerReadTimestamp's exclusion of optimistic messages for
+      // free, without needing to reach into the redux store themselves.
+      const heapState = store.getState().roomHeapSlice;
+      return await flushLastViewedToPrivateStore(this, rooms, {
+        ...opts,
+        heapState,
+      });
     } catch {
       return false;
     }

package/src/roomStore/index.ts

@@ -1,14 +1,18 @@
 import { configureStore, combineReducers } from '@reduxjs/toolkit';
 import chatSettingsReducer, { setUser } from './chatSettingsSlice';
 import roomsSlice, { addRoom } from './roomsSlice';
-import { roomHeapSlice } from './roomHeapSlice';
+import { roomHeapSlice, markMessageFailed } from './roomHeapSlice';
 import callReducer from './callSlice';
 import { IRoom } from '../types/types';
 import { unreadMiddleware } from './Middleware/unreadMidlleware';
 import { logoutMiddleware } from './Middleware/logoutMiddleware';
 import { newMessageMidlleware } from './Middleware/newMessageMidlleware';
 import { reactionsMiddleware } from './Middleware/reactionsMiddleware';
-import { persistenceMiddleware, readPersistedState } from './persistence';
+import {
+  persistenceMiddleware,
+  readPersistedState,
+  computeBootTimeFailures,
+} from './persistence';
 
 const rootReducer = combineReducers({
   chatSettingStore: chatSettingsReducer,
@@ -68,11 +72,12 @@ export const getActiveRoom = (state: RootState): IRoom | null => {
     : null;
 };
 
-// Async rehydrate — read persisted slices and replay them as standard
+// Async rehydrate: read persisted slices and replay them as standard
+// actions.
 export const persistorReady =
   globalScope.__CHAT_PERSISTOR_READY__ ||
   (globalScope.__CHAT_PERSISTOR_READY__ = (async () => {
-    const { chat, rooms } = await readPersistedState();
+    const { chat, rooms, heap } = await readPersistedState();
     if (chat?.user && chat.user.walletAddress) {
       store.dispatch(setUser(chat.user));
     }
@@ -82,4 +87,35 @@ export const persistorReady =
         store.dispatch(addRoom({ roomData: room as IRoom }));
       }
     }
+
+    // bug #39: restore failures that were already flagged (watchdog or
+    // an explicit send error) before the app was killed, so the bubble
+    // still shows "Failed / tap to retry" instead of quietly reverting
+    // to a normal sent bubble.
+    // Skip entries whose bubble no longer exists in the restored cache.
+    // A failure flag is only ever READ as `failedMessages[message.id]`,
+    // so one with no matching message is dead weight that would be
+    // replayed and re-persisted on every launch forever. This happens
+    // for real: a send that reached the server but whose echo was lost
+    // gets flagged failed at boot, then the history merge replaces the
+    // optimistic bubble with the archived copy under its server id (see
+    // mergeHistoryIntoCache), leaving the flag behind.
+    const restoredFailed = heap?.failedMessages || {};
+    for (const payload of Object.values(restoredFailed)) {
+      const stillRendered = (
+        rooms?.rooms?.[payload.roomJID]?.messages || []
+      ).some((m) => m?.id === payload.id);
+      if (!stillRendered) {continue;}
+      store.dispatch(markMessageFailed(payload));
+    }
+
+    // bug #39: a message that was still `pending: true` at kill time
+    // never got a server echo AND never got the chance to trip the
+    // in-session send watchdog (messageHeap is process-lifetime only,
+    // never persisted). Treat every such message as failed so it gets
+    // a working retry instead of silently rendering as delivered.
+    const bootFailures = computeBootTimeFailures(rooms?.rooms, restoredFailed);
+    for (const payload of bootFailures) {
+      store.dispatch(markMessageFailed(payload));
+    }
   })());

package/src/roomStore/persistence.ts

@@ -2,6 +2,7 @@ import AsyncStorage from '@react-native-async-storage/async-storage';
 import { Middleware } from '@reduxjs/toolkit';
 import { IMessage, IRoom, User } from '../types/types';
 import { encryptForPersist, decryptFromPersist } from '../helpers/persistCrypto';
+import type { FailedMessagePayload } from './roomHeapSlice';
 
 // -------------------------------------------------------------------
 // Lightweight RN persistence layer. Mirrors what redux-persist gives
@@ -21,12 +22,24 @@ import { encryptForPersist, decryptFromPersist } from '../helpers/persistCrypto'
 
 const KEY_CHAT = '@ethora/persist:chatSettingStore';
 const KEY_ROOMS = '@ethora/persist:rooms';
+// bug #39: a failed send needs to survive a relaunch as "failed / tap
+// to retry", not silently render as delivered. `roomHeapStore.failedMessages`
+// is the map the bubble reads (`isFailed = failedMessages[id]`, see
+// Message.tsx / useMessageHeapState): it lives in a separate, previously
+// non-persisted slice from `rooms`, so it gets its own key here.
+const KEY_HEAP = '@ethora/persist:roomHeap';
 
 // Per-room message cap on disk. Mirror this value in `roomsSlice`'s
 // in-memory cap (see `enforceMessageCap`) so the runtime and persisted
 // shapes stay aligned.
 export const MESSAGE_LIMIT = 100;
 
+// Defensive cap on the number of failed-message payloads written to
+// disk. In practice this map only grows while the user is actively
+// sending offline, but a runaway sender (or a bug that never clears an
+// entry) must not turn this key into an unbounded write.
+export const MAX_PERSISTED_FAILED_MESSAGES = 200;
+
 interface PersistedChatState {
   user: User;
 }
@@ -36,6 +49,14 @@ interface PersistedRoomsState {
   // intentionally NOT persisted: activeRoomJID, editAction, isLoading
 }
 
+interface PersistedHeapState {
+  failedMessages: Record<string, FailedMessagePayload>;
+  // intentionally NOT persisted: messageHeap, a process-lifetime
+  // "in flight" buffer (see roomHeapSlice.ts); anything still in it when
+  // the app dies is handled by the boot-time pending->failed scan below,
+  // not by replaying the heap itself.
+}
+
 const sanitizeUser = (user?: User): User | null => {
   if (!user) {return null;}
   // Drop secrets we don't want at rest — destructure to omit, then
@@ -81,6 +102,13 @@ const PERSISTED_MESSAGE_FIELDS: (keyof IMessage)[] = [
   'size',
   'langSource',
   'callLog',
+  // bug #39: without this, a message that was still in flight (no
+  // server echo yet) at kill time comes back from disk indistinguishable
+  // from a normal delivered message, so the bubble renders it as sent.
+  // Persisting `pending` lets the boot-time scan (see
+  // computeBootTimeFailures below) find exactly the messages that never
+  // got confirmed and flip them to failed instead.
+  'pending',
 ];
 
 // The sender identity that rides along on every message over the wire
@@ -180,6 +208,154 @@ const sanitizeRooms = (
   return out;
 };
 
+// Only the fields retryMessage actually needs to replay the send (see
+// FailedMessagePayload / useSendMessage.retryMessage). In particular, the
+// media `data` blob is trimmed to `uri/type/name/size` (the picker never
+// hands us auth material, but this stays defensive against a future
+// picker change smuggling extra fields, or a huge inline payload, into
+// `data`).
+const sanitizeMediaData = (
+  data: any
+): { uri?: string; type?: string; name?: string; size?: number } => {
+  if (!data || typeof data !== 'object') {return {};}
+  const out: { uri?: string; type?: string; name?: string; size?: number } = {};
+  if (typeof data.uri === 'string') {out.uri = data.uri;}
+  if (typeof data.type === 'string') {out.type = data.type;}
+  if (typeof data.name === 'string') {out.name = data.name;}
+  if (typeof data.size === 'number') {out.size = data.size;}
+  return out;
+};
+
+const sanitizeFailedMessagePayload = (
+  payload: FailedMessagePayload
+): FailedMessagePayload | null => {
+  if (!payload || typeof payload !== 'object') {return null;}
+  if (!payload.id || typeof payload.id !== 'string') {return null;}
+  if (!payload.roomJID || typeof payload.roomJID !== 'string') {return null;}
+  if (payload.kind === 'media') {
+    return {
+      kind: 'media',
+      id: payload.id,
+      roomJID: payload.roomJID,
+      data: sanitizeMediaData(payload.data),
+      type: typeof payload.type === 'string' ? payload.type : '',
+      isReply: payload.isReply,
+      isChecked: payload.isChecked,
+      mainMessage: payload.mainMessage,
+    };
+  }
+  if (payload.kind === 'text') {
+    return {
+      kind: 'text',
+      id: payload.id,
+      roomJID: payload.roomJID,
+      body: typeof payload.body === 'string' ? payload.body : '',
+      isReply: payload.isReply,
+      isChecked: payload.isChecked,
+      mainMessage: payload.mainMessage,
+    };
+  }
+  return null;
+};
+
+const sanitizeFailedMessages = (
+  failedMessages: Record<string, FailedMessagePayload> | undefined
+): Record<string, FailedMessagePayload> => {
+  if (!failedMessages || typeof failedMessages !== 'object') {return {};}
+  const out: Record<string, FailedMessagePayload> = {};
+  let count = 0;
+  for (const [id, payload] of Object.entries(failedMessages)) {
+    if (count >= MAX_PERSISTED_FAILED_MESSAGES) {break;}
+    const clean = sanitizeFailedMessagePayload(payload);
+    if (clean) {
+      out[id] = clean;
+      count++;
+    }
+  }
+  return out;
+};
+
+// -------------------------------------------------------------------
+// Boot-time pending -> failed conversion (bug #39).
+//
+// `messageHeap` (the "still sending" buffer) is intentionally NOT
+// persisted: it's a process-lifetime thing. That means on a cold start
+// there is no such thing as "still sending": a persisted message that
+// carries `pending: true` never got a server echo NOR got the chance to
+// trip the in-session watchdog (see PENDING_WATCHDOG_MS in
+// useSendMessage.tsx) before the process died. It must render as failed
+// with a working retry, not as delivered and not as stuck "sending...".
+//
+// Reconstructs the same FailedMessagePayload shape the live send path
+// builds in useSendMessage (markMessageFailed calls), from the fields we
+// persist per message.
+// -------------------------------------------------------------------
+
+export function reconstructFailedMessagePayload(
+  message: IMessage,
+  roomJID: string
+): FailedMessagePayload | null {
+  if (!message?.id || !roomJID) {return null;}
+  const isReply = !!message.isReply;
+  const isChecked = message.showInChannel === 'true';
+  const mainMessage = message.mainMessage;
+  if (message.isMediafile === 'true') {
+    return {
+      kind: 'media',
+      id: message.id,
+      roomJID,
+      data: sanitizeMediaData({
+        uri: message.location,
+        name: message.fileName,
+        type: message.mimetype,
+        size:
+          message.size !== undefined && message.size !== null
+            ? Number(message.size)
+            : undefined,
+      }),
+      type: message.mimetype || '',
+      isReply,
+      isChecked,
+      mainMessage,
+    };
+  }
+  return {
+    kind: 'text',
+    id: message.id,
+    roomJID,
+    body: message.body || '',
+    isReply,
+    isChecked,
+    mainMessage,
+  };
+}
+
+/**
+ * Scan every persisted room for messages still `pending: true` that
+ * DON'T already have a restored failure entry (those are handled by the
+ * caller separately, from the persisted `failedMessages` map), and
+ * synthesize a retry-able FailedMessagePayload for each. Pure function:
+ * the caller (roomStore/index.ts) is responsible for dispatching
+ * `markMessageFailed` for the results.
+ */
+export function computeBootTimeFailures(
+  rooms: Record<string, IRoom> | null | undefined,
+  alreadyFailed: Record<string, FailedMessagePayload> | null | undefined
+): FailedMessagePayload[] {
+  if (!rooms || typeof rooms !== 'object') {return [];}
+  const out: FailedMessagePayload[] = [];
+  for (const [jid, room] of Object.entries(rooms)) {
+    const messages = Array.isArray(room?.messages) ? room.messages : [];
+    for (const message of messages) {
+      if (!message || !message.pending) {continue;}
+      if (alreadyFailed && alreadyFailed[message.id]) {continue;}
+      const payload = reconstructFailedMessagePayload(message, jid);
+      if (payload) {out.push(payload);}
+    }
+  }
+  return out;
+}
+
 let writeTimer: ReturnType<typeof setTimeout> | null = null;
 
 /**
@@ -194,6 +370,7 @@ export const persistenceMiddleware: Middleware = (storeAPI) => (next) => (
   const type: string = action?.type || '';
   if (
     !type.startsWith('roomMessages/') &&
+    !type.startsWith('roomHeapStore/') &&
     !type.startsWith('chat/setUser') &&
     !type.startsWith('chat/updateUser') &&
     !type.startsWith('chat/refreshTokens') &&
@@ -213,13 +390,20 @@ export const persistenceMiddleware: Middleware = (storeAPI) => (next) => (
         const roomsPayload: PersistedRoomsState = {
           rooms: sanitizeRooms(state.rooms?.rooms || {}),
         };
-        const [chatCipher, roomsCipher] = await Promise.all([
+        const heapPayload: PersistedHeapState = {
+          failedMessages: sanitizeFailedMessages(
+            state.roomHeapSlice?.failedMessages
+          ),
+        };
+        const [chatCipher, roomsCipher, heapCipher] = await Promise.all([
           encryptForPersist(JSON.stringify(chatPayload)),
           encryptForPersist(JSON.stringify(roomsPayload)),
+          encryptForPersist(JSON.stringify(heapPayload)),
         ]);
         await AsyncStorage.multiSet([
           [KEY_CHAT, chatCipher],
           [KEY_ROOMS, roomsCipher],
+          [KEY_HEAP, heapCipher],
         ]);
       } catch (e) {
         console.warn('persist write failed', e);
@@ -238,15 +422,18 @@ export const persistenceMiddleware: Middleware = (storeAPI) => (next) => (
 export async function readPersistedState(): Promise<{
   chat: PersistedChatState | null;
   rooms: PersistedRoomsState | null;
+  heap: PersistedHeapState | null;
 }> {
   try {
-    const [chatRaw, roomsRaw] = await AsyncStorage.multiGet([
+    const [chatRaw, roomsRaw, heapRaw] = await AsyncStorage.multiGet([
       KEY_CHAT,
       KEY_ROOMS,
+      KEY_HEAP,
     ]);
-    const [chatPlain, roomsPlain] = await Promise.all([
+    const [chatPlain, roomsPlain, heapPlain] = await Promise.all([
       chatRaw[1] ? decryptFromPersist(chatRaw[1]) : Promise.resolve(null),
       roomsRaw[1] ? decryptFromPersist(roomsRaw[1]) : Promise.resolve(null),
+      heapRaw[1] ? decryptFromPersist(heapRaw[1]) : Promise.resolve(null),
     ]);
     // `decryptFromPersist` returns null both for "nothing stored" and
     // for "stored value isn't a valid envelope for the current key" —
@@ -257,19 +444,22 @@ export async function readPersistedState(): Promise<{
     const rooms = roomsPlain
       ? (JSON.parse(roomsPlain) as PersistedRoomsState)
       : null;
-    return { chat, rooms };
+    const heap = heapPlain
+      ? (JSON.parse(heapPlain) as PersistedHeapState)
+      : null;
+    return { chat, rooms, heap };
   } catch (e) {
     console.warn('persist read failed', e);
-    return { chat: null, rooms: null };
+    return { chat: null, rooms: null, heap: null };
   }
 }
 
 export async function clearPersistedState(): Promise<void> {
   try {
-    await AsyncStorage.multiRemove([KEY_CHAT, KEY_ROOMS]);
+    await AsyncStorage.multiRemove([KEY_CHAT, KEY_ROOMS, KEY_HEAP]);
   } catch (e) {
     console.warn('persist clear failed', e);
   }
 }
 
-export const PERSIST_KEYS = { KEY_CHAT, KEY_ROOMS };
+export const PERSIST_KEYS = { KEY_CHAT, KEY_ROOMS, KEY_HEAP };