@ethora/chat-component-rn 26.8.5 → 26.8.7

package/src/roomStore/roomsSlice.ts

@@ -15,6 +15,9 @@ import type XmppClient from '../networking/xmppClient';
 // page backward arbitrarily far without instantly losing what they
 // just fetched. After cap eviction we drop from the head (oldest).
 export const RUNTIME_MESSAGE_LIMIT = 100;
+/** One preload page: "N+" badges only ever mean "at least this many". */
+export const UNREAD_CAP_PAGE = 10;
+export const RUNTIME_MESSAGE_CEILING = 2000;
 
 // Body strings the server uses for call signaling broadcasts (call-token,
 // call-state ringing/ended, etc). These should never reach the chat
@@ -107,11 +110,215 @@ const collapseCallLogDuplicates = (messages: IMessage[]): IMessage[] => {
     });
 };
 
-const enforceMessageCap = (messages: IMessage[]): void => {
+type InsertOutcome = { grew: boolean; atHead: boolean };
+const NO_GROWTH: InsertOutcome = { grew: false, atHead: false };
+
+const insertRoomMessage = (
+  state: WritableDraft<RoomMessagesState>,
+  roomJID: string,
+  message: IMessage,
+  start?: boolean
+): InsertOutcome => {
+  if (isCallSignalMessage(message)) {
+    return NO_GROWTH;
+  }
+
+  if (!state.rooms[roomJID]) {
+    return NO_GROWTH;
+  }
+
+  if (!state.rooms[roomJID].messages) {
+    state.rooms[roomJID].messages = [];
+  }
+
+  const roomMessages = state.rooms[roomJID].messages!;
+
+  const incomingCallLog = message.callLog;
+  if (incomingCallLog?.callId) {
+    const existingCallIdx = roomMessages.findIndex(
+      (msg) => msg.callLog?.callId === incomingCallLog.callId
+    );
+    if (existingCallIdx !== -1) {
+      const existing = roomMessages[existingCallIdx];
+      const merged = mergeCallLogEntries(existing as IMessage, message);
+      if (merged !== (existing as IMessage)) {
+        roomMessages[existingCallIdx] = merged;
+      }
+      return NO_GROWTH;
+    }
+  }
+
+  takePendingReactions(state, roomJID, message);
+  const lengthBefore = roomMessages.length;
+  const tailBefore = roomMessages[lengthBefore - 1];
+
+  if (roomMessages.length === 0 || start) {
+    roomMessages.unshift(message);
+  } else {
+    const lastViewedValue = state.rooms[roomJID].lastViewedTimestamp;
+    const lastViewedTimestamp =
+      state.visibleRoomJID === roomJID
+        ? null
+        : lastViewedValue
+          ? lastViewedValue
+          : null;
+
+    insertMessageWithDelimiter(roomMessages, message, lastViewedTimestamp);
+  }
+
+  const grew = roomMessages.length > lengthBefore;
+  const atHead =
+    grew &&
+    lengthBefore > 0 &&
+    roomMessages[roomMessages.length - 1] === tailBefore;
+  return { grew, atHead };
+};
+
+const capAfterGrowth = (
+  messages: IMessage[],
+  lengthBefore: number,
+  atHead: boolean
+): void => {
+  if (atHead) {
+    enforceMessageCap(messages, RUNTIME_MESSAGE_CEILING);
+    return;
+  }
+  enforceMessageCap(
+    messages,
+    Math.min(RUNTIME_MESSAGE_CEILING, Math.max(RUNTIME_MESSAGE_LIMIT, lengthBefore))
+  );
+};
+
+const bumpLastMessageTimestamp = (
+  state: WritableDraft<RoomMessagesState>,
+  roomJID: string,
+  message: IMessage
+): void => {
+  const room = state.rooms[roomJID];
+  if (!room || message?.id === 'delimiter-new') {return;}
+  const ts = Number(message?.id);
+  if (!Number.isFinite(ts)) {return;}
+  if ((room.lastMessageTimestamp ?? 0) <= ts) {
+    room.lastMessageTimestamp = ts;
+  }
+};
+
+const upsertRoom = (
+  state: WritableDraft<RoomMessagesState>,
+  roomData: IRoom
+): void => {
+      const existing = state.rooms[roomData.jid];
+      let lastViewed: number;
+      const serverMarker = state.privateStoreMarkers?.[roomData.jid] || 0;
+
+      if (roomData.lastViewedTimestamp != null && roomData.lastViewedTimestamp !== 0) {
+        lastViewed = roomData.lastViewedTimestamp;
+      } else if (existing?.lastViewedTimestamp != null && existing.lastViewedTimestamp > 0) {
+        lastViewed = existing.lastViewedTimestamp;
+      } else if (serverMarker > 0) {
+        lastViewed = serverMarker;
+      } else {
+        const msgs = roomData.messages || [];
+        let newest = 0;
+        for (const m of msgs) {
+          const t = (m as any)?.messageTimestampMs ||
+            (m?.date ? new Date(m.date).getTime() : 0);
+          if (t > newest) {newest = t;}
+        }
+        lastViewed = newest; // 0 if no messages → cold-start safe
+      }
+
+      const incomingMessages = Array.isArray(roomData.messages)
+        ? roomData.messages
+        : [];
+      const existingMessages = Array.isArray(existing?.messages)
+        ? existing!.messages
+        : [];
+      state.rooms[roomData.jid] = {
+        ...roomData,
+        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,
+        unreadBaselineTimestamp:
+          existing?.unreadBaselineTimestamp ??
+          existing?.lastViewedTimestamp ??
+          (roomData as any).unreadBaselineTimestamp ??
+          0,
+      };
+};
+
+/** Order two numeric stanza ids (microsecond timestamps, too long for a
+ * double) without BigInt: by length, then lexicographically. */
+export const compareStanzaIds = (a: string, b: string): number =>
+  a.length !== b.length ? a.length - b.length : a < b ? -1 : a > b ? 1 : 0;
+
+export const applyReactionToMessage = (
+  message: IMessage,
+  from: string | undefined,
+  reactions: string[],
+  data?: Record<string, string>,
+  ts?: string
+): void => {
+  const fromId = String(from || '').split('/')[0].split('@')[0];
+  if (!fromId) {return;}
+  const list = (reactions || []).filter((r) => !!r);
+  const current = { ...(message.reaction || {}) };
+  const prev = current[fromId];
+  // An older reaction (from a history page loaded after a newer one) never
+  // overwrites what is already known.
+  if (ts && prev?.ts && compareStanzaIds(ts, prev.ts) < 0) {return;}
+  if (list.length === 0) {
+    if (ts) {
+      // Keep a "removed" marker so an older reaction can't come back.
+      current[fromId] = { emoji: [], data: data || {}, ts };
+    } else {
+      delete current[fromId];
+    }
+  } else {
+    current[fromId] = { emoji: list, data: data || {}, ...(ts ? { ts } : {}) };
+  }
+  const anyShown = Object.values(current).some((r) => r?.emoji?.length);
+  message.reaction = anyShown || Object.keys(current).length ? current : undefined;
+};
+
+type PendingReaction = {
+  from: string;
+  reactions: string[];
+  data?: Record<string, string>;
+  ts?: string;
+};
+
+/** Reactions whose message is not loaded yet — applied when it arrives. */
+const takePendingReactions = (
+  state: WritableDraft<RoomMessagesState>,
+  roomJID: string,
+  message: IMessage
+): void => {
+  const byMessage = state.pendingReactions?.[roomJID];
+  if (!byMessage) {return;}
+  const keys = [String(message.id), message.xmppId ? String(message.xmppId) : ''];
+  for (const key of keys) {
+    const list = key ? byMessage[key] : undefined;
+    if (!list) {continue;}
+    for (const r of list) {
+      applyReactionToMessage(message, r.from, r.reactions, r.data, r.ts);
+    }
+    delete byMessage[key];
+  }
+};
+
+const enforceMessageCap = (
+  messages: IMessage[],
+  limit: number = RUNTIME_MESSAGE_LIMIT
+): void => {
   // Trim oldest until we're at/under the limit. Mutates in place
   // (immer-compatible inside reducers).
-  while (messages.length > RUNTIME_MESSAGE_LIMIT) {
-    messages.shift();
+  if (messages.length > limit) {
+    messages.splice(0, messages.length - limit);
   }
 };
 
@@ -202,10 +409,16 @@ function mergeHistoryIntoCache(
     // body). Preserve `isEdited` from the cached copy so a message edited
     // before reload keeps its marker instead of losing it on history sync.
     const prev = byId.get(String(m.id));
-    byId.set(
-      String(m.id),
-      prev?.isEdited && !m.isEdited ? { ...m, isEdited: true } : m
-    );
+    let next = prev?.isEdited && !m.isEdited ? { ...m, isEdited: true } : m;
+
+    if (prev?.reaction && !next.reaction) {
+      next = { ...next, reaction: prev.reaction };
+    }
+    // A history merge must not close a thread the user has open.
+    if ((prev as any)?.activeMessage && !(next as any).activeMessage) {
+      next = { ...next, activeMessage: true } as IMessage;
+    }
+    byId.set(String(m.id), next);
   }
   const merged = collapseCallLogDuplicates(
     Array.from(byId.values()).sort(byMs)
@@ -237,6 +450,9 @@ export interface RoomMessagesState {
   // — see `applyPrivateStoreMarkers`. Re-fetched every init/reconnect,
   // so it is intentionally NOT persisted.
   privateStoreMarkers: Record<string, number>;
+  /** `{ roomJID: { messageId: reactions[] } }` — reactions that arrived
+   * before their message (a newer history page), applied on insert. */
+  pendingReactions?: Record<string, Record<string, PendingReaction[]>>;
   // The single source of truth for "read up to here, but the user
   // hasn't reached the bottom yet" (`{ roomJID: boundaryMs }`).
   // Set by MessageList (via ChatRoom's `onReadBoundaryChange`) the
@@ -281,6 +497,7 @@ const initialState: RoomMessagesState = {
   pendingNotificationJid: null,
   privateStoreMarkers: {},
   readBoundaries: {},
+  pendingReactions: {},
 };
 
 const isValidRoomJid = (jid: unknown): jid is string => {
@@ -306,81 +523,26 @@ export const addRoomViaApi = createAsyncThunk(
 // emitted .d.ts (TS4023). See chatSettingsSlice.ts for the same pattern.
 const reducers = {
   addRoom(state: WritableDraft<RoomMessagesState>, action: PayloadAction<{ roomData: IRoom }>) {
-      const { roomData } = action.payload;
-      const existing = state.rooms[roomData.jid];
-      // Default-marker resolution (cold-start unread bug):
-      //   1. Explicit value on the payload wins.
-      //   2. Existing redux value wins (preserves persisted/hydrated
-      //      markers when the privateStore pull lands before
-      //      /chats/my).
-      //   3. Otherwise, anchor to the *newest known message* in the
-      //      payload — this marks everything currently in the room
-      //      as "seen" but lets any NEWER incoming message count as
-      //      unread. Previously this fell back to `Date.now()`, which
-      //      stamped a future-leaning marker that hid genuinely-new
-      //      messages received while the app was closed.
-      //   4. If there are no messages at all yet, stamp `0` (=
-      //      "unknown — let the privateStore hydration set the real
-      //      marker before any future message arrives").
-      let lastViewed: number;
-      // Treat an incoming `0` as "unset". stanzaHandlers' addRoom passes
-      // `lastViewedTimestamp: 0` as a placeholder; the old `!= null` check
-      // let that 0 win and OVERWROTE the persisted/hydrated marker from
-      // the previous session, so cold-start showed no unread badge for
-      // messages received while the app was closed (bug #19/#20). A real
-      // (non-zero) explicit value still wins; otherwise keep the existing
-      // value; otherwise fall back to the server-side read marker fetched
-      // from the private store (so a room the user has NEVER opened this
-      // session still gets a real baseline — without it the unread
-      // middleware's `lastViewedTimestamp > 0` gate skipped the room
-      // forever and the badge never lit up); otherwise anchor to the
-      // newest message in the payload.
-      const serverMarker = state.privateStoreMarkers?.[roomData.jid] || 0;
-      if (roomData.lastViewedTimestamp != null && roomData.lastViewedTimestamp !== 0) {
-        lastViewed = roomData.lastViewedTimestamp;
-      } else if (existing?.lastViewedTimestamp != null && existing.lastViewedTimestamp > 0) {
-        lastViewed = existing.lastViewedTimestamp;
-      } else if (serverMarker > 0) {
-        lastViewed = serverMarker;
-      } else {
-        const msgs = roomData.messages || [];
-        let newest = 0;
-        for (const m of msgs) {
-          const t = (m as any)?.messageTimestampMs ||
-            (m?.date ? new Date(m.date).getTime() : 0);
-          if (t > newest) {newest = t;}
-        }
-        lastViewed = newest; // 0 if no messages → cold-start safe
+      upsertRoom(state, action.payload.roomData);
+    },
+
+    setUnreadCounts(state: WritableDraft<RoomMessagesState>, action: PayloadAction<Record<string, number>>) {
+      for (const [jid, count] of Object.entries(action.payload || {})) {
+        const room = state.rooms[jid];
+        if (!room) {continue;}
+        if (room.unreadMessages !== count) {room.unreadMessages = count;}
+        // "N+" only means "a whole page was unread"; an exact count below a
+        // page (or read to zero) settles it.
+        if (room.unreadCapped && count < UNREAD_CAP_PAGE) {room.unreadCapped = false;}
+      }
+    },
+    /** Several rooms in one action — the cold-start rehydrate of the whole
+     * cache used to be one `addRoom` per room, each running every
+     * middleware over every room already added (O(rooms²)). */
+    addRooms(state: WritableDraft<RoomMessagesState>, action: PayloadAction<{ rooms: IRoom[] }>) {
+      for (const roomData of action.payload.rooms || []) {
+        if (roomData?.jid) {upsertRoom(state, roomData);}
       }
-      // Preserve cached messages + unread when the incoming room carries
-      // none. The /chats/my fetch (rooms.api) builds rooms with
-      // `messages: []` and no unread; without this guard, re-entering the
-      // app replaced every cached room with an empty one — wiping history
-      // AND the unread badge before the history scheduler could re-merge
-      // (the user's "it clears cache, unread and messages" bug). New rooms
-      // (no existing) fall through to the incoming values. Mirrors
-      // addRoomFromApi's preservation.
-      const incomingMessages = Array.isArray(roomData.messages)
-        ? roomData.messages
-        : [];
-      const existingMessages = Array.isArray(existing?.messages)
-        ? existing!.messages
-        : [];
-      state.rooms[roomData.jid] = {
-        ...roomData,
-        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,
-        unreadBaselineTimestamp:
-          existing?.unreadBaselineTimestamp ??
-          existing?.lastViewedTimestamp ??
-          (roomData as any).unreadBaselineTimestamp ??
-          0,
-      };
     },
     deleteRoom(state: WritableDraft<RoomMessagesState>, action: PayloadAction<{ jid: string }>) {
       const { jid } = action.payload;
@@ -441,6 +603,7 @@ const reducers = {
       room.messages.map((message) => {
         if (message.id === messageId) {
           message.isDeleted = true;
+          message.reaction = undefined;
         }
       });
     },
@@ -486,79 +649,51 @@ const reducers = {
       }>
     ) {
       const { roomJID, message, start } = action.payload;
-
-      // Call signaling broadcasts ("call-token", "call-state", etc.)
-      // sometimes slip past the live XMPP filter (MAM history, mucsub
-      // catch-up), drop them here so they never land in the transcript
-      // or the room-list "last message" preview.
-      if (isCallSignalMessage(message)) {
-        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);
       }
-
-      // Guard against the "stanza arrived before /chats/my completed"
-      // race — without this, the optional-chain `?.messages` falls
-      // back to undefined, and the assignment below tries to set
-      // `.messages` on undefined → TypeError. Caller can safely
-      // ignore the message; the room will get its messages array on
-      // `addRoom` when the API response lands.
-      if (!state.rooms[roomJID]) {
+      bumpLastMessageTimestamp(state, roomJID, message);
+    },
+    /**
+     * A whole page of messages (a MAM history page) in ONE action: the same
+     * per-message insert as `addRoomMessage`, but the cap, the middleware
+     * chain and every subscriber run once per page instead of once per
+     * message.
+     */
+    addRoomMessages(
+      state: WritableDraft<RoomMessagesState>,
+      action: PayloadAction<{
+        roomJID: string;
+        messages: IMessage[];
+        start?: boolean;
+      }>
+    ) {
+      const { roomJID, messages, start } = action.payload;
+      if (!state.rooms[roomJID] || !Array.isArray(messages)) {
         return;
       }
-
-      if (!state.rooms[roomJID].messages) {
-        state.rooms[roomJID].messages = [];
-      }
-
-      const roomMessages = state.rooms[roomJID].messages;
-
-      // Collapse multiple call-state events for the same call into a single
-      // log entry. Sources: the client-side fallback written at hangup (id
-      // "calllog-<callId>", exists only locally) and the server broadcast(s),
-      // which can fire once per participant leaving (earlier ones carry a
-      // partial durationMs). Rules:
-      //  - the SERVER copy is canonical for identity (id/date/xmppId): its
-      //    archive id is what MAM and the catch-up anchor return later, so
-      //    keeping a local "calllog-" id around breaks anchor matching and
-      //    duplicates the entry on the next history merge;
-      //  - the LARGEST duration wins for display, so a 2-minute call doesn't
-      //    render as "2 sec".
-      const incomingCallLog = message.callLog;
-      if (incomingCallLog?.callId) {
-        const existingCallIdx = roomMessages.findIndex(
-          (msg) => msg.callLog?.callId === incomingCallLog.callId
-        );
-        if (existingCallIdx !== -1) {
-          const existing = roomMessages[existingCallIdx];
-          const merged = mergeCallLogEntries(existing as IMessage, message);
-          if (merged !== (existing as IMessage)) {
-            roomMessages[existingCallIdx] = merged;
-          }
-          return;
+      const lengthBefore = state.rooms[roomJID].messages?.length || 0;
+      let grew = false;
+      let anyAtTail = false;
+      let newest: IMessage | undefined;
+      for (const message of messages) {
+        const outcome = insertRoomMessage(state, roomJID, message, start);
+        if (outcome.grew) {
+          grew = true;
+          if (!outcome.atHead) {anyAtTail = true;}
+        }
+        if (!newest || Number(message?.id) > Number(newest.id)) {
+          newest = message;
         }
       }
-
-      const lengthBefore = roomMessages.length;
-
-      if (roomMessages.length === 0 || start) {
-        roomMessages.unshift(message);
-      } else {
-        const lastViewedValue = state.rooms[roomJID].lastViewedTimestamp;
-        const lastViewedTimestamp =
-          state.visibleRoomJID === roomJID
-            ? null
-            : lastViewedValue
-              ? lastViewedValue
-              : null;
-
-        insertMessageWithDelimiter(roomMessages, message, lastViewedTimestamp);
+      if (grew) {
+        // A page that only prepended older history is never trimmed.
+        capAfterGrowth(state.rooms[roomJID].messages!, lengthBefore, !anyAtTail);
       }
-
-      // Apply the in-memory cap only when the array actually GREW
-      // (i.e. this wasn't a dedupe/merge that left length unchanged).
-      // Otherwise repeated echoes of the same message would chip away
-      // at the oldest history for no reason.
-      if (roomMessages.length > lengthBefore) {
-        enforceMessageCap(roomMessages);
+      if (newest) {
+        bumpLastMessageTimestamp(state, roomJID, newest);
       }
     },
     deleteAllRooms(state: WritableDraft<RoomMessagesState>) {
@@ -798,18 +933,28 @@ const reducers = {
         data?: Record<string, string>;
       }>
     ) => {
-      const { roomJID, messageId, reactions } = action.payload;
+      const { roomJID, messageId, reactions, from, data, latestReactionTimestamp } =
+        action.payload;
+      if (!from) {return;}
       const room = state.rooms[roomJID];
-      if (!room?.messages) {return;}
-      for (const msg of room.messages) {
-        if (msg?.id === messageId) {
-          (msg as any).reactions = reactions;
-          break;
-        }
+      const target = room?.messages?.find(
+        (msg) => msg?.id === messageId || msg?.xmppId === messageId
+      );
+      if (target) {
+        applyReactionToMessage(target as IMessage, from, reactions, data, latestReactionTimestamp);
+        return;
+      }
+      // The message is not loaded (yet): keep the reaction for it.
+      if (!state.pendingReactions) {state.pendingReactions = {};}
+      const byMessage = (state.pendingReactions[roomJID] ||= {});
+      const list = (byMessage[messageId] ||= []);
+      if (list.length < 50) {
+        list.push({ from, reactions, data, ts: latestReactionTimestamp });
       }
     },
     setLogoutState: (state: WritableDraft<RoomMessagesState>) => {
       state.rooms = {};
+      state.pendingReactions = {};
       state.activeRoomJID = null;
       state.visibleRoomJID = null;
       state.isLoading = false;
@@ -911,6 +1056,7 @@ const reducers = {
           room.historyComplete = patch.historyComplete;
         }
         if (Array.isArray(patch.messages)) {
+          for (const m of patch.messages) {takePendingReactions(state, patch.jid, m);}
           // Merge the fetched page into cache by message id rather than
           // replacing — preserves older history + unread on re-entry. Only
           // a true gap (no overlapping id) clears this chat's cache. See
@@ -1043,6 +1189,9 @@ export const {
   deleteRoom,
   updateRoom,
   applyRoomsPreloadBatch,
+  addRoomMessages,
+  addRooms,
+  setUnreadCounts,
   setPendingNotificationJid,
   clearPendingNotificationJid,
   setReactions,

package/src/theme/theme.ts

@@ -33,8 +33,10 @@ export interface ChatThemeColors {
   icon: string;
   /** Sender name above incoming bubbles. */
   senderName: string;
-  /** Day-separator pill text; its background is a tint of it. */
+  /** Day-separator pill text (also system-message pills). */
   dateLabel: string;
+  /** Day-separator / system-message pill background. */
+  dateLabelBackground: string;
 
   /** Ground of the room list screen. */
   listBackground: string;
@@ -100,6 +102,7 @@ export const LIGHT_THEME: ChatThemeColors = {
   icon: DEFAULT_PRIMARY,
   senderName: DEFAULT_PRIMARY,
   dateLabel: DEFAULT_PRIMARY,
+  dateLabelBackground: '#E7EDF9',
 
   listBackground: '#E8EDF2',
   chatBackground: '#F3F6FC',
@@ -133,6 +136,7 @@ export const DARK_THEME: ChatThemeColors = {
   icon: '#4C8DFF',
   senderName: '#7FB0FF',
   dateLabel: '#7FB0FF',
+  dateLabelBackground: '#26303D',
 
   listBackground: '#0F1216',
   chatBackground: '#141A21',
@@ -174,6 +178,7 @@ export interface ThemeConfigInput {
     icon?: string;
     senderName?: string;
     dateLabel?: string;
+    dateLabelBackground?: string;
   };
   messageColor?: {
     backgroundMessage?: string;
@@ -239,6 +244,10 @@ export const resolveTheme = (
     icon: pick(c?.icon, c?.primary, LIGHT_THEME.icon)!,
     senderName: pick(c?.senderName, c?.primary, LIGHT_THEME.senderName)!,
     dateLabel: pick(c?.dateLabel, c?.primary, LIGHT_THEME.dateLabel)!,
+    dateLabelBackground: pick(
+      c?.dateLabelBackground,
+      LIGHT_THEME.dateLabelBackground
+    )!,
     chatBackground: pick(config?.backgroundChat?.color, LIGHT_THEME.chatBackground)!,
     messageBackground: pick(
       config?.messageColor?.backgroundMessage,

package/src/types/models/message.model.ts

@@ -17,6 +17,11 @@ export interface IMessage {
   mimetype?: string;
   location?: string;
   pending?: boolean;
+  unencrypted?: boolean;
+  undecryptable?: string;
+  e2eeError?: string;
+  e2eeKeys?: string[];
+  clientEncrypted?: string;
   timestamp?: number;
   showInChannel?: string;
   activeMessage?: boolean;
@@ -50,6 +55,10 @@ export interface IMessage {
 export interface ReactionMessage {
   emoji: string[];
   data: Record<string, string> | undefined;
+  /** Server stanza id of the reaction (microsecond timestamp). History
+   * pages arrive newest-first, so an older reaction must never overwrite
+   * a newer one; an empty `emoji` with a `ts` is a "removed" marker. */
+  ts?: string;
 }
 
 export interface IReply extends IMessage {}

package/src/types/models/room.model.ts

@@ -11,6 +11,8 @@ export interface RoomMember {
   name?: string;
   role?: string;
   last_active?: number;
+  profileImage?: string;
+  description?: string;
 }
 
 export interface RoomLastMessage {
@@ -29,6 +31,7 @@ export interface IRoom {
 
   members?: RoomMember[];
   type?: 'public' | 'group' | 'private';
+  e2ee?: boolean;
   creteadAt?: string; // Typo? Should it be createdAt?
 
   appId?: string;
@@ -60,10 +63,26 @@ export interface IRoom {
   historyComplete?: boolean;
 }
 
+/** The flattened last-message doc `GET /v1/chats/my` embeds per room.
+ * Only present when the backend supports it; every field is optional. */
+export interface ApiRoomLastMessage {
+  body?: string;
+  truncated?: boolean;
+  from?: string;
+  fromUserId?: string;
+  messageId?: string;
+  stanzaId?: string;
+  createdAt?: string;
+  isOwn?: boolean;
+  senderFirstName?: string;
+  senderLastName?: string;
+}
+
 export interface ApiRoom {
   name: string;
   type: 'public' | 'group' | 'private';
 
+  e2ee?: boolean;
   title?: string;
   description?: string;
   picture?: string;
@@ -78,8 +97,11 @@ export interface ApiRoom {
   __v?: string;
   jid?: string;
   participants?: number;
+  usersCnt?: number;
   icon?: string;
   muted?: boolean;
+  /** See ApiRoomLastMessage. */
+  lastMessage?: ApiRoomLastMessage;
 }
 
 export interface PostRoom {