@ethora/chat-component-rn 26.8.5 → 26.8.7

package/src/e2ee/send.ts

@@ -0,0 +1,70 @@
+import type { Client } from '@xmpp/client';
+import type { Element } from 'ltx';
+import {
+  accountDomain,
+  isE2eeEnabled,
+  isE2eeRoom,
+  omemoReady,
+  resolveRecipients,
+} from './index';
+
+export function shouldEncrypt(roomJID: string): boolean {
+  return isE2eeEnabled() && isE2eeRoom(roomJID);
+}
+
+let queue: Promise<void> = Promise.resolve();
+
+export function sendEncrypted(
+  client: Client,
+  roomJID: string,
+  id: string,
+  data: Element,
+  body: Element,
+  plain: Element
+): void {
+  queue = queue.then(async () => {
+    let stanza = plain;
+    try {
+      const crypto = await omemoReady();
+      if (!crypto) {throw new Error('omemo_not_ready');}
+      const recipients = await resolveRecipients(roomJID, accountDomain(client));
+      stanza = await crypto.encryptGroupMessage(roomJID, recipients, [body], id, [data]);
+    } catch (error) {
+      const reason = String((error as Error)?.message || error);
+      if (reason.startsWith('omemo_members_unknown')) {
+        console.warn(`OMEMO: not sending to ${roomJID} - ${reason}`);
+        return;
+      }
+      console.warn(`OMEMO: sending to ${roomJID} in clear - ${reason}`);
+    }
+    try {
+      await client.send(stanza);
+    } catch (error) {
+      console.error('An error occurred while sending message:', error);
+    }
+  });
+}
+
+export function sendSealedMedia(
+  client: Client,
+  roomJID: string,
+  id: string,
+  body: Element,
+  cleartext: Element[]
+): void {
+  queue = queue.then(async () => {
+    try {
+      const crypto = await omemoReady();
+      if (!crypto) {throw new Error('omemo_not_ready');}
+      const recipients = await resolveRecipients(roomJID, accountDomain(client));
+      const stanza = await crypto.encryptGroupMessage(roomJID, recipients, [body], id, cleartext);
+      await client.send(stanza);
+    } catch (error) {
+      console.error(
+        `OMEMO: refusing to send sealed attachment to ${roomJID} - ${String(
+          (error as Error)?.message || error
+        )}`
+      );
+    }
+  });
+}

package/src/e2ee/stanza.ts

@@ -0,0 +1,133 @@
+import { Element, parse } from 'ltx';
+import { store } from '../roomStore';
+import { translateKey } from '../i18n/strings';
+import { NS_OMEMO } from './ns';
+import { omemoReady, senderJidFromMuc } from './index';
+
+export type DecryptOutcome =
+  | 'not-encrypted'
+  | 'decrypted'
+  | 'undecryptable'
+  | 'drop';
+
+export type E2eeError =
+  | 'unsupported'
+  | 'other-device'
+  | 'failed';
+
+const READY_TIMEOUT_MS = 8000;
+
+export function encryptedCarrier(
+  stanza: Element,
+  depth = 0
+): Element | undefined {
+  if (depth > 4 || !stanza?.getChild) {return undefined;}
+  if (stanza.name === 'message' && stanza.getChild('encrypted', NS_OMEMO)) {
+    return stanza;
+  }
+  for (const child of stanza.children ?? []) {
+    if (typeof child === 'string') {continue;}
+    const found = encryptedCarrier(child as Element, depth + 1);
+    if (found) {return found;}
+  }
+  return undefined;
+}
+
+const PLACEHOLDER_KEY: Record<E2eeError, string> = {
+  unsupported: 'e2ee.unsupportedMessage',
+  'other-device': 'e2ee.otherDevice',
+  failed: 'e2ee.undecryptable',
+};
+
+export function placeholderKey(error?: string): string {
+  return PLACEHOLDER_KEY[error as E2eeError] ?? PLACEHOLDER_KEY.failed;
+}
+
+function placeholder(error: E2eeError): Element {
+  const settings = store.getState()?.chatSettingStore;
+  return new Element('body', {}).t(
+    translateKey(
+      placeholderKey(error),
+      settings?.config?.i18n?.locale || settings?.langSource,
+      settings?.config?.i18n?.strings
+    )
+  );
+}
+
+function mark(carrier: Element, error?: E2eeError): void {
+  let data = carrier.getChild('data');
+  if (!data) {
+    data = new Element('data', {});
+    carrier.append(data);
+  }
+  data.attrs.omemoEncrypted = 'true';
+  if (error) {
+    data.attrs.undecryptable = 'true';
+    data.attrs.e2eeError = error;
+  }
+}
+
+function strip(carrier: Element): void {
+  carrier.remove('encrypted', NS_OMEMO);
+  carrier.remove('encryption', 'urn:xmpp:eme:0');
+  carrier.remove('body');
+}
+
+function close(carrier: Element, error: E2eeError): DecryptOutcome {
+  strip(carrier);
+  carrier.append(placeholder(error));
+  mark(carrier, error);
+  return 'undecryptable';
+}
+
+export function rewriteEncryptedStanza(stanza: Element): DecryptOutcome {
+  const carrier = encryptedCarrier(stanza);
+  if (!carrier) {return 'not-encrypted';}
+  const encrypted = carrier.getChild('encrypted', NS_OMEMO);
+  if (!encrypted?.getChild('payload')) {return 'drop';}
+  return close(carrier, 'unsupported');
+}
+
+const waitForDevice = () => {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const timeout = new Promise<undefined>((resolve) => {
+    timer = setTimeout(() => resolve(undefined), READY_TIMEOUT_MS);
+  });
+  return Promise.race([omemoReady(), timeout]).finally(() => {
+    if (timer) {clearTimeout(timer);}
+  });
+};
+
+export async function decryptStanzaInPlace(
+  stanza: Element,
+  domain: string
+): Promise<DecryptOutcome> {
+  const carrier = encryptedCarrier(stanza);
+  if (!carrier) {return 'not-encrypted';}
+
+  const encrypted = carrier.getChild('encrypted', NS_OMEMO);
+  if (!encrypted?.getChild('payload')) {return 'drop';}
+
+  const from = String(carrier.attrs?.from || '');
+  const roomJid = from.split('/')[0]!;
+  const sender = senderJidFromMuc(from, domain);
+  const crypto = await waitForDevice();
+  const decrypted = sender
+    ? await crypto?.decrypt(carrier, sender, roomJid)
+    : undefined;
+
+  if (!decrypted?.content) {
+    return close(
+      carrier,
+      decrypted?.error === 'omemo_not_encrypted_for_this_device'
+        ? 'other-device'
+        : 'failed'
+    );
+  }
+
+  strip(carrier);
+  const wrapper = parse(`<omemo-content>${decrypted.content}</omemo-content>`);
+  carrier.append(...wrapper.children);
+  mark(carrier);
+  return 'decrypted';
+}

package/src/e2ee/store.ts

@@ -0,0 +1,54 @@
+import { fromBase64, toBase64 } from './crypto';
+
+export interface OmemoStore {
+  get<T>(key: string): Promise<T | undefined>;
+  set(key: string, value: unknown): Promise<void>;
+  delete(key: string): Promise<void>;
+}
+
+const BYTES_TAG = '$bytes';
+
+export function encodeValue(value: unknown): string {
+  return JSON.stringify(value, (_key, item) =>
+    item instanceof Uint8Array ? { [BYTES_TAG]: toBase64(item) } : item
+  );
+}
+
+export function decodeValue<T>(text: string): T {
+  return JSON.parse(text, (_key, item) =>
+    item && typeof item === 'object' && typeof item[BYTES_TAG] === 'string'
+      ? fromBase64(item[BYTES_TAG])
+      : item
+  ) as T;
+}
+
+export interface StringBackend {
+  getItem(key: string): Promise<string | null>;
+  setItem(key: string, value: string): Promise<void>;
+  removeItem(key: string): Promise<void>;
+}
+
+export function createStore(backend: StringBackend, jid: string): OmemoStore {
+  const prefix = `${jid.toLowerCase()}|`;
+  return {
+    get: async <T>(key: string) => {
+      const raw = await backend.getItem(prefix + key);
+      return raw === null ? undefined : decodeValue<T>(raw);
+    },
+    set: (key, value) => backend.setItem(prefix + key, encodeValue(value)),
+    delete: (key) => backend.removeItem(prefix + key),
+  };
+}
+
+export function createMemoryBackend(): StringBackend {
+  const data = new Map<string, string>();
+  return {
+    getItem: async (key) => data.get(key) ?? null,
+    setItem: async (key, value) => void data.set(key, value),
+    removeItem: async (key) => void data.delete(key),
+  };
+}
+
+export function createMemoryStore(jid = 'memory'): OmemoStore {
+  return createStore(createMemoryBackend(), jid);
+}

package/src/helpers/accountName.ts

@@ -0,0 +1,15 @@
+export const accountNameOf = (
+  user:
+    | { xmppUsername?: string; userJID?: string; id?: string; _id?: string }
+    | null
+    | undefined,
+  appId: string
+): string => {
+  for (const raw of [user?.xmppUsername, user?.userJID, user?.id, user?._id]) {
+    const value = String(raw || '').split('@')[0]!.trim();
+    if (!value) {continue;}
+    if (value.includes('_')) {return value;}
+    if (appId) {return `${appId}_${value}`;}
+  }
+  return '';
+};

package/src/helpers/createMessageFromXml.ts

@@ -1,4 +1,7 @@
 import { IMessage } from '../types/types';
+import { isE2eeRoom } from '../e2ee';
+import { composeName } from './displayName';
+import { parseSealedMediaBody } from '../e2ee/sealedBody';
 
 interface IMessageWithNewData extends IMessage {
   [x: string]: any;
@@ -86,13 +89,25 @@ export const createMessageFromXml = async (
   // Synthesize user.name from sender attrs (web reads usersSet from
   // redux in <Message>; we fix it once at the source so Avatar /
   // MessageHeader render the actual sender instead of "??").
-  const firstName = (merged.senderFirstName || '').toString().trim();
-  const lastName = (merged.senderLastName || '').toString().trim();
+  const firstName = (merged.senderFirstName || merged.firstName || '')
+    .toString()
+    .trim();
+  const lastName = (merged.senderLastName || merged.lastName || '')
+    .toString()
+    .trim();
   const fullName = (merged.fullName || '').toString().trim();
   const senderJID = (merged.senderJID || '').toString();
-  const senderLocal = senderJID.includes('@')
-    ? senderJID.split('@')[0]
-    : senderJID;
+  const senderBare = senderJID.split('/')[0] || '';
+  const senderResource = senderJID.includes('/') ? senderJID.split('/')[1] || '' : '';
+  const senderIsOccupant =
+    !!senderResource &&
+    (senderBare === String(merged.roomJid || '') ||
+      /@conference\./i.test(senderBare));
+  const senderLocal = senderIsOccupant
+    ? senderResource
+    : senderBare.includes('@')
+      ? senderBare.split('@')[0]
+      : senderBare;
 
   // Bug #41 root cause: the resource of the MUC `from` (room@conference/
   // occupant-id) is the SAME field getDataFromXml uses to derive
@@ -112,7 +127,7 @@ export const createMessageFromXml = async (
   const xmppFrom = (merged.xmppFrom || '').toString();
   const fromResource = xmppFrom.includes('/') ? xmppFrom.split('/')[1] : '';
 
-  const composed = [firstName, lastName].filter(Boolean).join(' ').trim();
+  const composed = composeName(firstName, lastName);
   const existingName = String(merged?.user?.name || '').trim();
   const resolvedName =
     existingName ||
@@ -122,8 +137,18 @@ export const createMessageFromXml = async (
     merged?.user?.id ||
     '';
 
+  const unencrypted =
+    merged.omemoEncrypted !== 'true' && isE2eeRoom(String(merged.roomJid || ''));
+
+  const sealedKeys =
+    merged.clientEncrypted === 'true'
+      ? parseSealedMediaBody(merged.body)
+      : undefined;
+
   const message: IMessage = {
     ...merged,
+    ...(unencrypted ? { unencrypted: true } : {}),
+    ...(sealedKeys ? { e2eeKeys: sealedKeys, body: 'media' } : {}),
     user: {
       ...(merged.user || {}),
       id: merged?.user?.id || fromResource || senderLocal,

package/src/helpers/createRoomFromApi.tsx

@@ -1,4 +1,36 @@
 import { ApiRoom, IRoom } from '../types/types';
+import type { LastMessage } from '../types/models/message.model';
+
+const mapApiLastMessage = (
+  apiLastMessage: ApiRoom['lastMessage'],
+  roomJid: string
+): LastMessage | undefined => {
+  const body = String(apiLastMessage?.body || '').trim();
+  if (!apiLastMessage || !body) {return undefined;}
+  const senderName = `${apiLastMessage.senderFirstName || ''} ${
+    apiLastMessage.senderLastName || ''
+  }`.trim();
+  return {
+    id: apiLastMessage.messageId || apiLastMessage.stanzaId || '',
+    xmppId: apiLastMessage.stanzaId,
+    roomJid,
+    body,
+    date: apiLastMessage.createdAt,
+    isDeleted: false,
+    user: {
+      id: apiLastMessage.fromUserId || apiLastMessage.from || '',
+      name: senderName,
+    },
+  } as LastMessage;
+};
+
+const seedTimestamp = (seed: LastMessage | undefined): number | undefined => {
+  if (!seed) {return undefined;}
+  const id = Number(seed.id);
+  if (Number.isFinite(id) && id > 0) {return id;}
+  const ms = seed.date ? new Date(seed.date).getTime() : NaN;
+  return Number.isFinite(ms) && ms > 0 ? ms * 1000 : undefined;
+};
 
 export const createRoomFromApi = (
   room: ApiRoom,
@@ -6,10 +38,12 @@ export const createRoomFromApi = (
   usersArrayLength: number = 0
 ): IRoom | null => {
   try {
+    const jid = `${room?.name}@${service}` || '';
+    const lastMessage = mapApiLastMessage(room?.lastMessage, jid);
     const roomData: IRoom = {
       ...room,
       id: (room as any)?._id || '',
-      jid: `${room?.name}@${service}` || '',
+      jid,
       name: room?.title || '',
       title: room?.title || '',
       usersCnt: Number(room?.members?.length || usersArrayLength + 1),
@@ -19,6 +53,8 @@ export const createRoomFromApi = (
       icon: room?.picture !== 'none' ? room?.picture : null,
       unreadMessages: 0,
       lastViewedTimestamp: 0,
+      lastMessage,
+      lastMessageTimestamp: seedTimestamp(lastMessage),
     };
     return roomData;
   } catch (error) {

package/src/helpers/createUserNameFromSetUser.ts

@@ -1,4 +1,5 @@
 import { IMessage, RoomMember } from '../types/types';
+import { composeName } from './displayName';
 
 /**
  * Cache-only lookup. Returns the literal "Deleted User" as a MISS sentinel
@@ -21,7 +22,7 @@ export const createUserNameFromSetUser = (
   // fall back to that before giving up and returning the raw id.
   const bareName = user.name?.trim() || '';
 
-  return `${firstName} ${lastName}`.trim() || bareName || userId;
+  return composeName(firstName, lastName) || bareName || userId;
 };
 
 /**

package/src/helpers/displayName.ts

@@ -0,0 +1,9 @@
+export const composeName = (
+  first?: string | null,
+  last?: string | null
+): string => {
+  const f = String(first ?? '').trim();
+  const l = String(last ?? '').trim();
+  if (f && f.includes('@') && f.toLowerCase() === l.toLowerCase()) {return f;}
+  return `${f} ${l}`.trim();
+};

package/src/helpers/emoji.ts

@@ -0,0 +1,39 @@
+import { EMOJI_CATEGORIES, type EmojiEntry } from '../assets/emojiData';
+
+let byId: Map<string, EmojiEntry> | null = null;
+const index = (): Map<string, EmojiEntry> => {
+  if (!byId) {
+    byId = new Map();
+    for (const category of EMOJI_CATEGORIES) {
+      for (const entry of category.emojis) {byId.set(entry[0], entry);}
+    }
+  }
+  return byId;
+};
+
+export const getEmojiNativeById = (id: string): string =>
+  index().get(id)?.[1] ?? id;
+
+export const getEmojiIdByNative = (native: string): string | undefined => {
+  for (const [id, entry] of index()) {
+    if (entry[1] === native) {return id;}
+  }
+  return undefined;
+};
+
+export const DEFAULT_QUICK_REACTIONS = ['+1', 'heart', 'joy', 'open_mouth', 'cry', 'pray'];
+
+export const searchEmojis = (query: string, limit = 60): EmojiEntry[] => {
+  const q = query.trim().toLowerCase();
+  if (!q) {return [];}
+  const out: EmojiEntry[] = [];
+  for (const category of EMOJI_CATEGORIES) {
+    for (const entry of category.emojis) {
+      if (entry[0].includes(q) || entry[2].includes(q)) {
+        out.push(entry);
+        if (out.length >= limit) {return out;}
+      }
+    }
+  }
+  return out;
+};

package/src/helpers/haptics.ts

@@ -0,0 +1,19 @@
+// expo-haptics is an OPTIONAL peer, probed the same way as expo-blur: the JS
+// package alone is not enough, the native module has to be in the binary,
+// otherwise the call throws. Without it the gesture simply has no feedback.
+let Haptics: any = null;
+try {
+  const { requireNativeModule } = require('expo-modules-core');
+  requireNativeModule('ExpoHaptics');
+  Haptics = require('expo-haptics');
+} catch {
+  Haptics = null;
+}
+
+/** Short tap, the messenger "I got your long-press" feedback. Never throws. */
+export const hapticTap = () => {
+  if (!Haptics) {
+    return;
+  }
+  Haptics.impactAsync?.(Haptics.ImpactFeedbackStyle?.Medium).catch?.(() => {});
+};

package/src/helpers/historyPreloadScheduler.ts

@@ -15,6 +15,7 @@ interface HistoryPreloadSchedulerOptions {
   pageSize?: number;
   retryLimit?: number;
   roomLimit?: number;
+  firstWave?: number;
   selectedRoomJid?: string | null;
   defaultRoomJids?: string[];
   forceReload?: boolean;
@@ -29,21 +30,15 @@ interface QueueItem {
 }
 
 const DEFAULT_CONCURRENCY = 3;
-// Fetch the most recent ~20 on re-entry (mirrors web). A larger first page
-// also means more id-overlap with cache, so the merge in
-// `mergeHistoryIntoCache` rarely has to fall back to clear-and-replace.
-const DEFAULT_PAGE_SIZE = 20;
+const DEFAULT_PAGE_SIZE = 10;
 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 DEFAULT_FIRST_WAVE = 30;
+const BACKGROUND_BATCH_PAUSE_MS = 400;
 
 const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
 
+declare const __DEV__: boolean | undefined;
+
 const messageTimestamp = (m: IMessage): number => {
   if (!m) {return 0;}
   const t = (m as any).timestamp;
@@ -54,8 +49,12 @@ const messageTimestamp = (m: IMessage): number => {
 };
 
 const getRoomLastActivityScore = (room: IRoom): number => {
-  if (!room?.messages?.length) {return 0;}
-  return room.messages.reduce((max, m) => Math.max(max, messageTimestamp(m)), 0);
+  const fromMessages = room?.messages?.length
+    ? room.messages.reduce((max, m) => Math.max(max, messageTimestamp(m)), 0)
+    : 0;
+  const fromStamp = Number(room?.lastMessageTimestamp) || 0;
+  const fromSeed = Number(room?.lastMessage?.id) || 0;
+  return Math.max(fromMessages, fromStamp, fromSeed);
 };
 
 const computeUnreadCapped = (
@@ -73,7 +72,10 @@ const computeUnreadCapped = (
   if (countable.length < pageSize) {return false;}
 
   const lastViewed = Number(room.lastViewedTimestamp) || 0;
-  if (lastViewed <= 0) {return true;}
+  // No read marker yet (the private-store markers often land after the
+  // first preload page): the count is unknown, not "more than a page".
+  // Claiming capped here showed "10+" on rooms with a single unread.
+  if (lastViewed <= 0) {return false;}
 
   const oldestTs = countable.reduce<number>((minTs, m) => {
     const ts = messageTimestamp(m);
@@ -116,6 +118,7 @@ export const runHistoryPreloadScheduler = async (
     pageSize = DEFAULT_PAGE_SIZE,
     retryLimit = DEFAULT_RETRY_LIMIT,
     roomLimit,
+    firstWave = DEFAULT_FIRST_WAVE,
     selectedRoomJid = null,
     defaultRoomJids = [],
     forceReload = false,
@@ -123,6 +126,12 @@ export const runHistoryPreloadScheduler = async (
 
   if (signal?.aborted) {return;}
 
+  const startedAt = Date.now();
+  let firstWaveLogged = false;
+  const devLog = (msg: string) => {
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {console.log(msg);}
+  };
+
   store.dispatch(setUnreadSyncing(true));
   try {
 
@@ -153,6 +162,10 @@ export const runHistoryPreloadScheduler = async (
 
   const inFlightByRoom = new Map<string, Promise<void>>();
   let consecutiveErrorCount = 0;
+  let started = 0;
+  devLog(
+    `[preload] ${queue.length} rooms queued, first wave ${Math.min(firstWave, queue.length)}, page ${pageSize}`
+  );
 
   while (queue.length > 0) {
     if (signal?.aborted) {return;}
@@ -176,6 +189,12 @@ export const runHistoryPreloadScheduler = async (
     }
 
     const batch = readyItems.slice(0, Math.max(1, concurrency));
+    const inBackgroundWave = started >= firstWave;
+    if (inBackgroundWave && !firstWaveLogged) {
+      firstWaveLogged = true;
+      devLog(`[preload] first wave done in ${Date.now() - startedAt}ms`);
+    }
+    started += batch.length;
 
     // Snapshot each room's historyPreloadState BEFORE marking the
     // batch as 'loading'. Without this snapshot the per-task
@@ -229,6 +248,7 @@ export const runHistoryPreloadScheduler = async (
                 coalesceRoom: true,
                 skipIfPreloaded: !forceReload,
                 source: 'background',
+                selfApplied: true,
               }
             );
             if (signal?.aborted) {return;}
@@ -237,59 +257,7 @@ 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;
-                }
-              }
-            }
+            const combined: IMessage[] = fetchedMessages || [];
 
             // `mergeHistoryIntoCache` (roomsSlice) caps whatever we dispatch
             // here to the newest RUNTIME_MESSAGE_LIMIT messages before it
@@ -353,10 +321,10 @@ export const runHistoryPreloadScheduler = async (
       })
     );
 
-    // Yield to JS event loop (no requestIdleCallback in RN).
-    await new Promise((r) => setTimeout(r, 0));
+    await sleep(inBackgroundWave ? BACKGROUND_BATCH_PAUSE_MS : 0);
   }
   } finally {
+    devLog(`[preload] finished in ${Date.now() - startedAt}ms`);
     store.dispatch(setUnreadSyncing(false));
   }
 };