@ethora/chat-component-rn 26.9.1 → 26.10.0

package/src/networking/ethoraEvents.ts

@@ -0,0 +1,262 @@
+import type { Element } from 'ltx';
+import { store } from '../roomStore';
+import { updateRoom } from '../roomStore/roomsSlice';
+import { isSafeKey, hasSafeIdSegments } from '../roomStore/safeKey';
+import { getRoomByName } from './api-requests/rooms.api';
+import { createRoomFromApi } from '../helpers/createRoomFromApi';
+import { getRoomUserCount } from '../helpers/roomUserCount';
+import { refreshUser } from '../helpers/userResolver';
+import { ethoraLogger } from '../helpers/ethoraLogger';
+import { getSessionAppId } from '../helpers/sessionAppId';
+import type { IRoom } from '../types/types';
+
+/**
+ * Server push `<ethora-event xmlns="urn:ethora:events:1" .../>` inside a
+ * `type="headline"` message from the server's admin account:
+ *
+ *   user-profile-updated  xmppUsername="<appId>_<userId>" uuid appId
+ *   chat-meta-updated     chatName="<appId>_<roomId>" appId
+ *
+ * The payload is a pointer only. The client re-reads the user or the room
+ * through the normal API, so nothing in the stanza is ever shown or stored.
+ * Everything in the stanza is untrusted input until proven otherwise.
+ */
+export const ETHORA_EVENT_XMLNS = 'urn:ethora:events:1';
+export const ETHORA_EVENT_USER_PROFILE = 'user-profile-updated';
+export const ETHORA_EVENT_CHAT_META = 'chat-meta-updated';
+
+const MUCSUB_EVENT_NS = 'http://jabber.org/protocol/pubsub#event';
+const ROOM_DEBOUNCE_MS = 500;
+const MAX_KEY_LENGTH = 128;
+const KEY_SHAPE = /^[A-Za-z0-9_-]+$/;
+const ROOM_BACKOFF_MS = [5_000, 30_000, 120_000];
+
+type HostLike = { host?: string; client?: { jid?: { getDomain?: () => string } } };
+
+const lower = (v: unknown): string => String(v ?? '').trim().toLowerCase();
+
+/** Server domain of this session: our own JID's domain, else the configured host. */
+const sessionDomain = (xmppWs: HostLike | undefined): string =>
+  lower(xmppWs?.client?.jid?.getDomain?.()) || lower(xmppWs?.host);
+
+/**
+ * True when a headline came from the server and not from a user or a room.
+ * - from must be a BARE jid (a user's c2s stanza or a MUC occupant always
+ *   carries a resource, and the server stamps it, so it cannot be spoofed)
+ * - its domain must be the session's own XMPP domain (not conference.*, not
+ *   another server)
+ * - when config.trustedEventSenders is set, the sender must be listed
+ * The server's admin local part is deployment config (XMPP_ADMIN), so it
+ * cannot be hard-coded here.
+ */
+export const isTrustedEventSender = (
+  stanza: Element,
+  xmppWs: HostLike | undefined
+): boolean => {
+  const from = String(stanza?.attrs?.from ?? '').trim();
+  if (!from || from.includes('/')) return false;
+  const at = from.indexOf('@');
+  if (at <= 0 || from.indexOf('@', at + 1) !== -1) return false;
+  const local = lower(from.slice(0, at));
+  const domain = lower(from.slice(at + 1));
+  if (!local || !domain) return false;
+  const own = sessionDomain(xmppWs);
+  if (!own || domain !== own) return false;
+
+  const pinned = (store.getState().chatSettingStore?.config as any)
+    ?.trustedEventSenders;
+  if (Array.isArray(pinned) && pinned.length) {
+    return pinned.some((entry: unknown) => {
+      const e = lower(entry);
+      return e === `${local}@${domain}` || e === local;
+    });
+  }
+  return true;
+};
+
+const sessionAppId = (): string =>
+  getSessionAppId();
+
+/**
+ * `<appId>_<id>` shape for an attribute that is about to become a URL
+ * segment or a store key: charset, length cap, no unsafe key, and the
+ * session's appId as prefix when the session has one.
+ */
+const isSafeEventKey = (value: unknown): value is string => {
+  if (!isSafeKey(value)) return false;
+  if (value.length > MAX_KEY_LENGTH || !KEY_SHAPE.test(value)) return false;
+  if (!value.includes('_')) return false;
+  if (!hasSafeIdSegments(value)) return false;
+  const appId = sessionAppId();
+  if (appId && !value.startsWith(`${appId}_`)) return false;
+  return true;
+};
+
+// --- chat-meta-updated -----------------------------------------------------
+
+const roomTimers = new Map<string, ReturnType<typeof setTimeout>>();
+const roomInflight = new Set<string>();
+const roomAgain = new Set<string>();
+const roomFailures = new Map<string, { count: number; until: number }>();
+
+const findRoomJid = (chatName: string): string | null => {
+  const rooms = (store.getState().rooms?.rooms || {}) as Record<string, IRoom>;
+  for (const jid of Object.keys(rooms)) {
+    if (jid.split('@')[0] === chatName) return jid;
+  }
+  return null;
+};
+
+const runRoomRefresh = async (chatName: string): Promise<void> => {
+  if (roomInflight.has(chatName)) {
+    roomAgain.add(chatName);
+    return;
+  }
+  const failure = roomFailures.get(chatName);
+  if (failure && failure.until > Date.now()) return;
+  const jid = findRoomJid(chatName);
+  if (!jid || !store.getState().chatSettingStore?.user?.token) return;
+
+  roomInflight.add(chatName);
+  try {
+    const apiRoom = await getRoomByName(chatName);
+    roomFailures.delete(chatName);
+    const current = (store.getState().rooms?.rooms || {})[jid] as
+      | IRoom
+      | undefined;
+    if (!current || !apiRoom) return;
+    const service = jid.split('@')[1] || '';
+    // createRoomFromApi applies the title rules (private chats derive the
+    // peer name, sentinel titles are refused) and the usersCnt rules
+    const fresh = createRoomFromApi(
+      { ...apiRoom, name: chatName },
+      service,
+      getRoomUserCount(current)
+    );
+    if (!fresh) return;
+
+    // Metadata only. members, messages, lastMessage and the unread fields
+    // stay as they are: the response carries the whole member list (a big
+    // room is tens of KB) and the loaded one may be a different, larger set.
+    const updates: Partial<IRoom> & { picture?: string } = {
+      title: fresh.title,
+      name: fresh.name,
+      description: fresh.description,
+      icon: fresh.icon,
+      // the API calls the room image `picture`; RN renders it from `icon`
+      picture: (fresh as any).picture,
+      // never lower the known total
+      usersCnt: Math.max(
+        Number(fresh.usersCnt) || 0,
+        getRoomUserCount(current)
+      ),
+    };
+    if (
+      apiRoom.type === 'public' ||
+      apiRoom.type === 'group' ||
+      apiRoom.type === 'private'
+    ) {
+      updates.type = apiRoom.type;
+    }
+    // A missing field in the answer must not blank the one we have
+    (Object.keys(updates) as Array<keyof IRoom>).forEach((k) => {
+      if ((updates as any)[k] === undefined) delete (updates as any)[k];
+    });
+    store.dispatch(updateRoom({ jid, updates }));
+  } catch (error) {
+    const count = (roomFailures.get(chatName)?.count ?? 0) + 1;
+    roomFailures.set(chatName, {
+      count,
+      until:
+        Date.now() +
+        ROOM_BACKOFF_MS[Math.min(count - 1, ROOM_BACKOFF_MS.length - 1)],
+    });
+    ethoraLogger.log('[EthoraEvent] room refresh failed', chatName, error);
+  } finally {
+    roomInflight.delete(chatName);
+    if (roomAgain.delete(chatName)) scheduleRoomRefresh(chatName);
+  }
+};
+
+const scheduleRoomRefresh = (chatName: string): void => {
+  const prior = roomTimers.get(chatName);
+  if (prior) clearTimeout(prior);
+  roomTimers.set(
+    chatName,
+    setTimeout(() => {
+      roomTimers.delete(chatName);
+      runRoomRefresh(chatName);
+    }, ROOM_DEBOUNCE_MS)
+  );
+};
+
+// --- entry point ------------------------------------------------------------
+
+const findCarrier = (stanza: Element): Element | null => {
+  const candidates: Element[] = [stanza];
+  const inner = (stanza as any)
+    ?.getChild?.('event', MUCSUB_EVENT_NS)
+    ?.getChild?.('items')
+    ?.getChild?.('item')
+    ?.getChild?.('message');
+  if (inner) candidates.push(inner as Element);
+  return (
+    candidates.find(
+      (c) =>
+        c?.attrs?.type === 'headline' &&
+        (c as any).getChild?.('ethora-event', ETHORA_EVENT_XMLNS)
+    ) ?? null
+  );
+};
+
+/**
+ * Handles `<ethora-event>` headlines. Returns true when the stanza carried
+ * one (trusted or not), so the caller can stop routing it. Unknown types,
+ * malformed attributes and untrusted senders are ignored silently. Never
+ * throws.
+ */
+export function onEthoraEvent(
+  stanza: Element,
+  xmppWs?: HostLike
+): boolean {
+  try {
+    const carrier = findCarrier(stanza);
+    if (!carrier) return false;
+    if (!isTrustedEventSender(carrier, xmppWs)) {
+      ethoraLogger.log('[EthoraEvent] ignored: untrusted sender');
+      return true;
+    }
+    const event = (carrier as any).getChild('ethora-event', ETHORA_EVENT_XMLNS);
+    const type = String(event?.attrs?.type ?? '');
+    const appIdAttr = event?.attrs?.appId;
+    const appId = sessionAppId();
+    if (appIdAttr !== undefined && appId && String(appIdAttr) !== appId) {
+      return true;
+    }
+
+    if (type === ETHORA_EVENT_USER_PROFILE) {
+      const id = event?.attrs?.xmppUsername;
+      if (isSafeEventKey(id)) refreshUser(id);
+    } else if (type === ETHORA_EVENT_CHAT_META) {
+      const chatName = event?.attrs?.chatName;
+      // a room we do not hold (a brand-new room we were just added to) is
+      // the invite/membership flow's job
+      if (isSafeEventKey(chatName) && findRoomJid(chatName)) {
+        scheduleRoomRefresh(chatName);
+      }
+    }
+    return true;
+  } catch (error) {
+    ethoraLogger.log('[EthoraEvent] failed to handle event', error);
+    return true;
+  }
+}
+
+/** Drops timers and per-room state (tests, logout). */
+export function resetEthoraEvents(): void {
+  roomTimers.forEach((t) => clearTimeout(t));
+  roomTimers.clear();
+  roomInflight.clear();
+  roomAgain.clear();
+  roomFailures.clear();
+}

package/src/networking/stanzaHandlers.ts

@@ -4,6 +4,7 @@ import {
   claimMamResult,
   collectMamMessage,
   collectMamReaction,
+  replayArchivedReaction,
 } from './xmpp/mamRouter';
 import { extractReaction } from '../helpers/mamReactions';
 import {
@@ -15,14 +16,19 @@ import {
   setCurrentRoom,
   setRoomRole,
   setReactions,
+  updateRoom,
 } from '../roomStore/roomsSlice';
-import { IMessage, IRoom } from '../types/types';
+import { IMessage, IRoom, RoomMember } from '../types/types';
+import { adjustUsersCnt, isRoomMembersTruncated } from '../helpers/roomUserCount';
+import { requestSendersOf } from '../helpers/userResolver';
 import { createMessageFromXml } from '../helpers/createMessageFromXml';
 import { getDataFromXml } from '../helpers/getDataFromXml';
 import { setDeleteModal } from '../roomStore/chatSettingsSlice';
 import { messageNotificationManager } from '../utils/messageNotificationManager';
+import { isOwnIncomingMessage } from '../helpers/notificationPolicy';
 import { transformCallLogMessage } from '../helpers/callLogMessage';
 import { translateKey } from '../i18n/strings';
+import { isWindowQueryId } from './xmpp/mamQueryIds';
 import { loadRoomMembers } from './api-requests/rooms.api';
 import { subscribeRoomForPush } from '../services/pushSubscriptionService';
 
@@ -114,15 +120,28 @@ const onRealtimeMessage = async (stanza: Element) => {
         message,
       })
     );
+    // A sender missing from usersSet (a big room only carries 30 members)
+    // is resolved lazily; known and recently failed ids are dropped inside.
+    try {
+      requestSendersOf([message]);
+    } catch {
+      // name resolution must never break message delivery
+    }
 
-    // Trigger in-app notification (manager dedupes + drops own messages
-    // for empty bodies). Self-messages are filtered by sender check.
+    // Trigger in-app notification (the manager dedupes and drops empty
+    // bodies; the provider drops the open chat, muted chats and a
+    // backgrounded app). The reader's own messages never toast.
     try {
       const state = store.getState();
-      const currentUserWallet = (state.chatSettingStore.user?.walletAddress || '').toLowerCase();
-      const senderJIDLower = String(senderJID || '').toLowerCase();
-      if (currentUserWallet && senderJIDLower.includes(currentUserWallet)) {
-        return message; // own message, skip toast
+      if (
+        isOwnIncomingMessage({
+          message,
+          stanzaFrom: stanza.attrs.from,
+          senderJID,
+          user: state.chatSettingStore.user,
+        })
+      ) {
+        return message;
       }
       const room = state.rooms.rooms[roomJID];
       const roomName = room?.title || room?.name || '';
@@ -198,7 +217,7 @@ const onEditMessage = async (stanza: Element) => {
 
 const isMamResult = (stanza: any): boolean =>
   !!stanza?.is?.('message') &&
-  stanza.children?.[0]?.attrs?.xmlns === 'urn:xmpp:mam:2';
+  stanza.getChild?.('result')?.attrs?.xmlns === 'urn:xmpp:mam:2';
 
 const parseMamResult = async (stanza: any): Promise<IMessage | undefined> => {
   {
@@ -213,16 +232,9 @@ const parseMamResult = async (stanza: any): Promise<IMessage | undefined> => {
         stanza.getChild('result')?.attrs?.id
       );
       if (reaction && !collectMamReaction(stanza, reaction)) {
-        store.dispatch(
-          setReactions({
-            roomJID: reaction.roomJID,
-            messageId: reaction.messageId,
-            from: reaction.from,
-            reactions: reaction.emoji,
-            data: reaction.data,
-            latestReactionTimestamp: reaction.ts,
-          })
-        );
+        // No page is waiting for it: replay it by hand. Flagged fromHistory
+        // so the room preview is not turned into an emoji.
+        replayArchivedReaction(reaction);
       }
       return undefined;
     }
@@ -331,6 +343,10 @@ const parseMamResult = async (stanza: any): Promise<IMessage | undefined> => {
 
 const onMessageHistory = async (stanza: any) => {
   if (!isMamResult(stanza)) {return;}
+  // A windowed query (a jump target's neighbourhood, a time lookup) belongs
+  // to the caller that asked: its rows are collected and returned there and
+  // must never be claimed by the router or merged into the live list.
+  if (isWindowQueryId(stanza.getChild('result')?.attrs?.queryid)) {return;}
   const claimed = claimMamResult(stanza);
   let message: IMessage | undefined;
   try {
@@ -398,7 +414,70 @@ const handleComposing = async (stanza: Element, currentUser: string) => {
   }
 };
 
+// Server-driven membership change: when someone is added to or removed from
+// a MUC the room broadcasts <message><x xmlns="muc#user"><item jid=...
+// affiliation="member|none|outcast"/></x></message> to the occupants. It is
+// the ONLY thing that counts as a join or leave: usersCnt is adjusted by
+// +1/-1 from its CURRENT value, because a big room carries a truncated
+// members[] (the real total is usersCnt) and recomputing from its length
+// would collapse the count to the page size.
+const MUC_USER_NS = 'http://jabber.org/protocol/muc#user';
+
+const onRoomMembershipChange = (stanza: Element | any): void => {
+  if (typeof stanza?.is !== 'function' || !stanza.is('message')) {return;}
+  const roomJid = String(stanza.attrs?.from || '').split('/')[0];
+  const room = roomJid ? store.getState().rooms.rooms[roomJid] : undefined;
+  if (!room) {return;}
+
+  const x = (stanza.getChildren?.('x') || []).find(
+    (e: Element) => e?.attrs?.xmlns === MUC_USER_NS
+  );
+  if (!x || x.getChild('invite')) {return;}
+  const item = x.getChild('item');
+  const memberJid = String(item?.attrs?.jid || '');
+  if (!memberJid) {return;}
+
+  const xmppUsername = memberJid.split('@')[0];
+  const affiliation = String(item?.attrs?.affiliation || '');
+  const leaving = affiliation === 'none' || affiliation === 'outcast';
+  const members = Array.isArray(room.members) ? room.members : [];
+  const idx = members.findIndex((m) => m.xmppUsername === xmppUsername);
+
+  let next: RoomMember[];
+  if (leaving) {
+    if (idx < 0) {
+      // The leaver may exist only in the directory of a truncated room.
+      if (!isRoomMembersTruncated(room)) {return;}
+      store.dispatch(
+        updateRoom({
+          jid: roomJid,
+          updates: { usersCnt: adjustUsersCnt(room, -1, members.length) },
+        })
+      );
+      return;
+    }
+    next = members.filter((_, i) => i !== idx);
+  } else {
+    if (idx >= 0) {return;}
+    next = [
+      ...members,
+      { _id: '', firstName: '', lastName: '', xmppUsername, jid: memberJid },
+    ];
+  }
+
+  store.dispatch(
+    updateRoom({
+      jid: roomJid,
+      updates: {
+        members: next,
+        usersCnt: adjustUsersCnt(room, leaving ? -1 : 1, next.length),
+      },
+    })
+  );
+};
+
 const onPresenceInRoom = (stanza: Element | any) => {
+  onRoomMembershipChange(stanza);
   if (
     typeof stanza.attrs.id === 'string' &&
     stanza.attrs.id.startsWith('presenceInRoom') &&
@@ -546,8 +625,55 @@ const onReactionMessage = (stanza: Element) => {
 };
 // Archived reactions are handled by parseMamResult + the MAM router.
 const onReactionHistory = (_stanza: Element) => {};
-const onRoomKicked = (_stanza: Element) => {};
+// Presence that removes a member: unavailable + affiliation none/outcast.
+// A presence is never a join (an unlisted occupant of a truncated big room
+// is indistinguishable from a new member), so it only ever adjusts -1; the
+// affiliation message (onRoomMembershipChange) is what counts joins.
+const onRoomKicked = (stanza: Element | any) => {
+  try {
+    if (stanza?.attrs?.type !== 'unavailable') {return;}
+    const from = String(stanza.attrs?.from || '');
+    const slash = from.indexOf('/');
+    const roomJID = slash >= 0 ? from.slice(0, slash) : from;
+    const nickname = slash >= 0 ? from.slice(slash + 1) : '';
+    const state = store.getState();
+    const room = roomJID ? state.rooms.rooms[roomJID] : undefined;
+    if (!room || !nickname) {return;}
+    if (nickname === (state.chatSettingStore.user?.xmppUsername || '')) {return;}
 
+    const x = (stanza.getChildren?.('x') || []).find(
+      (e: Element) => e?.attrs?.xmlns === MUC_USER_NS
+    );
+    const item = x?.getChild?.('item');
+    const affiliation = String(item?.attrs?.affiliation || '');
+    if (!item || (affiliation !== 'none' && affiliation !== 'outcast')) {return;}
+
+    const members = Array.isArray(room.members) ? room.members : [];
+    const idx = members.findIndex((m) => m.xmppUsername === nickname);
+    if (idx < 0) {
+      if (!isRoomMembersTruncated(room)) {return;}
+      store.dispatch(
+        updateRoom({
+          jid: roomJID,
+          updates: { usersCnt: adjustUsersCnt(room, -1, members.length) },
+        })
+      );
+      return;
+    }
+    const next = members.filter((_, i) => i !== idx);
+    store.dispatch(
+      updateRoom({
+        jid: roomJID,
+        updates: {
+          members: next,
+          usersCnt: adjustUsersCnt(room, -1, next.length),
+        },
+      })
+    );
+  } catch (error) {
+    console.warn('onRoomKicked failed', error);
+  }
+};
 export {
   onRealtimeMessage,
   onMessageHistory,

package/src/networking/xmpp/allRoomPresences.xmpp.ts

@@ -1,10 +1,160 @@
-import { Client, xml } from '@xmpp/client';
+import { Client } from '@xmpp/client';
 import { store } from '../../roomStore';
 import { presenceInRoom } from './presenceInRoom.xmpp';
+import { isLikelyMucJid } from '../../helpers/isLikelyMucJid';
 
-export async function allRoomPresences(client: Client) {
-  const rooms = store.getState().rooms.rooms;
-  await Promise.all(
-    Object.keys(rooms).map((roomJid) => presenceInRoom(client, roomJid))
+export interface AllRoomPresenceSummary {
+  total: number;
+  success: number;
+  failed: number;
+  failedRooms: string[];
+  // Every JID this sweep sent a presence for (snapshot taken at start).
+  sweptRooms: string[];
+  failures?: Array<{ roomJid: string; reason: string }>;
+}
+
+// `join` lets the owner route each room through its dedup layer
+// (RoomJoinManager.ensureRoomPresence) so the sweep shares an in-flight join
+// with other callers instead of sending a second <presence> for the same
+// room: the server answers a duplicate join once, one waiter would time out
+// and the room got a failure backoff while actually being joined.
+export type RoomJoiner = (roomJid: string) => Promise<boolean>;
+
+export interface AllRoomPresencesOptions {
+  /** Parallel joins. Default 5. */
+  concurrency?: number;
+  /** Pause after each join, per worker. Default 30 ms. */
+  pacingMs?: number;
+  /** Rooms the connection already joined: skipped, no round trip. */
+  isJoined?: (roomJid: string) => boolean;
+  /** The room the user has open: always joined next, ahead of the queue. */
+  getActiveRoomJid?: () => string | null | undefined;
+  /** Higher = joined earlier (recent activity). Default: store order. */
+  rank?: (roomJid: string) => number;
+  /** True once this sweep is obsolete (connection dropped and replaced). */
+  isCancelled?: () => boolean;
+  /** Fired once the first wave (the active room plus one pool-width of the
+   *  most recent rooms) has settled, long before the rest of the sweep. */
+  onPriorityDone?: () => void;
+  /** Which store keys are joinable rooms. Default: isLikelyMucJid. */
+  isRoomJid?: (jid: string) => boolean;
+}
+
+// Joins every room in the store in the background. Order: the active room
+// first (re-read before every pick, so a room the user opens while it is
+// still queued jumps the queue), then by recent activity. Rooms discovered
+// while the sweep runs are picked up before it ends.
+export async function allRoomPresences(
+  client: Client,
+  join?: RoomJoiner,
+  options: AllRoomPresencesOptions = {}
+): Promise<AllRoomPresenceSummary> {
+  const concurrency = Math.max(1, Math.floor(options.concurrency || 5));
+  const pacingMs = options.pacingMs ?? 30;
+  const isJoined = options.isJoined || (() => false);
+  const rank = options.rank || (() => 0);
+  const isRoomJid = options.isRoomJid || isLikelyMucJid;
+
+  const seen = new Set<string>();
+  const queue: string[] = [];
+  const collect = () => {
+    const rooms = store.getState().rooms.rooms;
+    const keys = rooms && typeof rooms === 'object' ? Object.keys(rooms) : [];
+    const fresh = keys.filter(
+      (jid) => isRoomJid(jid) && !seen.has(jid) && !isJoined(jid)
+    );
+    fresh.forEach((jid) => seen.add(jid));
+    // Stable sort: equal scores keep store order.
+    fresh.sort((a, b) => rank(b) - rank(a));
+    queue.push(...fresh);
+  };
+  collect();
+
+  const sweptRooms: string[] = [];
+  const settledByJid = new Map<string, PromiseSettledResult<any>>();
+  const firstWave = Math.min(concurrency, queue.length);
+  let started = 0;
+  let waveSettled = 0;
+  let priorityFired = false;
+  const firePriority = () => {
+    if (priorityFired) {return;}
+    priorityFired = true;
+    options.onPriorityDone?.();
+  };
+  if (firstWave === 0) {firePriority();}
+
+  const pickNext = (): string | undefined => {
+    const active = options.getActiveRoomJid?.();
+    if (active) {
+      const at = queue.indexOf(active);
+      if (at >= 0) {return queue.splice(at, 1)[0];}
+    }
+    return queue.shift();
+  };
+
+  const worker = async () => {
+    while (!options.isCancelled?.()) {
+      if (queue.length === 0) {collect();}
+      const roomJid = pickNext();
+      if (!roomJid) {return;}
+      // Opened (and joined) by someone else while this one waited.
+      if (isJoined(roomJid)) {continue;}
+      const inFirstWave = started < firstWave;
+      started += 1;
+      sweptRooms.push(roomJid);
+      const result = await Promise.allSettled([
+        join
+          ? join(roomJid).then((joined) => {
+              if (!joined) {throw new Error(`presence_failed:${roomJid}`);}
+              return joined;
+            })
+          : presenceInRoom(client, roomJid, 0, 5000),
+      ]);
+      settledByJid.set(roomJid, result[0]);
+      if (inFirstWave) {
+        waveSettled += 1;
+        if (waveSettled >= firstWave) {firePriority();}
+      }
+      if (pacingMs > 0) {
+        await new Promise((resolve) => setTimeout(resolve, pacingMs));
+      }
+    }
+  };
+
+  await Promise.all(Array.from({ length: concurrency }, () => worker()));
+  firePriority();
+  const roomJids = sweptRooms;
+  const settled = roomJids.map(
+    (jid) =>
+      settledByJid.get(jid) ||
+      ({ status: 'rejected', reason: 'cancelled' } as PromiseRejectedResult)
   );
+  const failedRooms: string[] = [];
+  const failures: Array<{ roomJid: string; reason: string }> = [];
+  let success = 0;
+
+  settled.forEach((result, index) => {
+    if (result.status === 'fulfilled') {
+      success += 1;
+      return;
+    }
+    const roomJid = roomJids[index];
+    failedRooms.push(roomJid);
+    const reason =
+      result.reason instanceof Error
+        ? result.reason.message
+        : typeof result.reason === 'string'
+          ? result.reason
+          : JSON.stringify(result.reason ?? { error: 'unknown' });
+    failures.push({ roomJid, reason });
+  });
+
+  return {
+    total: roomJids.length,
+    success,
+    failed: failedRooms.length,
+    failedRooms,
+    sweptRooms: roomJids,
+    failures,
+  };
 }