@ethora/chat-component-rn 26.7.10 → 26.8.1

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

@@ -1,38 +1,21 @@
 import { IMessage } from '../types/types';
 import { isDateAfter, isDateBefore } from './dateComparison';
-import { msgSortableMs } from './msgSortableMs';
-
-// Robustly resolve a caller-supplied read marker to epoch milliseconds.
-// Callers pass a plain number (the redux read boundary, or a room's
-// lastViewedTimestamp), a Date object (older call sites), or occasionally
-// a numeric string. These are NOT interchangeable through the Date
-// constructor: `new Date(1757000000123)` (a number) reads as epoch-ms,
-// but `new Date("1757000000123")` (a string) is parsed as a date STRING
-// - a bare 13-digit string matches no recognized date format, so the
-// result is silently Invalid Date and every comparison against it is
-// `false`. Try Number() first so a numeric string/number is read as
-// epoch-ms; only fall through to Date parsing for genuine date/ISO
-// strings (e.g. a Date object's own `.toString()`). Never falls back to
-// `Date.now()` - a marker we can't resolve is treated as "no marker",
-// not "now" (bug #38).
-function resolveMarkerMs(
-  marker: number | { toString: () => string } | null | undefined
-): number {
-  if (marker == null) {return 0;}
-  if (typeof marker === 'number') {
-    return Number.isFinite(marker) ? marker : 0;
-  }
-  const raw = marker.toString();
-  if (raw.trim() !== '') {
-    const asNumber = Number(raw);
-    if (Number.isFinite(asNumber)) {return asNumber;}
-  }
-  const parsed = Date.parse(raw);
-  return Number.isFinite(parsed) ? parsed : 0;
-}
 
 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' &&
@@ -49,7 +32,7 @@ function deepMerge(target: any, source: any): any {
 export function insertMessageWithDelimiter(
   roomMessages: Partial<IMessage>[],
   message: IMessage,
-  lastViewedTimestamp: number | { toString: () => string } | null,
+  lastViewedTimestamp: { toString: () => string } | null,
 ) {
   const existingIndex = roomMessages.findIndex(
     (msg) =>
@@ -92,39 +75,33 @@ export function insertMessageWithDelimiter(
       roomMessages.push(message);
     }
 
-    const lastViewedMs = resolveMarkerMs(lastViewedTimestamp);
-    const newMessageMs = msgSortableMs(message);
     if (
-      lastViewedMs > 0 &&
-      newMessageMs > lastViewedMs &&
-      !roomMessages.some((msg) => msg.id === 'delimiter-new')
+      lastViewedTimestamp &&
+      !roomMessages.some((msg) => msg.id === 'delimiter-new') &&
+      isDateAfter(newMessageDate.toString(), lastViewedTimestamp.toString())
     ) {
-      // Find the first message STRICTLY newer than the marker, using the
-      // SAME timestamp source (msgSortableMs - the server id-encoded ms)
-      // as the unread middleware and countNewerMessages use to decide
-      // what counts as unread. Comparing against a DIFFERENT source (the
-      // old code compared `msg.date` strings) risks the boundary message
-      // itself landing on the wrong side of the cut: since bug #38 the
-      // marker can equal a real message's own timestamp exactly, and any
-      // drift between `date` and the id-encoded ms - or a raw numeric
-      // marker silently producing an Invalid Date via the Date
-      // constructor's string-parsing path - could count that message as
-      // unread, pushing the divider one message too early (ABOVE the
-      // last read message instead of directly below it). Customer #42.
-      const delimiterIndex = roomMessages.findIndex(
-        (msg) => msg.id !== 'delimiter-new' && msgSortableMs(msg) > lastViewedMs
+      const delimiterIndex = roomMessages.findIndex((msg) =>
+        isDateAfter(msg.date?.toString() ?? '', lastViewedTimestamp.toString())
       );
 
       if (delimiterIndex !== -1) {
         // The divider's date is what ORDERS it: roomsSlice re-sorts every
         // merged page by timestamp (see `byMs`), so a divider stamped with
-        // `new Date()` (i.e. now) sorted past every real message and
+        // `new Date()` — i.e. now — sorted past every real message and
         // rendered at the very bottom, BELOW the new messages it is
         // supposed to introduce. Anchor it a hair before the first unread
         // instead, which is where it belongs and where any later sort keeps
-        // it.
-        const firstUnreadMs = msgSortableMs(roomMessages[delimiterIndex]);
-        const anchorMs = firstUnreadMs > 0 ? firstUnreadMs - 1 : lastViewedMs;
+        // it. Derived from that message rather than from
+        // lastViewedTimestamp so it works whatever format the caller passes.
+        const firstUnreadMs = Date.parse(
+          String(roomMessages[delimiterIndex]?.date ?? '')
+        );
+        const rawLastViewed = lastViewedTimestamp.toString();
+        const lastViewedMs =
+          Date.parse(rawLastViewed) || Number(rawLastViewed) || Date.now();
+        const anchorMs = Number.isFinite(firstUnreadMs)
+          ? firstUnreadMs - 1
+          : lastViewedMs;
 
         roomMessages.splice(delimiterIndex, 0, {
           id: 'delimiter-new',
@@ -139,7 +116,7 @@ export function insertMessageWithDelimiter(
           roomJid: '',
         });
       }
-    }
+      }
   } else if (
     isDateBefore(newMessageDate.toString(), firstMessage?.date?.toString() ?? '')
   ) {

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();

package/src/helpers/keyboardLayout.ts

@@ -14,30 +14,9 @@ export const getKeyboardVerticalOffset = ({
 }: KeyboardLayoutArgs): number =>
   configuredOffset + (platform === 'ios' ? bottomInset : 0);
 
-type InputDockPaddingArgs = Omit<KeyboardLayoutArgs, 'configuredOffset'> & {
-  // Explicit `inputDockPaddingBottom` config value, verbatim on both
-  // platforms when provided (0 allowed). Takes priority over every other
-  // rule below, including `hostOwnsLayout`.
-  configuredPadding?: number;
-  // True when the host app owns keyboard layout entirely (i.e.
-  // `disableKeyboardAvoidingView` is set) and `configuredPadding` was not
-  // given. The dock then gets no built-in bottom padding of its own,
-  // since it already sits above the host's own chrome (e.g. its tab bar).
-  hostOwnsLayout?: boolean;
-};
-
 export const getInputDockPaddingBottom = ({
   platform,
   bottomInset = 0,
   keyboardVisible = false,
-  configuredPadding,
-  hostOwnsLayout = false,
-}: InputDockPaddingArgs): number => {
-  if (typeof configuredPadding === 'number') {
-    return configuredPadding;
-  }
-  if (hostOwnsLayout) {
-    return 0;
-  }
-  return platform === 'ios' ? bottomInset : ANDROID_INPUT_DOCK_GAP;
-};
+}: Omit<KeyboardLayoutArgs, 'configuredOffset'>): number =>
+  platform === 'ios' ? bottomInset : ANDROID_INPUT_DOCK_GAP;

package/src/helpers/mimeToExtension.ts

@@ -289,9 +289,25 @@ export function ensureFilenameHasExtension(
   return `${base}${getExtensionForMime(mime)}`;
 }
 
-// NOTE: the "which name wins" decision (originalName vs the stored
-// fileName vs the URL) lives in helpers/getDisplayFileName.ts - that is
-// the single source of truth used across display, save, share and
-// download call sites (bug #40: this used to be duplicated here with
-// the priority backwards, so attachments showed/saved under the
-// server's hash name instead of the sender's original one).
+/**
+ * Best-effort filename derivation for a message bubble:
+ *   - server-provided `fileName`
+ *   - server-provided `originalName`
+ *   - URL pathname
+ *   - generic `media_<timestamp>` so we never render an empty label
+ *
+ * Always returns a string with a valid extension.
+ */
+export function deriveDisplayFilename(opts: {
+  fileName?: string | null;
+  originalName?: string | null;
+  url?: string | null;
+  mime?: string | null;
+}): string {
+  const candidate =
+    (opts.fileName && opts.fileName.trim()) ||
+    (opts.originalName && opts.originalName.trim()) ||
+    filenameFromUrl(opts.url) ||
+    '';
+  return ensureFilenameHasExtension(candidate, opts.mime);
+}

package/src/helpers/resolveInitBeforeLoadUser.ts

@@ -1,12 +1,12 @@
-import { setBaseURL } from '../networking/apiClient';
-import { refreshAuthTokens, isRefreshFatalError } from '../networking/authRefresh';
+import http, { setBaseURL } from '../networking/apiClient';
 import { loginViaJwt } from '../networking/api-requests/auth.api';
 import { getMyUser } from '../networking/api-requests/user.api';
 import { IConfig, User } from '../types/types';
 import { store } from '../roomStore';
 import { setUser } from '../roomStore/chatSettingsSlice';
 import { walletToUsername } from './walletUsername';
-import { secureUserStorage } from './secureUserStorage';
+import { asyncLocalStorage } from '../hooks/useLocalStorage';
+import { localStorageConstants } from './constants/LOCAL_STORAGE';
 
 interface ResolveInitBeforeLoadUserOptions {
   config?: IConfig;
@@ -46,107 +46,15 @@ const normalizeUserForXmpp = (user?: User | null): User | null => {
   return { ...user, xmppUsername: normalizedXmppUsername };
 };
 
-// Hermes has no atob/Buffer; hand-decode just enough base64url to read a
-// JWT's `iat`. Claims are ASCII so the byte-per-char string is fine.
-const B64_ALPHABET =
-  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-
-const readJwtIat = (token?: string | null): number => {
-  if (!token || typeof token !== 'string') {return 0;}
-  const part = token.split('.')[1];
-  if (!part) {return 0;}
-  try {
-    const clean = part.replace(/-/g, '+').replace(/_/g, '/');
-    let out = '';
-    let buffer = 0;
-    let bits = 0;
-    for (let i = 0; i < clean.length; i++) {
-      const idx = B64_ALPHABET.indexOf(clean[i]);
-      if (idx === -1) {continue;}
-      buffer = (buffer << 6) | idx;
-      bits += 6;
-      if (bits >= 8) {
-        bits -= 8;
-        out += String.fromCharCode((buffer >> bits) & 0xff);
-      }
-    }
-    const iat = JSON.parse(out)?.iat;
-    return typeof iat === 'number' ? iat : 0;
-  } catch {
-    return 0;
-  }
-};
-
-/**
- * A `userLogin.user` is typically a snapshot the host captured at ITS
- * login time and re-presents verbatim on every mount, while this SDK
- * keeps rotating the session and persisting the newest pair to
- * `ETHORA_USER`. Taking the snapshot as-is therefore discards the live
- * session in favour of an ever-aging copy: media goes blank the moment
- * the snapshot has no `fileToken` (secure-files URLs 401 without it),
- * and once the snapshot's refresh token ages out entirely the account
- * looks dead even though the SDK held a working session all along.
- *
- * So, for the SAME account only, prefer whichever refresh pair was
- * minted later (JWT `iat` decides — a host that genuinely re-logged-in
- * hands us newer tokens and wins), and fill in a missing `fileToken`
- * from the persisted copy either way.
- */
-const adoptFresherPersistedSession = async (candidate: User): Promise<User> => {
-  try {
-    const stored = await secureUserStorage().get();
-    if (!stored) {return candidate;}
-
-    const sameUser =
-      (candidate._id && stored._id && candidate._id === stored._id) ||
-      (candidate.xmppUsername &&
-        stored.xmppUsername &&
-        candidate.xmppUsername === stored.xmppUsername);
-    if (!sameUser) {return candidate;}
-
-    const merged = { ...candidate };
-
-    if (
-      stored.refreshToken &&
-      readJwtIat(stored.refreshToken) > readJwtIat(candidate.refreshToken)
-    ) {
-      merged.refreshToken = stored.refreshToken;
-      if (stored.token) {merged.token = stored.token;}
-      if (stored.fileToken) {merged.fileToken = stored.fileToken;}
-    }
-
-    if (!merged.fileToken && stored.fileToken) {
-      merged.fileToken = stored.fileToken;
-    }
-
-    return merged;
-  } catch {
-    return candidate;
-  }
-};
-
-/**
- * Bootstrap rotation.
- *
- * Was a second, independent `/users/login/refresh` caller that bypassed
- * every lock in the SDK — and, worse, only wrote the rotated token to
- * the store on the happy path, so several of the early-return branches
- * below used to drop it. Under the backend's reuse detection a dropped
- * rotation means the next launch presents a burned token and the
- * session is killed.
- *
- * `refreshAuthTokens` persists the new pair before it resolves, so by
- * the time this returns the rotation is safe no matter which branch the
- * caller takes afterwards. The explicit token is required here: during
- * bootstrap the candidate session isn't in the store yet.
- */
 const refreshWithToken = async (refreshToken: string) => {
-  const result = await refreshAuthTokens({ refreshToken });
+  const response = await http.post(
+    '/users/login/refresh',
+    {},
+    { headers: { Authorization: refreshToken } }
+  );
   return {
-    token: result.token,
-    refreshToken: result.refreshToken || refreshToken,
-    xmppPassword: result.xmppPassword || '',
-    fileToken: result.fileToken || '',
+    token: response?.data?.token || '',
+    refreshToken: response?.data?.refreshToken || refreshToken,
   };
 };
 
@@ -179,15 +87,11 @@ const tryHydrateViaMy = async (
 
   let workingToken = candidate?.token || '';
   let workingRefresh = candidate?.refreshToken || '';
-  let rotatedXmppPassword = '';
-  let workingFileToken = candidate?.fileToken || '';
 
   const candidateWithCurrentTokens = (): User => ({
     ...candidate,
     token: workingToken || candidate.token,
     refreshToken: workingRefresh || candidate.refreshToken,
-    xmppPassword: rotatedXmppPassword || candidate.xmppPassword,
-    fileToken: workingFileToken || candidate.fileToken,
   });
 
   const fallbackWithCreds = (): User | null => {
@@ -203,8 +107,6 @@ const tryHydrateViaMy = async (
       if (merged) {
         merged.token = workingToken || merged.token;
         merged.refreshToken = workingRefresh || merged.refreshToken;
-        merged.xmppPassword = rotatedXmppPassword || merged.xmppPassword;
-        merged.fileToken = workingFileToken || merged.fileToken;
       }
       return merged;
     } catch (error) {
@@ -225,8 +127,6 @@ const tryHydrateViaMy = async (
     const refreshed = await refreshWithToken(workingRefresh);
     workingToken = refreshed.token;
     workingRefresh = refreshed.refreshToken;
-    rotatedXmppPassword = refreshed.xmppPassword || rotatedXmppPassword;
-    workingFileToken = refreshed.fileToken || workingFileToken;
 
     try {
       const myUser = await getMyUser({ token: workingToken, endpoint: myEndpoint });
@@ -236,8 +136,6 @@ const tryHydrateViaMy = async (
       if (merged) {
         merged.token = workingToken || merged.token;
         merged.refreshToken = workingRefresh || merged.refreshToken;
-        merged.xmppPassword = rotatedXmppPassword || merged.xmppPassword;
-        merged.fileToken = workingFileToken || merged.fileToken;
       }
       return merged;
     } catch (myError) {
@@ -249,11 +147,6 @@ const tryHydrateViaMy = async (
     }
   } catch (error) {
     if (signal?.aborted || isAbortError(error)) {return null;}
-    // A fatal refresh verdict (reuse detected / token not found / stale
-    // with nothing newer around) carries no HTTP response, so it would
-    // otherwise fall through to `throw` — the session is simply dead,
-    // which for bootstrap means "nothing to restore".
-    if (isRefreshFatalError(error)) {return null;}
     if (isAuthError(error)) {return null;}
     throw error;
   }
@@ -269,15 +162,13 @@ export const resolveInitBeforeLoadUser = async (
     setBaseURL(config.baseUrl, config.customAppToken);
   }
 
-  const myEndpoint = config?.initBeforeLoadAuth?.myEndpoint || '/v1/users/my';
+  const myEndpoint = config?.initBeforeLoadAuth?.myEndpoint || '/users/my';
 
   // Priority 1: explicit userLogin
   const explicitUser = config?.userLogin?.enabled ? config?.userLogin?.user : null;
   if (explicitUser) {
     const candidate = normalizeUserForXmpp(explicitUser);
-    if (candidate && hasXmppCredentials(candidate)) {
-      return await adoptFresherPersistedSession(candidate);
-    }
+    if (candidate && hasXmppCredentials(candidate)) {return candidate;}
 
     const hydrated = await tryHydrateViaMy(explicitUser, myEndpoint, signal).catch(
       () => null
@@ -326,13 +217,13 @@ export const resolveInitBeforeLoadUser = async (
 
   // Priority 5: persisted user in AsyncStorage
   try {
-    const storedUser = await secureUserStorage().get();
+    const storedUser = await asyncLocalStorage<User>(localStorageConstants.ETHORA_USER).get();
     if (storedUser && (storedUser.token || storedUser.refreshToken || storedUser.xmppPassword)) {
       const hydrated = await tryHydrateViaMy(storedUser, myEndpoint, signal).catch(
         () => null
       );
       if (hydrated && hasXmppCredentials(hydrated)) {return hydrated;}
-      await secureUserStorage().remove();
+      await asyncLocalStorage(localStorageConstants.ETHORA_USER).remove();
     }
   } catch {
     // ignore storage errors
@@ -384,7 +275,7 @@ export const refreshUserCredentialsForXmpp = async (
     }
   }
 
-  const myEndpoint = config?.initBeforeLoadAuth?.myEndpoint || '/v1/users/my';
+  const myEndpoint = config?.initBeforeLoadAuth?.myEndpoint || '/users/my';
 
   // Priority 2: redux store user (covers userLogin + customLogin +
   // anything previously persisted into chatSettingStore.user). The
@@ -404,7 +295,9 @@ export const refreshUserCredentialsForXmpp = async (
   // should already mirror this, but if the redux state got cleared
   // mid-session (logout race) this gives us one last shot.
   try {
-    const storedUser = await secureUserStorage().get();
+    const storedUser = await asyncLocalStorage<User>(
+      localStorageConstants.ETHORA_USER
+    ).get();
     if (
       storedUser &&
       (storedUser.token || storedUser.refreshToken || storedUser.xmppPassword)

package/src/helpers/resolveLangSource.ts

@@ -0,0 +1,40 @@
+import { IConfig, Iso639_1Codes } from '../types/types';
+
+/**
+ * Legacy single-locale config (`translates.translations`) seeds langSource
+ * only when the host ACTUALLY set it.
+ *
+ * The condition used to be inverted (`!translates.translations`), so merely
+ * enabling translation fired `setLangSource(undefined)` on every XMPP init
+ * and wiped whatever the reader had picked from the globe — the language
+ * reset itself on every reconnect. Web fixed this; RN had not.
+ */
+export const resolveLegacyTranslatesLangSource = (
+  translatesConfig?: IConfig['translates']
+): Iso639_1Codes | undefined =>
+  translatesConfig?.enabled && translatesConfig?.translations
+    ? translatesConfig.translations
+    : undefined;
+
+/**
+ * A host drives the reader's language from OUTSIDE the component by setting
+ * `config.translates.readerLocale` (their own language switcher, or the
+ * testbed's Setup tab). Nothing was syncing it into `langSource`, so pinning
+ * it only redirected the incoming-translation lookup: the UI captions and
+ * the `<translate source>` on outgoing messages both kept following the
+ * unset `langSource`.
+ *
+ * Unlike web this keeps the FULL locale rather than the base language. RN's
+ * LANGUAGE_OPTIONS are region-tagged (`es-US`, `fr-CA`) because the region
+ * is forwarded to the translation service, and the in-chat picker stores
+ * that full form — so the external path has to store the same thing or the
+ * two would disagree. Caption lookups strip to the base themselves.
+ *
+ * Resolves only when actually set, so a host that leaves it unset never
+ * clobbers what the reader chose for themselves.
+ */
+export const resolveExternalReaderLocaleLangSource = (
+  readerLocale?: string
+): Iso639_1Codes | undefined =>
+  (readerLocale || undefined) as Iso639_1Codes | undefined;
+

package/src/helpers/xmppUsername.ts

@@ -0,0 +1,38 @@
+import { store } from '../roomStore';
+
+/**
+ * Collapse a duplicated `<appId>_` prefix down to one.
+ *
+ * Ported from the web SDK (src/helpers/xmppUsername.ts). Some senders stamp
+ * an already-qualified username and it gets qualified a second time, which
+ * yields `<appId>_<appId>_<userId>` — a key `usersSet` will never match.
+ *
+ * RN reads the appId off the logged-in user's own xmppUsername
+ * (`<appId>_<userId>`) since the chat store has no standalone `appId` field
+ * the way web's does.
+ */
+export const normalizeXmppUsername = (
+  value: string | undefined | null
+): string => {
+  if (!value) {
+    return '';
+  }
+  let result = String(value).trim();
+  if (!result) {
+    return '';
+  }
+
+  const ownXmpp = String(
+    store.getState().chatSettingStore?.user?.xmppUsername || ''
+  );
+  const appId = ownXmpp.includes('_') ? ownXmpp.split('_')[0] : '';
+  if (!appId) {
+    return result;
+  }
+
+  const prefix = `${appId}_`;
+  while (result.startsWith(prefix + prefix)) {
+    result = result.slice(prefix.length);
+  }
+  return result;
+};

package/src/hooks/useChatRoomFocus.ts

@@ -1,17 +1,12 @@
 import { useEffect, useRef } from 'react';
 import { useDispatch } from 'react-redux';
 import {
-  clearReadBoundary,
   clearVisibleRoom,
   setCurrentRoom,
   setLastViewedTimestamp,
   setVisibleRoom,
 } from '../roomStore/roomsSlice';
 import { store } from '../roomStore';
-import {
-  getFlushBoundaryTs,
-  getReadMarkerTimestamp,
-} from '../helpers/getServerReadTimestamp';
 
 interface UseChatRoomFocusOptions {
   /** The room JID that the consumer's tab/screen is currently showing. */
@@ -37,10 +32,7 @@ interface UseChatRoomFocusOptions {
  * Without this hook, `useUnread()` will always return 0 for the chat
  * room because the SDK assumes "mounted == active". With this hook,
  * focus marks the room visible (clearing the badge) and blur stamps
- * `lastViewedTimestamp` to the newest SERVER-acknowledged message so
- * future messages count as unread. Deliberately not `Date.now()`: a
- * device clock running ahead would write a future marker that the
- * forward-only private-store merge could never correct again (bug #38).
+ * `lastViewedTimestamp = Date.now()` so future messages count as unread.
  *
  * Usage with React Navigation:
  *
@@ -66,52 +58,20 @@ export const useChatRoomFocus = ({
     isFocused: false,
   });
 
-  // `clearBoundary`: pass true only when the room the user is leaving is
-  // genuinely being released (switching to a different room, or this
-  // hook unmounting) - not on a mere same-room blur. `<ChatRoom>`'s
-  // MessageList typically stays mounted across a same-room focus loss
-  // (the whole point of this hook is that the host keeps `<Chat>`
-  // mounted in a hidden tab), so its own scroll-tracking ref is still
-  // intact and the redux boundary must stay in sync with it - clearing
-  // it here would desync the two.
-  const leaveRoom = (jid: string, clearBoundary: boolean) => {
-    const state = store.getState();
-    const rooms = state.rooms?.rooms;
-    const boundaryTs = state.rooms?.readBoundaries?.[jid] ?? null;
-    // getReadMarkerTimestamp: honour the boundary (the newest message the
-    // user actually reached) when the user left this room scrolled up,
-    // otherwise fall back to the newest server-acked message. Only stamp
-    // when we actually have something to anchor to - skip rather than
-    // fall back to the device clock (bug #38). Ignoring the boundary here
-    // would stamp "everything read" regardless of scroll position (bug
-    // #42, a regression of #33 reintroduced by #38).
-    const timestamp = getReadMarkerTimestamp(rooms?.[jid], state.roomHeapSlice, boundaryTs);
-    if (timestamp > 0) {
-      dispatch(setLastViewedTimestamp({ chatJID: jid, timestamp }));
-    }
+  const leaveRoom = (jid: string) => {
+    const timestamp = Date.now();
+    dispatch(setLastViewedTimestamp({ chatJID: jid, timestamp }));
     dispatch(clearVisibleRoom());
-    (state.chatSettingStore as any)?.client
-      ?.flushLastViewedToPrivateStoreStanza(rooms, {
-        visibleRoomJID: jid,
-        // Carry the same boundary to the SERVER marker - without it the
-        // flush defaults to "everything" for the visible room. Clamped
-        // through the same helper as the local stamp above.
-        visibleRoomTs: getFlushBoundaryTs(
-          rooms?.[jid],
-          state.roomHeapSlice,
-          boundaryTs
-        ),
-      })
+    const rooms = store.getState().rooms?.rooms;
+    (store.getState().chatSettingStore as any)?.client
+      ?.flushLastViewedToPrivateStoreStanza(rooms, { visibleRoomJID: jid })
       .catch(() => {});
-    if (clearBoundary) {
-      dispatch(clearReadBoundary({ jid }));
-    }
   };
 
   useEffect(() => {
     const prev = prevRef.current;
     if (prev.isFocused && prev.roomJID && (prev.roomJID !== roomJID || !isFocused)) {
-      leaveRoom(prev.roomJID, prev.roomJID !== roomJID);
+      leaveRoom(prev.roomJID);
     }
 
     if (roomJID && isFocused) {
@@ -126,7 +86,7 @@ export const useChatRoomFocus = ({
     return () => {
       const prev = prevRef.current;
       if (prev.isFocused && prev.roomJID) {
-        leaveRoom(prev.roomJID, true);
+        leaveRoom(prev.roomJID);
       }
     };
   }, []);