@ethora/chat-component-rn 26.10.5 → 26.10.6

package/src/networking/xmppClient.ts

@@ -17,6 +17,8 @@ import {
 } from './xmpp/getHistory.xmpp';
 import { sendTextMessage } from './xmpp/sendTextMessage.xmpp';
 import { sendMessageReaction } from './xmpp/sendMessageReaction.xmpp';
+import { sendReceivedReceipt } from './xmpp/sendReceivedReceipt.xmpp';
+import { sendDisplayedMarker } from './xmpp/sendDisplayedMarker.xmpp';
 import { sendTextMessageWithTranslateTag } from './xmpp/sendTextMessageWithTranslateTag.xmpp';
 import { deleteMessage } from './xmpp/deleteMessage.xmpp';
 import { RoomJoinManager } from './xmpp/roomJoinSweep';
@@ -48,6 +50,8 @@ import {
 
 // Canonical production XMPP WSS endpoint (standard wss/443, no port suffix).
 const DEFAULT_DEV_SERVER = 'xmpp.chat.ethora.com';
+// Upper bound on remembered XEP-0184 acks (oldest forgotten first).
+const RECEIPT_ACKED_CAP = 2000;
 
 // How long to wait for the old client's stop() during a reconnect before
 // giving up on it. Short on purpose: we are already tearing this client
@@ -279,6 +283,13 @@ export class XmppClient {
   }
   disableLastRead = false;
   private activeRoomJID: string | null = null;
+  // XEP-0184 acks already sent, as `room:messageId`. A message is acked once,
+  // whether it arrived live or again inside a MAM page. Oldest entries drop
+  // first once the set passes the cap.
+  private receiptAckedIds: Set<string> = new Set();
+  // XEP-0333: the last read watermark sent per room. A repeat flush for the
+  // same newest message sends nothing.
+  private lastWatermarkSentByRoom: Map<string, string> = new Map();
   private activeRoomBoostUntil = 0;
   private softPauseUntil = 0;
   private mamInFlightByRoom: Map<string, MamInFlightEntry> = new Map();
@@ -1594,6 +1605,43 @@ export class XmppClient {
     return typeof result === 'string' ? result : '';
   }
 
+  /**
+   * XEP-0184 delivery receipt for a message from someone else. Sent for live
+   * messages and for messages a MAM page brings in; a message already acked
+   * is skipped. When the stream is down (or `config.disableReadReceipts` is
+   * on) nothing is recorded, so a later page can still ack it.
+   */
+  sendReceivedReceiptStanza(messageId: string, roomJid: string) {
+    // Privacy switch: with read receipts off this client stays silent, so
+    // nobody learns that (or when) it received their message.
+    if (store.getState().chatSettingStore.config?.disableReadReceipts) {return;}
+    if (!messageId || !roomJid || !this.isStreamReady()) {return;}
+    const jid = normalizeRoomJid(roomJid, this.conference);
+    const key = `${jid}:${messageId}`;
+    if (this.receiptAckedIds.has(key)) {return;}
+    this.receiptAckedIds.add(key);
+    if (this.receiptAckedIds.size > RECEIPT_ACKED_CAP) {
+      const oldest = this.receiptAckedIds.values().next().value;
+      if (oldest !== undefined) {this.receiptAckedIds.delete(oldest);}
+    }
+    sendReceivedReceipt(this.client, messageId, jid);
+  }
+
+  /**
+   * XEP-0333 read watermark for a room: the newest message the user has
+   * displayed. Off with `disableLastRead` or `config.disableReadReceipts`.
+   * The caller decides when the room counts as read (see computeReadWatermark).
+   */
+  sendDisplayedMarkerStanza(messageId: string, roomJid: string) {
+    if (this.disableLastRead) {return;}
+    if (store.getState().chatSettingStore.config?.disableReadReceipts) {return;}
+    if (!messageId || !roomJid || !this.isStreamReady()) {return;}
+    const jid = normalizeRoomJid(roomJid, this.conference);
+    if (this.lastWatermarkSentByRoom.get(jid) === messageId) {return;}
+    this.lastWatermarkSentByRoom.set(jid, messageId);
+    sendDisplayedMarker(this.client, messageId, jid);
+  }
+
   sendMessageReactionStanza(
     messageId: string,
     roomJid: string,

package/src/roomStore/persistence.ts

@@ -1,6 +1,6 @@
 import { Middleware } from '@reduxjs/toolkit';
 import { IMessage, IRoom, User } from '../types/types';
-import type { FailedMessagePayload } from './roomHeapSlice';
+import type { FailedMediaFile, FailedMessagePayload } from './roomHeapSlice';
 import {
   getPersistBackend,
   legacyAsyncStorageBackend,
@@ -107,6 +107,11 @@ const PERSISTED_MESSAGE_FIELDS: (keyof IMessage)[] = [
   'fileName',
   'originalName',
   'size',
+  // Every file of a multi-attach message and its caption: without them a
+  // restored album paints as its first file only (see compactAttachments).
+  'attachments',
+  'caption',
+  'captionMentions',
   'langSource',
   // `translations` MUST be here. A previous version of this list dropped
   // it, on the theory that it mirrored the web SDK's persist contract —
@@ -185,8 +190,45 @@ const pickDefined = <T extends object>(
   return out;
 };
 
+// What a restored attachment is rendered from. Ownership and timestamp
+// fields the storage returns, and the sender's local upload state, are not
+// ours to cache and would repeat across up to ten files of every message.
+const PERSISTED_ATTACHMENT_FIELDS = [
+  'attachmentId',
+  'location',
+  'locationPreview',
+  'mimetype',
+  'originalName',
+  'fileName',
+  'size',
+  'duration',
+  'width',
+  'height',
+] as const;
+
+const compactAttachments = (attachments: unknown): IMessage['attachments'] => {
+  if (!Array.isArray(attachments) || attachments.length === 0) {return undefined;}
+  return attachments
+    .filter((item) => item && typeof item === 'object')
+    .map(
+      (item) =>
+        pickDefined(
+          item,
+          PERSISTED_ATTACHMENT_FIELDS as unknown as readonly string[]
+        ) as NonNullable<IMessage['attachments']>[number]
+    );
+};
+
 const compactMessageForPersist = (message: IMessage): IMessage => {
   const compact = pickDefined(message, PERSISTED_MESSAGE_FIELDS) as IMessage;
+  if (compact.attachments !== undefined) {
+    const attachments = compactAttachments(compact.attachments);
+    if (attachments) {
+      compact.attachments = attachments;
+    } else {
+      delete compact.attachments;
+    }
+  }
   const user = message?.user as Record<string, any> | undefined;
   if (user) {
     compact.user = pickDefined(
@@ -209,11 +251,17 @@ const sanitizeMessages = (messages: IMessage[]): IMessage[] => {
 /**
  * Room fields that describe ONE session and must never be written to disk:
  * the server's unread snapshot (a moment-in-time number the next /chats/my
- * re-seeds). Volatile slice state that is not on the room at all (jumpWindow,
+ * re-seeds) and the read watermarks other occupants sent this session. Volatile slice state that is not on the room at all (jumpWindow,
  * pendingJump, archivedMessage, usersSet) is never persisted because only
  * `rooms.rooms` is picked from the slice.
  */
-const SESSION_ROOM_FIELDS = ['apiUnreadCount', 'apiUnreadSeededAt'] as const;
+const SESSION_ROOM_FIELDS = [
+  'apiUnreadCount',
+  'apiUnreadSeededAt',
+  // XEP-0333 read watermarks: a peer's "seen" state is re-learned from the
+  // live marker stanzas, never restored from a previous session.
+  'lastDisplayedByUser',
+] as const;
 
 /**
  * Rehydrate step: a persisted room must be refetched once per session, so
@@ -303,6 +351,21 @@ const sanitizeMediaData = (
   return out;
 };
 
+// Every file of a multi-file failed send, trimmed the same way as `data`.
+// Capped so a corrupt payload cannot grow the cache without bound.
+const MAX_PERSISTED_FAILED_FILES = 10;
+const sanitizeMediaFiles = (files: unknown): FailedMediaFile[] | undefined => {
+  if (!Array.isArray(files)) {return undefined;}
+  const out: FailedMediaFile[] = [];
+  for (const file of files.slice(0, MAX_PERSISTED_FAILED_FILES)) {
+    const clean = sanitizeMediaData(file) as FailedMediaFile;
+    if (typeof (file as any)?.duration === 'number') {clean.duration = (file as any).duration;}
+    if (typeof (file as any)?.waveForm === 'string') {clean.waveForm = (file as any).waveForm;}
+    out.push(clean);
+  }
+  return out.length > 0 ? out : undefined;
+};
+
 const sanitizeFailedMessagePayload = (
   payload: FailedMessagePayload
 ): FailedMessagePayload | null => {
@@ -310,6 +373,8 @@ const sanitizeFailedMessagePayload = (
   if (!payload.id || typeof payload.id !== 'string') {return null;}
   if (!payload.roomJID || typeof payload.roomJID !== 'string') {return null;}
   if (payload.kind === 'media') {
+    const files = sanitizeMediaFiles(payload.files);
+    const caption = typeof payload.caption === 'string' ? payload.caption : undefined;
     return {
       kind: 'media',
       id: payload.id,
@@ -319,6 +384,11 @@ const sanitizeFailedMessagePayload = (
       isReply: payload.isReply,
       isChecked: payload.isChecked,
       mainMessage: payload.mainMessage,
+      ...(files ? { files } : {}),
+      ...(caption ? { caption } : {}),
+      ...(caption && Array.isArray(payload.captionMentions)
+        ? { captionMentions: payload.captionMentions }
+        : {}),
     };
   }
   if (payload.kind === 'text') {
@@ -377,6 +447,25 @@ export function reconstructFailedMessagePayload(
   const isChecked = message.showInChannel === 'true';
   const mainMessage = message.mainMessage;
   if (message.isMediafile === 'true') {
+    // A multi-file send keeps every file. Only a file still on this device
+    // has a uri to replay; an uploaded one has no local copy left to send.
+    const localUri = (value: unknown): string | undefined =>
+      typeof value === 'string' && /^(file|content|ph|assets-library):\/\//.test(value)
+        ? value
+        : undefined;
+    const attachments = Array.isArray(message.attachments) ? message.attachments : [];
+    const files: FailedMediaFile[] | undefined =
+      attachments.length > 1
+        ? attachments.slice(0, MAX_PERSISTED_FAILED_FILES).map((attachment) => ({
+            uri: localUri(attachment.localUrl) ?? localUri(attachment.location),
+            name: attachment.originalName || attachment.fileName,
+            type: attachment.mimetype,
+            size:
+              attachment.size !== undefined && attachment.size !== null
+                ? Number(attachment.size)
+                : undefined,
+          }))
+        : undefined;
     return {
       kind: 'media',
       id: message.id,
@@ -394,6 +483,8 @@ export function reconstructFailedMessagePayload(
       isReply,
       isChecked,
       mainMessage,
+      ...(files ? { files } : {}),
+      ...(message.caption ? { caption: message.caption } : {}),
     };
   }
   return {

package/src/roomStore/roomHeapSlice.ts

@@ -1,11 +1,24 @@
 import { createSlice, PayloadAction, type Slice } from '@reduxjs/toolkit';
 import type { WritableDraft } from 'immer';
-import { IMessage } from '../types/types';
+import { IMentionSpan, IMessage } from '../types/types';
 
 // Saved alongside a failed-message id so the retry button can resend
 // without the bubble needing to remember the original draft itself.
 // `kind === 'text'` carries the plain body; `kind === 'media'` carries
 // the upload payload so we don't have to make the user re-pick the file.
+/**
+ * One file of a failed media send, as the retry replays it. Only the fields
+ * an upload needs, so it persists as a plain JSON object.
+ */
+export interface FailedMediaFile {
+  uri?: string;
+  type?: string;
+  name?: string;
+  size?: number;
+  duration?: number;
+  waveForm?: string;
+}
+
 export type FailedMessagePayload =
   | {
       kind: 'text';
@@ -20,11 +33,20 @@ export type FailedMessagePayload =
       kind: 'media';
       id: string;
       roomJID: string;
+      /** The first file (or the only one); kept for single-file readers. */
       data: any;
       type: string;
       isReply?: boolean;
       isChecked?: boolean;
       mainMessage?: string;
+      /**
+       * Every file of the message, in selection order. Retry replays the
+       * whole list; a message with no list falls back to `data`.
+       */
+      files?: FailedMediaFile[];
+      /** The caption the files were sent with, if any. */
+      caption?: string;
+      captionMentions?: IMentionSpan[];
     };
 
 export interface roomHeapSliceState {

package/src/roomStore/roomsSlice.ts

@@ -1,6 +1,6 @@
 import { createAsyncThunk, createSlice, PayloadAction, type Slice } from '@reduxjs/toolkit';
 import type { WritableDraft } from 'immer';
-import { EditAction, HistoryPreloadState, IMessage, IRoom } from '../types/types';
+import { EditAction, HistoryPreloadState, IAttachment, IMessage, IRoom } from '../types/types';
 import { insertMessageWithDelimiter } from '../helpers/insertMessageWithDelimiter';
 import { msgSortableMs } from '../helpers/msgSortableMs';
 import type XmppClient from '../networking/xmppClient';
@@ -955,6 +955,66 @@ const reducers = {
         message.translations[locale] = entry;
       });
     },
+    /**
+     * Local upload state of one file of an outgoing media message: its
+     * `uploadStatus` ('uploading' | 'failed') and `uploadProgress` (0-100).
+     * `null` for `uploadStatus` clears both, once the file is up. Matches the
+     * message in the room and in the jump window, like the other patches.
+     * Never persisted: the persist whitelist drops these fields.
+     */
+    setMediaUploadState(
+      state: WritableDraft<RoomMessagesState>,
+      action: PayloadAction<{
+        roomJID: string;
+        messageId: string;
+        attachmentId: string;
+        uploadStatus?: 'uploading' | 'failed' | null;
+        uploadProgress?: number;
+      }>
+    ) {
+      const { roomJID, messageId, attachmentId, uploadStatus, uploadProgress } =
+        action.payload;
+      if (!isSafeKey(roomJID) || !isSafeKey(messageId) || !isSafeKey(attachmentId)) {
+        return;
+      }
+      forEachMessageCopy(state, roomJID, messageId, (message) => {
+        const target = message.attachments?.find(
+          (attachment) => attachment.attachmentId === attachmentId
+        );
+        if (!target) {return;}
+        if (uploadStatus === null) {
+          delete target.uploadStatus;
+          delete target.uploadProgress;
+          return;
+        }
+        if (uploadStatus !== undefined) {target.uploadStatus = uploadStatus;}
+        if (typeof uploadProgress === 'number' && Number.isFinite(uploadProgress)) {
+          target.uploadProgress = Math.min(100, Math.max(0, uploadProgress));
+        }
+      });
+    },
+    /**
+     * Replaces the attachments of a message the sender already has, without
+     * touching its other fields: `pending` stays as it is, so the bubble is
+     * still waiting for the server echo. (addRoomMessage would count this as
+     * the echo and clear `pending`.)
+     */
+    setMessageAttachments(
+      state: WritableDraft<RoomMessagesState>,
+      action: PayloadAction<{
+        roomJID: string;
+        messageId: string;
+        attachments: IAttachment[];
+      }>
+    ) {
+      const { roomJID, messageId, attachments } = action.payload;
+      if (!isSafeKey(roomJID) || !isSafeKey(messageId) || !Array.isArray(attachments)) {
+        return;
+      }
+      forEachMessageCopy(state, roomJID, messageId, (message) => {
+        message.attachments = attachments.map((attachment) => ({ ...attachment }));
+      });
+    },
     addRoomMessage(
       state: WritableDraft<RoomMessagesState>,
       action: PayloadAction<{
@@ -1412,6 +1472,53 @@ const reducers = {
         list.push({ from, reactions, data, ts: latestReactionTimestamp });
       }
     },
+    /**
+     * XEP-0184: an occupant's client acknowledged one of our messages. Only
+     * the message id is matched (archive ids), on the live list and on a jump
+     * window copy. Session-only: not persisted.
+     */
+    setReceivedReceipt: (
+      state: WritableDraft<RoomMessagesState>,
+      action: PayloadAction<{
+        roomJID: string;
+        messageId: string;
+        fromXmppUsername: string;
+        timestamp: number;
+      }>
+    ) => {
+      const { roomJID, messageId, fromXmppUsername, timestamp } = action.payload;
+      // Both keys become property names: an unsafe key must never reach the write.
+      if (!isSafeKey(roomJID) || !isSafeKey(fromXmppUsername)) {return;}
+      if (!state.rooms[roomJID] || !messageId) {return;}
+      forEachMessageCopy(
+        state,
+        roomJID,
+        (message) => message.id === messageId,
+        (message) => {
+          if (!message.receivedBy) {message.receivedBy = {};}
+          message.receivedBy[fromXmppUsername] = timestamp;
+        }
+      );
+    },
+    /**
+     * XEP-0333: an occupant displayed up to `messageId`. One watermark per
+     * user and room, replaced on every marker. Session-only: not persisted.
+     */
+    setDisplayedMarker: (
+      state: WritableDraft<RoomMessagesState>,
+      action: PayloadAction<{
+        roomJID: string;
+        xmppUsername: string;
+        messageId: string;
+      }>
+    ) => {
+      const { roomJID, xmppUsername, messageId } = action.payload;
+      if (!isSafeKey(roomJID) || !isSafeKey(xmppUsername)) {return;}
+      const room = state.rooms[roomJID];
+      if (!room || !messageId) {return;}
+      if (!room.lastDisplayedByUser) {room.lastDisplayedByUser = {};}
+      room.lastDisplayedByUser[xmppUsername] = messageId;
+    },
     setLogoutState: (state: WritableDraft<RoomMessagesState>) => {
       state.rooms = {};
       state.pendingReactions = {};
@@ -1640,6 +1747,8 @@ export const {
   deleteAllRooms,
   setRoomMessages,
   addRoomMessage,
+  setMediaUploadState,
+  setMessageAttachments,
   deleteRoomMessage,
   setEditAction,
   editRoomMessage,
@@ -1671,6 +1780,8 @@ export const {
   setJoiningRoom,
   clearJoiningRoom,
   setReactions,
+  setReceivedReceipt,
+  setDisplayedMarker,
   mergeUsersSet,
   removeRoomMessage,
   addRoomFromApi,

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

@@ -0,0 +1,51 @@
+/**
+ * One uploaded file carried by a media message.
+ *
+ * Historically a media message described exactly one file through flat
+ * `IMessage` fields (`location`, `mimetype`, `originalName`, ...). Those
+ * fields are still written (they are what every already-shipped client
+ * reads), and they now double as attachment #0 of `IMessage.attachments`.
+ * Anything past #0 only exists in the `attachments` payload, so old clients
+ * degrade to "shows the first file" instead of breaking.
+ */
+export interface IAttachment {
+  /** `_id` returned by POST /files/ - stable per upload, used as a render key. */
+  attachmentId?: string;
+  /** Canonical file URL. */
+  location: string;
+  /** Server-side generated preview (images always, other types sometimes). */
+  locationPreview?: string;
+  mimetype?: string;
+  /** Name the user picked. */
+  originalName?: string;
+  /** Name on the storage side. */
+  fileName?: string;
+  /** Bytes, as a string - that is how it travels on the wire. */
+  size?: string;
+  duration?: string;
+  /** Natural pixel size, when the storage recorded it. */
+  width?: number;
+  height?: number;
+  ownerKey?: string;
+  userId?: string;
+  createdAt?: string;
+  updatedAt?: string;
+  expiresAt?: string;
+  isVisible?: boolean;
+  isPrivate?: boolean;
+  /**
+   * Local-only state of an outgoing attachment, set by the sender while its
+   * message is still being sent. Never written to the wire.
+   *   uploading - the file is going up (or every file is up and the message
+   *               is waiting on its siblings); `uploadProgress` is 0 to 100.
+   *   failed    - this file did not upload; the message is held until it
+   *               is retried.
+   */
+  uploadStatus?: 'uploading' | 'failed';
+  uploadProgress?: number;
+  /**
+   * The file as it is on this device (`file://`), shown on the sender's own
+   * bubble while it uploads. Local only, like the upload state above.
+   */
+  localUrl?: string;
+}

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

@@ -1,6 +1,7 @@
 import { IUser } from './user.model';
 import { TranslationObject } from '../../helpers/transformTranslatations';
 import { Iso639_1Codes } from './language.model';
+import type { IAttachment } from './attachment.model';
 
 export interface IMessage {
   id: string;
@@ -35,6 +36,25 @@ export interface IMessage {
   langSource?: Iso639_1Codes;
   originalName?: string;
   size?: string;
+  /**
+   * Every file carried by this message. `attachments[0]` mirrors the flat
+   * `location`/`mimetype`/`originalName` fields above. Undefined on messages
+   * that predate multi-attach; read it through `getMessageAttachments()`.
+   */
+  attachments?: IAttachment[];
+  /**
+   * Text sent with a media message's files. `body` stays "media". In a sealed
+   * message it comes out of the encrypted body, never from `<data>`. Read it
+   * through `getMessageCaption()`.
+   */
+  caption?: string;
+  /** @-mention spans into `caption`. Stored, not rendered on RN. */
+  captionMentions?: IMentionSpan[];
+  /**
+   * XEP-0184 delivery receipts: xmpp username -> epoch ms when that
+   * occupant's client acknowledged the message. Session-only (never persisted).
+   */
+  receivedBy?: Record<string, number>;
   xmppId?: string;
   xmppFrom?: string;
   deleted?: boolean;
@@ -52,6 +72,15 @@ export interface IMessage {
   };
 }
 
+// One @-mention span inside a caption (or text body). `offset`/`length` index
+// into that string in UTF-16 code units.
+export interface IMentionSpan {
+  jid: string;
+  name: string;
+  offset: number;
+  length: number;
+}
+
 export interface ReactionMessage {
   emoji: string[];
   data: Record<string, string> | undefined;

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

@@ -9,4 +9,11 @@ export interface ModalFile {
   originalName?: string;
   duration?: number | string;
   waveForm?: string;
+  /**
+   * The other files of the album this one was opened from, this one
+   * included, in order. With `index` it lets the viewer page through them.
+   */
+  siblings?: ModalFile[];
+  /** Position of this file in `siblings`. */
+  index?: number;
 }

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

@@ -52,6 +52,8 @@ export interface IRoom {
   composing?: boolean;
   composingList?: string[];
   lastViewedTimestamp?: number;
+  /** XEP-0333 read watermark per user (last displayed message id). Session-only. */
+  lastDisplayedByUser?: Record<string, string>;
   unreadMessages?: number;
   /**
    * Unread count the server reported for this room in `GET /v1/chats/my`

package/src/types/types.ts

@@ -43,6 +43,11 @@ export interface IRoom {
   composing?: boolean;
   composingList?: string[];
   lastViewedTimestamp?: number;
+  /**
+   * XEP-0333 read watermark per user: the id of the newest message each other
+   * occupant has displayed. Session-only (never persisted). See readReceipts.ts.
+   */
+  lastDisplayedByUser?: Record<string, string>;
   unreadMessages?: number;
   /**
    * Unread count the server reported for this room in `GET /v1/chats/my`
@@ -473,6 +478,15 @@ export interface IConfig {
   };
   disableHeader?: boolean;
   disableMedia?: boolean;
+  /**
+   * Limits for files picked in the composer. One message carries up to
+   * `maxFiles` files (hard ceiling 10, the default); `maxSizeMB` lowers the
+   * per-file cap below the built-in 50 MB upload limit.
+   */
+  attachments?: {
+    maxFiles?: number;
+    maxSizeMB?: number;
+  };
   /**
    * Enable in-chat voice-message recording. **Opt-in — off by default.**
    * When `true`, an idle input (no text, no attachments) shows a
@@ -580,6 +594,12 @@ export interface IConfig {
   // ----- xmpp / QoS -----
   xmppSettings?: xmppSettingsInterface;
   disableLastRead?: boolean;
+  /**
+   * Stops this client from sending receipts: both the XEP-0184 delivery
+   * receipt and the XEP-0333 read marker, so other members see neither
+   * "delivered" nor "seen" for what this reader gets. Default false.
+   */
+  disableReadReceipts?: boolean;
   historyQoS?: HistoryQoSConfig;
   /**
    * Background history preload for the room list.
@@ -1129,13 +1149,27 @@ export interface ModalFile {
   originalName?: string;
   duration?: number | string;
   waveForm?: string;
+  /**
+   * The other files of the album this one was opened from, this one
+   * included, in order. With `index` it lets the viewer page through them.
+   */
+  siblings?: ModalFile[];
+  /** Position of this file in `siblings`. */
+  index?: number;
 }
 
 // Re-export so middleware/hooks that historically import from `types`
 // keep working without reaching into `types/models/...`.
 export type { ReactionAction } from './models/action.model';
 export type { Iso639_1Codes } from './models/language.model';
-export type { IMessage, IReply, LastMessage, ReactionMessage } from './models/message.model';
+export type {
+  IMessage,
+  IReply,
+  LastMessage,
+  ReactionMessage,
+  IMentionSpan,
+} from './models/message.model';
+export type { IAttachment } from './models/attachment.model';
 export type { RoomMember, ApiRoom, ChatAccessOption } from './models/room.model';
 export type { MediaFile } from './models/media.model';
 export type { TranslationObject } from '../helpers/transformTranslatations';

package/src/version.ts

@@ -1,3 +1,3 @@
 // Generated by scripts/sync-version.mjs on `npm version`.
 // Edit package.json's version instead of this file.
-export const ETHORA_CHAT_COMPONENT_VERSION = '26.10.5';
+export const ETHORA_CHAT_COMPONENT_VERSION = '26.10.6';