@ethora/chat-component-rn 26.9.1 → 26.10.1

package/src/networking/xmpp/mamRouter.ts

@@ -14,6 +14,29 @@ interface PendingQuery {
   reject: (error: Error) => void;
 }
 
+/**
+ * Replay an archived reaction into the store. Flagged `fromHistory` so
+ * reactionsMiddleware leaves the room preview alone: a replay must not turn
+ * the last real message into an emoji. (setReactions has no prepare(), so
+ * the flag is added by hand.)
+ */
+export const replayArchivedReaction = (
+  reaction: ExtractedReaction,
+  fallbackRoomJID = ''
+) => {
+  store.dispatch({
+    ...setReactions({
+      roomJID: reaction.roomJID || fallbackRoomJID,
+      messageId: reaction.messageId,
+      from: reaction.from,
+      reactions: reaction.emoji,
+      data: reaction.data,
+      latestReactionTimestamp: reaction.ts,
+    }),
+    meta: { fromHistory: true },
+  });
+};
+
 const pending = new Map<string, PendingQuery>();
 
 const flush = (query: PendingQuery) => {
@@ -39,16 +62,7 @@ const flush = (query: PendingQuery) => {
   }
   for (const reaction of deferred) {
     try {
-      store.dispatch(
-        setReactions({
-          roomJID: reaction.roomJID || query.roomJID,
-          messageId: reaction.messageId,
-          from: reaction.from,
-          reactions: reaction.emoji,
-          data: reaction.data,
-          latestReactionTimestamp: reaction.ts,
-        })
-      );
+      replayArchivedReaction(reaction, query.roomJID);
     } catch (e) {
       console.warn('[mam] applying a reaction failed', e);
     }

package/src/networking/xmpp/presenceInRoom.xmpp.ts

@@ -1,67 +1,66 @@
 import { Client, xml } from '@xmpp/client';
-import { createTimeoutPromise } from './createTimeoutPromise.xmpp';
 import { Element } from '@xmpp/xml';
 
+// A bare `local@domain.tld`. The conference prefix is NOT required here (a
+// host may run its MUC service on a custom domain, xmppSettings.conference);
+// callers that fan out over the room list filter with isLikelyMucJid first.
+const isValidRoomJid = (jid: unknown): jid is string => {
+  if (typeof jid !== 'string') {return false;}
+  const at = jid.indexOf('@');
+  if (at <= 0) {return false;}
+  const domain = jid.slice(at + 1).split('/')[0];
+  return !!domain;
+};
+
 let presenceIdCounter = 0;
 const nextPresenceId = () =>
   `presenceInRoom-${Date.now().toString(36)}-${(++presenceIdCounter).toString(36)}`;
 
-const joinedByClient = new WeakMap<Client, Map<string, Promise<Element>>>();
-
-const joinedRooms = (client: Client): Map<string, Promise<Element>> => {
-  let map = joinedByClient.get(client);
-  if (!map) {
-    map = new Map();
-    joinedByClient.set(client, map);
-    const forget = () => joinedByClient.get(client)?.clear();
-    client.on('disconnect', forget);
-    client.on('offline', forget);
-  }
-  return map;
-};
-
-export const __forgetJoinedRooms = (client: Client) =>
-  joinedByClient.get(client)?.clear();
-
-export const presenceInRoom = (
-  client: Client,
-  roomJID: string,
-  delay = 0
-): Promise<Element> => {
-  const joined = joinedRooms(client);
-  const existing = joined.get(roomJID);
-  if (existing) {return existing;}
-  const join = joinRoom(client, roomJID, delay);
-  joined.set(roomJID, join);
-  // A failed join is not a join: let the next caller try again.
-  join.catch(() => {
-    if (joined.get(roomJID) === join) {joined.delete(roomJID);}
-  });
-  return join;
-};
-
-const joinRoom = async (
+/**
+ * Sends the MUC join presence for `roomJID` and resolves with the room's
+ * answer. Rejects with `presence_error:<code>:<jid>` on an error presence,
+ * `presence_timeout:<jid>` when nothing answers within `timeoutMs`, and
+ * `presence_send_failed:<jid>:...` when the stanza could not be written.
+ *
+ * `delay` is an optional extra wait after the answer. It used to be a fixed
+ * 2 s: the join answer arrives BEFORE the server's replay of the room history
+ * (default up to 20 stanzas), and callers waited for that replay to settle.
+ * The join now asks for `historyStanzas` (default 0) so nothing is replayed
+ * (history comes from MAM), and the default settle delay is 0.
+ */
+export const presenceInRoom = async (
   client: Client,
   roomJID: string,
-  delay: number
+  delay = 0,
+  timeoutMs = 2000,
+  // How many of the room's recent messages the MUC service replays on join
+  // (XEP-0045 <history maxstanzas/>). Default 0: history comes from MAM only.
+  // Without the element the server replays its default (ejabberd: up to 20
+  // stanzas) for EVERY room joined: N rooms * 20 messages of wire traffic
+  // that MAM then fetches again.
+  historyStanzas = 0
 ): Promise<Element> => {
+  if (!isValidRoomJid(roomJID)) {
+    return Promise.reject(
+      new Error(`presence_invalid_jid:${String(roomJID)}`)
+    );
+  }
   let stanzaHandler: (stanza: Element) => void;
-  const unsubscribe = () => client.off('stanza', stanzaHandler);
+
+  const unsubscribe = () => client?.off?.('stanza', stanzaHandler);
   const stanzaId = nextPresenceId();
 
-  // Avoid `new Promise(async (resolve, reject) => …)` — the async
-  // executor's own thrown errors / unhandled rejections inside it can
-  // escape the constructed promise depending on the order of catch
-  // attachment vs rejection. Use a regular Promise + a separate async
-  // wrapper that funnels every failure path through reject().
   return new Promise<Element>((resolve, reject) => {
     let settled = false;
+    // Cleared as soon as the promise settles by any other path, so the
+    // timeout timer doesn't linger after we already know the outcome.
+    let cancelTimeout: (() => void) | null = null;
 
     const finish = (cb: (value?: any) => void, value?: any) => {
       if (settled) {return;}
       settled = true;
-
-      if (delay <= 0) {
+      cancelTimeout?.();
+      if (!(delay > 0)) {
         unsubscribe();
         cb(value);
         return;
@@ -78,6 +77,26 @@ const joinRoom = async (
         stanza.attrs.id === stanzaId &&
         stanza.attrs.from?.startsWith(roomJID)
       ) {
+        if (stanza.attrs.type === 'error') {
+          const errEl = stanza.getChild('error');
+          const code =
+            (errEl &&
+              (errEl.getChild('forbidden')
+                ? 'forbidden'
+                : errEl.getChild('remote-server-not-found')
+                  ? 'remote-server-not-found'
+                  : errEl.getChild('not-allowed')
+                    ? 'not-allowed'
+                    : errEl.getChild('item-not-found')
+                      ? 'item-not-found'
+                      : errEl.attrs?.type || 'unknown')) ||
+            'unknown';
+          settled = true;
+          cancelTimeout?.();
+          unsubscribe();
+          reject(new Error(`presence_error:${code}:${roomJID}`));
+          return;
+        }
         finish(resolve, stanza);
       }
     };
@@ -94,32 +113,36 @@ const joinRoom = async (
       xml(
         'x',
         { xmlns: 'http://jabber.org/protocol/muc' },
-        xml('history', { maxstanzas: '0' })
+        xml('history', {
+          maxstanzas: String(
+            Number.isFinite(historyStanzas) && historyStanzas > 0
+              ? Math.floor(historyStanzas)
+              : 0
+          ),
+        })
       )
     );
 
-    // Side-effects sequence: send the presence (handles its own
-    // failure → reject), then wait the timeout (also handles its own
-    // failure → reject). Each chain attaches its rejection handler
-    // synchronously, so no race with the outer Promise's catch.
-    (async () => {
-      try {
-        await client.send(presence);
-      } catch (err) {
+    Promise.resolve(client.send(presence))
+      .then(() => {
+        // The answer may already have arrived while send() was settling.
+        if (settled) {return;}
+        const timer = setTimeout(() => {
+          if (settled) {return;}
+          settled = true;
+          unsubscribe();
+          reject(new Error(`presence_timeout:${roomJID}`));
+        }, timeoutMs);
+        cancelTimeout = () => clearTimeout(timer);
+      })
+      .catch((err) => {
         unsubscribe();
-        reject(err);
-        return;
-      }
-      try {
-        await createTimeoutPromise(2000, unsubscribe);
-      } catch (err) {
-        // The room's reply schedules resolve() `delay` ms later (2000 by
-        // default) — the same length as this timeout, so the timeout used
-        // to win the race and reject a join that had actually succeeded
-        // (allRoomPresences "failed" with undefined on every bootstrap).
-        // Only a join that never got an answer is a failure.
-        if (!settled) {reject(err);}
-      }
-    })();
+        settled = true;
+        reject(
+          new Error(
+            `presence_send_failed:${roomJID}:${err instanceof Error ? err.message : String(err)}`
+          )
+        );
+      });
   });
 };

package/src/networking/xmpp/roomJoinSweep.ts

@@ -0,0 +1,412 @@
+import type { Client } from '@xmpp/client';
+import { store } from '../../roomStore';
+import { presenceInRoom } from './presenceInRoom.xmpp';
+import {
+  allRoomPresences,
+  AllRoomPresenceSummary,
+} from './allRoomPresences.xmpp';
+import { isLikelyMucJid } from '../../helpers/isLikelyMucJid';
+import { getRoomLastActivityScore } from '../../helpers/roomActivityScore';
+import type { HistoryQoSConfig } from '../../types/types';
+
+/**
+ * The slice of XmppClient the join manager needs. Keeping it an interface
+ * keeps this file free of an import cycle with xmppClient.ts.
+ */
+export interface RoomJoinHost {
+  /** The underlying @xmpp/client (changes on every reconnect). */
+  getClient: () => Client | undefined;
+  /** Bumped on every disconnect / reconnect / close. */
+  getConnectionEpoch: () => number;
+  /** True while the stream is online (join then needs no wait). */
+  isOnline?: () => boolean;
+  /** Resolves when the stream is online, rejects on timeout. */
+  waitForOnline: (timeoutMs?: number) => Promise<void>;
+  /** MUC conference domain of this server (custom domains allowed). */
+  getConference?: () => string;
+  getHistoryQoS: () => HistoryQoSConfig | undefined;
+}
+
+export interface EnsureRoomPresenceOptions {
+  /** Extra wait after the room answered. Default 0. */
+  settleDelay?: number;
+  /** How long this caller waits for the join. Default 2000. */
+  timeoutMs?: number;
+  /** false: fire the join and return true at once. Default true. */
+  waitForJoin?: boolean;
+  source?: 'active_room' | 'send' | 'background' | 'other';
+}
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+export const SWEEP_RETRY_DELAYS_MS = [2000, 5000, 10000];
+const DEFAULT_JOIN_CONCURRENCY = 5;
+const DEFAULT_FAILURE_BACKOFF_MS = 10000;
+
+const formatError = (error: unknown): string =>
+  error instanceof Error ? error.message : String(error);
+
+const emptySummary = (): AllRoomPresenceSummary => ({
+  total: 0,
+  success: 0,
+  failed: 0,
+  failedRooms: [],
+  sweptRooms: [],
+  failures: [],
+});
+
+/**
+ * Per-connection MUC join state and the background join sweep.
+ *
+ * Why it exists: the RN client used to join every room with a Promise.all
+ * and only then call the session ready, so the room list waited for the
+ * slowest of N joins and a join in flight when the socket dropped could
+ * poison the next connection. Here joins go through one dedup layer
+ * (ensureRoomPresence), the sweep is a bounded pool that runs in the
+ * background (active room first, then by recent activity), and every join
+ * remembers the connection epoch it started on: when the socket was
+ * replaced meanwhile its outcome is discarded (no joined mark, no backoff).
+ *
+ * `presencesReady` means the whole sweep finished, `priorityPresencesReady`
+ * that its first wave (active room + one pool width) settled.
+ */
+export class RoomJoinManager {
+  presencesReady = false;
+  priorityPresencesReady = false;
+  joinedRooms: Set<string> = new Set();
+  roomPresenceInFlight: Map<string, Promise<boolean>> = new Map();
+  roomPresenceBlockedUntil: Map<string, number> = new Map();
+  sweepRetryTimer: ReturnType<typeof setTimeout> | null = null;
+  private sweepRetryRunning = false;
+  private sendAllPresencesInFlight: Promise<void> | null = null;
+
+  constructor(private readonly host: RoomJoinHost) {}
+
+  // ---- config -------------------------------------------------------
+  private qos(): HistoryQoSConfig {
+    const own = this.host.getHistoryQoS() || {};
+    let fromConfig: HistoryQoSConfig = {};
+    try {
+      fromConfig =
+        (store.getState() as any)?.chatSettingStore?.config?.historyQoS || {};
+    } catch {
+      fromConfig = {};
+    }
+    return { ...fromConfig, ...own };
+  }
+
+  get joinConcurrency(): number {
+    return Math.max(
+      1,
+      Math.floor(Number(this.qos().joinConcurrency) || DEFAULT_JOIN_CONCURRENCY)
+    );
+  }
+
+  get joinHistoryStanzas(): number {
+    return Math.max(0, Math.floor(Number(this.qos().joinHistoryStanzas) || 0));
+  }
+
+  private get failureBackoffMs(): number {
+    return Math.max(
+      0,
+      Number(this.qos().presenceFailureBackoffMs || DEFAULT_FAILURE_BACKOFF_MS)
+    );
+  }
+
+  private get epoch(): number {
+    return this.host.getConnectionEpoch();
+  }
+
+  // A room the sweep may fan out over: a conference-domain JID (or the
+  // server's own, possibly custom, conference domain).
+  private isValidRoomJid(jid: unknown): jid is string {
+    if (isLikelyMucJid(jid)) {return true;}
+    if (typeof jid !== 'string') {return false;}
+    const conference = this.host.getConference?.();
+    const at = jid.indexOf('@');
+    return (
+      !!conference && at > 0 && jid.slice(at + 1).split('/')[0] === conference
+    );
+  }
+
+  // An explicit join of one room (a send, an open room, an invite) only
+  // needs a well-formed `local@domain`: the caller named the room.
+  private isJoinableJid(jid: unknown): jid is string {
+    if (typeof jid !== 'string') {return false;}
+    const at = jid.indexOf('@');
+    return at > 0 && at < jid.length - 1;
+  }
+
+  // ---- lifecycle ----------------------------------------------------
+  /** Called on every disconnect / reconnect / close: nothing carries over. */
+  reset() {
+    this.presencesReady = false;
+    this.priorityPresencesReady = false;
+    this.clearSweepRetry();
+    this.sendAllPresencesInFlight = null;
+    this.joinedRooms.clear();
+    this.roomPresenceInFlight.clear();
+    this.roomPresenceBlockedUntil.clear();
+  }
+
+  isJoined(roomJid: string): boolean {
+    return this.joinedRooms.has(roomJid);
+  }
+
+  // ---- one room -----------------------------------------------------
+  ensureRoomPresence = async (
+    roomJID: string,
+    options?: EnsureRoomPresenceOptions
+  ): Promise<boolean> => {
+    if (!roomJID) {return true;}
+    const source = options?.source || 'other';
+    if (!this.isJoinableJid(roomJID)) {
+      console.warn(
+        `[XMPP] room_presence_skipped_invalid_jid jid=${String(roomJID)} source=${source}`
+      );
+      // Block for a long time so repeated callers don't keep retrying.
+      this.roomPresenceBlockedUntil.set(roomJID, Date.now() + DAY_MS);
+      return false;
+    }
+    if (this.joinedRooms.has(roomJID)) {return true;}
+    const blockedUntil = this.roomPresenceBlockedUntil.get(roomJID) || 0;
+    if (Date.now() < blockedUntil) {return false;}
+
+    const settleDelay = options?.settleDelay ?? 0;
+    const timeoutMs = options?.timeoutMs ?? 2000;
+    const waitForJoin = options?.waitForJoin ?? true;
+
+    const existing = this.roomPresenceInFlight.get(roomJID);
+    if (existing) {
+      if (!waitForJoin) {return true;}
+      // Piggyback on someone else's in-flight join but never wait past OUR
+      // OWN budget: that join may have been started with a longer timeout
+      // (the sweep uses 5 s, a send wants less).
+      const OWN_TIMEOUT = Symbol('ensureRoomPresence_own_timeout');
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      const ownTimeout = new Promise<typeof OWN_TIMEOUT>((resolve) => {
+        timer = setTimeout(() => resolve(OWN_TIMEOUT), timeoutMs);
+      });
+      const result = await Promise.race([existing, ownTimeout]);
+      if (timer) {clearTimeout(timer);}
+      return result === OWN_TIMEOUT ? false : result;
+    }
+
+    // A join that outlives its connection (socket dropped while it waited)
+    // must not write into the NEW connection's state: neither joined nor a
+    // failure backoff.
+    const joinEpoch = this.epoch;
+    const promise: Promise<boolean> = (async () => {
+      // Online: go straight to the write (synchronously for the first
+      // caller), so a send queued right behind it stays ordered after it.
+      if (!this.host.isOnline?.()) {
+        await this.host.waitForOnline(Math.max(timeoutMs, 1000));
+      }
+      if (joinEpoch !== this.epoch) {return false;}
+      const client = this.host.getClient();
+      if (!client) {return false;}
+      await presenceInRoom(
+        client,
+        roomJID,
+        settleDelay,
+        timeoutMs,
+        this.joinHistoryStanzas
+      );
+      if (joinEpoch !== this.epoch) {return false;}
+      this.joinedRooms.add(roomJID);
+      this.roomPresenceBlockedUntil.delete(roomJID);
+      return true;
+    })()
+      .catch((error) => {
+        if (joinEpoch !== this.epoch) {return false;}
+        const message = formatError(error);
+        // Permanent / long-lived failures: "you are not a member" or "this
+        // room does not exist". No point retrying for an hour.
+        const isHardFailure =
+          message.includes('presence_error:forbidden') ||
+          message.includes('presence_error:not-allowed') ||
+          message.includes('presence_error:remote-server-not-found') ||
+          message.includes('presence_error:item-not-found') ||
+          message.includes('presence_invalid_jid');
+        if (isHardFailure) {
+          this.roomPresenceBlockedUntil.set(roomJID, Date.now() + 60 * 60 * 1000);
+        } else if (
+          message.includes('presence_timeout') ||
+          message.includes('presence_send_failed') ||
+          message.includes('presence_error')
+        ) {
+          this.roomPresenceBlockedUntil.set(
+            roomJID,
+            Date.now() + this.failureBackoffMs
+          );
+        }
+        console.warn(
+          `[XMPP] room_presence_failed room=${roomJID} source=${source} error=${message}`
+        );
+        return false;
+      })
+      .finally(() => {
+        // The map was cleared on disconnect: only drop our own entry.
+        if (this.roomPresenceInFlight.get(roomJID) === promise) {
+          this.roomPresenceInFlight.delete(roomJID);
+        }
+      });
+
+    this.roomPresenceInFlight.set(roomJID, promise);
+    if (waitForJoin) {return promise;}
+    return true;
+  };
+
+  // ---- the sweep ----------------------------------------------------
+  /**
+   * Start the background join sweep. Every caller shares one in-flight
+   * sweep; a finished sweep is only repeated when rooms appeared since.
+   * Never throws.
+   */
+  async sendAllPresencesAndMarkReady(): Promise<void> {
+    if (this.sendAllPresencesInFlight) {return this.sendAllPresencesInFlight;}
+    if (this.presencesReady && !this.hasUnjoinedRooms()) {return;}
+    const run: Promise<void> = this.runAllPresencesSweep().finally(() => {
+      if (this.sendAllPresencesInFlight === run) {
+        this.sendAllPresencesInFlight = null;
+      }
+    });
+    this.sendAllPresencesInFlight = run;
+    return run;
+  }
+
+  // Store rooms this connection has not joined and is not backing off from.
+  private hasUnjoinedRooms(): boolean {
+    const rooms = store.getState().rooms.rooms;
+    const now = Date.now();
+    return Object.keys(rooms || {}).some(
+      (jid) =>
+        this.isValidRoomJid(jid) &&
+        !this.joinedRooms.has(jid) &&
+        now >= (this.roomPresenceBlockedUntil.get(jid) || 0)
+    );
+  }
+
+  private async runAllPresencesSweep(): Promise<void> {
+    const epoch = this.epoch;
+    this.presencesReady = false;
+    let summary = emptySummary();
+    try {
+      summary = await this.allRoomPresencesStanza(epoch);
+    } catch (error) {
+      console.warn(`[XMPP] allRoomPresences fallback reason=${formatError(error)}`);
+    }
+    // The connection dropped mid-sweep: a newer connection owns the state.
+    if (epoch !== this.epoch) {return;}
+    // Only rooms the sweep actually sent a presence for count as joined.
+    // Reading the store here would also mark rooms discovered DURING the
+    // sweep, and ensureRoomPresence would then short-circuit for them.
+    summary.sweptRooms.forEach((jid) => {
+      if (!summary.failedRooms.includes(jid)) {this.joinedRooms.add(jid);}
+    });
+    if (summary.failed > 0 && summary.failures?.length) {
+      const text = summary.failures
+        .slice(0, 3)
+        .map((item) => `${item.roomJid}:${item.reason}`)
+        .join(' | ');
+      console.warn(`[XMPP] allRoomPresences failures_top3=${text}`);
+    }
+    this.priorityPresencesReady = true;
+    this.presencesReady = true;
+    this.scheduleSweepRetry(epoch, 0);
+  }
+
+  private clearSweepRetry() {
+    if (this.sweepRetryTimer) {clearTimeout(this.sweepRetryTimer);}
+    this.sweepRetryTimer = null;
+    this.sweepRetryRunning = false;
+  }
+
+  // Rooms the connection has not joined that a retry can still help: not
+  // joined, not under a long (hard) block. Returns the soonest moment a retry
+  // is worthwhile (0 = now) or null when nothing is left.
+  private nextSweepRetryAt(): number | null {
+    const rooms = store.getState().rooms?.rooms;
+    const now = Date.now();
+    let soonest: number | null = null;
+    Object.keys(rooms || {}).forEach((jid) => {
+      if (!this.isValidRoomJid(jid) || this.joinedRooms.has(jid)) {return;}
+      const until = this.roomPresenceBlockedUntil.get(jid) || 0;
+      // Hard failures (1 h) and invalid JIDs (24 h) are not worth a retry.
+      if (until - now > Math.max(this.failureBackoffMs, 1000) * 2) {return;}
+      const at = Math.max(until, now);
+      if (soonest === null || at < soonest) {soonest = at;}
+    });
+    return soonest;
+  }
+
+  private scheduleSweepRetry(epoch: number, round: number) {
+    if (epoch !== this.epoch) {return;}
+    if (round >= SWEEP_RETRY_DELAYS_MS.length) {return;}
+    const at = this.nextSweepRetryAt();
+    if (at === null) {return;}
+    if (this.sweepRetryTimer) {clearTimeout(this.sweepRetryTimer);}
+    const delay = Math.max(SWEEP_RETRY_DELAYS_MS[round], at - Date.now() + 100);
+    this.sweepRetryTimer = setTimeout(() => {
+      this.sweepRetryTimer = null;
+      this.runSweepRetry(epoch, round).catch(() => undefined);
+    }, delay);
+  }
+
+  private async runSweepRetry(epoch: number, round: number) {
+    if (epoch !== this.epoch || !this.host.getClient()) {return;}
+    // A fresh full sweep owns the pool right now: try again after it.
+    if (this.sweepRetryRunning || this.sendAllPresencesInFlight) {
+      this.scheduleSweepRetry(epoch, round);
+      return;
+    }
+    if (this.nextSweepRetryAt() === null) {return;}
+    this.sweepRetryRunning = true;
+    try {
+      const summary = await this.allRoomPresencesStanza(epoch);
+      if (epoch !== this.epoch) {return;}
+      const failed = new Set(summary.failedRooms);
+      summary.sweptRooms.forEach((jid) => {
+        if (!failed.has(jid)) {this.joinedRooms.add(jid);}
+      });
+    } catch (error) {
+      console.warn(`[XMPP] sweep_retry:error ${formatError(error)}`);
+    } finally {
+      this.sweepRetryRunning = false;
+    }
+    this.scheduleSweepRetry(epoch, round + 1);
+  }
+
+  async allRoomPresencesStanza(
+    epoch: number = this.epoch
+  ): Promise<AllRoomPresenceSummary> {
+    const client = this.host.getClient();
+    if (!client) {return emptySummary();}
+    try {
+      return await allRoomPresences(
+        client,
+        (roomJid) =>
+          this.ensureRoomPresence(roomJid, {
+            settleDelay: 0,
+            timeoutMs: 5000,
+            waitForJoin: true,
+            source: 'background',
+          }),
+        {
+          concurrency: this.joinConcurrency,
+          isJoined: (jid) => this.joinedRooms.has(jid),
+          getActiveRoomJid: () => store.getState().rooms.activeRoomJID,
+          rank: (jid) =>
+            getRoomLastActivityScore(store.getState().rooms.rooms?.[jid]),
+          isCancelled: () => epoch !== this.epoch,
+          isRoomJid: (jid) => this.isValidRoomJid(jid),
+          onPriorityDone: () => {
+            if (epoch === this.epoch) {this.priorityPresencesReady = true;}
+          },
+        }
+      );
+    } catch (error) {
+      console.warn(`[XMPP] allRoomPresencesStanza:error ${formatError(error)}`);
+      return emptySummary();
+    }
+  }
+}

package/src/networking/xmpp/sendMediaMessage.xmpp.ts

@@ -36,7 +36,6 @@ export function sendMediaMessage(
     senderFirstName: data.firstName,
     senderLastName: data.lastName,
     senderWalletAddress: data.walletAddress,
-    isSystemMessage: false,
     tokenAmount: '0',
     receiverMessageId: '0',
     mucname: data.chatName,

package/src/networking/xmpp/sendTextMessage.xmpp.ts

@@ -62,7 +62,6 @@ export const sendTextMessage = (
         senderJID: client.jid?.toString(),
         senderWalletAddress: walletAddress,
         roomJid: roomJID,
-        isSystemMessage: false,
         tokenAmount: 0,
         quickReplies: '',
         notDisplayedValue: '',

package/src/networking/xmpp/sendTextMessageWithTranslateTag.xmpp.ts

@@ -49,7 +49,6 @@ export const sendTextMessageWithTranslateTag = (
         senderJID: client.jid?.toString(),
         senderWalletAddress: stanzaMessage.walletAddress,
         roomJid: stanzaMessage.roomJID,
-        isSystemMessage: false,
         tokenAmount: 0,
         quickReplies: '',
         notDisplayedValue: '',