@ethora/chat-component-rn 26.9.1 → 26.10.0

package/lib/module/roomStore/roomsSlice.js

@@ -3,6 +3,9 @@
 import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
 import { insertMessageWithDelimiter } from '../helpers/insertMessageWithDelimiter';
 import { msgSortableMs } from '../helpers/msgSortableMs';
+import { isSafeKey } from './safeKey';
+import { mergeUsersSet as mergeIntoUsersSet } from './usersSetCap';
+import { getRoomUserCount } from '../helpers/roomUserCount';
 import { subscribeRoomForPush } from '../services/pushSubscriptionService';
 
 // Per-room runtime message cap. Mirrors the persistence layer's
@@ -145,6 +148,65 @@ const insertRoomMessage = (state, roomJID, message, start) => {
     atHead
   };
 };
+
+/**
+ * Keeps the jump window's separate copy of a message in step with the live
+ * list: an echo of a message the reader sees flips it from "sending" to
+ * delivered there too, call-log entries collapse per callId, and (only for a
+ * live single-message add, `allowAppend`) a reader parked at the LIVE END of
+ * a window (hasNewer false) sees what arrives next. While hasNewer is true
+ * the window is not adjacent to the tail and the message waits in
+ * room.messages until the reader returns to live.
+ */
+const syncJumpWindowWithMessage = (state, roomJID, message, start, allowAppend) => {
+  const win = state.jumpWindow;
+  if (!win || win.roomJID !== roomJID || isCallSignalMessage(message)) {
+    return;
+  }
+  const incomingCallLog = message.callLog;
+  if (incomingCallLog?.callId) {
+    const wi = win.messages.findIndex(msg => msg.callLog?.callId === incomingCallLog.callId);
+    if (wi !== -1) {
+      const wExisting = win.messages[wi];
+      const wMerged = mergeCallLogEntries(wExisting, message);
+      if (wMerged !== wExisting) {
+        win.messages[wi] = wMerged;
+      }
+      return;
+    }
+  }
+  if (win.messages.length === 0) {
+    return;
+  }
+  const isKnownMessage = msg => msg.id === message.id || !!message.xmppId && msg.id === message.xmppId || !!msg.xmppId && msg.xmppId === message.id;
+  const wi = win.messages.findIndex(isKnownMessage);
+  if (wi !== -1) {
+    const prev = win.messages[wi];
+    const next = {
+      ...prev
+    };
+    for (const [key, value] of Object.entries(message)) {
+      if (value !== undefined && isSafeKey(key)) {
+        next[key] = value;
+      }
+    }
+    // The sender identity captured on first insert wins, as in the live
+    // list (the echo parses a different id form).
+    next.user = prev.user;
+    next.pending = false;
+    win.messages[wi] = next;
+  } else if (allowAppend && !win.hasNewer && !start) {
+    win.messages.push({
+      ...message
+    });
+    if (win.messages.length > JUMP_WINDOW_MAX_MESSAGES) {
+      win.messages = win.messages.slice(-JUMP_WINDOW_MAX_MESSAGES);
+      const oldest = Number(win.messages[0].id);
+      win.olderCursor = Number.isFinite(oldest) ? oldest : win.olderCursor;
+      win.hasOlder = true;
+    }
+  }
+};
 const capAfterGrowth = (messages, lengthBefore, atHead) => {
   if (atHead) {
     enforceMessageCap(messages, RUNTIME_MESSAGE_CEILING);
@@ -166,6 +228,9 @@ const bumpLastMessageTimestamp = (state, roomJID, message) => {
   }
 };
 const upsertRoom = (state, roomData) => {
+  if (!isSafeKey(roomData?.jid)) {
+    return;
+  }
   const existing = state.rooms[roomData.jid];
   let lastViewed;
   const serverMarker = state.privateStoreMarkers?.[roomData.jid] || 0;
@@ -190,11 +255,17 @@ const upsertRoom = (state, roomData) => {
   const existingMessages = Array.isArray(existing?.messages) ? existing.messages : [];
   state.rooms[roomData.jid] = {
     ...roomData,
+    usersCnt: resolveIncomingUsersCnt(roomData, existing),
+    // A seed for the room-list preview: take the freshest API value but
+    // never let a payload without one erase what is already there.
+    lastMessage: roomData.lastMessage ?? existing?.lastMessage,
+    ...resolveApiUnread(state, roomData.jid, roomData, existing),
     icon: roomData.icon !== undefined ? roomData.icon : existing?.icon,
     roomBg: roomData.roomBg !== undefined ? roomData.roomBg : existing?.roomBg,
     messages: existingMessages.length > 0 ? existingMessages : incomingMessages,
     lastViewedTimestamp: lastViewed,
-    unreadMessages: roomData.unreadMessages ?? existing?.unreadMessages ?? 0,
+    // A server-seeded count must not badge a room that is open right now.
+    unreadMessages: roomData.apiUnreadCount !== undefined && (state.activeRoomJID === roomData.jid || state.visibleRoomJID === roomData.jid) ? existing?.unreadMessages ?? 0 : roomData.unreadMessages ?? existing?.unreadMessages ?? 0,
     unreadBaselineTimestamp: existing?.unreadBaselineTimestamp ?? existing?.lastViewedTimestamp ?? roomData.unreadBaselineTimestamp ?? 0
   };
 };
@@ -363,6 +434,40 @@ function mergeHistoryIntoCache(existing, fetched) {
   const merged = collapseCallLogDuplicates(Array.from(byId.values()).sort(byMs));
   return [...capTail(merged), ...pending];
 }
+
+/** A message found in the archive that the chat cannot show in place. */
+
+/** A request to scroll a room's transcript to one message. */
+
+/**
+ * A short slice of a room's archive around one message, shown INSTEAD of the
+ * live list while the reader is away from the tail (a search jump to a message
+ * far back). Separate from room.messages on purpose: it is not contiguous with
+ * the live history, so it must not touch messageStats or historyComplete.
+ * Never persisted.
+ */
+
+/** The window is trimmed on the far side past this many messages. */
+export const JUMP_WINDOW_MAX_MESSAGES = 300;
+const mergeWindowMessages = (a, b) => {
+  const seen = new Set();
+  const merged = [];
+  for (const message of [...a, ...b]) {
+    const key = String(message.id);
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    merged.push(message);
+  }
+  const num = message => {
+    const id = Number(message.id);
+    return Number.isFinite(id) && id > 0 ? id : new Date(message.date).getTime();
+  };
+  // Archive ids are microsecond stanza ids and ascending in time; fall back to
+  // the date when an id is not numeric.
+  return merged.sort((x, y) => num(x) - num(y));
+};
 const initialState = {
   rooms: {},
   activeRoomJID: null,
@@ -377,14 +482,89 @@ const initialState = {
   },
   pendingNotificationJid: null,
   privateStoreMarkers: {},
+  pendingJump: null,
+  joiningRoomJID: null,
   readBoundaries: {},
+  usersSet: {},
+  jumpWindow: null,
+  archivedMessage: null,
   pendingReactions: {}
 };
 const isValidRoomJid = jid => {
-  if (typeof jid !== 'string' || !jid) return false;
-  if (!jid.includes('@')) return false;
+  if (!isSafeKey(jid)) {
+    return false;
+  }
+  if (!jid.includes('@')) {
+    return false;
+  }
   return true;
 };
+
+/**
+ * Visits every stored copy of one message: the live copy in
+ * state.rooms[jid].messages and, when a jump window is open on that room, the
+ * window's separate copy. The window is a second list of the same messages, so
+ * every reducer that mutates ONE message must go through this or the reader
+ * sees stale edits/reactions/delivery state while away from the live tail.
+ * `matches` is an id, or a predicate when a reducer also matches on xmppId.
+ */
+const forEachMessageCopy = (state, jid, matches, fn) => {
+  const pred = typeof matches === 'function' ? matches : message => message.id === matches;
+  const live = state.rooms[jid]?.messages;
+  if (Array.isArray(live)) {
+    for (const message of live) {
+      if (pred(message)) {
+        fn(message);
+      }
+    }
+  }
+  const win = state.jumpWindow;
+  if (win && win.roomJID === jid && Array.isArray(win.messages)) {
+    for (const message of win.messages) {
+      if (pred(message)) {
+        fn(message);
+      }
+    }
+  }
+};
+
+/**
+ * usersCnt after a /chats/my refresh. The API reports the true total in
+ * `usersCnt` but at most 30 `members` for a big room, so the members array
+ * length is only a floor; and a count already known (a larger one from an
+ * earlier response or a live join) is never lowered by a refresh.
+ */
+const resolveIncomingUsersCnt = (incoming, existing) => {
+  const apiTotal = typeof incoming.usersCnt === 'number' && incoming.usersCnt > 0 ? incoming.usersCnt : 0;
+  const membersLen = Array.isArray(incoming.members) ? incoming.members.length : 0;
+  const next = Math.max(apiTotal, membersLen);
+  return Math.max(next, existing ? getRoomUserCount(existing) : 0);
+};
+
+/**
+ * The server-reported unread snapshot of a room after an incoming /chats/my
+ * item: the freshest API value wins while the user is not looking at the
+ * room; one being read right now keeps none. Absent from the response =
+ * keep what an earlier, richer response set.
+ */
+const resolveApiUnread = (state, jid, incoming, existing) => {
+  if (state.activeRoomJID === jid || state.visibleRoomJID === jid) {
+    return {
+      apiUnreadCount: undefined,
+      apiUnreadSeededAt: undefined
+    };
+  }
+  if (incoming.apiUnreadCount !== undefined) {
+    return {
+      apiUnreadCount: incoming.apiUnreadCount,
+      apiUnreadSeededAt: incoming.apiUnreadSeededAt ?? Date.now()
+    };
+  }
+  return {
+    apiUnreadCount: existing?.apiUnreadCount,
+    apiUnreadSeededAt: existing?.apiUnreadSeededAt
+  };
+};
 export const addRoomViaApi = createAsyncThunk('roomMessages/addRoomViaApi', async ({
   room,
   xmpp
@@ -437,6 +617,9 @@ const reducers = {
     const {
       jid
     } = action.payload;
+    if (!isSafeKey(jid)) {
+      return;
+    }
     if (state.rooms[jid]) {
       delete state.rooms[jid];
       if (state.visibleRoomJID === jid) {
@@ -449,19 +632,40 @@ const reducers = {
       jid,
       updates
     } = action.payload;
+    if (!isSafeKey(jid)) {
+      return;
+    }
     const existingRoom = state.rooms[jid];
-    if (existingRoom) {
-      state.rooms[jid] = {
-        ...existingRoom,
-        ...updates
-      };
+    if (!existingRoom) {
+      return;
     }
+    const merged = {
+      ...existingRoom,
+      ...updates
+    };
+    if (typeof updates.usersCnt === 'number') {
+      // An explicit count (a live join or leave) is taken as given, with the
+      // known members as a floor.
+      const newMembers = Array.isArray(updates.members) ? updates.members : existingRoom.members;
+      const floor = Array.isArray(newMembers) ? newMembers.length : 0;
+      merged.usersCnt = Math.max(updates.usersCnt, floor);
+    } else if (Array.isArray(updates.members)) {
+      // A members-only refresh of a truncated big room (usersCnt > the
+      // first page) must not collapse the true total to the page length.
+      const prevMembers = Array.isArray(existingRoom.members) ? existingRoom.members.length : 0;
+      const prevCnt = typeof existingRoom.usersCnt === 'number' ? existingRoom.usersCnt : 0;
+      merged.usersCnt = prevCnt > prevMembers ? Math.max(prevCnt, updates.members.length) : updates.members.length;
+    }
+    state.rooms[jid] = merged;
   },
   setRoomMessages(state, action) {
     const {
       roomJID,
       messages
     } = action.payload;
+    if (!isSafeKey(roomJID)) {
+      return;
+    }
     if (state.rooms[roomJID]) {
       // Cap to the runtime limit on replace too — guards against a
       // single MAM page returning more than the limit (would balloon
@@ -475,6 +679,9 @@ const reducers = {
       roomJID,
       messageId
     } = action.payload;
+    if (!isSafeKey(roomJID)) {
+      return;
+    }
     const room = state.rooms[roomJID];
     if (!room?.messages) {
       return;
@@ -491,11 +698,9 @@ const reducers = {
       }
       return;
     }
-    room.messages.map(message => {
-      if (message.id === messageId) {
-        message.isDeleted = true;
-        message.reaction = undefined;
-      }
+    forEachMessageCopy(state, roomJID, messageId, message => {
+      message.isDeleted = true;
+      message.reaction = undefined;
     });
   },
   setEditAction: (state, action) => {
@@ -516,30 +721,77 @@ const reducers = {
       messageId,
       text
     } = action.payload;
-    if (state.rooms[roomJID]) {
-      state.rooms[roomJID].messages.map(message => {
-        if (message.id === messageId) {
-          message.body = text;
-          // Flag the correction so the bubble can render an "edited" marker.
-          // Covers both the author's own edit and edits from other users —
-          // every <replace> echo flows through here.
-          message.isEdited = true;
-        }
-      });
+    if (!isSafeKey(roomJID)) {
+      return;
+    }
+    // Edited in place on every copy (live list and jump window).
+    forEachMessageCopy(state, roomJID, messageId, message => {
+      message.body = text;
+      // Flag the correction so the bubble can render an "edited" marker.
+      // Covers both the author's own edit and edits from other users -
+      // every <replace> echo flows through here.
+      message.isEdited = true;
+    });
+  },
+  /**
+   * Hard removal, unlike `deleteRoomMessage`'s tombstone. For optimistic
+   * messages that never made it onto the wire.
+   */
+  removeRoomMessage(state, action) {
+    const {
+      roomJID,
+      messageId
+    } = action.payload;
+    if (!isSafeKey(roomJID)) {
+      return;
+    }
+    if (state.rooms[roomJID]?.messages) {
+      state.rooms[roomJID].messages = state.rooms[roomJID].messages.filter(message => message.id !== messageId);
+    }
+    const win = state.jumpWindow;
+    if (win && win.roomJID === roomJID) {
+      win.messages = win.messages.filter(message => message.id !== messageId);
     }
   },
+  /**
+   * Caches one translation onto the message it belongs to, keyed by the
+   * locale tag the translate service echoed back. Applied to the live
+   * copy and the jump window's copy.
+   */
+  setMessageTranslation(state, action) {
+    const {
+      roomJID,
+      messageId,
+      locale,
+      entry
+    } = action.payload;
+    if (!isSafeKey(roomJID) || !isSafeKey(locale)) {
+      return;
+    }
+    forEachMessageCopy(state, roomJID, messageId, message => {
+      if (!message.translations) {
+        message.translations = {};
+      }
+      message.translations[locale] = entry;
+    });
+  },
   addRoomMessage(state, action) {
     const {
       roomJID,
       message,
       start
     } = action.payload;
+    if (!isSafeKey(roomJID)) {
+      return;
+    }
     const lengthBefore = state.rooms[roomJID]?.messages?.length || 0;
     const outcome = insertRoomMessage(state, roomJID, message, start);
     if (outcome.grew) {
       capAfterGrowth(state.rooms[roomJID].messages, lengthBefore, outcome.atHead);
     }
     bumpLastMessageTimestamp(state, roomJID, message);
+    // Keep the jump window's copy in step with the live list.
+    syncJumpWindowWithMessage(state, roomJID, message, start, true);
   },
   /**
    * A whole page of messages (a MAM history page) in ONE action: the same
@@ -553,7 +805,7 @@ const reducers = {
       messages,
       start
     } = action.payload;
-    if (!state.rooms[roomJID] || !Array.isArray(messages)) {
+    if (!isSafeKey(roomJID) || !state.rooms[roomJID] || !Array.isArray(messages)) {
       return;
     }
     const lengthBefore = state.rooms[roomJID].messages?.length || 0;
@@ -571,6 +823,9 @@ const reducers = {
       if (!newest || Number(message?.id) > Number(newest.id)) {
         newest = message;
       }
+      // History pages never append to a reader's jump window (they are not
+      // "the newest message"); they only refresh copies it already holds.
+      syncJumpWindowWithMessage(state, roomJID, message, start, false);
     }
     if (grew) {
       // A page that only prepended older history is never trimmed.
@@ -582,6 +837,7 @@ const reducers = {
   },
   deleteAllRooms(state) {
     state.rooms = {};
+    state.jumpWindow = null;
     state.visibleRoomJID = null;
     state.privateStoreMarkers = {};
     state.readBoundaries = {};
@@ -593,6 +849,9 @@ const reducers = {
       composing,
       composingList
     } = action.payload;
+    if (!isSafeKey(chatJID) || !state.rooms[chatJID]) {
+      return;
+    }
     state.rooms[chatJID].composing = composing;
     state.rooms[chatJID].composingList = composingList;
   },
@@ -602,7 +861,7 @@ const reducers = {
       loading,
       loadingText
     } = action.payload;
-    if (chatJID && state.rooms?.[chatJID]) {
+    if (isSafeKey(chatJID) && state.rooms?.[chatJID]) {
       state.rooms[chatJID].isLoading = loading;
     }
     state.isLoading = loading;
@@ -616,7 +875,7 @@ const reducers = {
       chatJID,
       timestamp
     } = action.payload;
-    if (state.rooms[chatJID]) {
+    if (isSafeKey(chatJID) && state.rooms[chatJID]) {
       state.rooms[chatJID].lastViewedTimestamp = timestamp;
       // A non-positive timestamp means "no persisted marker yet" and
       // must not inflate unread from history that predates the first
@@ -667,7 +926,7 @@ const reducers = {
     }
     for (const jid of Object.keys(markers)) {
       const ts = Number(markers[jid]);
-      if (!jid || !Number.isFinite(ts) || ts <= 0) {
+      if (!isSafeKey(jid) || !Number.isFinite(ts) || ts <= 0) {
         continue;
       }
       const room = state.rooms[jid];
@@ -711,7 +970,7 @@ const reducers = {
       jid,
       ts
     } = action.payload;
-    if (!jid) {
+    if (!isSafeKey(jid)) {
       return;
     }
     if (!state.readBoundaries) {
@@ -733,7 +992,7 @@ const reducers = {
     const {
       jid
     } = action.payload;
-    if (jid && state.readBoundaries) {
+    if (isSafeKey(jid) && state.readBoundaries) {
       delete state.readBoundaries[jid];
     }
   },
@@ -742,7 +1001,7 @@ const reducers = {
       chatJID,
       role
     } = action.payload;
-    if (state.rooms[chatJID]) {
+    if (isSafeKey(chatJID) && state.rooms[chatJID]) {
       state.rooms[chatJID].role = role;
     }
   },
@@ -751,20 +1010,40 @@ const reducers = {
       value,
       chatJID
     } = action.payload;
-    if (chatJID) {
+    if (isSafeKey(chatJID) && state.rooms[chatJID]) {
       state.rooms[chatJID].noMessages = value;
     }
   },
   setCurrentRoom: (state, action) => {
     // Accept null/empty so callers can clear the active room (e.g.
     // back button from chat → return to RoomList). Mirrors web.
-    state.activeRoomJID = action.payload.roomJID || '';
+    const {
+      roomJID
+    } = action.payload;
+    if (roomJID && !isSafeKey(roomJID)) {
+      return;
+    }
+    state.activeRoomJID = roomJID || '';
+    // Opening a room reads it: the server's earlier unread count no longer
+    // applies (the unread middleware would otherwise bring it back the
+    // moment the user leaves the room again).
+    if (roomJID && state.rooms[roomJID]?.apiUnreadCount !== undefined) {
+      state.rooms[roomJID].apiUnreadCount = undefined;
+      state.rooms[roomJID].apiUnreadSeededAt = undefined;
+      state.rooms[roomJID].unreadMessages = 0;
+    }
   },
   setVisibleRoom: (state, action) => {
-    state.visibleRoomJID = action.payload.roomJID || null;
+    const requested = action.payload.roomJID;
+    if (requested && !isSafeKey(requested)) {
+      return;
+    }
+    state.visibleRoomJID = requested || null;
     const jid = state.visibleRoomJID;
     if (jid && state.rooms[jid]) {
       state.rooms[jid].unreadMessages = 0;
+      state.rooms[jid].apiUnreadCount = undefined;
+      state.rooms[jid].apiUnreadSeededAt = undefined;
     }
   },
   clearVisibleRoom: state => {
@@ -787,6 +1066,81 @@ const reducers = {
   clearPendingNotificationJid: state => {
     state.pendingNotificationJid = null;
   },
+  requestJumpToMessage: (state, action) => {
+    const ids = action.payload.ids.filter(Boolean);
+    const canMatchByContent = Boolean(action.payload.createdAt && action.payload.body);
+    if (!action.payload.roomJID || ids.length === 0 && !canMatchByContent) {
+      return;
+    }
+    state.pendingJump = {
+      roomJID: action.payload.roomJID,
+      ids,
+      createdAt: action.payload.createdAt,
+      body: action.payload.body,
+      preview: action.payload.preview,
+      at: Date.now()
+    };
+  },
+  clearPendingJump: state => {
+    state.pendingJump = null;
+  },
+  showArchivedMessage: (state, action) => {
+    state.archivedMessage = action.payload;
+  },
+  clearArchivedMessage: state => {
+    state.archivedMessage = null;
+  },
+  setJumpWindow: (state, action) => {
+    state.jumpWindow = {
+      ...action.payload,
+      messages: mergeWindowMessages(action.payload.messages, [])
+    };
+  },
+  prependJumpWindowMessages: (state, action) => {
+    const win = state.jumpWindow;
+    if (!win || win.roomJID !== action.payload.roomJID) {
+      return;
+    }
+    win.messages = mergeWindowMessages(action.payload.messages, win.messages);
+    win.olderCursor = action.payload.olderCursor;
+    win.hasOlder = action.payload.hasOlder;
+    if (win.messages.length > JUMP_WINDOW_MAX_MESSAGES) {
+      // Reader is going up: drop the far (newest) side and page it again if
+      // they come back down.
+      win.messages = win.messages.slice(0, JUMP_WINDOW_MAX_MESSAGES);
+      const newest = Number(win.messages[win.messages.length - 1].id);
+      win.newerCursor = Number.isFinite(newest) ? newest : win.newerCursor;
+      win.hasNewer = true;
+    }
+  },
+  appendJumpWindowMessages: (state, action) => {
+    const win = state.jumpWindow;
+    if (!win || win.roomJID !== action.payload.roomJID) {
+      return;
+    }
+    win.messages = mergeWindowMessages(win.messages, action.payload.messages);
+    win.newerCursor = action.payload.newerCursor;
+    win.hasNewer = action.payload.hasNewer;
+    if (win.messages.length > JUMP_WINDOW_MAX_MESSAGES) {
+      win.messages = win.messages.slice(-JUMP_WINDOW_MAX_MESSAGES);
+      const oldest = Number(win.messages[0].id);
+      win.olderCursor = Number.isFinite(oldest) ? oldest : win.olderCursor;
+      win.hasOlder = true;
+    }
+  },
+  clearJumpWindow: state => {
+    state.jumpWindow = null;
+  },
+  setJoiningRoom: (state, action) => {
+    state.joiningRoomJID = action.payload || null;
+  },
+  // Only clears when it still names that room, so a slow join for a room
+  // the user already left cannot wipe the join of the current one.
+  clearJoiningRoom: (state, action) => {
+    if (state.joiningRoomJID === action.payload) {
+      state.joiningRoomJID = null;
+    }
+  },
   /**
    * Stamp a message in `state.rooms[roomJID].messages` with an updated
    * reactions list. The reactionsMiddleware listens for this action to
@@ -801,13 +1155,21 @@ const reducers = {
       data,
       latestReactionTimestamp
     } = action.payload;
-    if (!from) {
+    if (!isSafeKey(roomJID) || !from) {
       return;
     }
-    const room = state.rooms[roomJID];
-    const target = room?.messages?.find(msg => msg?.id === messageId || msg?.xmppId === messageId);
-    if (target) {
-      applyReactionToMessage(target, from, reactions, data, latestReactionTimestamp);
+    // `fromId` becomes a property name on the message's reaction map.
+    const fromId = String(from).split('/')[0].split('@')[0];
+    if (!isSafeKey(fromId)) {
+      return;
+    }
+    let found = false;
+    // Applied on every stored copy (live list and jump window).
+    forEachMessageCopy(state, roomJID, msg => msg?.id === messageId || msg?.xmppId === messageId, message => {
+      found = true;
+      applyReactionToMessage(message, from, reactions, data, latestReactionTimestamp);
+    });
+    if (found) {
       return;
     }
     // The message is not loaded (yet): keep the reaction for it.
@@ -834,27 +1196,42 @@ const reducers = {
     state.isUnreadSyncing = false;
     state.privateStoreMarkers = {};
     state.readBoundaries = {};
+    state.usersSet = {};
+    state.jumpWindow = null;
+    state.archivedMessage = null;
+    state.pendingJump = null;
   },
   setActiveMessage: (state, action) => {
     const {
       id,
       chatJID
     } = action.payload;
-    state.rooms[chatJID].messages.map(message => {
-      if (message.id === id) {
-        message.activeMessage = true;
-      } else {
-        message.activeMessage = false;
-      }
-    });
+    if (!isSafeKey(chatJID) || !state.rooms[chatJID]) {
+      return;
+    }
+    const flag = message => {
+      message.activeMessage = message.id === id;
+    };
+    state.rooms[chatJID].messages.forEach(flag);
+    if (state.jumpWindow?.roomJID === chatJID) {
+      state.jumpWindow.messages.forEach(flag);
+    }
   },
   setCloseActiveMessage: (state, action) => {
     const {
       chatJID
     } = action.payload;
-    state.rooms[chatJID].messages.map(message => {
+    if (!isSafeKey(chatJID) || !state.rooms[chatJID]) {
+      return;
+    }
+    state.rooms[chatJID].messages.forEach(message => {
       message.activeMessage = false;
     });
+    if (state.jumpWindow?.roomJID === chatJID) {
+      state.jumpWindow.messages.forEach(message => {
+        message.activeMessage = false;
+      });
+    }
   },
   /**
    * Batched update used by the history preload scheduler. Each patch is
@@ -873,15 +1250,14 @@ const reducers = {
       ...existing,
       ...room,
       title: room.title || existing?.title || room.title,
-      usersCnt: (() => {
-        const incoming = typeof room.usersCnt === 'number' && room.usersCnt > 0 ? room.usersCnt : 0;
-        const previous = typeof existing?.usersCnt === 'number' && existing.usersCnt > 0 ? existing.usersCnt : 0;
-        if (incoming === 0 && previous === 0) return room.usersCnt;
-        return Math.max(incoming, previous);
-      })(),
+      usersCnt: resolveIncomingUsersCnt(room, existing),
       icon: room.icon ?? existing?.icon,
       messages: existingMessages.length > 0 ? existingMessages : incomingMessages,
+      // A seed for the room-list preview (the API's `lastMessage`): take the
+      // freshest value, never let a refresh without one erase it.
+      lastMessage: room.lastMessage ?? existing?.lastMessage,
       unreadMessages: existing?.unreadMessages ?? room.unreadMessages ?? 0,
+      ...resolveApiUnread(state, room.jid, room, existing),
       lastViewedTimestamp: existing?.lastViewedTimestamp ?? room.lastViewedTimestamp ?? 0,
       unreadBaselineTimestamp: existing?.unreadBaselineTimestamp ?? existing?.lastViewedTimestamp ?? room.unreadBaselineTimestamp ?? room.lastViewedTimestamp ?? 0,
       composingList: existing?.composingList ?? room.composingList,
@@ -897,8 +1273,11 @@ const reducers = {
       rooms
     } = action.payload;
     for (const patch of rooms) {
+      if (!isSafeKey(patch?.jid)) {
+        continue;
+      }
       const room = state.rooms[patch.jid];
-      if (!room) {
+      if (!room || typeof room !== 'object' || Array.isArray(room)) {
         continue;
       }
       if (typeof patch.historyPreloadState !== 'undefined') {
@@ -910,6 +1289,12 @@ const reducers = {
       if (typeof patch.historyComplete !== 'undefined') {
         room.historyComplete = patch.historyComplete;
       }
+      if (patch.messageStats) {
+        room.messageStats = {
+          ...room.messageStats,
+          ...patch.messageStats
+        };
+      }
       if (Array.isArray(patch.messages)) {
         for (const m of patch.messages) {
           takePendingReactions(state, patch.jid, m);
@@ -927,10 +1312,13 @@ const reducers = {
   // part and the full jid so either lookup style hits — a message's
   // `user.id` can be either depending on how it was parsed.
   mergeUsersSet(state, action) {
-    state.usersSet = {
-      ...(state.usersSet || {}),
-      ...action.payload.members
-    };
+    // A real merge with a cap: fresh entries win (and move to the newest
+    // position), entries fetched lazily earlier stay, the oldest-inserted
+    // are evicted past USERS_SET_CAP. Unsafe keys are skipped.
+    if (!state.usersSet || typeof state.usersSet !== 'object') {
+      state.usersSet = {};
+    }
+    mergeIntoUsersSet(state.usersSet, action.payload?.members || {});
   }
 };
 export const roomsStore = createSlice({
@@ -1050,8 +1438,21 @@ export const {
   setUnreadCounts,
   setPendingNotificationJid,
   clearPendingNotificationJid,
+  requestJumpToMessage,
+  clearPendingJump,
+  setJoiningRoom,
+  clearJoiningRoom,
   setReactions,
-  mergeUsersSet
+  mergeUsersSet,
+  removeRoomMessage,
+  addRoomFromApi,
+  setMessageTranslation,
+  showArchivedMessage,
+  clearArchivedMessage,
+  setJumpWindow,
+  prependJumpWindowMessages,
+  appendJumpWindowMessages,
+  clearJumpWindow
 } = roomsStore.actions;
 export default roomsStore.reducer;
 //# sourceMappingURL=roomsSlice.js.map