@ethora/chat-component 26.8.1 → 26.9.0

package/dist/VisibilityModal-CckTnGKB.js

@@ -0,0 +1,138 @@
+import { jsxs as r, jsx as s } from "react/jsx-runtime";
+import { useState as b, useEffect as x } from "react";
+import { x as o, a as L, p as P, u as z, aG as D, aH as I } from "./main-BHtKhpBZ.js";
+import { S as N, D as C, a as $, b as k, e as w, f as p } from "./SideDrawer-DLqEOqAi.js";
+o.div``;
+o.div`
+  font-size: 16px;
+  font-weight: bold;
+  color: var(--ethora-color-text, #141414);
+`;
+o.p`
+  font-size: 14px;
+  color: var(--ethora-color-text-muted, #6b7280);
+  margin-bottom: 32px;
+`;
+const O = o.div`
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+`, h = o.label`
+  display: flex;
+  align-items: center;
+  font-size: 14px;
+  gap: 8px;
+`, u = o.input`
+  accent-color: ${({ $radioColor: i }) => i || "var(--ethora-color-primary, #0052CD)"};
+  margin: 0px;
+`, R = o.div`
+  padding: 10px 15px;
+  margin-top: 16px;
+  color: ${({ type: i }) => i === "success" ? "#10b981" : "#ef4444"};
+  background: ${({ type: i }) => i === "success" ? "#d1fae5" : "#fee2e2"};
+  border: 1px solid
+    ${({ type: i }) => i === "success" ? "#10b981" : "#ef4444"};
+  border-radius: 4px;
+
+  [data-ethora-color-scheme='dark'] & {
+    color: ${({ type: i }) => i === "success" ? "var(--ethora-color-success, #10b981)" : "var(--ethora-color-danger, #ef4444)"};
+    background: ${({ type: i }) => i === "success" ? "rgba(16, 185, 129, 0.15)" : "rgba(242, 118, 107, 0.15)"};
+    border-color: ${({ type: i }) => i === "success" ? "var(--ethora-color-success, #10b981)" : "var(--ethora-color-danger, #ef4444)"};
+  }
+`, H = ({
+  handleCloseModal: i
+}) => {
+  const S = L(), e = P(), { user: n, config: l } = z(
+    (t) => t.chatSettingStore
+  ), g = (t) => S(I(t)), [a, m] = b(n?.isProfileOpen), [c, v] = b(n?.isAssetsOpen), [f, y] = b(null), d = (t, A) => {
+    y({ message: t, type: A }), setTimeout(() => y(null), 3e3);
+  };
+  return x(() => {
+    a !== n.isProfileOpen && D({ isProfileOpen: a }).then(({ data: t }) => {
+      g(t.user), d(e("notification.saved"), "success");
+    }).catch(() => d(e("toast.error"), "error"));
+  }, [a]), x(() => {
+    c !== n?.isAssetsOpen && D({ isAssetsOpen: c }).then(({ data: t }) => {
+      g(t.user), d(e("notification.saved"), "success");
+    }).catch(() => d(e("toast.error"), "error"));
+  }, [c]), /* @__PURE__ */ r(
+    N,
+    {
+      title: e("settings.visibility.title"),
+      onClose: i,
+      backLabel: e("action.back"),
+      children: [
+        /* @__PURE__ */ r(C, { children: [
+          /* @__PURE__ */ s($, { children: e("settings.visibility.profileLabel") }),
+          /* @__PURE__ */ s(k, { children: /* @__PURE__ */ s(w, { children: /* @__PURE__ */ r(O, { children: [
+            /* @__PURE__ */ r(h, { children: [
+              /* @__PURE__ */ s(
+                u,
+                {
+                  $radioColor: l?.colors?.primary,
+                  type: "radio",
+                  name: "ethora-profile-visibility",
+                  checked: a === !0,
+                  onChange: () => m(!0)
+                }
+              ),
+              e("settings.visibility.open")
+            ] }),
+            /* @__PURE__ */ s(p, { children: e("settings.visibility.openDescription") }),
+            /* @__PURE__ */ r(h, { children: [
+              /* @__PURE__ */ s(
+                u,
+                {
+                  $radioColor: l?.colors?.primary,
+                  type: "radio",
+                  name: "ethora-profile-visibility",
+                  checked: a === !1,
+                  onChange: () => m(!1)
+                }
+              ),
+              e("settings.visibility.restricted")
+            ] }),
+            /* @__PURE__ */ s(p, { children: e("settings.visibility.restrictedDescription") })
+          ] }) }) })
+        ] }),
+        /* @__PURE__ */ r(C, { children: [
+          /* @__PURE__ */ s($, { children: e("settings.visibility.documentsLabel") }),
+          /* @__PURE__ */ s(k, { children: /* @__PURE__ */ s(w, { children: /* @__PURE__ */ r(O, { children: [
+            /* @__PURE__ */ r(h, { children: [
+              /* @__PURE__ */ s(
+                u,
+                {
+                  $radioColor: l?.colors?.primary,
+                  type: "radio",
+                  name: "ethora-documents-visibility",
+                  checked: c === !0,
+                  onChange: () => v(!0)
+                }
+              ),
+              e("settings.visibility.full")
+            ] }),
+            /* @__PURE__ */ s(p, { children: e("settings.visibility.fullDescription") }),
+            /* @__PURE__ */ r(h, { children: [
+              /* @__PURE__ */ s(
+                u,
+                {
+                  $radioColor: l?.colors?.primary,
+                  type: "radio",
+                  name: "ethora-documents-visibility",
+                  checked: c === !1,
+                  onChange: () => v(!1)
+                }
+              ),
+              e("settings.visibility.individual")
+            ] }),
+            /* @__PURE__ */ s(p, { children: e("settings.visibility.individualDescription") })
+          ] }) }) })
+        ] }),
+        f && /* @__PURE__ */ s(R, { type: f.type, children: f.message })
+      ]
+    }
+  );
+};
+export {
+  H as default
+};

package/dist/assets/icons.d.ts

@@ -172,3 +172,11 @@ export declare const ZoomResetIcon: ({ color, ...props }: {
     [x: string]: any;
     color?: string;
 }) => import("react/jsx-runtime").JSX.Element;
+export declare const LockIcon: ({ color, ...props }: {
+    [x: string]: any;
+    color?: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const LockOffIcon: ({ color, ...props }: {
+    [x: string]: any;
+    color?: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/MainComponents/AttachmentList.d.ts

@@ -2,6 +2,11 @@ import { default as React } from 'react';
 import { IAttachment } from '../../types/types';
 interface AttachmentListProps {
     attachments: IAttachment[];
+    /** See CustomMessageImage's `onUnavailable` - only wired to the full-width
+     * single-image renderer (AttachmentRow), not the multi-file grid tiles,
+     * since one dead thumbnail there shouldn't tombstone a message that still
+     * has other live attachments. */
+    onUnavailable?: () => void;
 }
 declare const AttachmentList: React.FC<AttachmentListProps>;
 export default AttachmentList;

package/dist/components/MainComponents/SealedAttachmentList.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+import { IAttachment } from '../../types/types';
+/**
+ * Sealed attachments, offered as downloads rather than previews.
+ *
+ * `keys` are positional: keys[i] opens attachments[i] (getDataFromXml lifts
+ * them out of the OMEMO-decrypted <body>). An attachment with no key belongs
+ * to a message we could not decrypt, and renders as unavailable.
+ */
+declare const SealedAttachmentList: React.FC<{
+    attachments: IAttachment[];
+    keys?: string[];
+}>;
+export default SealedAttachmentList;

package/dist/components/RoomComponents/styled/LastMessageSealed.d.ts

@@ -0,0 +1,14 @@
+import { FC } from 'react';
+import { LastMessage } from '../../../types/types';
+interface LastMessageSealedProps extends Pick<LastMessage, 'user'> {
+}
+/**
+ * Room-list preview for a sealed attachment.
+ *
+ * It cannot say what the file is: the name and type are inside the seal and
+ * only come out on download, and the server-held ones are placeholders - an
+ * opaque `originalName` and `application/octet-stream`. So it says exactly
+ * what is known, which is that an encrypted file arrived.
+ */
+declare const LastMessageSealed: FC<LastMessageSealedProps>;
+export default LastMessageSealed;

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

@@ -2,5 +2,43 @@ import { default as React } from 'react';
 interface AudioMessageProps {
     src: string;
 }
+/**
+ * wavesurfer paints into a canvas, and a canvas fill takes a concrete
+ * colour - it cannot read `var(--ethora-color-primary)` or `color-mix()`
+ * portably. So the colours are resolved off the DOM and mixed here.
+ */
+type Rgb = {
+    r: number;
+    g: number;
+    b: number;
+};
+/**
+ * Played and unplayed bar colours for whatever this bubble turned out to
+ * be. The brand colour leads when it can be seen against the bubble; when
+ * it cannot (own-message bubbles, and any host whose primary is close to
+ * its own surface) the bubble's text colour takes over, which is readable
+ * on that surface by definition. Unplayed bars are the same colour mixed
+ * halfway into the surface, so they read as "the rest of the clip" rather
+ * than as a different element.
+ */
+export declare const resolveWaveColors: (primary: string, text: string, surface: Rgb) => {
+    wave: string;
+    progress: string;
+};
+/**
+ * Bars for one voice note.
+ *
+ * NOT the peak envelope wavesurfer draws by itself. Measured on a real QA
+ * recording: two transients hit 0.98 and 0.99 while the speech around them
+ * sits at an RMS of 0.002 to 0.058. Scaled against the peak, those two
+ * samples own the whole 28px and every other bar collapses to a hairline -
+ * the "faint dashed line with a couple of spikes" look these bubbles had.
+ *
+ * So: RMS per bucket (what the ear hears, not the worst sample), scaled
+ * against the 95th percentile so a single click cannot set the scale, then
+ * a square-root curve because loudness is perceived that way, and a floor
+ * so a quiet passage still reads as a bar rather than as nothing.
+ */
+export declare const buildWaveformPeaks: (samples: Float32Array, barCount: number) => number[];
 declare const AudioMessage: React.FC<AudioMessageProps>;
 export default AudioMessage;

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

@@ -4,6 +4,16 @@ interface CustomMessageImageProps {
     fileName: string;
     mimetype: string;
     locationPreview?: string;
+    /**
+     * Called only once the server itself says the file is gone (404/410),
+     * not merely when the <img> failed to load. The only known cause in
+     * practice is the file having been deleted from the Files panel without
+     * a matching message found locally to tombstone up front (see
+     * FilesPanel.tsx's handleDelete) - the caller uses this to flip the
+     * message to the normal "deleted" placeholder instead of leaving this
+     * broken-image card on screen.
+     */
+    onUnavailable?: () => void;
 }
 declare const CustomMessageImage: React.FC<CustomMessageImageProps>;
 export default CustomMessageImage;

package/dist/e2ee/crypto.d.ts

@@ -0,0 +1,32 @@
+import { concatBytes, randomBytes } from '@noble/hashes/utils.js';
+export { concatBytes, randomBytes };
+export interface KeyPair {
+    priv: Uint8Array;
+    pub: Uint8Array;
+}
+/** Ed25519 identity key; `seed` is the 32-byte Ed25519 secret key. */
+export interface IdentityKey {
+    seed: Uint8Array;
+    pub: Uint8Array;
+}
+export declare function hkdfSha256(ikm: Uint8Array, salt: Uint8Array | undefined, info: string, length: number): Uint8Array<ArrayBufferLike> & Uint8Array<ArrayBuffer>;
+export declare function hmacSha256(key: Uint8Array, data: Uint8Array): Uint8Array;
+/** AES-256-CBC with PKCS#7 padding. */
+export declare function aesEncrypt(key: Uint8Array, iv: Uint8Array, data: Uint8Array): Uint8Array;
+export declare function aesDecrypt(key: Uint8Array, iv: Uint8Array, data: Uint8Array): Uint8Array;
+export declare function generateKeyPair(): KeyPair;
+export declare function generateIdentity(): IdentityKey;
+/** X25519; throws on low-order public keys. */
+export declare function dh(priv: Uint8Array, pub: Uint8Array): Uint8Array;
+/** The X25519 form of an identity key, for X3DH. */
+export declare function identityDhPrivate(identity: IdentityKey): Uint8Array;
+export declare function identityDhPublic(identityPub: Uint8Array): Uint8Array;
+export declare function sign(identity: IdentityKey, message: Uint8Array): Uint8Array;
+export declare function verify(signature: Uint8Array, message: Uint8Array, identityPub: Uint8Array): boolean;
+/** Constant-time comparison. */
+export declare function bytesEqual(a: Uint8Array, b: Uint8Array): boolean;
+export declare function toBase64(bytes: Uint8Array): string;
+export declare function fromBase64(text: string): Uint8Array;
+export declare function toHex(bytes: Uint8Array): string;
+/** Random integer in [min, max]. */
+export declare function randomInt(min: number, max: number): number;

package/dist/e2ee/fileEnvelope.d.ts

@@ -0,0 +1,48 @@
+/** What the server must not learn, and the receiver needs to render. */
+export interface FileEnvelopeMeta {
+    mimetype: string;
+    originalname: string;
+    size: number;
+}
+export interface SealedFile {
+    /** Ciphertext, ready to upload. */
+    ciphertext: Uint8Array;
+    /** Base64 of the 48-byte key material. Belongs in the encrypted <body>. */
+    keyMaterial: string;
+    /** Random, extension-free name to upload under. */
+    filename: string;
+}
+/**
+ * MAGIC(8) | version(1) | headerLen(4, big-endian) | headerJSON | fileBytes
+ *
+ * Length-prefixed rather than delimited: a JSON header is arbitrary text and
+ * the body is arbitrary bytes, so there is no separator that cannot occur in
+ * either.
+ */
+export declare function encodeFileEnvelope(meta: FileEnvelopeMeta, bytes: Uint8Array): Uint8Array;
+export declare function decodeFileEnvelope(envelope: Uint8Array): {
+    meta: FileEnvelopeMeta;
+    bytes: Uint8Array;
+};
+/**
+ * Seal a file for upload.
+ *
+ * Reuses the OMEMO payload primitives (AES-256-CBC + truncated HMAC, fresh
+ * random key per call) so attachments and message bodies are protected by the
+ * same construction rather than a second, separately-reviewed one.
+ */
+export declare function sealFileForUpload(file: File | Blob): Promise<SealedFile>;
+/** Inverse of sealFileForUpload, for the receiving side. */
+export declare function openSealedFile(ciphertext: Uint8Array, keyMaterial: string): {
+    meta: FileEnvelopeMeta;
+    bytes: Uint8Array;
+};
+/**
+ * Pull the attachment keys 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.
+ */
+export declare function parseSealedMediaBody(body?: string): string[] | undefined;

package/dist/e2ee/index.d.ts

@@ -0,0 +1,53 @@
+import { Client } from '@xmpp/client';
+import { Omemo } from './omemo';
+export { NS_OMEMO, FALLBACK_BODY, formatFingerprint } from './omemo';
+export type { Decrypted, DeviceInfo, Trust } from './omemo';
+export { Omemo } from './omemo';
+/**
+ * Set from IConfig when the chat mounts.
+ *
+ * The config effect and the XMPP `online` event race, and either order is
+ * normal, so both this and onOnline() end in the same maybeStart().
+ */
+export declare function setE2eeEnabled(value: boolean): void;
+export declare function isE2eeEnabled(): boolean;
+/** Called once the XMPP session is up. */
+export declare function onOnline(client: Client): void;
+/** Drops the in-memory instance. Stored keys survive, so a re-login resumes. */
+export declare function stopOmemo(): void;
+/** The live instance, or undefined when encryption is off / not ready. */
+export declare function omemo(): Omemo | undefined;
+/**
+ * The instance once it is usable, rather than whatever exists right now.
+ *
+ * Publishing this device's bundle takes a round trip, and the server starts
+ * pushing archived messages the moment we join a room - so the first page of
+ * history routinely arrives while OMEMO is still starting. Reading `omemo()`
+ * there returns undefined and those messages get permanently rendered as
+ * undecryptable, even though the keys to read them land a moment later.
+ * Awaiting this instead makes the seam wait out that window.
+ */
+export declare function omemoReady(): Promise<Omemo | undefined>;
+/** True when the backend marked this room as end-to-end encrypted. */
+export declare function isE2eeRoom(roomJid: string): boolean;
+/**
+ * Bare JIDs to encrypt for: every member of the room.
+ *
+ * The member list comes from `GET /v1/chats/my` (RoomMember.xmppUsername), so
+ * it is the backend's view of who belongs to the room, not the list of who
+ * happens to be joined right now. That is what we want - somebody offline
+ * still has to be able to read the message later.
+ */
+export declare function roomRecipients(roomJid: string, domain: string): string[];
+/**
+ * The real bare JID behind a MUC `from`.
+ *
+ * `room@conference.host/nick` -> `nick@host`. This works because the SDK
+ * always joins with `client.jid.getLocal()` as the nick (presenceInRoom and
+ * createRoomPresence), so the nick IS the account's localpart. It is also why
+ * OMEMO works here without making rooms non-anonymous: we never need the MUC
+ * to disclose real JIDs.
+ */
+export declare function senderJidFromMuc(from: string | undefined, domain: string): string | undefined;
+/** Account domain taken from our own JID, e.g. "dappros.com". */
+export declare function accountDomain(client: Client | undefined): string;

package/dist/e2ee/omemo.d.ts

@@ -0,0 +1,130 @@
+import { Client } from '@xmpp/client';
+import { Element } from 'ltx';
+import { OmemoStore } from './store';
+export declare const NS_OMEMO = "urn:xmpp:omemo:2";
+/**
+ * The cleartext <body> of an encrypted stanza.
+ *
+ * Two audiences, one string, and it cannot be localised for either: it is
+ * written once by the sender, who does not know the reader's language.
+ *
+ * - clients that cannot read `urn:xmpp:omemo:2` render it in place of the
+ *   message;
+ * - the server's push module copies it into `msgText`, so it is what lands on
+ *   a lock screen. That rules out anything phrased as an error - keep it to a
+ *   short, neutral label.
+ */
+export declare const FALLBACK_BODY = "Encrypted message";
+/** Blind Trust Before Verification: new devices are trusted until one is verified. */
+export type Trust = 'blind' | 'verified' | 'untrusted';
+export interface Decrypted {
+    /**
+     * Content of the SCE envelope: the original <body>, <data> and whatever
+     * else the sender put there, serialized back to XML. Undefined for empty
+     * messages, which exist only to advance a session.
+     */
+    content?: string;
+    /** 'own' - sent from this device, read back from the local cache. */
+    trust: Trust | 'own';
+    error?: string;
+}
+export interface DeviceInfo {
+    id: number;
+    fingerprint: string;
+    trust: Trust | 'own';
+}
+/** Identity key fingerprint as shown to users: hex in groups of 8. */
+export declare function formatFingerprint(ik: Uint8Array): string;
+/** OMEMO 2 for one account on this device, across the MUC rooms it is in. */
+export declare class Omemo {
+    /** Our own bare JID. */
+    readonly jid: string;
+    private readonly xmpp;
+    private readonly store;
+    private keys;
+    private queue;
+    private deviceLists;
+    private constructor();
+    /** Loads (or creates) this device's keys and publishes them. */
+    static create(xmpp: Client, jid: string, store: OmemoStore): Promise<Omemo>;
+    get deviceId(): number;
+    get fingerprint(): string;
+    /** Runs tasks one at a time: sessions and keys are read-modify-write. */
+    private serial;
+    /**
+     * Publishes, and repairs the node if its configuration blocks us.
+     *
+     * Without this, one server-side change to the PEP node configuration locks
+     * every existing account out of publishing its keys for good: the device
+     * can never announce itself, so nobody can encrypt to it and everything it
+     * sends silently degrades to plaintext. Reconfiguring is tried first
+     * because it keeps the published items; deleting the node is the last
+     * resort, and costs only bundles that every device republishes on its next
+     * login anyway.
+     */
+    private publishWithRecovery;
+    /** Rewrites an existing node's configuration to what we publish against. */
+    private configureNode;
+    private deleteNode;
+    private publish;
+    private fetchItems;
+    private fetchDeviceList;
+    private deviceIds;
+    /** Adds this device to our published device list. */
+    private announceDevice;
+    private publishBundle;
+    private fetchBundle;
+    /** Records the device's identity key on first sight and returns its trust. */
+    private trustOf;
+    /** Devices of `jid` (fetching unknown bundles), including this one for our own JID. */
+    devices(jid: string): Promise<DeviceInfo[]>;
+    setTrust(jid: string, id: number, trust: Trust): Promise<void>;
+    /** Encrypts `keyMaterial` for every trusted device of `jid` (except this one). */
+    private encryptKey;
+    /**
+     * Builds the encrypted groupchat stanza for `roomJid`.
+     *
+     * The plaintext stanza's children are split in two:
+     *
+     * - `content` goes inside the SCE envelope and is what OMEMO protects.
+     *   Today that is <body> alone.
+     * - `cleartext` is appended to the stanza untouched, beside <encrypted>.
+     *   That is Ethora's <data> element, which the server's push module reads
+     *   directly off the wire (get_data_map in mod_offline_post takes the
+     *   first <data> sub-element); encrypting it turns every notification into
+     *   a bare JID localpart plus FALLBACK_BODY.
+     *
+     * Nothing in `cleartext` is protected in any way - it is archived in MAM
+     * and POSTed to the push service exactly as an unencrypted room's would
+     * be. Keep it to what the server genuinely has to read, and never move a
+     * message's text into it.
+     *
+     * `members` are the bare JIDs of everyone in the room - ours is added
+     * automatically so our other devices can read it too. `id` must be the id
+     * the plaintext stanza would have used, because the optimistic UI matches
+     * the room's echo by it.
+     */
+    encryptGroupMessage(roomJid: string, members: string[], content: Element[], id: string, cleartext?: Element[]): Promise<Element>;
+    /**
+     * 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
+     * the room.
+     */
+    private sendEmpty;
+    /**
+     * Decrypts one OMEMO stanza. `sender` is the real bare JID of the author
+     * (resolved from the room nick by the caller) and `roomJid` the room it
+     * arrived in. Returns undefined when the stanza carries no OMEMO payload.
+     */
+    decrypt(el: Element, sender: string, roomJid: string): Promise<Decrypted> | undefined;
+    private decryptUncached;
+    /**
+     * Checks the SCE envelope (XEP-0420) and returns its content as XML.
+     *
+     * The from/to check is what stops one member replaying another's encrypted
+     * message under their own nick: `from` must be the JID the room nick
+     * resolves to, and `to` must be the room the stanza arrived in.
+     */
+    private openEnvelope;
+    private replacePrekey;
+}

package/dist/e2ee/protobuf.d.ts

@@ -0,0 +1,25 @@
+export interface OmemoMessage {
+    n: number;
+    pn: number;
+    dhPub: Uint8Array;
+    ciphertext?: Uint8Array;
+}
+export declare function encodeMessage(m: OmemoMessage): Uint8Array;
+export declare function decodeMessage(buf: Uint8Array): OmemoMessage;
+export interface AuthenticatedMessage {
+    mac: Uint8Array;
+    /** Encoded OMEMOMessage. */
+    message: Uint8Array;
+}
+export declare function encodeAuthenticated(m: AuthenticatedMessage): Uint8Array;
+export declare function decodeAuthenticated(buf: Uint8Array): AuthenticatedMessage;
+export interface KeyExchange {
+    pkId: number;
+    spkId: number;
+    ik: Uint8Array;
+    ek: Uint8Array;
+    /** Encoded OMEMOAuthenticatedMessage. */
+    message: Uint8Array;
+}
+export declare function encodeKeyExchange(m: KeyExchange): Uint8Array;
+export declare function decodeKeyExchange(buf: Uint8Array): KeyExchange;

package/dist/e2ee/ratchet.d.ts

@@ -0,0 +1,54 @@
+import { IdentityKey, KeyPair } from './crypto';
+export interface Bundle {
+    ik: Uint8Array;
+    spkId: number;
+    spk: Uint8Array;
+    spkSignature: Uint8Array;
+    pkId: number;
+    pk: Uint8Array;
+}
+export interface Session {
+    rk: Uint8Array;
+    dhs: KeyPair;
+    dhr?: Uint8Array;
+    cks?: Uint8Array;
+    ckr?: Uint8Array;
+    ns: number;
+    nr: number;
+    pn: number;
+    /** Message keys of skipped messages, by `${dhPub}:${n}`, oldest first. */
+    skipped: Record<string, Uint8Array>;
+    /** X3DH associated data: initiator IK || responder IK. */
+    ad: Uint8Array;
+    /** The peer device's Ed25519 identity key. */
+    peerIk: Uint8Array;
+    /** We initiated and got no reply yet: wrap outgoing messages in a key exchange. */
+    pendingKex?: {
+        pkId: number;
+        spkId: number;
+        ek: Uint8Array;
+    };
+    /** Ephemeral key of the key exchange that created this session (responder side). */
+    kexEk?: Uint8Array;
+}
+/** Starts a session with a device from its published bundle (X3DH, active side). */
+export declare function initiateSession(own: IdentityKey, bundle: Bundle): Session;
+/** Builds the session from a received key exchange (X3DH, passive side). */
+export declare function acceptSession(own: IdentityKey, spk: KeyPair, pk: KeyPair, peerIk: Uint8Array, ek: Uint8Array): Session;
+/** Encrypts with the sending chain; returns an encoded OMEMOAuthenticatedMessage. */
+export declare function ratchetEncrypt(session: Session, plaintext: Uint8Array): [Session, Uint8Array];
+/**
+ * Decrypts an encoded OMEMOAuthenticatedMessage. The input session is left
+ * untouched; the returned one must be stored only after the whole message
+ * was processed successfully.
+ */
+export declare function ratchetDecrypt(session: Session, data: Uint8Array): [Session, Uint8Array];
+/**
+ * Encrypts the SCE envelope. `keyMaterial` (key || truncated HMAC, 48 bytes)
+ * is what gets encrypted for every recipient device.
+ */
+export declare function encryptPayload(plaintext: Uint8Array): {
+    keyMaterial: Uint8Array;
+    payload: Uint8Array;
+};
+export declare function decryptPayload(keyMaterial: Uint8Array, payload: Uint8Array): Uint8Array;

package/dist/e2ee/stanza.d.ts

@@ -0,0 +1,24 @@
+import { Element } from 'ltx';
+export type DecryptOutcome = 
+/** No OMEMO payload; the caller should carry on as before. */
+'not-encrypted'
+/** Rewritten with the sender's original children. */
+ | 'decrypted'
+/** Rewritten with a placeholder body; still a message worth showing. */
+ | 'undecryptable'
+/** Session maintenance only - there is nothing to render, skip it. */
+ | 'drop';
+/**
+ * Finds the <message> that actually carries <encrypted>, looking through the
+ * wrappers a message can arrive in: a mucsub event, a MAM <result>/<forwarded>
+ * pair, or both at once.
+ */
+export declare function encryptedCarrier(stanza: Element, depth?: number): Element | undefined;
+/**
+ * Decrypts `stanza` in place, if it carries OMEMO at all.
+ *
+ * `stanza` may be the message itself or anything wrapping it. Safe to call on
+ * every message: without an OMEMO payload it returns immediately and touches
+ * nothing.
+ */
+export declare function decryptStanzaInPlace(stanza: Element, domain: string): Promise<DecryptOutcome>;

package/dist/e2ee/store.d.ts

@@ -0,0 +1,12 @@
+/** Key-value storage for OMEMO keys, sessions and decrypted messages. */
+export interface OmemoStore {
+    get<T>(key: string): Promise<T | undefined>;
+    set(key: string, value: unknown): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+/**
+ * IndexedDB database per account. Private keys are stored unencrypted, like
+ * in other web clients: anyone with access to this browser profile can read them.
+ */
+export declare function openIndexedDbStore(jid: string): Promise<OmemoStore>;
+export declare function createMemoryStore(): OmemoStore;

package/dist/{handleCopyClick-Bj2V_brV.js → handleCopyClick-CWw4UAlT.js}

@@ -1,4 +1,4 @@
-import { v as e, x as t } from "./main-DmtEeYji.js";
+import { x as e, z as t } from "./main-BHtKhpBZ.js";
 const i = e.div`
   display: flex;
   flex-direction: column;
@@ -59,7 +59,7 @@ const i = e.div`
   padding: var(--ethora-space-1, 4px) var(--ethora-space-3, 12px);
   border-radius: var(--ethora-radius-full, 999px);
   background: var(--ethora-color-primary-soft, #e7edf9);
-  color: var(--ethora-color-primary, #0052cd);
+  color: var(--ethora-color-primary-text, var(--ethora-color-primary, #0052cd));
   font-size: var(--ethora-font-size-xs, 12px);
   font-weight: var(--ethora-font-weight-semibold, 600);