@ethora/chat-component-rn 26.10.5 → 26.10.7

package/src/push/sealedPushTask.ts

@@ -0,0 +1,175 @@
+import { AppState, Platform } from 'react-native';
+import { pushLog } from '../utils/devLogger';
+import { loadPushSecretKey } from './pushKeyStore';
+import { openSealedPush, sealedPushEnvelopeOf, type OpenSealedPushResult } from './sealedPush';
+
+// Android half of encrypted pushes. A sealed push is data-only, so the OS
+// shows nothing by itself: expo-notifications hands it to a background
+// task (expo-task-manager, foreground, background and killed app alike)
+// and this task opens the box and posts the notification. iOS does the
+// same in the notification service extension; here `registerSealedPushTask`
+// is a no-op.
+//
+// Both packages are optional peers, required lazily: a host that does not
+// want encrypted pushes never pays for them.
+
+export const SEALED_PUSH_TASK = 'ETHORA_SEALED_PUSH';
+
+export interface SealedPushTaskOptions {
+  /** Android notification channel; the OS default channel when omitted. */
+  channelId?: string;
+  /** Shown when the box does not open (no key, another key, damaged). Default "New message". */
+  placeholderTitle?: string;
+  placeholderBody?: string;
+}
+
+const PLACEHOLDER_TITLE = 'New message';
+
+let registered = false;
+
+const loadTaskManager = (): any => {
+  try {
+    return require('expo-task-manager');
+  } catch {
+    return null;
+  }
+};
+
+const loadNotifications = (): any => {
+  try {
+    return require('expo-notifications');
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * The FCM data map out of the task payload. expo-notifications passes the
+ * message as `{ notification, data }`; the data keys are on `data`
+ * itself, `data.dataString` carries the same as a JSON string on some
+ * versions, and a Firebase `RemoteMessage` keeps them under `data.data`.
+ */
+export const sealedPushDataOf = (payload: unknown): Record<string, unknown> | null => {
+  const root = payload && typeof payload === 'object' ? (payload as Record<string, unknown>) : null;
+  if (!root) {return null;}
+  const candidates: unknown[] = [root.data, root];
+  const data = root.data && typeof root.data === 'object' ? (root.data as Record<string, unknown>) : null;
+  if (data) {
+    if (typeof data.dataString === 'string') {
+      try {
+        candidates.unshift(JSON.parse(data.dataString));
+      } catch {
+        // not JSON — fall through to the map itself
+      }
+    }
+    candidates.push(data.data);
+  }
+  for (const candidate of candidates) {
+    if (sealedPushEnvelopeOf(candidate as Record<string, unknown>)) {
+      return candidate as Record<string, unknown>;
+    }
+  }
+  return null;
+};
+
+const notificationContent = (result: OpenSealedPushResult, options: SealedPushTaskOptions) => {
+  const { envelope } = result;
+  // What the tap handler (`handlePushPayload` through the host's response
+  // listener) needs: the same ids a plain push carries on `data`.
+  const data = {
+    jid: envelope.jid,
+    msgID: envelope.msgID,
+    userJid: envelope.userJid,
+    sealed: true,
+  };
+  if (!result.ok) {
+    return {
+      title: options.placeholderTitle || PLACEHOLDER_TITLE,
+      ...(options.placeholderBody ? { body: options.placeholderBody } : {}),
+      data,
+      sound: 'default',
+    };
+  }
+  const { content } = result;
+  return {
+    title: content.title || content.sender || content.chat || PLACEHOLDER_TITLE,
+    body: content.body,
+    data: { ...data, chatJid: content.chatJid, senderJid: content.senderJid },
+    sound: 'default',
+  };
+};
+
+/**
+ * Open a sealed push and show it. One notification per chat: the room JID
+ * is the identifier, so a newer message replaces the older one the way the
+ * service's collapse key does for plain pushes.
+ */
+export async function presentSealedPush(
+  data: Record<string, unknown>,
+  options: SealedPushTaskOptions = {}
+): Promise<OpenSealedPushResult | null> {
+  const envelope = sealedPushEnvelopeOf(data);
+  if (!envelope) {return null;}
+  const notifications = loadNotifications();
+  if (!notifications?.scheduleNotificationAsync) {return null;}
+
+  const result = openSealedPush(envelope, await loadPushSecretKey());
+  // console, not only pushLog: with the app killed this runs headless and
+  // `adb logcat -s ReactNativeJS` is the only place to see it.
+  if (result.ok) {
+    console.log(`[push] sealed push kid=${envelope.kid} opened for ${envelope.jid}`);
+  } else {
+    console.warn(`[push] sealed push kid=${envelope.kid} not opened (${result.reason}), showing the placeholder`);
+    pushLog('warn', `push: sealed push not opened (${result.reason}), showing the placeholder`);
+  }
+  await notifications.scheduleNotificationAsync({
+    identifier: envelope.jid || envelope.msgID || undefined,
+    content: notificationContent(result, options),
+    trigger: options.channelId ? { channelId: options.channelId } : null,
+  });
+  return result;
+}
+
+/**
+ * Define and register the background task that renders sealed pushes on
+ * Android. Call it at module scope of a file the app loads first (the
+ * entry file, or the root layout with expo-router): a killed app is
+ * started headless to run it, and the task must exist by then. No-op on
+ * iOS and when expo-task-manager / expo-notifications are not installed.
+ */
+export function registerSealedPushTask(options: SealedPushTaskOptions = {}): boolean {
+  if (Platform.OS !== 'android' || registered) {return registered;}
+  const taskManager = loadTaskManager();
+  const notifications = loadNotifications();
+  if (!taskManager?.defineTask || !notifications?.registerTaskAsync) {
+    pushLog(
+      'warn',
+      'push: expo-task-manager and expo-notifications are needed to show encrypted pushes on Android'
+    );
+    return false;
+  }
+  taskManager.defineTask(SEALED_PUSH_TASK, async ({ data, error }: { data: unknown; error: unknown }) => {
+    if (error) {return;}
+    const map = sealedPushDataOf(data);
+    if (!map) {return;}
+    // In the foreground the room is live over XMPP; the host's
+    // notification handler decides about plain pushes there too.
+    if (AppState.currentState === 'active') {return;}
+    try {
+      await presentSealedPush(map, options);
+    } catch (e) {
+      pushLog('warn', 'push: showing a sealed push failed', e);
+    }
+  });
+  registered = true;
+  notifications.registerTaskAsync(SEALED_PUSH_TASK).catch((e: unknown) => {
+    registered = false;
+    pushLog('warn', 'push: registering the sealed push task failed', e);
+  });
+  return true;
+}
+
+/** Test seam only. */
+export const __resetSealedPushTaskForTests = (): void => {
+  registered = false;
+};

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/services/pushRegistration.ts

@@ -11,6 +11,13 @@ import { pushLog } from '../utils/devLogger';
 
 export interface RegisterPushTokenOptions {
   tokenType?: PushTokenType;
+  /**
+   * Encrypted pushes: base64 of the device's X25519 public key
+   * (`ensurePushKeyPair().publicKey`). Sent with the token as `pushKey`;
+   * the service seals every chat push for it. A backend without the
+   * feature refuses the registration instead of delivering in the clear.
+   */
+  pushKey?: string;
 }
 
 export type RegisterPushTokenOutcome =
@@ -29,6 +36,7 @@ export type UnregisterPushTokenOutcome =
 export interface RegisteredPushToken {
   token: string;
   tokenType: PushTokenType;
+  pushKey?: string;
 }
 
 type Slot = 'chat' | 'voip';
@@ -93,6 +101,7 @@ const sameRegistration = (
   !!current &&
   current.token === token.token &&
   current.tokenType === token.tokenType &&
+  (current.pushKey || '') === (token.pushKey || '') &&
   current.gateway === isGateway(session) &&
   current.appId === session.appId &&
   current.xmppUsername === session.xmppUsername;
@@ -147,6 +156,7 @@ const registerOne = async (
       token: token.token,
       tokenType: token.tokenType,
       authToken: session.authToken,
+      pushKey: token.pushKey,
     });
   }
   registered.set(slotOf(token.tokenType), {
@@ -158,7 +168,8 @@ const registerOne = async (
   pushLog(
     'rn',
     `push: ${token.tokenType} token registered` +
-      (isGateway(session) ? ' (gateway)' : ` for app ${session.appId}`)
+      (isGateway(session) ? ' (gateway)' : ` for app ${session.appId}`) +
+      (token.pushKey && !isGateway(session) ? ' with a device key (encrypted pushes)' : '')
   );
 };
 
@@ -209,7 +220,7 @@ const runTokenHook = (session: Session): void => {
       if (typeof entry?.token !== 'string' || !entry.token.trim()) {
         continue;
       }
-      hold(entry.token.trim(), entry.tokenType);
+      hold(entry.token.trim(), entry.tokenType, entry.pushKey);
     }
     await registerNow();
   })().catch((error) => {
@@ -219,9 +230,18 @@ const runTokenHook = (session: Session): void => {
   });
 };
 
-const hold = (token: string, tokenType?: PushTokenType): RegisteredPushToken => {
+const hold = (
+  token: string,
+  tokenType?: PushTokenType,
+  pushKey?: string
+): RegisteredPushToken => {
   const resolved = tokenType ?? detectPushTokenType(token);
-  const entry: RegisteredPushToken = { token, tokenType: resolved };
+  const key = typeof pushKey === 'string' ? pushKey.trim() : '';
+  const entry: RegisteredPushToken = {
+    token,
+    tokenType: resolved,
+    ...(key ? { pushKey: key } : {}),
+  };
   held.set(slotOf(resolved), entry);
   return entry;
 };
@@ -274,7 +294,7 @@ export async function registerPushToken(
   if (typeof token !== 'string' || !token.trim()) {
     throw new TypeError('registerPushToken: token must be a non-empty string');
   }
-  hold(token.trim(), options?.tokenType);
+  hold(token.trim(), options?.tokenType, options?.pushKey);
   ensureWatching();
 
   const session = readSession();

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;
+}