@ethora/chat-component-rn 26.7.9 → 26.8.1

package/src/context/xmppProvider.tsx

@@ -14,7 +14,7 @@ import { VideoCallOverlay } from '../components/VideoCalls/VideoCallOverlay';
 import XmppClient, {
   XmppCredentialsProvider,
 } from '../networking/xmppClient';
-import { refreshAuthTokensQuietly } from '../networking/authRefresh';
+import { refreshTokens } from '../roomStore/chatSettingsSlice';
 import {
   IConfig,
   ProviderBootstrapStatus,
@@ -37,7 +37,6 @@ import {
 import { ensureScopedChatCache } from '../helpers/ensureScopedChatCache';
 import { getRooms as prefetchRoomsViaRest } from '../networking/api-requests/rooms.api';
 import { allRoomPresences } from '../networking/xmpp/allRoomPresences.xmpp';
-import { pushSubscriptionService } from '../services/pushSubscriptionService';
 import { store } from '../roomStore';
 import { logout, setStoreClient, setConfig } from '../roomStore/chatSettingsSlice';
 import {
@@ -46,12 +45,12 @@ import {
   clearVisibleRoom,
   setLastViewedTimestamp,
   deleteRoomMessage,
+  msgSortableMs,
   setUnreadSyncing,
 } from '../roomStore/roomsSlice';
-import { getServerReadTimestamp } from '../helpers/getServerReadTimestamp';
 import { runHistoryPreloadScheduler } from '../helpers/historyPreloadScheduler';
-import { updateMessagesTillLast } from '../helpers/updateMessagesTillLast';
-import { secureUserStorage } from '../helpers/secureUserStorage';
+import { asyncLocalStorage } from '../hooks/useLocalStorage';
+import { localStorageConstants } from '../helpers/constants/LOCAL_STORAGE';
 import { clearPersistedState } from '../roomStore/persistence';
 import { pushLog as devPushLog } from '../utils/devLogger';
 
@@ -84,16 +83,6 @@ interface XmppProviderProps {
 
 const LOGOUT_EVENT = 'ethora-xmpp-logout';
 
-const subscribeAllRoomsForPush = (client: any, reason: string) => {
-  const rooms = Object.keys(store.getState().rooms.rooms || {});
-  if (!client || !rooms.length) {return;}
-  const nick = client.jid?.getLocal();
-  pushSubscriptionService
-    .subscribeToRooms(client, rooms, nick)
-    .then(() => devPushLog('xmpp', `${reason}: mucsub ok for ${rooms.length} rooms`))
-    .catch((e) => devPushLog('warn', `${reason}: mucsub subscribe failed`, e));
-};
-
 export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, isVisible }) => {
   const [client, setClient] = useState<XmppClient | null>(null);
   const [providerBootstrapStatus, setProviderBootstrapStatus] =
@@ -118,25 +107,23 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
   // the XmppClient at least doesn't crash on `undefined.password`.
   const credentialsProvider = useMemo<XmppCredentialsProvider>(() => {
     return async () => {
-      // 1. Make sure the REST tokens are fresh before re-minting XMPP
-      //    creds. This used to call `config.refreshTokens.refreshFunction`
-      //    directly and then fall into step 2, which refreshes again —
-      //    two rotations back to back, which the new backend scheme
-      //    reads as a race at best and token reuse at worst. One call to
-      //    the shared rotation point covers both the consumer-supplied
-      //    function and the built-in endpoint.
-      if (config?.refreshTokens?.enabled) {
-        const rotated = await refreshAuthTokensQuietly({ force: true });
-
-        if (rotated?.xmppPassword) {
-          const rotatedUser = store.getState().chatSettingStore.user;
-          return {
-            username:
-              rotatedUser?.xmppUsername ||
-              rotatedUser?.defaultWallet?.walletAddress ||
-              '',
-            password: rotated.xmppPassword,
-          };
+      // 1. Consumer-supplied REST refresh (when wired). This runs
+      //    before the SDK's own refresh chain so non-Ethora backends
+      //    can keep auth state in sync with their own token endpoint.
+      const customRefresh = config?.refreshTokens?.refreshFunction;
+      if (customRefresh) {
+        try {
+          const result = await customRefresh();
+          if (result?.accessToken) {
+            store.dispatch(
+              refreshTokens({
+                token: result.accessToken,
+                refreshToken: result.refreshToken || '',
+              })
+            );
+          }
+        } catch (err) {
+          devPushLog('warn', 'XMPP creds refresh: customRefresh failed', err);
         }
       }
 
@@ -176,7 +163,7 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
   }, [
     config?.jwtLogin?.enabled,
     config?.jwtLogin?.token,
-    config?.refreshTokens?.enabled,
+    config?.refreshTokens?.refreshFunction,
     config?.userLogin?.enabled,
     config?.customLogin?.enabled,
     config?.initBeforeLoadAuth?.myEndpoint,
@@ -240,11 +227,9 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
       created.setOnOnline(() => {
         const underlying = (created as any).client;
         if (!underlying) {return;}
-        allRoomPresences(underlying)
-          .catch((e) =>
-            devPushLog('warn', 'reconnect: allRoomPresences re-join failed', e)
-          )
-          .finally(() => subscribeAllRoomsForPush(underlying, 'reconnect'));
+        allRoomPresences(underlying).catch((e) =>
+          devPushLog('warn', 'reconnect: allRoomPresences re-join failed', e)
+        );
         // Also refresh the private store so unread / lastViewed markers
         // are accurate after a long reconnect — the MUC re-join above only
         // restores delivery, not unread state. Idempotent on first connect.
@@ -253,19 +238,6 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
           .catch((e: unknown) =>
             devPushLog('warn', 'reconnect: privateStore refresh failed', e)
           );
-        // Pull whatever landed in each room's archive while the stream was
-        // down. MUC presence re-join above only restores delivery for
-        // messages sent AFTER this reconnect — anything sent during the
-        // offline window has no live stanza to catch, and previously only
-        // came back on a full app restart (fresh useChatWrapperInit mount
-        // re-running its own one-shot boot sync). Safe on the very first
-        // connect too: rooms have no `lastMessageTimestamp` yet at that
-        // point, so this is a no-op until the bootstrap's own history load
-        // populates it. Customer-reported #32.
-        const rooms = store.getState().rooms?.rooms || {};
-        updateMessagesTillLast(rooms, created).catch((e: unknown) =>
-          devPushLog('warn', 'reconnect: offline catch-up sync failed', e)
-        );
       });
 
       setClient(created);
@@ -350,7 +322,7 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
           devPushLog('rn', 'initBeforeLoad: clearStoreBeforeInit');
           store.dispatch(setLogoutState());
           store.dispatch(logout());
-          await secureUserStorage().remove().catch(() => undefined);
+          await asyncLocalStorage(localStorageConstants.ETHORA_USER).remove().catch(() => undefined);
         }
 
         await ensureScopedChatCache(config);
@@ -381,29 +353,6 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
           store.dispatch(setConfig(config));
         }
 
-        // Rotate BEFORE the first XMPP connect. On the rotating backend
-        // the xmpp password is a short-lived JWT that only the newest
-        // rotation knows, and each rotation invalidates its predecessors
-        // — so a snapshot's password (a host's cached `userLogin.user`,
-        // a persisted session) is usually already dead at boot. Without
-        // this, the first SASL attempt fails `not-authorized`, all three
-        // bootstrap retries re-present the same dead password, and the
-        // user dead-ends on the Connection error modal even though one
-        // rotation away a perfectly good session existed. The rotation
-        // also lands the fileToken pre-render, so secure media never
-        // paints blank first. Quiet + deduped; when it can't rotate
-        // (no refresh material, non-rotating backend) we just connect
-        // with what the snapshot has, exactly as before.
-        // jwtLogin is skipped: /users/client just minted fresh creds.
-        let connectPassword = resolved.xmppPassword;
-        if (config?.refreshTokens?.enabled && !config?.jwtLogin?.enabled) {
-          const rotated = await refreshAuthTokensQuietly({ force: true });
-          if (cancelled) {return;}
-          if (rotated?.xmppPassword) {
-            connectPassword = rotated.xmppPassword;
-          }
-        }
-
         // Kick off REST /chats/my; allRoomPresences below needs the
         // room list to be in redux, otherwise it joins 0 MUCs and the
         // user receives zero realtime messages until they manually tap
@@ -413,7 +362,7 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
 
         const c = await initializeClient(
           resolved.xmppUsername!,
-          connectPassword,
+          resolved.xmppPassword,
           config?.xmppSettings
         );
         if (cancelled) {return;}
@@ -449,7 +398,6 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
         } catch (e) {
           devPushLog('warn', 'initBeforeLoad: allRoomPresences failed', e);
         }
-        subscribeAllRoomsForPush((c as any).client, 'initBeforeLoad');
 
         store.dispatch(setStoreClient(c));
         completedBootstrapKeyRef.current = key;
@@ -594,14 +542,9 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
     // be re-marked visible on return. Lives in the effect closure (one per
     // client) — persists across the listener's many invocations.
     let visibleBeforeBackground: string | null = null;
-    const suspendInBackground = !config?.xmppSettings?.keepAliveInBackground;
     const sub = AppState.addEventListener('change', (next) => {
       const c = client;
       if (next === 'active') {
-        if (c?.isSuspended) {
-          devPushLog('rn', 'AppState active: resuming suspended XMPP client');
-          c.resume();
-        }
         // Returned to foreground. If the socket died while backgrounded
         // (iOS suspends the WebSocket; long background kills it), the
         // status may still read 'online' until xmpp.js notices the dead
@@ -629,39 +572,22 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
       }
       // Going to background/inactive (sleep / app switcher / tray):
       if (!c) {return;}
-      if (next === 'background' && suspendInBackground) {
-        c.suspend().catch(() => undefined);
-      }
       const state = store.getState();
       const rooms = state.rooms?.rooms;
       const visibleRoomJID = state.rooms?.visibleRoomJID || null;
       // Mark the open room "not visible" while backgrounded so messages
       // that arrive (or MAM-replay on reconnect) count as unread instead
       // of being silently treated as read — the "mounted == visible ==
-      // read" gap. Stamp lastViewed=<newest server-acked message>, not
-      // Date.now(), as the read baseline: a device clock running ahead
-      // would otherwise write a future marker that the forward-only
-      // private-store merge can never correct again (bug #38). Then
-      // clear visibility and flush that marker to the server private
-      // store. Restored on the next 'active' transition above. Handled
-      // here in the provider so consumers using the component as a
-      // package get correct unread without reaching into the chat store
-      // themselves.
+      // read" gap. Stamp lastViewed=now as the read baseline, clear
+      // visibility, then flush that marker to the server private store.
+      // Restored on the next 'active' transition above. Handled here in
+      // the provider so consumers using the component as a package get
+      // correct unread without reaching into the chat store themselves.
       visibleBeforeBackground = visibleRoomJID;
       if (visibleRoomJID) {
-        const readTs = getServerReadTimestamp(
-          rooms?.[visibleRoomJID],
-          state.roomHeapSlice
+        store.dispatch(
+          setLastViewedTimestamp({ chatJID: visibleRoomJID, timestamp: Date.now() })
         );
-        // Nothing to anchor to yet (no known messages, no prior marker)
-        // - skip the local stamp rather than fall back to the device
-        // clock. The flush below still runs so the visibility clear
-        // isn't blocked on this.
-        if (readTs > 0) {
-          store.dispatch(
-            setLastViewedTimestamp({ chatJID: visibleRoomJID, timestamp: readTs })
-          );
-        }
         // Drop the "New messages" divider for the room we're leaving so it
         // doesn't linger when the user comes back (mirrors ChatRoom's
         // unmount cleanup, which never runs while the pane stays mounted).
@@ -677,7 +603,7 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
       );
     });
     return () => sub.remove();
-  }, [client, config?.xmppSettings?.keepAliveInBackground]);
+  }, [client]);
 
   // -----------------------------------------------------------
   // Consumer visibility signal (`isVisible` prop). For hosts that keep
@@ -686,11 +612,11 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
   // "shown" from "hidden", so the unread middleware would keep the open
   // room's badge at 0 and messages arriving while you're elsewhere look
   // already-read. When the host passes `isVisible`, mirror the AppState
-  // background/foreground handling: hidden → stamp lastViewed=<newest
-  // server-acked message> + clear room visibility (so later messages
-  // count) + flush; shown → restore visibility for the open room. Doing
-  // it here means consumers never touch the chat store themselves.
-  // (Undefined = host unmounts on hide, nothing to do.)
+  // background/foreground handling: hidden → stamp lastViewed=now + clear
+  // room visibility (so later messages count) + flush; shown → restore
+  // visibility for the open room. Doing it here means consumers never
+  // touch the chat store themselves. (Undefined = host unmounts on hide,
+  // nothing to do.)
   // -----------------------------------------------------------
   const chatWasVisibleRef = useRef(false);
   useEffect(() => {
@@ -706,18 +632,9 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
       }
     } else {
       if (wasVisible && activeRoomJID) {
-        // Never Date.now(): a fast device clock would write a future
-        // marker that the forward-only private-store merge could then
-        // never correct (bug #38).
-        const readTs = getServerReadTimestamp(
-          rooms?.[activeRoomJID],
-          state.roomHeapSlice
+        store.dispatch(
+          setLastViewedTimestamp({ chatJID: activeRoomJID, timestamp: Date.now() })
         );
-        if (readTs > 0) {
-          store.dispatch(
-            setLastViewedTimestamp({ chatJID: activeRoomJID, timestamp: readTs })
-          );
-        }
         // Drop the "New messages" divider so it's gone when the user
         // returns to the chat (mirrors ChatRoom's unmount cleanup).
         store.dispatch(
@@ -749,18 +666,18 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
       if (room.messages === lastMessagesRef) {return;}
       lastMessagesRef = room.messages;
 
-      // getServerReadTimestamp (not a hand-rolled scan + Date.now()):
-      // it excludes pending/optimistic messages, which carry the DEVICE
-      // send time via `date` until the server echoes them back - a
-      // manual scan without that exclusion could pick up a pending
-      // message's device timestamp here and write a future marker the
-      // same way a raw Date.now() would (bug #38).
-      const newest = getServerReadTimestamp(room, s.roomHeapSlice);
-      if (!newest || newest <= lastStampedMs) {return;}
+      let newest = 0;
+      const list = room.messages || [];
+      for (const m of list) {
+        if (!m || m.id === 'delimiter-new') {continue;}
+        const ms = msgSortableMs(m);
+        if (ms > newest) {newest = ms;}
+      }
+      if (newest <= lastStampedMs) {return;}
       lastStampedMs = newest;
 
       store.dispatch(
-        setLastViewedTimestamp({ chatJID: jid, timestamp: newest })
+        setLastViewedTimestamp({ chatJID: jid, timestamp: Date.now() })
       );
 
       if (flushTimer) {clearTimeout(flushTimer);}

package/src/helpers/createMessageFromXml.ts

@@ -93,25 +93,6 @@ export const createMessageFromXml = async (
   const senderLocal = senderJID.includes('@')
     ? senderJID.split('@')[0]
     : senderJID;
-
-  // Bug #41 root cause: the resource of the MUC `from` (room@conference/
-  // occupant-id) is the SAME field getDataFromXml uses to derive
-  // `user.id` for live messages and for the wrapped MAM convention
-  // (getHistory.xmpp.ts) - it's stamped by the server itself when the
-  // sender joined the room, so it's always present and always correct.
-  // The positional convention (onMessageHistory's MAM catch-up path)
-  // never called getDataFromXml, so it fell back to splitting the
-  // sender-supplied `<data senderJID>` attr on '@' instead - usually the
-  // same value, but WRONG (picks up the room's own id, not the
-  // sender's) whenever senderJID is absent from the stanza, and simply a
-  // different derivation than the live path even when it happens to
-  // agree. Prefer the resource-of-`from` here too so every path that
-  // reaches this function resolves the same sender identity the same
-  // way, instead of MAM catch-up rows needing a later correction once
-  // the "official" fetch lands.
-  const xmppFrom = (merged.xmppFrom || '').toString();
-  const fromResource = xmppFrom.includes('/') ? xmppFrom.split('/')[1] : '';
-
   const composed = [firstName, lastName].filter(Boolean).join(' ').trim();
   const existingName = String(merged?.user?.name || '').trim();
   const resolvedName =
@@ -126,7 +107,7 @@ export const createMessageFromXml = async (
     ...merged,
     user: {
       ...(merged.user || {}),
-      id: merged?.user?.id || fromResource || senderLocal,
+      id: merged?.user?.id || senderLocal,
       name: resolvedName,
       firstName: firstName || merged?.user?.firstName,
       lastName: lastName || merged?.user?.lastName,

package/src/helpers/ensureScopedChatCache.ts

@@ -3,7 +3,7 @@ import { store } from '../roomStore';
 import { logout } from '../roomStore/chatSettingsSlice';
 import { setLogoutState } from '../roomStore/roomsSlice';
 import { asyncLocalStorage } from '../hooks/useLocalStorage';
-import { secureUserStorage } from './secureUserStorage';
+import { localStorageConstants } from './constants/LOCAL_STORAGE';
 import { clearRoomsRestCache } from '../networking/api-requests/rooms.api';
 import { clearPersistedState } from '../roomStore/persistence';
 import {
@@ -53,7 +53,7 @@ export async function ensureScopedChatCache(config?: IConfig): Promise<void> {
     clearRoomsRestCache();
     store.dispatch(setLogoutState());
     store.dispatch(logout());
-    await secureUserStorage().remove();
+    await asyncLocalStorage(localStorageConstants.ETHORA_USER).remove();
     await clearPersistedState();
   }
 

package/src/helpers/getDataFromXml.ts

@@ -1,6 +1,13 @@
 import { Element } from 'ltx';
 import { Iso639_1Codes, IUser } from '../types/types';
 import { transformArrayToObject } from './transformTranslatations';
+import { normalizeXmppUsername } from './xmppUsername';
+
+const getLocalpartFromJid = (jid?: string): string | undefined => {
+  const value = String(jid || '').trim();
+  if (!value) {return undefined;}
+  return value.split('@')[0] || undefined;
+};
 
 // Tolerant JSON parse: a malformed `translations` attr must not reject the
 // whole stanza (which would silently drop the message). Mirrors the web
@@ -64,7 +71,7 @@ export const getDataFromXml = async (stanza: Element): Promise<DataXml | undefin
 
   const xmppId = fullData?.attrs.id;
   const xmppFrom = fullData?.attrs?.from;
-  const [roomJid, userWallet] = (xmppFrom || '').split('/');
+  const [roomJid, userWalletFromResource] = (xmppFrom || '').split('/');
   let id =
     stanza.getChild('result')?.attrs.id ||
     extractTimestamp(stanza?.getChild('stanza-id')?.attrs?.id, stanza);
@@ -93,6 +100,23 @@ export const getDataFromXml = async (stanza: Element): Promise<DataXml | undefin
   const data = fullData?.getChild('data') || stanza?.getChild('data');
   const photoURL = data?.attrs?.photo;
 
+  // Sender identity, resolved the way the web SDK does it: the occupant
+  // RESOURCE of `from` first, then the localpart of `<data senderJID>`.
+  //
+  // RN only had the first. The translate-tagged send path arrives with no
+  // occupant resource and no senderJID either, so `user.id` came out
+  // undefined and every downstream fallback landed on the bare room jid's
+  // localpart — which for a 1:1 room is `<appId>_<userA>-<appId>_<userB>`.
+  // That composite id is what got rendered as the sender's name.
+  //
+  // normalizeXmppUsername collapses a doubled `<appId>_` prefix so the key
+  // matches what usersSet is indexed by.
+  const rawUserWallet =
+    userWalletFromResource ||
+    getLocalpartFromJid(data?.attrs?.senderJID) ||
+    undefined;
+  const userWallet = normalizeXmppUsername(rawUserWallet) || rawUserWallet;
+
   const user = {
     id: userWallet,
     photoURL,

package/src/helpers/historyPreloadScheduler.ts

@@ -1,11 +1,7 @@
 import { AppState } from 'react-native';
 import XmppClient from '../networking/xmppClient';
 import { store } from '../roomStore';
-import {
-  applyRoomsPreloadBatch,
-  setUnreadSyncing,
-  RUNTIME_MESSAGE_LIMIT,
-} from '../roomStore/roomsSlice';
+import { applyRoomsPreloadBatch, setUnreadSyncing } from '../roomStore/roomsSlice';
 import { IMessage, IRoom } from '../types/types';
 
 interface HistoryPreloadSchedulerOptions {
@@ -34,13 +30,6 @@ const DEFAULT_CONCURRENCY = 3;
 // `mergeHistoryIntoCache` rarely has to fall back to clear-and-replace.
 const DEFAULT_PAGE_SIZE = 20;
 const DEFAULT_RETRY_LIMIT = 2;
-// When the first page is entirely unread (every fetched message is newer
-// than `lastViewedTimestamp`), the true unread count could be far bigger
-// than `pageSize` — `useUnread()` only ever sees what's been loaded. Page
-// further back, up to this many extra fetches, until we either find the
-// boundary or give up (`unreadCapped` then stays true so callers at least
-// know the count is a floor, not exact). Customer-reported #34.
-const MAX_UNREAD_CATCHUP_PAGES = 8;
 
 const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
 
@@ -237,75 +226,9 @@ export const runHistoryPreloadScheduler = async (
             }
 
             const nextRoom = store.getState().rooms.rooms[item.jid];
-            let combined: IMessage[] = fetchedMessages || [];
-            const lastViewed = Number(nextRoom?.lastViewedTimestamp) || 0;
-
-            // The first page was entirely unread — keep paging older until
-            // we find a message at/before `lastViewedTimestamp` (the true
-            // boundary) or run out of catch-up budget, so the count isn't
-            // silently truncated at `pageSize`.
-            if (lastViewed > 0 && computeUnreadCapped(nextRoom, combined, pageSize)) {
-              let lastPageLen = combined.length;
-              let extraPages = 0;
-              while (
-                extraPages < MAX_UNREAD_CATCHUP_PAGES &&
-                lastPageLen >= pageSize &&
-                !signal?.aborted
-              ) {
-                const oldestId = combined.reduce<number | null>((min, m) => {
-                  const idNum = Number((m as any)?.id);
-                  if (!Number.isFinite(idNum)) {return min;}
-                  return min === null || idNum < min ? idNum : min;
-                }, null);
-                if (oldestId === null) {break;}
-
-                let older: IMessage[] | undefined;
-                try {
-                  older = await client.getHistoryStanza(
-                    item.jid,
-                    pageSize,
-                    oldestId,
-                    undefined,
-                    {
-                      coalesceRoom: true,
-                      skipIfPreloaded: !forceReload,
-                      source: 'background',
-                    }
-                  );
-                } catch {
-                  break;
-                }
-                if (!older || !older.length) {break;}
-
-                combined = [...older, ...combined];
-                lastPageLen = older.length;
-                extraPages++;
-
-                const oldestTs = combined.reduce<number>((minTs, m) => {
-                  const ts = messageTimestamp(m);
-                  return ts > 0 ? Math.min(minTs, ts) : minTs;
-                }, Number.MAX_SAFE_INTEGER);
-                if (oldestTs !== Number.MAX_SAFE_INTEGER && oldestTs <= lastViewed) {
-                  break;
-                }
-              }
-            }
-
-            // `mergeHistoryIntoCache` (roomsSlice) caps whatever we dispatch
-            // here to the newest RUNTIME_MESSAGE_LIMIT messages before it
-            // ever reaches `unreadMiddleware` — so a catch-up fetch that
-            // pulled the true boundary can still have it silently dropped
-            // by that cap, leaving a falsely-confident `unreadCapped:false`
-            // (bug #34's failure mode again, just one layer downstream).
-            // Simulate that cap here so the flag reflects what will
-            // actually survive, not just what this fetch retrieved.
-            const simulatedStored =
-              combined.length > RUNTIME_MESSAGE_LIMIT
-                ? combined.slice(-RUNTIME_MESSAGE_LIMIT)
-                : combined;
             const unreadCapped = computeUnreadCapped(
               nextRoom,
-              simulatedStored,
+              fetchedMessages || [],
               pageSize
             );
 
@@ -314,7 +237,7 @@ export const runHistoryPreloadScheduler = async (
                 rooms: [
                   {
                     jid: item.jid,
-                    messages: combined,
+                    messages: fetchedMessages || [],
                     unreadCapped,
                     historyPreloadState: 'done',
                   },

package/src/helpers/initXmppRooms.tsx

@@ -1,9 +1,9 @@
 import { setCurrentRoom, setIsLoading } from '../roomStore/roomsSlice';
+import { updatedChatLastTimestamps } from './updatedChatLastTimestamps';
 import { initRoomsPresence } from './initRoomsPresence';
 import XmppClient from '../networking/xmppClient';
 import { IConfig, IRoom, User } from '../types/types';
 import { store } from '../roomStore';
-import { refreshAuthTokensQuietly } from '../networking/authRefresh';
 
 const initXmppRooms = async (
   user: User,
@@ -47,23 +47,19 @@ const initXmppRooms = async (
         console.log(res);
       }
 
-      // getChatsPrivateStoreRequestStanza hydrates redux itself
-      // (dispatch(applyPrivateStoreMarkers(...)) internally, clamped +
-      // forward-only) - do not also apply the raw return value here. That
-      // used to double-dispatch via updatedChatLastTimestamps' unconditional
-      // setLastViewedTimestamp, which has neither the forward-only guard
-      // nor the future-marker clamp, so it could silently re-clobber a
-      // value the clamp had just corrected (bug #38).
-      await (xmmpClient as any as XmppClient).getChatsPrivateStoreRequestStanza();
+      //@ts-ignore
+      const roomTimestampObject: [jid: string, timestamp: string] =
+        await (xmmpClient as any as XmppClient).getChatsPrivateStoreRequestStanza();
+      updatedChatLastTimestamps(roomTimestampObject, store.dispatch);
     } else {
-      await xmmpClient.getChatsPrivateStoreRequestStanza();
+      //@ts-ignore
+      const roomTimestampObject: [jid: string, timestamp: string] =
+        await xmmpClient.getChatsPrivateStoreRequestStanza();
+      updatedChatLastTimestamps(roomTimestampObject, store.dispatch);
     }
 
     if (config?.refreshTokens?.enabled) {
-      // Was a bare call to the consumer-supplied refreshFunction, i.e. a
-      // rotation completely outside the SDK's lock. Routed through the
-      // one rotation point, which calls that same function internally.
-      refreshAuthTokensQuietly();
+      config?.refreshTokens?.refreshFunction?.();
     }
   } catch (error) {
     console.error(error);

package/src/helpers/insertMessageWithDelimiter.ts

@@ -3,6 +3,19 @@ import { isDateAfter, isDateBefore } from './dateComparison';
 
 function deepMerge(target: any, source: any): any {
   for (const key in source) {
+    if (source[key] === undefined) {
+      // `for...in` visits a key even when its value is `undefined` — every
+      // stanza parser (getDataFromXml/createMessageFromXml) returns an
+      // object literal with `translations` always present, explicitly
+      // `undefined` whenever the wire message didn't carry a
+      // <translations> element. Without this guard, merging THAT message
+      // over an existing row would blow away a translation the row
+      // already had (e.g. a MAM/live echo of a message arriving without
+      // its translation re-attached) — a real message flips from
+      // translated back to original text for no reason. Absence on the
+      // incoming side must mean "leave it alone", never "clear it".
+      continue;
+    }
     if (
       source[key] &&
       typeof source[key] === 'object' &&

package/src/helpers/isUnresolvedSenderId.ts

@@ -14,7 +14,15 @@
  * matches. A raw objectId on its own is matched too, since some senders
  * carry only that half.
  */
-const ETHORA_ID = /^[0-9a-f]{24}(_[0-9a-f]{24})?$/i;
+const ETHORA_ID_PART = '[0-9a-f]{24}(?:_[0-9a-f]{24})?';
+// A private (1:1) room's own id is two of those joined by a hyphen —
+// `<appId>_<userA>-<appId>_<userB>` — and that is what a message whose
+// `from` carries no occupant resource resolves to. Matched as well, so a
+// bubble is never captioned with a room id.
+const ETHORA_ID = new RegExp(
+  `^${ETHORA_ID_PART}(?:-${ETHORA_ID_PART})?$`,
+  'i'
+);
 
 export const isUnresolvedSenderId = (name?: string): boolean => {
   const trimmed = String(name || '').trim();