@ethora/chat-component 26.9.8 → 26.10.1

package/dist/components/styled/StyledComponents.d.ts

@@ -42,21 +42,88 @@ export declare const UserName: import('styled-components/dist/types').IStyledCom
 export declare const InputContainer: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
 export declare const MessageInput: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, never>> & string;
 export declare const SendButton: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, never>> & string;
+/**
+ * How far a reaction row hangs below the bubble's bottom edge, in px. The row
+ * straddles the edge, so half of it (12px) is inside the bubble and the other
+ * half is the only space the message row reserves below it.
+ */
+export declare const REACTION_HANG_PX = 12;
+/** Clear space between the lowest reaction chip and the next bubble, in px. */
+export declare const REACTION_CLEAR_PX = 4;
+/** Vertical gap below a message that is followed by the same sender, in px. */
+export declare const RUN_GAP_PX = 2;
+/** Vertical gap below the last message of a run, before the next sender, in px. */
+export declare const SENDER_GAP_PX = 8;
+/** Side gutter of a message row, so a bubble's tail is not clipped, in px. */
+export declare const MESSAGE_ROW_GUTTER_PX = 6;
 export declare const CustomMessageContainer: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
     $isUser: boolean;
     $reply: boolean;
-    $reaction: boolean;
+    /** The bubble carries a reaction row that hangs below its bottom edge. */
+    $reaction?: boolean;
+    /** False when the next message comes from the same sender (a run). */
+    $lastInGroup?: boolean;
+    /**
+     * How far the reaction chips hang below the bubble, in px, as measured by
+     * MessageReaction (one row is REACTION_HANG_PX). Only used with $reaction.
+     */
+    $reactionHang?: number;
 }>> & string;
+/**
+ * Visual inset between a bubble's edge and what it holds, in px. A bubble with
+ * a 1px border (anyone else's message) takes one px less of padding so the
+ * visual inset still matches.
+ *
+ * Media bubbles (pictures, videos, file cards, voice notes) use 6px on every
+ * side, the compact Telegram-style inset that the media block aligns to. Text
+ * bubbles use 8px vertical and 12px horizontal.
+ */
+export declare const MEDIA_BUBBLE_INSET_PX = 6;
+export declare const TEXT_BUBBLE_INSET_Y_PX = 8;
+export declare const TEXT_BUBBLE_INSET_X_PX = 12;
+/** Bubble corner radius; media inside it is concentric (radius minus inset). */
+export declare const BUBBLE_RADIUS_PX = 18;
+export declare const MEDIA_RADIUS_PX: number;
+/** Glass time pill over media: how far it sits inside the media edge, in px. */
+export declare const MEDIA_TIME_PILL_OFFSET_PX = 8;
+/** Padding (CSS shorthand value) that yields the visual inset, net of the border. */
+export declare const bubblePadding: (props: {
+    $isUser: boolean;
+    $deleted: boolean;
+    $media?: boolean;
+}) => string;
+/** Corner radius where a tail attaches: the bottom corner on the tail side. */
+export declare const TAIL_CORNER_RADIUS_PX = 4;
+/** Tail box: 10px wide, 12px tall, 6px of it outside the bubble edge. */
+export declare const TAIL_WIDTH_PX = 10;
+export declare const TAIL_HEIGHT_PX = 12;
 export declare const CustomMessageBubble: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
     $isUser: boolean;
     $deleted: boolean;
+    /** The bubble carries a media block (pictures, videos, cards, voice notes). */
+    $media?: boolean;
+    /** Its only media is one solo picture or video: the bubble hugs it. */
+    $solo?: boolean;
+    /** Last of its sender's run, and not a media-only bubble: it gets the tail. */
+    $tail?: boolean;
 }>> & string;
 export declare const CustomMessageText: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
 export declare const CustomUserName: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {
     $isUser: boolean;
     $color?: string;
+    /** Inside a media bubble (6px inset): 4px more so it lines up with the caption. */
+    $media?: boolean;
+}>> & string;
+export declare const CustomMessageTimestamp: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {
+    /** Media bubble: the row sits under the media with 0 8px 4px padding. */
+    $media?: boolean;
+    /** Text bubble: the time floats at the end of the last line of text. */
+    $inline?: boolean;
+    /** Glass pill over the media's bottom right corner (media-only bubbles). */
+    $overlay?: boolean;
+    /** Whether the bubble has its 1px border (it shifts the pill by one px). */
+    $bordered?: boolean;
 }>> & string;
-export declare const CustomMessageTimestamp: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>> & string;
 export declare const CustomMessagePhoto: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, never>> & string;
 export declare const CustomMessagePhotoContainer: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
 export declare const CustomSystemMessage: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

package/dist/components/styled/StyledInputComponents/MediaComponents.d.ts

@@ -1,33 +1,45 @@
-export declare const MediaLoadingSkeleton: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
-    $width?: number | string;
-    $height?: number | string;
-}>> & string;
-export declare const Container: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
-export declare const FullScreenImage: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, never>> & string;
-export declare const ModalContent: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
-export declare const ButtonContainer: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
-export declare const IconButton: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, never>> & string;
-export declare const UnsupportedContainer: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, never>> & string;
-export declare const BackgroundFile: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
-export declare const FileInformation: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
-export declare const FileName: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>> & string;
-export declare const FileSizeContainer: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
-export declare const FileSize: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>> & string;
+import { default as React } from 'react';
+/**
+ * Loading spinner rules shared by the media loading states. The spinner is
+ * a fixed-pixel circle with `flex: none`, so a flex parent (the upload scrim,
+ * a tiny album tile) cannot squash it into an oval. Whether it is drawn at
+ * all is decided by a container query on the box it sits in, see below.
+ */
+export declare const MEDIA_SPINNER_PX = 24;
+/** Boxes smaller than this (on either side) get the shimmer only, no spinner. */
+export declare const MEDIA_SPINNER_MIN_BOX_PX = 48;
+export declare const MediaLoadingSkeleton: React.FC<{
+    $width?: number;
+    $height?: number;
+}>;
+/** Standalone spinner for a loading overlay. Hidden inside boxes under the min size. */
+export declare const MediaSpinner: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>> & string;
+export declare const Container: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const FullScreenImage: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, never>> & string;
+export declare const ModalContent: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const ButtonContainer: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const IconButton: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, never>> & string;
+export declare const UnsupportedContainer: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, never>> & string;
+export declare const BackgroundFile: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const FileInformation: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const FileName: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>> & string;
+export declare const FileSizeContainer: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const FileSize: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>> & string;
 /** Wraps every attachment of one message. Single-file messages keep the
  *  old, un-gapped look because there is nothing to separate them from. */
-export declare const AttachmentStack: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
-export declare const AttachmentGrid: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+export declare const AttachmentStack: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const AttachmentGrid: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
     $columns: number;
 }>> & string;
-export declare const AttachmentTile: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, never>> & string;
-export declare const PdfContainer: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, {
+export declare const AttachmentTile: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, never>> & string;
+export declare const PdfContainer: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, {
     $compact: boolean;
 }>> & string;
-export declare const PdfThumbnailFrame: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+export declare const PdfThumbnailFrame: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
     $compact: boolean;
 }>> & string;
 /** Sits on the thumbnail while pdf.js parses so the row does not pop in. */
-export declare const PdfThumbnailSkeleton: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
-export declare const PdfInformation: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
-export declare const PdfMetaRow: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
-export declare const PdfBadge: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>> & string;
+export declare const PdfThumbnailSkeleton: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const PdfInformation: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const PdfMetaRow: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const PdfBadge: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>> & string;

package/dist/components/styled/UnsupportedType.d.ts

@@ -6,5 +6,6 @@ interface FileDownloadProps {
     size?: string;
     locationPreview?: string;
 }
+/** Generic file in a bubble, as a card. A missing preview falls back to the type glyph. */
 declare const FileDownload: React.FC<FileDownloadProps>;
 export default FileDownload;

package/dist/components/styled/VideoMessage.d.ts

@@ -1,14 +1,19 @@
 import { default as React } from 'react';
+/** Full-size player used by the preview modal. Kept here with the bubble video. */
+export declare const FullScreenVideo: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>, never>> & string;
 interface CustomMessageVideoProps {
     fileName: string;
     fileURL: string;
     mimetype: string;
+    /** Length in seconds, when the attachment recorded one. */
+    duration?: string;
+    width?: number;
+    height?: number;
 }
-export declare const Container: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
-export declare const FullScreenVideo: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>, never>> & string;
-export declare const FixedSizeVideo: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>, never>> & string;
-export declare const ModalContent: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
-export declare const ButtonContainer: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
-export declare const IconButton: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, never>> & string;
+/**
+ * A single video in a bubble: the first frame with a glass play button and,
+ * when known, a duration chip. A click opens the preview modal, which holds
+ * the controls.
+ */
 declare const CustomMessageVideo: React.FC<CustomMessageVideoProps>;
 export default CustomMessageVideo;

package/dist/e2ee/callKey.d.ts

@@ -0,0 +1,32 @@
+import { Element } from 'ltx';
+/** Namespace of the <call-key> signal element carried inside the SCE envelope. */
+export declare const NS_CALL_E2EE = "ethora:call:e2ee:0";
+/**
+ * A fresh 256-bit media key for one call, as a base64 string. A new key per
+ * call gives forward secrecy between calls: a key recovered from one call
+ * cannot open the next. The string is fed verbatim to both peers'
+ * `ExternalE2EEKeyProvider.setKey`, which HKDFs it into the frame key.
+ */
+export declare function generateCallKey(): string;
+/** The <call-key> element that rides inside the OMEMO SCE envelope. */
+export declare function callKeyElement(callId: string, key: string): Element;
+/**
+ * Hands `key` to every member of `roomJid`, end-to-end encrypted via OMEMO so
+ * the server never sees it.
+ *
+ * Returns false (a no-op) unless E2EE is enabled for the app AND the backend
+ * marked the room `e2ee`, or when no member has published an OMEMO device yet
+ * (in which case the caller falls back to a non-E2EE call rather than
+ * failing). Returns true once the encrypted key is on its way to at least one
+ * recipient device.
+ */
+export declare function distributeCallKey(roomJid: string, callId: string, key: string): Promise<boolean>;
+/**
+ * Reads a decrypted <call-key> off a stanza the OMEMO seam has already
+ * rewritten in place (so the element sits as an ordinary child). Returns
+ * undefined when the stanza is not a call-key signal.
+ */
+export declare function parseCallKey(stanza: Element): {
+    callId: string;
+    key: string;
+} | undefined;

package/dist/e2ee/fileEnvelope.d.ts

@@ -1,3 +1,4 @@
+import { IMentionSpan } from '../types/types';
 /** What the server must not learn, and the receiver needs to render. */
 export interface FileEnvelopeMeta {
     mimetype: string;
@@ -37,12 +38,22 @@ export declare function openSealedFile(ciphertext: Uint8Array, keyMaterial: stri
     meta: FileEnvelopeMeta;
     bytes: Uint8Array;
 };
+/** What a sealed media <body> carries besides the keys. */
+export interface SealedMediaPayload {
+    keys: string[];
+    /** The text typed with the files. Sealed here, never on <data>. */
+    caption?: string;
+    captionMentions?: IMentionSpan[];
+}
 /**
- * Pull the attachment keys out of a decrypted media <body>.
+ * Pull the attachment keys (and the caption, when there is one) out of a
+ * decrypted media <body>.
  *
- * The sender put `{v:1,keys:[...]}` there instead of the usual literal
- * "media" (see sendMediaMessage). Returns undefined for anything else, so
- * an ordinary media message - or one from a build that predates sealing -
- * falls through untouched.
+ * The sender put `{v:1,keys:[...],caption?,captionMentions?}` there instead of
+ * the usual literal "media" (see sendMediaMessage). Returns undefined for
+ * anything else, so an ordinary media message - or one from a build that
+ * predates sealing - falls through untouched.
  */
+export declare function parseSealedMediaPayload(body?: string): SealedMediaPayload | undefined;
+/** The attachment keys out of a sealed media <body>; see parseSealedMediaPayload. */
 export declare function parseSealedMediaBody(body?: string): string[] | undefined;

package/dist/e2ee/omemo.d.ts

@@ -105,6 +105,24 @@ export declare class Omemo {
      * the room's echo by it.
      */
     encryptGroupMessage(roomJid: string, members: string[], content: Element[], id: string, cleartext?: Element[]): Promise<Element>;
+    /**
+     * Sends an ephemeral, end-to-end encrypted control signal to a room's
+     * members. Same OMEMO envelope as `encryptGroupMessage`, but it is NOT a
+     * chat message: no fallback <body>, no <store> hint, and MAM/carbons are
+     * asked to drop it (`no-store` / `no-permanent-store` / `no-copy`).
+     *
+     * The use case is handing a LiveKit call's media key to the other
+     * participants without the server - or anyone relaying the stanza - ever
+     * seeing it. The payload rides inside the SCE envelope exactly like a
+     * message body would, so the server observes ciphertext only.
+     *
+     * Returns true when at least one recipient device was reachable (so the
+     * caller knows the key actually went out), false when nobody in the room
+     * has published an OMEMO device yet. Unlike `encryptGroupMessage` it does
+     * not throw on an empty recipient set: a call simply falls back to plaintext
+     * media rather than failing, and the caller decides what to surface.
+     */
+    sendGroupSignal(roomJid: string, members: string[], content: Element[], id: string): Promise<boolean>;
     /**
      * Empty OMEMO message: completes a session the peer started. It targets one
      * device, so it goes straight to that member's real JID rather than through

package/dist/firebase-messaging-sw.js

@@ -151,8 +151,25 @@ async function checkAssetAvailability(url) {
   }
 }
 
+// `<appId>_<userId>` (24-hex ids, or an appId and a uuid) is a machine id,
+// never something to put in a notification title.
+const OPAQUE_ID_RE =
+  /^(?:[0-9a-f]{24}(?:_[0-9a-f]{24})?|[a-z0-9]+_(?:[0-9a-f]{24}|[0-9a-f-]{36})(?:_[0-9a-z-]+)*)$/i;
+
+function isOpaqueId(value) {
+  const text = String(value || '').trim();
+  return !!text && OPAQUE_ID_RE.test(text.split('@')[0]);
+}
+
 function pickTitle(raw = {}, data = {}, notification = {}) {
-  return notification.title || raw.title || data.title || 'New Message';
+  const title = notification.title || raw.title || data.title || '';
+  return title && !isOpaqueId(title) ? title : 'New Message';
+}
+
+// One notification per chat: a newer message in the same room replaces it.
+function roomTag(data = {}) {
+  const jid = String(data.jid || '').split('@')[0];
+  return jid ? `ethora-room-${jid}` : '';
 }
 
 function pickBody(raw = {}, data = {}, notification = {}) {
@@ -449,8 +466,8 @@ async function handlePush(raw = {}, source = 'push') {
     icon,
     badge,
     image,
-    tag: isCall ? `call:${callId || dedupKey}` : dedupKey,
-    renotify: isCall,
+    tag: isCall ? `call:${callId || dedupKey}` : roomTag(data) || dedupKey,
+    renotify: isCall || !!roomTag(data),
     requireInteraction: isCall,
     // Spread the ORIGINAL payload first so the click handler's isCallPush()
     // sees the full call fields (callId/callToken/kind/room); our routing

package/dist/{handleCopyClick-BtXos0AJ.js → handleCopyClick-DGaZhy_u.js}

@@ -1,4 +1,4 @@
-import { x as e, z as t } from "./main-BnLtessp.js";
+import { E as e, G as t } from "./main-CUB_w8AZ.js";
 const i = e.div`
   display: flex;
   flex-direction: column;

package/dist/helpers/albumLayout.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Geometry for a multi-media album bubble. Pure data so the grid component
+ * stays a dumb renderer and the layout rules can be tested without a DOM.
+ *
+ *   1 item   full width, 4:3
+ *   2 items  side by side, square cells
+ *   3 items  one large cell on the left, two stacked on the right
+ *   4 items  2 x 2
+ *   5+ items 2 x 2 showing the first four, the last cell carries "+N"
+ */
+/** Gap between neighbouring tiles. */
+export declare const ALBUM_GAP_PX = 3;
+/** Radius of a tile corner that sits on the bubble's own corner. */
+export declare const ALBUM_OUTER_RADIUS_PX = 12;
+/** Radius of every other tile corner, the ones that face a neighbour. */
+export declare const ALBUM_INNER_RADIUS_PX = 3;
+export interface AlbumCellPlacement {
+    /** CSS `grid-column` value. */
+    column: string;
+    /** CSS `grid-row` value. */
+    row: string;
+}
+export interface AlbumLayout {
+    kind: 'full' | 'pair' | 'hero' | 'quad';
+    /** Number of tiles actually drawn. */
+    visible: number;
+    /** Items folded into the "+N" overlay on the last visible tile. */
+    hidden: number;
+    /** CSS `grid-template-columns`. */
+    columns: string;
+    /** CSS `grid-template-rows`. */
+    rows: string;
+    /** CSS `aspect-ratio` of the whole grid. */
+    aspectRatio: string;
+    /** One entry per visible tile, in order. */
+    placements: AlbumCellPlacement[];
+}
+/** Layout for `count` media tiles. Counts below 1 are treated as 1. */
+export declare const getAlbumLayout: (count: number) => AlbumLayout;
+/**
+ * Which corners of one tile lie on the bubble's outer edge. Only those get
+ * the large radius; corners that face a neighbour get the small inner one.
+ */
+export interface TileCorners {
+    topLeft: boolean;
+    topRight: boolean;
+    bottomRight: boolean;
+    bottomLeft: boolean;
+}
+/** Outer-corner flags for the tile at `position` (0-based) of `layout`. */
+export declare const getTileCorners: (layout: AlbumLayout, position: number) => TileCorners;
+/** CSS `border-radius` shorthand (TL TR BR BL) for one tile. */
+export declare const getTileBorderRadius: (layout: AlbumLayout, position: number) => string;

package/dist/helpers/attachments.d.ts

@@ -28,6 +28,27 @@ export declare const serializeAttachments: (attachments: IAttachment[]) => strin
  * predates this feature - and every message from a client that does not
  * speak it - takes the second path.
  */
-export declare const getMessageAttachments: (message?: Pick<IMessage, "attachments" | "location" | "locationPreview" | "mimetype" | "originalName" | "fileName" | "size"> | null) => IAttachment[];
+export declare const getMessageAttachments: (message?: (Pick<IMessage, "attachments" | "location" | "locationPreview" | "mimetype" | "originalName" | "fileName" | "size"> & {
+    duration?: unknown;
+    mediaDuration?: unknown;
+}) | null) => IAttachment[];
+/**
+ * True when the message carries a file: flagged `isMediafile`, or (older
+ * senders that never set the flag) with a real file URL or attachment. The
+ * one test every surface uses for "is this a media bubble".
+ */
+export declare const isMediaMessage: (message?: (Partial<Pick<IMessage, "isDeleted" | "isMediafile" | "attachments">> & {
+    location?: unknown;
+    mimetype?: unknown;
+    originalName?: unknown;
+    fileName?: unknown;
+    locationPreview?: unknown;
+}) | null) => boolean;
+/**
+ * Maps one object from POST /files/ `results` to the attachment a sent
+ * message carries. Field names here follow the API's own spelling
+ * (`originalname`, `filename`), not the wire attribute names.
+ */
+export declare const toUploadedAttachment: (raw: any) => IAttachment;
 /** Name to show for an attachment, with the URL tail as the last resort. */
 export declare const getAttachmentName: (attachment: IAttachment) => string;

package/dist/helpers/avatarImageCache.d.ts

@@ -0,0 +1,9 @@
+export declare const FAILED_TTL_MS = 60000;
+export declare const avatarIdentity: (url: string) => string;
+/** The URL that already loaded for this file (any token), if any. */
+export declare const getLoadedAvatarUrl: (url: string) => string | undefined;
+export declare const markAvatarLoaded: (url: string) => void;
+export declare const markAvatarFailed: (url: string) => void;
+export declare const hasAvatarFailed: (url: string) => boolean;
+/** Test helper. */
+export declare const resetAvatarCache: () => void;

package/dist/helpers/caption.d.ts

@@ -0,0 +1,63 @@
+import { IMentionSpan } from '../types/types';
+/**
+ * The text typed with a set of attachments, sent as part of the media
+ * message itself (never as a separate text stanza).
+ *
+ * `mentions` index into `text`, the same way a text message's mention spans
+ * index into its body.
+ */
+export interface CaptionInput {
+    text: string;
+    mentions?: IMentionSpan[];
+}
+export interface NormalizedCaption {
+    caption: string;
+    mentions?: IMentionSpan[];
+}
+/**
+ * Mention spans for a caption, checked against the caption text: a span that
+ * no longer reads "@Name" at its offset is dropped. Undefined when nothing is
+ * left, so a caption without mentions carries no empty attribute.
+ */
+export declare const normalizeCaptionMentions: (value: unknown, caption: string) => IMentionSpan[] | undefined;
+/**
+ * Turns what the composer typed into the caption that travels with the
+ * media. Undefined for blank text, which means "no caption".
+ */
+export declare const normalizeCaptionInput: (input?: CaptionInput | null) => NormalizedCaption | undefined;
+/** What a media message's text is, and the @-mention spans that index into it. */
+export interface ResolvedCaption {
+    text: string;
+    mentions?: IMentionSpan[];
+}
+export interface CaptionOptions {
+    /**
+     * The caller already knows this is a media message (a thin `lastMessage`
+     * that only says so by its id). Otherwise it is read off the message.
+     */
+    isMedia?: boolean;
+    /** The message is sealed: only a caption that came out of the envelope counts. */
+    sealed?: boolean;
+    /** Extra names of the sender, which a body may merely echo. */
+    senderNames?: string[];
+}
+/**
+ * The text of a media message, from whichever format carried it. The one
+ * place that knows the formats, so every surface (bubble, room list preview,
+ * notification, reply quote, copy) agrees:
+ *
+ *  1. `caption` (+ `captionMentions`): what this SDK sends. The only source
+ *     for a sealed message, whose caption comes out of the envelope.
+ *  2. The caption under another name on `<data>` (`captionText`, `text`,
+ *     `message`, `description`, `title`) from other clients.
+ *  3. A real `body`: older clients and other SDKs put the text in the
+ *     `<body>` of the media message itself. "media", the file's name or URL,
+ *     the sender's own name or e-mail and generated labels are not text.
+ *
+ * Never derived for a sealed message, and never for a message with no file.
+ */
+export declare const resolveMessageCaption: (message?: object | null, options?: CaptionOptions) => ResolvedCaption | undefined;
+/** The caption a message carries, or undefined when it has none. */
+export declare const getMessageCaption: (message?: object | null, options?: CaptionOptions) => string | undefined;
+/** The mention spans of `getMessageCaption`'s text. */
+export declare const getMessageCaptionMentions: (message?: object | null, options?: CaptionOptions) => IMentionSpan[] | undefined;

package/dist/helpers/composerFocus.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Hands "focus the message input" from the room list to the composer.
+ *
+ * The room list and the composer live in different subtrees, and the
+ * composer may only mount after the switch (or re-render later), so a plain
+ * callback would race it. Instead the request is parked here until the
+ * mounted composer for that room claims it. A claim is one-shot, so a single
+ * click focuses exactly once.
+ */
+type Listener = () => void;
+/** Ask the composer for `roomJid` to take focus. Wakes mounted composers. */
+export declare const requestComposerFocus: (roomJid: string | null | undefined) => void;
+/** Mounted composers subscribe here to learn that a request arrived. */
+export declare const subscribeComposerFocus: (listener: Listener) => (() => void);
+/**
+ * Claims a pending request for `roomJid`. Returns true exactly once per
+ * request, and only for the room the request was made for.
+ */
+export declare const takeComposerFocusRequest: (roomJid: string | null | undefined) => boolean;
+/** Test helper: drops any parked request and all listeners. */
+export declare const resetComposerFocusForTests: () => void;
+export {};

package/dist/helpers/createMainMessageForThread.d.ts

@@ -1,2 +1,2 @@
 import { IMessage } from '../types/types';
-export declare const createMainMessageForThread: (message: IMessage) => string;
+export declare const createMainMessageForThread: (message: IMessage, t?: (key: string, vars?: Record<string, string | number>) => string) => string;

package/dist/helpers/downloadFile.d.ts

@@ -0,0 +1,19 @@
+export type DownloadResult = 'blob' | 'direct' | 'http-error';
+export interface DownloadDeps {
+    fetchImpl?: typeof fetch;
+    /** Hands a blob to the browser as a download. */
+    saveBlob?: (blob: Blob, fileName: string) => void;
+    /** Hands a plain URL to the browser as a download / new tab. */
+    saveUrl?: (url: string, fileName: string) => void;
+}
+/**
+ * Saves a media file. The blob route is preferred (it keeps the user's file
+ * name), but it needs CORS: <img>/<video>/<a> to a host such as
+ * secure-files.* never did, so a host without Access-Control-Allow-Origin
+ * makes fetch() reject with a bare TypeError. That says nothing about the
+ * file, so fall back to handing the URL to the browser directly.
+ *
+ * A reachable server that answers with an error status is different: its
+ * body is an error page, not the file, so nothing is saved.
+ */
+export declare function downloadFile(url: string, fileName: string, deps?: DownloadDeps): Promise<DownloadResult>;

package/dist/helpers/fileKind.d.ts

@@ -11,7 +11,24 @@ export type FileKind = 'image' | 'video' | 'audio' | 'pdf' | 'file';
 /** Lowercase extension without the dot; '' when the name carries none. */
 export declare const getFileExtension: (name?: string) => string;
 export declare const isPdfFile: (mimetype?: string, name?: string) => boolean;
+/**
+ * SVG is deliberately not an image here. It does not render reliably as a
+ * message picture, can be blocked by the host's CSP, and is a script
+ * injection vector when opened directly. It is treated as a plain file.
+ */
+export declare const isSvgFile: (mimetype?: string, name?: string) => boolean;
+/** True when the file renders as a picture (never for SVG). */
+export declare const isRasterImage: (mimetype?: string, name?: string) => boolean;
+/**
+ * The mimetype a file name's extension stands for, for the pictures, videos,
+ * audio and PDFs a bubble can show. Undefined for anything else.
+ */
+export declare const inferMimeFromName: (name?: string) => string | undefined;
+/** A mimetype that says nothing: empty, or the storage's "could not sniff". */
+export declare const isGenericMime: (mimetype?: string) => boolean;
 export declare const getFileKind: (mimetype?: string, name?: string) => FileKind;
 export declare const formatFileSize: (sizeInBytes?: string | number) => string;
 /** Middle-truncates the base name, always keeping the extension visible. */
 export declare const formatFileName: (name: string, maxLength: number) => string;
+/** An animated-picture candidate: image/gif, or a name or URL ending in .gif. */
+export declare const isGifFile: (mimetype?: string, nameOrUrl?: string) => boolean;