@ethora/chat-component-rn 26.7.8 → 26.7.10

package/src/helpers/insertMessageWithDelimiter.ts

@@ -1,5 +1,35 @@
 import { IMessage } from '../types/types';
 import { isDateAfter, isDateBefore } from './dateComparison';
+import { msgSortableMs } from './msgSortableMs';
+
+// Robustly resolve a caller-supplied read marker to epoch milliseconds.
+// Callers pass a plain number (the redux read boundary, or a room's
+// lastViewedTimestamp), a Date object (older call sites), or occasionally
+// a numeric string. These are NOT interchangeable through the Date
+// constructor: `new Date(1757000000123)` (a number) reads as epoch-ms,
+// but `new Date("1757000000123")` (a string) is parsed as a date STRING
+// - a bare 13-digit string matches no recognized date format, so the
+// result is silently Invalid Date and every comparison against it is
+// `false`. Try Number() first so a numeric string/number is read as
+// epoch-ms; only fall through to Date parsing for genuine date/ISO
+// strings (e.g. a Date object's own `.toString()`). Never falls back to
+// `Date.now()` - a marker we can't resolve is treated as "no marker",
+// not "now" (bug #38).
+function resolveMarkerMs(
+  marker: number | { toString: () => string } | null | undefined
+): number {
+  if (marker == null) {return 0;}
+  if (typeof marker === 'number') {
+    return Number.isFinite(marker) ? marker : 0;
+  }
+  const raw = marker.toString();
+  if (raw.trim() !== '') {
+    const asNumber = Number(raw);
+    if (Number.isFinite(asNumber)) {return asNumber;}
+  }
+  const parsed = Date.parse(raw);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
 
 function deepMerge(target: any, source: any): any {
   for (const key in source) {
@@ -19,7 +49,7 @@ function deepMerge(target: any, source: any): any {
 export function insertMessageWithDelimiter(
   roomMessages: Partial<IMessage>[],
   message: IMessage,
-  lastViewedTimestamp: { toString: () => string } | null,
+  lastViewedTimestamp: number | { toString: () => string } | null,
 ) {
   const existingIndex = roomMessages.findIndex(
     (msg) =>
@@ -62,33 +92,39 @@ export function insertMessageWithDelimiter(
       roomMessages.push(message);
     }
 
+    const lastViewedMs = resolveMarkerMs(lastViewedTimestamp);
+    const newMessageMs = msgSortableMs(message);
     if (
-      lastViewedTimestamp &&
-      !roomMessages.some((msg) => msg.id === 'delimiter-new') &&
-      isDateAfter(newMessageDate.toString(), lastViewedTimestamp.toString())
+      lastViewedMs > 0 &&
+      newMessageMs > lastViewedMs &&
+      !roomMessages.some((msg) => msg.id === 'delimiter-new')
     ) {
-      const delimiterIndex = roomMessages.findIndex((msg) =>
-        isDateAfter(msg.date?.toString() ?? '', lastViewedTimestamp.toString())
+      // Find the first message STRICTLY newer than the marker, using the
+      // SAME timestamp source (msgSortableMs - the server id-encoded ms)
+      // as the unread middleware and countNewerMessages use to decide
+      // what counts as unread. Comparing against a DIFFERENT source (the
+      // old code compared `msg.date` strings) risks the boundary message
+      // itself landing on the wrong side of the cut: since bug #38 the
+      // marker can equal a real message's own timestamp exactly, and any
+      // drift between `date` and the id-encoded ms - or a raw numeric
+      // marker silently producing an Invalid Date via the Date
+      // constructor's string-parsing path - could count that message as
+      // unread, pushing the divider one message too early (ABOVE the
+      // last read message instead of directly below it). Customer #42.
+      const delimiterIndex = roomMessages.findIndex(
+        (msg) => msg.id !== 'delimiter-new' && msgSortableMs(msg) > lastViewedMs
       );
 
       if (delimiterIndex !== -1) {
         // The divider's date is what ORDERS it: roomsSlice re-sorts every
         // merged page by timestamp (see `byMs`), so a divider stamped with
-        // `new Date()` — i.e. now — sorted past every real message and
+        // `new Date()` (i.e. now) sorted past every real message and
         // rendered at the very bottom, BELOW the new messages it is
         // supposed to introduce. Anchor it a hair before the first unread
         // instead, which is where it belongs and where any later sort keeps
-        // it. Derived from that message rather than from
-        // lastViewedTimestamp so it works whatever format the caller passes.
-        const firstUnreadMs = Date.parse(
-          String(roomMessages[delimiterIndex]?.date ?? '')
-        );
-        const rawLastViewed = lastViewedTimestamp.toString();
-        const lastViewedMs =
-          Date.parse(rawLastViewed) || Number(rawLastViewed) || Date.now();
-        const anchorMs = Number.isFinite(firstUnreadMs)
-          ? firstUnreadMs - 1
-          : lastViewedMs;
+        // it.
+        const firstUnreadMs = msgSortableMs(roomMessages[delimiterIndex]);
+        const anchorMs = firstUnreadMs > 0 ? firstUnreadMs - 1 : lastViewedMs;
 
         roomMessages.splice(delimiterIndex, 0, {
           id: 'delimiter-new',
@@ -103,7 +139,7 @@ export function insertMessageWithDelimiter(
           roomJid: '',
         });
       }
-      }
+    }
   } else if (
     isDateBefore(newMessageDate.toString(), firstMessage?.date?.toString() ?? '')
   ) {

package/src/helpers/isOwnMessage.ts

@@ -0,0 +1,90 @@
+import { IMessage } from '../types/types';
+
+/**
+ * Bug #41: during reconnect catch-up (app was backgrounded/offline, then
+ * comes back online), messages replayed from MAM could transiently render
+ * on the RIGHT (as if sent by the current user) before flipping to the
+ * LEFT a moment later. Root cause: `message.user.id === walletAddress`
+ * treats `undefined === undefined` (or `'' === ''`) as a match, and the
+ * two sides could independently be empty for one frame -- the message's
+ * sender id before the MAM-derived value settled, and/or the current
+ * user's id before it rehydrated. Two blank ids must never compare equal.
+ *
+ * A second, related issue: the same logical sender id can show up in
+ * different shapes depending on which code path produced it -- a bare
+ * id ("wallet123") or a bare JID with an incidental session resource
+ * ("wallet123@host/sessionResource", as `senderJID` attrs carry on the
+ * wire -- see src/assets/test.xml). In every shape used in this
+ * codebase the identifying segment is the part BEFORE the first '@' (or
+ * before '/' when there's no '@'); anything after that -- domain,
+ * resource -- is noise. Comparing raw strings with `===` fails whenever
+ * one side still carries that noise and the other doesn't. Normalizing
+ * both sides (strip resource, strip domain, lowercase) before comparing
+ * makes the check tolerant of that drift.
+ */
+
+export interface OwnMessageUserLike {
+  id?: string | null;
+  xmppUsername?: string | null;
+  walletAddress?: string | null;
+}
+
+export type OwnMessageCurrentUser =
+  | OwnMessageUserLike
+  | string
+  | null
+  | undefined;
+
+/**
+ * Strip a MUC resource (`room@host/resource` -> `room@host`) and then a
+ * JID domain (`local@host` -> `local`), lowercasing the result. Applies
+ * to both plain ids and full/partial JIDs so either shape normalizes to
+ * the same comparable value.
+ */
+const normalizeId = (raw: unknown): string => {
+  const value = String(raw ?? '').trim();
+  if (!value) {
+    return '';
+  }
+  const withoutResource = value.split('/')[0];
+  const withoutDomain = withoutResource.includes('@')
+    ? withoutResource.split('@')[0]
+    : withoutResource;
+  return withoutDomain.toLowerCase();
+};
+
+// Same precedence the rest of the app uses when it needs "who am I" as a
+// single id: xmppUsername first, walletAddress as the fallback.
+const resolveCurrentUserId = (currentUser: OwnMessageCurrentUser): string => {
+  if (typeof currentUser === 'string') {
+    return currentUser;
+  }
+  if (!currentUser) {
+    return '';
+  }
+  return (
+    currentUser.xmppUsername || currentUser.walletAddress || currentUser.id || ''
+  );
+};
+
+/**
+ * Robustly determine whether `message` was sent by `currentUser`. Never
+ * returns true from two blank/undefined ids, and tolerates bare-id vs.
+ * full-JID mismatches between the sender id and the current user id.
+ */
+export const isOwnMessage = (
+  message: Pick<IMessage, 'user'> | null | undefined,
+  currentUser: OwnMessageCurrentUser
+): boolean => {
+  const messageUserId = normalizeId(message?.user?.id);
+  if (!messageUserId) {
+    return false;
+  }
+
+  const currentUserId = normalizeId(resolveCurrentUserId(currentUser));
+  if (!currentUserId) {
+    return false;
+  }
+
+  return messageUserId === currentUserId;
+};

package/src/helpers/keyboardLayout.ts

@@ -14,9 +14,30 @@ export const getKeyboardVerticalOffset = ({
 }: KeyboardLayoutArgs): number =>
   configuredOffset + (platform === 'ios' ? bottomInset : 0);
 
+type InputDockPaddingArgs = Omit<KeyboardLayoutArgs, 'configuredOffset'> & {
+  // Explicit `inputDockPaddingBottom` config value, verbatim on both
+  // platforms when provided (0 allowed). Takes priority over every other
+  // rule below, including `hostOwnsLayout`.
+  configuredPadding?: number;
+  // True when the host app owns keyboard layout entirely (i.e.
+  // `disableKeyboardAvoidingView` is set) and `configuredPadding` was not
+  // given. The dock then gets no built-in bottom padding of its own,
+  // since it already sits above the host's own chrome (e.g. its tab bar).
+  hostOwnsLayout?: boolean;
+};
+
 export const getInputDockPaddingBottom = ({
   platform,
   bottomInset = 0,
   keyboardVisible = false,
-}: Omit<KeyboardLayoutArgs, 'configuredOffset'>): number =>
-  platform === 'ios' ? bottomInset : ANDROID_INPUT_DOCK_GAP;
+  configuredPadding,
+  hostOwnsLayout = false,
+}: InputDockPaddingArgs): number => {
+  if (typeof configuredPadding === 'number') {
+    return configuredPadding;
+  }
+  if (hostOwnsLayout) {
+    return 0;
+  }
+  return platform === 'ios' ? bottomInset : ANDROID_INPUT_DOCK_GAP;
+};

package/src/helpers/mimeToExtension.ts

@@ -289,25 +289,9 @@ export function ensureFilenameHasExtension(
   return `${base}${getExtensionForMime(mime)}`;
 }
 
-/**
- * Best-effort filename derivation for a message bubble:
- *   - server-provided `fileName`
- *   - server-provided `originalName`
- *   - URL pathname
- *   - generic `media_<timestamp>` so we never render an empty label
- *
- * Always returns a string with a valid extension.
- */
-export function deriveDisplayFilename(opts: {
-  fileName?: string | null;
-  originalName?: string | null;
-  url?: string | null;
-  mime?: string | null;
-}): string {
-  const candidate =
-    (opts.fileName && opts.fileName.trim()) ||
-    (opts.originalName && opts.originalName.trim()) ||
-    filenameFromUrl(opts.url) ||
-    '';
-  return ensureFilenameHasExtension(candidate, opts.mime);
-}
+// NOTE: the "which name wins" decision (originalName vs the stored
+// fileName vs the URL) lives in helpers/getDisplayFileName.ts - that is
+// the single source of truth used across display, save, share and
+// download call sites (bug #40: this used to be duplicated here with
+// the priority backwards, so attachments showed/saved under the
+// server's hash name instead of the sender's original one).

package/src/helpers/msgSortableMs.ts

@@ -0,0 +1,25 @@
+// Count messages strictly newer than a given millisecond timestamp using
+// `msg.id` (the server-authoritative microsecond timestamp prefixed by a
+// 13-digit millis, see `helpers/dateComparison`'s
+// `getHighResolutionTimestamp`) rather than `msg.date`, which can be
+// derived client-side (`createMessageFromXml` falls back to `Date.now()`
+// for realtime stanzas without a `date` attr) and drift from what the
+// server actually assigned.
+//
+// Extracted to its own module (rather than living in roomsSlice.ts, its
+// original home) so helpers that need the SAME ordering source - notably
+// `insertMessageWithDelimiter.ts`, which decides where the "New messages"
+// divider sits - can import it without creating a roomStore <-> helpers
+// import cycle (roomsSlice.ts already imports insertMessageWithDelimiter).
+// roomsSlice.ts re-exports this for backward compatibility with existing
+// call sites.
+export const msgSortableMs = (msg: any): number => {
+  const id = String(msg?.id || '');
+  const m = /^(\d{13})/.exec(id);
+  if (m) {return Number(m[1]);}
+  if (msg?.date) {
+    const t = new Date(msg.date as any).getTime();
+    if (Number.isFinite(t)) {return t;}
+  }
+  return 0;
+};

package/src/hooks/useChatRoomFocus.ts

@@ -1,12 +1,17 @@
 import { useEffect, useRef } from 'react';
 import { useDispatch } from 'react-redux';
 import {
+  clearReadBoundary,
   clearVisibleRoom,
   setCurrentRoom,
   setLastViewedTimestamp,
   setVisibleRoom,
 } from '../roomStore/roomsSlice';
 import { store } from '../roomStore';
+import {
+  getFlushBoundaryTs,
+  getReadMarkerTimestamp,
+} from '../helpers/getServerReadTimestamp';
 
 interface UseChatRoomFocusOptions {
   /** The room JID that the consumer's tab/screen is currently showing. */
@@ -32,7 +37,10 @@ interface UseChatRoomFocusOptions {
  * Without this hook, `useUnread()` will always return 0 for the chat
  * room because the SDK assumes "mounted == active". With this hook,
  * focus marks the room visible (clearing the badge) and blur stamps
- * `lastViewedTimestamp = Date.now()` so future messages count as unread.
+ * `lastViewedTimestamp` to the newest SERVER-acknowledged message so
+ * future messages count as unread. Deliberately not `Date.now()`: a
+ * device clock running ahead would write a future marker that the
+ * forward-only private-store merge could never correct again (bug #38).
  *
  * Usage with React Navigation:
  *
@@ -58,20 +66,52 @@ export const useChatRoomFocus = ({
     isFocused: false,
   });
 
-  const leaveRoom = (jid: string) => {
-    const timestamp = Date.now();
-    dispatch(setLastViewedTimestamp({ chatJID: jid, timestamp }));
+  // `clearBoundary`: pass true only when the room the user is leaving is
+  // genuinely being released (switching to a different room, or this
+  // hook unmounting) - not on a mere same-room blur. `<ChatRoom>`'s
+  // MessageList typically stays mounted across a same-room focus loss
+  // (the whole point of this hook is that the host keeps `<Chat>`
+  // mounted in a hidden tab), so its own scroll-tracking ref is still
+  // intact and the redux boundary must stay in sync with it - clearing
+  // it here would desync the two.
+  const leaveRoom = (jid: string, clearBoundary: boolean) => {
+    const state = store.getState();
+    const rooms = state.rooms?.rooms;
+    const boundaryTs = state.rooms?.readBoundaries?.[jid] ?? null;
+    // getReadMarkerTimestamp: honour the boundary (the newest message the
+    // user actually reached) when the user left this room scrolled up,
+    // otherwise fall back to the newest server-acked message. Only stamp
+    // when we actually have something to anchor to - skip rather than
+    // fall back to the device clock (bug #38). Ignoring the boundary here
+    // would stamp "everything read" regardless of scroll position (bug
+    // #42, a regression of #33 reintroduced by #38).
+    const timestamp = getReadMarkerTimestamp(rooms?.[jid], state.roomHeapSlice, boundaryTs);
+    if (timestamp > 0) {
+      dispatch(setLastViewedTimestamp({ chatJID: jid, timestamp }));
+    }
     dispatch(clearVisibleRoom());
-    const rooms = store.getState().rooms?.rooms;
-    (store.getState().chatSettingStore as any)?.client
-      ?.flushLastViewedToPrivateStoreStanza(rooms, { visibleRoomJID: jid })
+    (state.chatSettingStore as any)?.client
+      ?.flushLastViewedToPrivateStoreStanza(rooms, {
+        visibleRoomJID: jid,
+        // Carry the same boundary to the SERVER marker - without it the
+        // flush defaults to "everything" for the visible room. Clamped
+        // through the same helper as the local stamp above.
+        visibleRoomTs: getFlushBoundaryTs(
+          rooms?.[jid],
+          state.roomHeapSlice,
+          boundaryTs
+        ),
+      })
       .catch(() => {});
+    if (clearBoundary) {
+      dispatch(clearReadBoundary({ jid }));
+    }
   };
 
   useEffect(() => {
     const prev = prevRef.current;
     if (prev.isFocused && prev.roomJID && (prev.roomJID !== roomJID || !isFocused)) {
-      leaveRoom(prev.roomJID);
+      leaveRoom(prev.roomJID, prev.roomJID !== roomJID);
     }
 
     if (roomJID && isFocused) {
@@ -86,7 +126,7 @@ export const useChatRoomFocus = ({
     return () => {
       const prev = prevRef.current;
       if (prev.isFocused && prev.roomJID) {
-        leaveRoom(prev.roomJID);
+        leaveRoom(prev.roomJID, true);
       }
     };
   }, []);

package/src/hooks/useChatWrapperInit.ts

@@ -8,7 +8,6 @@ import { AppDispatch, RootState } from '../roomStore';
 import { useXmppClient } from '../context/xmppProvider';
 import { chatAutoEnterer } from '../helpers/chatAutoEnterer';
 import { initRoomsPresence } from '../helpers/initRoomsPresence';
-import { updatedChatLastTimestamps } from '../helpers/updatedChatLastTimestamps';
 import { updateMessagesTillLast } from '../helpers/updateMessagesTillLast';
 import { refreshAuthTokensQuietly } from '../networking/authRefresh';
 import { setLangSource, setConfig } from '../roomStore/chatSettingsSlice';
@@ -170,15 +169,21 @@ const useChatWrapperInit = ({
                 }
               }
               try {
+                // getChatsPrivateStoreRequestStanza hydrates redux itself
+                // (dispatch(applyPrivateStoreMarkers(...)) internally,
+                // clamped + forward-only) - do not also apply the raw
+                // return value here. That used to double-dispatch via
+                // updatedChatLastTimestamps' unconditional
+                // setLastViewedTimestamp, which has neither the
+                // forward-only guard nor the future-marker clamp, so on
+                // every reconnect it could silently re-clobber a value
+                // the clamp had just corrected (bug #38).
                 const roomTimestampObject: any =
                   await newClient.getChatsPrivateStoreRequestStanza();
                 console.log(
                   'Got chats private store',
                   roomTimestampObject?.length || 0
                 );
-                if (roomTimestampObject) {
-                  updatedChatLastTimestamps(roomTimestampObject, dispatch);
-                }
                 if (!hasSyncedHistoryRef.current) {
                   console.log('Updating messages till last');
                   await updateMessagesTillLast(rooms, newClient);
@@ -220,15 +225,15 @@ const useChatWrapperInit = ({
             setInited(true);
             console.log(' Getting chats private store for existing client');
             try {
+              // See the "new client" branch above: getChatsPrivateStoreRequestStanza
+              // already hydrates redux (clamped + forward-only); do not
+              // also apply the raw return value here.
               const roomTimestampObject: any =
                 await client.getChatsPrivateStoreRequestStanza();
               console.log(
                 'Got chats private store for existing client',
                 roomTimestampObject?.length || 0
               );
-              if (roomTimestampObject) {
-                updatedChatLastTimestamps(roomTimestampObject, dispatch);
-              }
               if (!hasSyncedHistoryRef.current) {
                 console.log(
                   'Updating messages till last for existing client'

package/src/hooks/useLogout.tsx

@@ -10,6 +10,7 @@ import { pushSubscriptionService } from '../services/pushSubscriptionService';
 import { clearRoomsRestCache } from '../networking/api-requests/rooms.api';
 import { clearPersistedState } from '../roomStore/persistence';
 import { secureUserStorage } from '../helpers/secureUserStorage';
+import { getFlushBoundaryTs } from '../helpers/getServerReadTimestamp';
 
 // AsyncStorage keys the library writes but that aren't cleared by any
 // slice reducer. Listed here so a single logout call wipes the full
@@ -59,10 +60,23 @@ const logoutService = {
       const client = (state.chatSettingStore as any)?.client;
       const rooms = state.rooms?.rooms;
       const visibleRoomJID = state.rooms?.visibleRoomJID || null;
+      // The visible room is exempt from `onlyIfNoUnread`'s skip (it's
+      // meant to write "read up to now" for whatever's open), so if the
+      // user is logging out while scrolled up with unread messages
+      // above, the boundary must still be carried through here - same
+      // reasoning as every other "leaving a room" path (bug #42).
+      const boundaryTs = visibleRoomJID
+        ? getFlushBoundaryTs(
+            rooms?.[visibleRoomJID],
+            state.roomHeapSlice,
+            state.rooms?.readBoundaries?.[visibleRoomJID] ?? null
+          )
+        : undefined;
       if (client?.flushLastViewedToPrivateStoreStanza) {
         await Promise.race([
           client.flushLastViewedToPrivateStoreStanza(rooms, {
             visibleRoomJID,
+            visibleRoomTs: boundaryTs,
             onlyIfNoUnread: true,
           }),
           new Promise((res) => setTimeout(res, 2000)),

package/src/i18n/strings.ts

@@ -81,9 +81,6 @@ const en: UiStringTable = {
   'action.save': 'Save',
   'action.delete': 'Delete',
   'action.leave': 'Leave',
-  'action.muted': 'Muted',
-  'action.unmuted': 'Unmuted',
-  'toast.muteFailed': 'Could not update notifications for this chat',
   'action.create': 'Create',
   'action.submit': 'Submit',
   'action.translate': 'Translate',
@@ -312,9 +309,6 @@ const fr: UiStringTable = {
   'action.save': 'Enregistrer',
   'action.delete': 'Supprimer',
   'action.leave': 'Quitter',
-  'action.muted': 'En sourdine',
-  'action.unmuted': 'Activé',
-  'toast.muteFailed': 'Impossible de modifier les notifications de ce chat',
   'action.create': 'Créer',
   'action.submit': 'Soumettre',
   'action.translate': 'Traduire',
@@ -543,9 +537,6 @@ const es: UiStringTable = {
   'action.save': 'Guardar',
   'action.delete': 'Eliminar',
   'action.leave': 'Salir',
-  'action.muted': 'Silenciado',
-  'action.unmuted': 'Activado',
-  'toast.muteFailed': 'No se pudieron cambiar las notificaciones de este chat',
   'action.create': 'Crear',
   'action.submit': 'Enviar',
   'action.translate': 'Traducir',
@@ -774,9 +765,6 @@ const pt: UiStringTable = {
   'action.save': 'Guardar',
   'action.delete': 'Eliminar',
   'action.leave': 'Sair',
-  'action.muted': 'Muted',
-  'action.unmuted': 'Unmuted',
-  'toast.muteFailed': 'Could not update notifications for this chat',
   'action.create': 'Criar',
   'action.submit': 'Enviar',
   'action.translate': 'Traduzir',
@@ -1005,9 +993,6 @@ const ht: UiStringTable = {
   'action.save': 'Anrejistre',
   'action.delete': 'Efase',
   'action.leave': 'Kite',
-  'action.muted': 'Muted',
-  'action.unmuted': 'Unmuted',
-  'toast.muteFailed': 'Could not update notifications for this chat',
   'action.create': 'Kreye',
   'action.submit': 'Soumèt',
   'action.translate': 'Tradui',
@@ -1236,9 +1221,6 @@ const zh: UiStringTable = {
   'action.save': '保存',
   'action.delete': '删除',
   'action.leave': '退出',
-  'action.muted': 'Muted',
-  'action.unmuted': 'Unmuted',
-  'toast.muteFailed': 'Could not update notifications for this chat',
   'action.create': '创建',
   'action.submit': '提交',
   'action.translate': '翻译',

package/src/networking/api-requests/rooms.api.ts

@@ -130,7 +130,6 @@ function dispatchRoomsFromRestItems(items: ApiRoom[]): void {
       icon: item.picture || item.icon,
       createdAt: item.createdAt,
       updatedAt: item.updatedAt,
-      muted: item.muted === true,
       description: (item as any).description,
       type: (item as any).type,
       // ChatProfileModal renders this list under the description/type
@@ -255,14 +254,6 @@ export async function postPrivateRoom(
   }
 }
 
-export async function setRoomMuted(chatName: string, muted: boolean): Promise<boolean> {
-  const token = store.getState().chatSettingStore.user.token || '';
-  const url = `/v1/chats/my/${encodeURIComponent(chatName)}/mute`;
-  const config = { headers: { Authorization: token } };
-  const response = muted ? await http.put(url, {}, config) : await http.delete(url, config);
-  return response.data?.result?.muted ?? muted;
-}
-
 export async function postReportRoom(data: PostReportRoom) {
   const { chatName, category, text } = data;
   const token = store.getState().chatSettingStore.user.token || '';

package/src/networking/stanzaHandlers.ts

@@ -227,11 +227,11 @@ const onMessageHistory = async (stanza: any) => {
     // what senderJID would have held — fall back to it. createMessageFromXml
     // already derives a display name from the jid when senderFirstName/
     // senderLastName are absent.
-    const innerFrom =
-      stanza
-        .getChild('result')
-        ?.getChild('forwarded')
-        ?.getChild('message')?.attrs?.from || stanza.attrs.from;
+    const forwardedMessage = stanza
+      .getChild('result')
+      ?.getChild('forwarded')
+      ?.getChild('message');
+    const innerFrom = forwardedMessage?.attrs?.from || stanza.attrs.from;
     const senderJID = data?.attrs?.senderJID || innerFrom;
     if (!data?.attrs || !senderJID) {
       // console.log(
@@ -242,11 +242,25 @@ const onMessageHistory = async (stanza: any) => {
     }
     const mergedAttrs = { ...data.attrs };
     if (!mergedAttrs.senderJID) {mergedAttrs.senderJID = senderJID;}
+    // The forwarded <message>'s own stanza id is our original send id
+    // (what `xmppId` holds on the live/wrapped paths) - capture it so
+    // this MAM-replayed message dedupes against its live echo /
+    // optimistic pending bubble the same way, instead of never carrying
+    // an xmppId at all.
+    if (forwardedMessage?.attrs?.id) {mergedAttrs.xmppId = forwardedMessage.attrs.id;}
     const rawMessage = await createMessageFromXml(
       mergedAttrs,
       body,
       id,
-      stanza.attrs.from,
+      // Bug #41: pass the resource-bearing occupant `from`
+      // (room@conference/sender-id) here, not the outer envelope's
+      // `stanza.attrs.from` (which has no resource for a MAM result).
+      // createMessageFromXml derives `user.id` from this field's
+      // resource - the same authoritative source getDataFromXml uses
+      // for live messages - so catch-up rows resolve the correct
+      // sender from the very first render instead of needing a later
+      // correction once the "official" history fetch lands.
+      innerFrom,
       !!deleted
     );