@dtelecom/secure-chat-client 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2189 @@
+'use strict';
+
+var vodozemac = require('@dtelecom/vodozemac-wasm');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var vodozemac__namespace = /*#__PURE__*/_interopNamespace(vodozemac);
+
+// src/content/protocol.ts
+var CONTENT_PROTOCOL_VERSION = 1;
+var enc = new TextEncoder();
+var dec = new TextDecoder();
+function encodeEvent(event) {
+  if (event.v !== CONTENT_PROTOCOL_VERSION) {
+    throw new Error(`encodeEvent: bad version ${event.v}`);
+  }
+  if (!event.id || !event.type) {
+    throw new Error("encodeEvent: missing id or type");
+  }
+  return JSON.stringify(event);
+}
+function decodeEvent(plaintext) {
+  let raw;
+  try {
+    raw = JSON.parse(plaintext);
+  } catch {
+    return null;
+  }
+  if (typeof raw !== "object" || raw === null) return null;
+  const obj = raw;
+  if (typeof obj.v !== "number" || obj.v > CONTENT_PROTOCOL_VERSION) return null;
+  if (typeof obj.id !== "string" || !obj.id) return null;
+  if (typeof obj.type !== "string") return null;
+  if (typeof obj.clientSentAt !== "number") return null;
+  switch (obj.type) {
+    case "text": {
+      if (typeof obj.text !== "string") return null;
+      const replyTo = typeof obj.replyTo === "string" ? obj.replyTo : void 0;
+      return {
+        v: 1,
+        id: obj.id,
+        type: "text",
+        clientSentAt: obj.clientSentAt,
+        text: obj.text,
+        ...replyTo !== void 0 ? { replyTo } : {}
+      };
+    }
+    case "edit": {
+      if (typeof obj.targetId !== "string" || typeof obj.text !== "string") return null;
+      return {
+        v: 1,
+        id: obj.id,
+        type: "edit",
+        clientSentAt: obj.clientSentAt,
+        targetId: obj.targetId,
+        text: obj.text
+      };
+    }
+    case "delete": {
+      if (typeof obj.targetId !== "string") return null;
+      return {
+        v: 1,
+        id: obj.id,
+        type: "delete",
+        clientSentAt: obj.clientSentAt,
+        targetId: obj.targetId
+      };
+    }
+    case "read": {
+      if (typeof obj.upToId !== "string") return null;
+      return {
+        v: 1,
+        id: obj.id,
+        type: "read",
+        clientSentAt: obj.clientSentAt,
+        upToId: obj.upToId
+      };
+    }
+    case "received": {
+      if (!Array.isArray(obj.ids) || !obj.ids.every((x) => typeof x === "string")) return null;
+      return {
+        v: 1,
+        id: obj.id,
+        type: "received",
+        clientSentAt: obj.clientSentAt,
+        ids: obj.ids
+      };
+    }
+    case "typing": {
+      if (obj.state !== "started" && obj.state !== "stopped") return null;
+      return {
+        v: 1,
+        id: obj.id,
+        type: "typing",
+        clientSentAt: obj.clientSentAt,
+        state: obj.state
+      };
+    }
+    case "selfEcho": {
+      if (typeof obj.originalPeer !== "string" || !obj.originalPeer) return null;
+      if (typeof obj.original !== "object" || obj.original === null) return null;
+      const inner = decodeEvent(JSON.stringify(obj.original));
+      if (inner === null) return null;
+      if (inner.type !== "text" && inner.type !== "edit" && inner.type !== "delete" && inner.type !== "read") {
+        return null;
+      }
+      return {
+        v: 1,
+        id: obj.id,
+        type: "selfEcho",
+        clientSentAt: obj.clientSentAt,
+        originalPeer: obj.originalPeer,
+        original: inner
+      };
+    }
+    default:
+      return null;
+  }
+}
+function encodeEventBytes(event) {
+  return enc.encode(encodeEvent(event));
+}
+function decodeEventBytes(bytes) {
+  return decodeEvent(dec.decode(bytes));
+}
+function newId() {
+  return globalThis.crypto.randomUUID();
+}
+function newText(text, replyTo) {
+  return {
+    v: 1,
+    id: newId(),
+    type: "text",
+    clientSentAt: Date.now(),
+    text,
+    ...replyTo !== void 0 ? { replyTo } : {}
+  };
+}
+function newEdit(targetId, text) {
+  return { v: 1, id: newId(), type: "edit", clientSentAt: Date.now(), targetId, text };
+}
+function newDelete(targetId) {
+  return { v: 1, id: newId(), type: "delete", clientSentAt: Date.now(), targetId };
+}
+function newRead(upToId) {
+  return { v: 1, id: newId(), type: "read", clientSentAt: Date.now(), upToId };
+}
+function newReceived(ids) {
+  return { v: 1, id: newId(), type: "received", clientSentAt: Date.now(), ids };
+}
+function newTyping(state) {
+  return { v: 1, id: newId(), type: "typing", clientSentAt: Date.now(), state };
+}
+function newSelfEcho(originalPeer, original) {
+  return {
+    v: 1,
+    id: newId(),
+    type: "selfEcho",
+    clientSentAt: Date.now(),
+    originalPeer,
+    original
+  };
+}
+var OLM_ACCOUNT_KEY = "olm/account";
+var OLM_SESSION_PREFIX = "olm/session/";
+var wasmInitialized = null;
+async function ensureWasmReady() {
+  if (wasmInitialized) return wasmInitialized;
+  const mod = vodozemac__namespace;
+  if (typeof mod.default !== "function") {
+    wasmInitialized = Promise.resolve();
+    return wasmInitialized;
+  }
+  wasmInitialized = mod.default().then(() => void 0);
+  return wasmInitialized;
+}
+var OlmCryptoAdapter = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  account = null;
+  sessions = /* @__PURE__ */ new Map();
+  async init() {
+    await ensureWasmReady();
+    if (this.account) return;
+    const pickled = await this.opts.store.getString(OLM_ACCOUNT_KEY);
+    if (pickled) {
+      this.account = vodozemac.Account.fromPickle(pickled);
+    }
+  }
+  async hasAccount() {
+    return this.account !== null;
+  }
+  async generateAccount(otkCount) {
+    if (this.account) throw new Error("account already exists");
+    const acc = new vodozemac.Account();
+    acc.generateOneTimeKeys(otkCount);
+    acc.generateFallbackKey();
+    this.account = acc;
+    const bundle = this.buildBundle(acc);
+    acc.markKeysAsPublished();
+    await this.persistAccount();
+    return bundle;
+  }
+  async getCurrentBundle() {
+    return this.buildBundle(this.requireAccount());
+  }
+  async generateOneTimeKeys(n) {
+    const acc = this.requireAccount();
+    acc.generateOneTimeKeys(n);
+    const otks = parseOneTimeKeys(acc.oneTimeKeys());
+    acc.markKeysAsPublished();
+    await this.persistAccount();
+    return otks;
+  }
+  async unusedOneTimeKeyCount() {
+    const acc = this.requireAccount();
+    return parseOneTimeKeys(acc.oneTimeKeys()).length;
+  }
+  async encryptForPeer(peerUserId, peerDeviceId, peerBundle, plaintext) {
+    const acc = this.requireAccount();
+    let session = await this.loadSession(peerUserId, peerDeviceId);
+    if (!session) {
+      const remoteOtk = peerBundle.oneTimeKey?.public ?? peerBundle.fallbackPrekey;
+      session = acc.createOutboundSession(peerBundle.identityKeyCurve, remoteOtk);
+      this.sessions.set(sessionKey(peerUserId, peerDeviceId), session);
+    }
+    const out = JSON.parse(session.encrypt(plaintext));
+    await this.persistSession(peerUserId, peerDeviceId, session);
+    return {
+      ciphertext: out.body,
+      msgType: out.type === 0 ? "prekey" : "normal"
+    };
+  }
+  async decryptFromPeer(peerUserId, peerDeviceId, ciphertext, msgType) {
+    const acc = this.requireAccount();
+    let session = await this.loadSession(peerUserId, peerDeviceId);
+    const isPrekey = msgType === "prekey";
+    if (!session) {
+      if (!isPrekey) {
+        throw new Error(`no session for normal-type ciphertext from ${peerUserId}/${peerDeviceId}`);
+      }
+      const inbound = acc.createInboundSession(ciphertext);
+      session = inbound.takeSession();
+      const plaintext2 = inbound.plaintext;
+      await this.persistAccount();
+      this.sessions.set(sessionKey(peerUserId, peerDeviceId), session);
+      await this.persistSession(peerUserId, peerDeviceId, session);
+      return plaintext2;
+    }
+    const olmType = isPrekey ? 0 : 1;
+    const plaintext = session.decrypt(olmType, ciphertext);
+    await this.persistSession(peerUserId, peerDeviceId, session);
+    return plaintext;
+  }
+  async forgetSession(peerUserId, peerDeviceId) {
+    const key = sessionKey(peerUserId, peerDeviceId);
+    this.sessions.delete(key);
+    await this.opts.store.delete(OLM_SESSION_PREFIX + key);
+  }
+  async hasSession(peerUserId, peerDeviceId) {
+    if (this.sessions.has(sessionKey(peerUserId, peerDeviceId))) return true;
+    const persisted = await this.opts.store.getString(
+      OLM_SESSION_PREFIX + sessionKey(peerUserId, peerDeviceId)
+    );
+    return persisted !== null;
+  }
+  // ── internal ───────────────────────────────────────────────────────────────
+  requireAccount() {
+    if (!this.account) throw new Error("no Olm account; call generateAccount() or init()");
+    return this.account;
+  }
+  buildBundle(acc) {
+    const idKeys = JSON.parse(acc.identityKeys());
+    const otks = parseOneTimeKeys(acc.oneTimeKeys());
+    const signedPrekey = idKeys.curve25519;
+    const signedPrekeySig = acc.sign(signedPrekey);
+    const fallbackParsed = parseOneTimeKeys(acc.fallbackKey());
+    const fallbackPrekey = fallbackParsed[0]?.public ?? signedPrekey;
+    const fallbackPrekeySig = acc.sign(fallbackPrekey);
+    return {
+      identityKeyCurve: idKeys.curve25519,
+      identityKeyEd: idKeys.ed25519,
+      signedPrekey,
+      signedPrekeySig,
+      fallbackPrekey,
+      fallbackPrekeySig,
+      fingerprint: formatFingerprint(idKeys.ed25519),
+      oneTimeKeys: otks
+    };
+  }
+  async persistAccount() {
+    const acc = this.requireAccount();
+    await this.opts.store.setString(OLM_ACCOUNT_KEY, acc.pickle());
+  }
+  async loadSession(peerUserId, peerDeviceId) {
+    const key = sessionKey(peerUserId, peerDeviceId);
+    const cached = this.sessions.get(key);
+    if (cached) return cached;
+    const pickled = await this.opts.store.getString(OLM_SESSION_PREFIX + key);
+    if (!pickled) return null;
+    const session = vodozemac.Session.fromPickle(pickled);
+    this.sessions.set(key, session);
+    return session;
+  }
+  async persistSession(peerUserId, peerDeviceId, session) {
+    await this.opts.store.setString(
+      OLM_SESSION_PREFIX + sessionKey(peerUserId, peerDeviceId),
+      session.pickle()
+    );
+  }
+};
+function sessionKey(peerUserId, peerDeviceId) {
+  return `${peerUserId}|${peerDeviceId}`;
+}
+function parseOneTimeKeys(json) {
+  const parsed = JSON.parse(json);
+  const out = [];
+  for (const [id, pub] of Object.entries(parsed.curve25519 ?? {})) {
+    out.push({ id, public: pub });
+  }
+  return out;
+}
+function formatFingerprint(ed25519PubB64) {
+  const groups = (ed25519PubB64.replace(/[+/=]/g, "").match(/.{1,4}/g) ?? []).slice(0, 12);
+  return groups.join("-");
+}
+
+// src/device.ts
+var DEVICE_ID_KEY = "deviceId";
+function generateUUID() {
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  const bytes = new Uint8Array(16);
+  globalThis.crypto.getRandomValues(bytes);
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+async function loadOrCreateDeviceId(store) {
+  const existing = await store.getString(DEVICE_ID_KEY);
+  if (existing) return existing;
+  const id = generateUUID();
+  await store.setString(DEVICE_ID_KEY, id);
+  return id;
+}
+
+// src/device_discovery.ts
+var DEFAULT_STALE_AFTER_MS = 5 * 60 * 1e3;
+var PeerDeviceCache = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  cache = /* @__PURE__ */ new Map();
+  /**
+   * Return peer's known devices, refreshing if cache is missing or older
+   * than `staleAfterMs`.
+   */
+  async getPeerDevices(peerUserId) {
+    const now = Date.now();
+    const stale = this.opts.staleAfterMs ?? DEFAULT_STALE_AFTER_MS;
+    const entry = this.cache.get(peerUserId);
+    if (entry && now - entry.fetchedAt < stale) {
+      return entry.devices;
+    }
+    return this.refresh(peerUserId);
+  }
+  /** Force a fresh fetch regardless of staleness. */
+  async refresh(peerUserId) {
+    const res = await this.opts.http.listDevices(this.opts.selfDeviceId, peerUserId);
+    const devices = res.devices.map((d) => ({
+      deviceId: d.deviceId,
+      fingerprint: d.fingerprint,
+      lastActiveAt: d.lastActiveAt
+    }));
+    this.cache.set(peerUserId, { devices, fetchedAt: Date.now() });
+    return devices;
+  }
+  /**
+   * Add a peer device discovered through other channels (e.g., an inbound
+   * prekey-message from a device the cache doesn't know about). Doesn't
+   * hit the network. Caller is responsible for the (deviceId, fingerprint).
+   */
+  noteNewPeerDevice(peerUserId, device) {
+    const entry = this.cache.get(peerUserId);
+    if (!entry) {
+      this.cache.set(peerUserId, { devices: [device], fetchedAt: Date.now() });
+      return;
+    }
+    if (entry.devices.some((d) => d.deviceId === device.deviceId)) return;
+    entry.devices.push(device);
+  }
+  /** Drop the cached entry; next getPeerDevices will refetch. */
+  invalidate(peerUserId) {
+    this.cache.delete(peerUserId);
+  }
+  /** Drop everything. */
+  clear() {
+    this.cache.clear();
+  }
+};
+
+// src/key_bundle.ts
+var DEFAULT_OTK_COUNT = 100;
+var OTK_TOPUP_WATERMARK = 20;
+var OTK_TOPUP_TARGET = 100;
+var KeyBundleManager = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  /** In-flight topup promise — coalesces concurrent callers so the
+   *  initial connect + onWsState("open") path doesn't double-upload. */
+  inflightTopup = null;
+  /**
+   * Idempotent. On first call generates a new Olm account and uploads
+   * the bundle; on subsequent calls no-ops if the adapter already has
+   * an account. Safe to call on every connect.
+   */
+  async ensureKeyBundle() {
+    await this.opts.crypto.init();
+    if (await this.opts.crypto.hasAccount()) {
+      return;
+    }
+    const bundle = await this.opts.crypto.generateAccount(
+      this.opts.initialOtkCount ?? DEFAULT_OTK_COUNT
+    );
+    await this.opts.http.uploadKeyBundle(this.opts.deviceId, {
+      deviceId: this.opts.deviceId,
+      identityKeyCurve: bundle.identityKeyCurve,
+      identityKeyEd: bundle.identityKeyEd,
+      signedPrekey: bundle.signedPrekey,
+      signedPrekeySig: bundle.signedPrekeySig,
+      fallbackPrekey: bundle.fallbackPrekey,
+      fallbackPrekeySig: bundle.fallbackPrekeySig,
+      fingerprint: bundle.fingerprint,
+      oneTimeKeys: bundle.oneTimeKeys
+    });
+  }
+  /**
+   * Re-upload the existing bundle without generating new keys. Used after
+   * backend wipes during testing, or when the SDK detects a registry
+   * mismatch.
+   */
+  async reuploadCurrentBundle() {
+    await this.opts.crypto.init();
+    if (!await this.opts.crypto.hasAccount()) {
+      throw new Error("reuploadCurrentBundle: no account; call ensureKeyBundle first");
+    }
+    const bundle = await this.opts.crypto.getCurrentBundle();
+    await this.opts.http.uploadKeyBundle(this.opts.deviceId, {
+      deviceId: this.opts.deviceId,
+      identityKeyCurve: bundle.identityKeyCurve,
+      identityKeyEd: bundle.identityKeyEd,
+      signedPrekey: bundle.signedPrekey,
+      signedPrekeySig: bundle.signedPrekeySig,
+      fallbackPrekey: bundle.fallbackPrekey,
+      fallbackPrekeySig: bundle.fallbackPrekeySig,
+      fingerprint: bundle.fingerprint,
+      oneTimeKeys: bundle.oneTimeKeys
+    });
+  }
+  /**
+   * Top up if the SERVER's OTK count for this device has dropped below
+   * the watermark. Generates fresh OTKs and uploads. Idempotent: a no-op
+   * if the count is healthy.
+   */
+  async topUpIfNeeded() {
+    if (this.inflightTopup) return this.inflightTopup;
+    const p = (async () => {
+      const { count } = await this.opts.http.otkCount(this.opts.deviceId);
+      if (count >= OTK_TOPUP_WATERMARK) {
+        return { topped: false };
+      }
+      const need = OTK_TOPUP_TARGET - count;
+      const fresh = await this.opts.crypto.generateOneTimeKeys(need);
+      const res = await this.opts.http.topupOtks(this.opts.deviceId, fresh);
+      return { topped: true, newCount: res.currentCount };
+    })();
+    this.inflightTopup = p;
+    try {
+      return await p;
+    } finally {
+      this.inflightTopup = null;
+    }
+  }
+};
+
+// src/message_store.ts
+var MessageStore = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  cache = /* @__PURE__ */ new Map();
+  /** Insert or overwrite. Used for both outbound (self-sent) and inbound. */
+  async put(msg) {
+    this.cache.set(msg.id, msg);
+    await this.store.setString(this.kvKey(msg.id), JSON.stringify(msg));
+  }
+  async get(messageId) {
+    const cached = this.cache.get(messageId);
+    if (cached) return cached;
+    const raw = await this.store.getString(this.kvKey(messageId));
+    if (!raw) return null;
+    try {
+      const parsed = JSON.parse(raw);
+      this.cache.set(parsed.id, parsed);
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Return messages for `peerUserId`, oldest→newest within the page.
+   *
+   * `beforeSentAt` filters to messages with `sentAt < beforeSentAt`, used by
+   * the chat UI to load older history above what's already rendered. `limit`
+   * caps the page size; when set, the most-recent matches are returned (i.e.
+   * the page sits at the boundary just before `beforeSentAt`).
+   *
+   * v1 implementation walks every persisted message; secondary indexing is
+   * a follow-up. For typical chat volumes (hundreds of messages per peer)
+   * this is fine; >10k per peer should add a per-peer KV index.
+   */
+  async listForPeer(peerUserId, opts = {}) {
+    const keys = await this.store.listKeys("messages/");
+    const out = [];
+    for (const key of keys) {
+      const id = key.slice("messages/".length);
+      const cached = this.cache.get(id);
+      let msg = cached ?? null;
+      if (!msg) {
+        const raw = await this.store.getString(key);
+        if (!raw) continue;
+        try {
+          msg = JSON.parse(raw);
+          this.cache.set(msg.id, msg);
+        } catch {
+          continue;
+        }
+      }
+      if (msg.peerUserId !== peerUserId) continue;
+      if (opts.beforeSentAt !== void 0 && msg.sentAt >= opts.beforeSentAt) continue;
+      out.push(msg);
+    }
+    out.sort((a, b) => a.sentAt - b.sentAt);
+    if (opts.limit !== void 0 && out.length > opts.limit) {
+      return out.slice(-opts.limit);
+    }
+    return out;
+  }
+  /**
+   * Apply an edit if authorized. Returns the resulting message on
+   * success, or null if the message doesn't exist, is already deleted,
+   * or the editor is not the original sender.
+   */
+  async applyEdit(opts) {
+    const target = await this.get(opts.targetId);
+    if (!target) return null;
+    if (target.deletedAt !== null) return null;
+    if (target.senderUserId !== opts.editorUserId) return null;
+    const updated = {
+      ...target,
+      text: opts.newText,
+      editedAt: opts.editedAt
+    };
+    await this.put(updated);
+    return updated;
+  }
+  /**
+   * Apply a delete (tombstone) if authorized. Same authorization rule as
+   * edit. Returns the tombstoned message or null.
+   */
+  async applyDelete(opts) {
+    const target = await this.get(opts.targetId);
+    if (!target) return null;
+    if (target.senderUserId !== opts.deleterUserId) return null;
+    const updated = {
+      ...target,
+      // Purge the original text — the contract is "tombstone, not preserve".
+      text: "",
+      deletedAt: opts.deletedAt
+    };
+    await this.put(updated);
+    return updated;
+  }
+  kvKey(messageId) {
+    return `messages/${messageId}`;
+  }
+};
+
+// src/outbox.ts
+var DEFAULT_MAX_ATTEMPTS = 5;
+var DEFAULT_BASE_BACKOFF = 500;
+var Outbox = class {
+  queue = [];
+  inflightIds = /* @__PURE__ */ new Set();
+  opts;
+  constructor(opts = {}) {
+    this.opts = {
+      maxAttempts: opts.maxAttempts ?? DEFAULT_MAX_ATTEMPTS,
+      baseBackoffMs: opts.baseBackoffMs ?? DEFAULT_BASE_BACKOFF
+    };
+  }
+  /**
+   * Enqueue a send attempt. Idempotent on messageId — a second enqueue
+   * with the same id is a no-op (returns the existing entry's promise).
+   */
+  enqueue(entry) {
+    if (this.inflightIds.has(entry.messageId)) return;
+    this.inflightIds.add(entry.messageId);
+    this.queue.push({ ...entry, attempts: 0, nextRetryAt: 0 });
+  }
+  /**
+   * Process the queue once. Sends due-now entries; reschedules failures
+   * with backoff. Returns the number of entries that completed (success
+   * or terminal failure) on this tick.
+   */
+  async tick() {
+    const now = Date.now();
+    let completed = 0;
+    const stillPending = [];
+    for (const entry of this.queue) {
+      if (entry.nextRetryAt > now) {
+        stillPending.push(entry);
+        continue;
+      }
+      entry.attempts++;
+      let outcomes;
+      try {
+        outcomes = await entry.attempt();
+      } catch {
+        outcomes = /* @__PURE__ */ new Map();
+      }
+      const anyOk = Array.from(outcomes.values()).some((s) => s === "live" || s === "stored");
+      if (anyOk) {
+        this.inflightIds.delete(entry.messageId);
+        completed++;
+        continue;
+      }
+      if (entry.attempts >= this.opts.maxAttempts) {
+        this.inflightIds.delete(entry.messageId);
+        completed++;
+        continue;
+      }
+      entry.nextRetryAt = now + this.computeBackoff(entry.attempts);
+      stillPending.push(entry);
+    }
+    this.queue = stillPending;
+    return completed;
+  }
+  size() {
+    return this.queue.length;
+  }
+  /** Test helper. */
+  has(messageId) {
+    return this.inflightIds.has(messageId);
+  }
+  computeBackoff(attempt) {
+    const base = this.opts.baseBackoffMs * 2 ** (attempt - 1);
+    const jitter = base * (0.4 * Math.random() - 0.2);
+    return Math.max(100, Math.floor(base + jitter));
+  }
+};
+
+// src/sessions.ts
+var SessionManager = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  /**
+   * Per-peer-device locks to serialize outbound session creation. Without
+   * this, two parallel sends to the same fresh peer would each consume an
+   * OTK and create two competing sessions.
+   */
+  locks = /* @__PURE__ */ new Map();
+  // Cached peer-device bundles. Refreshed by device_discovery; consumed
+  // here on send. null = no claim attempted yet for this peer.
+  bundleCache = /* @__PURE__ */ new Map();
+  // In-flight claim_all promises keyed by peer user. Coalesces parallel
+  // first-time sends so they share one claim_all → one OTK consumed → one
+  // outbound session per peer device. Without this, two parallel sendText
+  // calls both miss the cache, both call claim_all, both consume an OTK,
+  // both create outbound sessions, the second persisted session overwrites
+  // the first — and subsequent messages encrypt with a session the peer's
+  // inbound side never saw.
+  inflightRefresh = /* @__PURE__ */ new Map();
+  /**
+   * Encrypt one plaintext for ALL of a peer's currently-known devices.
+   * On first contact OR when bundleCache is empty for this peer, calls
+   * claim_all to fetch fresh bundles (which atomically pop OTKs).
+   *
+   * Returns an empty array when the peer has no chat-registered devices
+   * (or has blocked the caller — same shape; see contract §2.5).
+   */
+  async encryptForPeer(peerUserId, plaintext) {
+    let devices = await this.ensurePeerBundles(peerUserId);
+    if (this.opts.selfUserId && peerUserId === this.opts.selfUserId) {
+      devices = devices.filter((d) => d.deviceId !== this.opts.selfDeviceId);
+    }
+    if (devices.length === 0) return [];
+    const results = [];
+    for (const dev of devices) {
+      const env = await this.encryptForOneDevice(peerUserId, dev, plaintext);
+      results.push({ peerDeviceId: dev.deviceId, ciphertext: env.ciphertext, msgType: env.msgType });
+    }
+    return results;
+  }
+  /**
+   * Decrypt an inbound ciphertext from (peerUserId, peerDeviceId). On
+   * msgType=="prekey" with no existing session, creates an inbound
+   * session from the prekey message itself — no claim needed.
+   */
+  async decrypt(peerUserId, peerDeviceId, ciphertext, msgType) {
+    return this.opts.crypto.decryptFromPeer(peerUserId, peerDeviceId, ciphertext, msgType);
+  }
+  /**
+   * Drop the cached bundle list and any session with this peer device.
+   * Used on decrypt-failure recovery, before a re-claim.
+   */
+  async forgetPeerDevice(peerUserId, peerDeviceId) {
+    const cached = this.bundleCache.get(peerUserId);
+    if (cached) {
+      this.bundleCache.set(
+        peerUserId,
+        cached.filter((d) => d.deviceId !== peerDeviceId)
+      );
+    }
+    await this.opts.crypto.forgetSession(peerUserId, peerDeviceId);
+  }
+  /** Test/diagnostic helper. */
+  async hasSession(peerUserId, peerDeviceId) {
+    return this.opts.crypto.hasSession(peerUserId, peerDeviceId);
+  }
+  /**
+   * Number of cached devices for `peerUserId` that we'd actually fanout
+   * to (excludes selfDeviceId when peerUserId === selfUserId). Returns
+   * `null` when no claim has been attempted yet for this peer — caller
+   * should treat that as "unknown, prefer refresh."
+   */
+  cachedFanoutSize(peerUserId) {
+    const cached = this.bundleCache.get(peerUserId);
+    if (!cached) return null;
+    if (this.opts.selfUserId && peerUserId === this.opts.selfUserId) {
+      return cached.filter((d) => d.deviceId !== this.opts.selfDeviceId).length;
+    }
+    return cached.length;
+  }
+  /**
+   * Force a refresh of peer bundles (e.g., from device_discovery on a
+   * detected new peer device). Calls claim_all again; subsequent sends
+   * use the new bundles. Pops fresh OTKs server-side.
+   */
+  async refreshPeerBundles(peerUserId) {
+    const res = await this.opts.http.claimAll(this.opts.selfDeviceId, peerUserId);
+    this.bundleCache.set(peerUserId, res.devices);
+    return res.devices;
+  }
+  // ── internal ───────────────────────────────────────────────────────────────
+  async ensurePeerBundles(peerUserId) {
+    const cached = this.bundleCache.get(peerUserId);
+    if (cached) return cached;
+    const inflight = this.inflightRefresh.get(peerUserId);
+    if (inflight) return inflight;
+    const p = (async () => {
+      try {
+        return await this.refreshPeerBundles(peerUserId);
+      } finally {
+        this.inflightRefresh.delete(peerUserId);
+      }
+    })();
+    this.inflightRefresh.set(peerUserId, p);
+    return p;
+  }
+  async encryptForOneDevice(peerUserId, bundle, plaintext) {
+    const lockKey = sessionKey2(peerUserId, bundle.deviceId);
+    const prev = this.locks.get(lockKey) ?? Promise.resolve();
+    let release;
+    const next = new Promise((r) => {
+      release = r;
+    });
+    this.locks.set(lockKey, prev.then(() => next));
+    await prev;
+    try {
+      return await this.opts.crypto.encryptForPeer(peerUserId, bundle.deviceId, bundle, plaintext);
+    } finally {
+      release();
+      if (this.locks.get(lockKey) === prev.then(() => next)) {
+        this.locks.delete(lockKey);
+      }
+    }
+  }
+};
+function sessionKey2(peerUserId, peerDeviceId) {
+  return `${peerUserId}|${peerDeviceId}`;
+}
+
+// src/status.ts
+var StatusTracker = class {
+  outbound = /* @__PURE__ */ new Map();
+  /** Reverse index for quick lookup on chatSendResult. */
+  envelopeToMessage = /* @__PURE__ */ new Map();
+  /** Sorted list of (messageId, peerUserId) ordered by send time, used to
+   *  resolve `read` watermarks against earlier messages. Append-only. */
+  byPeer = /* @__PURE__ */ new Map();
+  listeners = [];
+  on(fn) {
+    this.listeners.push(fn);
+    return () => {
+      const i = this.listeners.indexOf(fn);
+      if (i >= 0) this.listeners.splice(i, 1);
+    };
+  }
+  /**
+   * Register a freshly-sent message. envelopeToDevice maps each target's
+   * envelopeUuid to the peer device it was sent to — fed by the SDK from
+   * the chatSend frame's targets[].
+   */
+  trackOutbound(opts) {
+    const peerDevices = new Set(opts.envelopeToDevice.values());
+    this.outbound.set(opts.messageId, {
+      messageId: opts.messageId,
+      peerUserId: opts.peerUserId,
+      envelopeToDevice: opts.envelopeToDevice,
+      peerDevices,
+      receivedFrom: /* @__PURE__ */ new Set(),
+      status: "pending"
+    });
+    for (const uuid of opts.envelopeToDevice.keys()) {
+      this.envelopeToMessage.set(uuid, opts.messageId);
+    }
+    const list = this.byPeer.get(opts.peerUserId) ?? [];
+    list.push(opts.messageId);
+    this.byPeer.set(opts.peerUserId, list);
+  }
+  /**
+   * Process a chatSendResult outcome. Multiple outcomes per message (one
+   * per target). Marks the message at least "sent" once any target
+   * succeeds.
+   */
+  onSendResult(envelopeUuid, status) {
+    const messageId = this.envelopeToMessage.get(envelopeUuid);
+    if (!messageId) return;
+    const outbound = this.outbound.get(messageId);
+    if (!outbound) return;
+    if (status === "live" || status === "stored") {
+      this.bump(outbound, "sent");
+    }
+  }
+  /**
+   * Process an inbound `received` event from peer. Marks corresponding
+   * outbound messages as delivered (or deliveredAll once all peer
+   * devices have acknowledged).
+   */
+  onReceived(opts) {
+    for (const id of opts.messageIds) {
+      const outbound = this.outbound.get(id);
+      if (!outbound) continue;
+      if (outbound.peerUserId !== opts.peerUserId) continue;
+      if (!outbound.peerDevices.has(opts.peerDeviceId)) {
+        outbound.peerDevices.add(opts.peerDeviceId);
+      }
+      outbound.receivedFrom.add(opts.peerDeviceId);
+      const allReceived = outbound.receivedFrom.size >= outbound.peerDevices.size && outbound.peerDevices.size > 0;
+      this.bump(outbound, allReceived ? "deliveredAll" : "delivered");
+    }
+  }
+  /**
+   * Process a `read` watermark from the peer. All this peer's outbound
+   * messages with sentAt index <= upToId's index move to "read".
+   * Resolution is by send-order (insertion order in byPeer).
+   */
+  onRead(opts) {
+    const list = this.byPeer.get(opts.peerUserId);
+    if (!list) return;
+    const idx = list.indexOf(opts.upToId);
+    if (idx < 0) return;
+    for (let i = 0; i <= idx; i++) {
+      const outbound = this.outbound.get(list[i]);
+      if (!outbound) continue;
+      this.bump(outbound, "read");
+    }
+  }
+  /** Test/diagnostic helper. */
+  getStatus(messageId) {
+    return this.outbound.get(messageId)?.status;
+  }
+  // ── internal ───────────────────────────────────────────────────────────────
+  bump(outbound, candidate) {
+    if (rank(candidate) <= rank(outbound.status)) return;
+    outbound.status = candidate;
+    for (const fn of this.listeners) {
+      try {
+        fn(outbound.messageId, candidate, outbound.peerUserId);
+      } catch {
+      }
+    }
+  }
+};
+function rank(s) {
+  switch (s) {
+    case "pending":
+      return 0;
+    case "sent":
+      return 1;
+    case "delivered":
+      return 2;
+    case "deliveredAll":
+      return 3;
+    case "read":
+      return 4;
+  }
+}
+
+// src/store/web-adapter.ts
+var DB_NAME = "dtelecom-secure-chat";
+var STORE = "kv";
+var VERSION = 1;
+var dbPromise = null;
+function openDB() {
+  if (dbPromise) return dbPromise;
+  dbPromise = new Promise((resolve, reject) => {
+    const req = indexedDB.open(DB_NAME, VERSION);
+    req.onupgradeneeded = () => {
+      const db = req.result;
+      if (!db.objectStoreNames.contains(STORE)) {
+        db.createObjectStore(STORE);
+      }
+    };
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+  return dbPromise;
+}
+async function withStore(mode, fn) {
+  const db = await openDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(STORE, mode);
+    const store = tx.objectStore(STORE);
+    const result = fn(store);
+    tx.oncomplete = () => {
+      if (result && typeof result === "object" && "result" in result) {
+        resolve(result.result);
+      } else {
+        resolve(result);
+      }
+    };
+    tx.onerror = () => reject(tx.error);
+    tx.onabort = () => reject(tx.error);
+  });
+}
+var WebKVStore = class {
+  async getString(key) {
+    const v = await withStore("readonly", (s) => s.get(key));
+    if (!v) return null;
+    const sv = v;
+    return sv.type === "string" ? sv.value : null;
+  }
+  async setString(key, value) {
+    const sv = { type: "string", value };
+    await withStore("readwrite", (s) => s.put(sv, key));
+  }
+  async getBytes(key) {
+    const v = await withStore("readonly", (s) => s.get(key));
+    if (!v) return null;
+    const sv = v;
+    return sv.type === "bytes" ? sv.value : null;
+  }
+  async setBytes(key, value) {
+    const sv = { type: "bytes", value };
+    await withStore("readwrite", (s) => s.put(sv, key));
+  }
+  async delete(key) {
+    await withStore("readwrite", (s) => s.delete(key));
+  }
+  async listKeys(prefix) {
+    const db = await openDB();
+    return new Promise((resolve, reject) => {
+      const out = [];
+      const tx = db.transaction(STORE, "readonly");
+      const cursorReq = tx.objectStore(STORE).openKeyCursor();
+      cursorReq.onsuccess = () => {
+        const cursor = cursorReq.result;
+        if (!cursor) {
+          resolve(out);
+          return;
+        }
+        const k = cursor.key;
+        if (k.startsWith(prefix)) out.push(k);
+        cursor.continue();
+      };
+      cursorReq.onerror = () => reject(cursorReq.error);
+    });
+  }
+};
+
+// src/transport/http.ts
+var HttpError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "HttpError";
+  }
+  status;
+  code;
+};
+var HttpClient = class {
+  apiBase;
+  fetchToken;
+  fetchImpl;
+  // Cached MintTokenResponse, keyed by device id. Refreshed when expired.
+  cached = null;
+  cachedDeviceId = null;
+  constructor(opts) {
+    this.apiBase = opts.apiBaseURL.replace(/\/$/, "");
+    this.fetchToken = opts.fetchChatToken;
+    this.fetchImpl = opts.fetchImpl ?? globalThis.fetch.bind(globalThis);
+  }
+  // ── token + node-url lifecycle ─────────────────────────────────────────────
+  /**
+   * Returns the full mint response (token + chatNodeWsUrl + expiry),
+   * fetching afresh if no cached value exists or it expires within 60 seconds.
+   * Also re-fetches when the device id changes.
+   */
+  async getMint(deviceId) {
+    const now = Math.floor(Date.now() / 1e3);
+    if (this.cached && this.cachedDeviceId === deviceId && this.cached.expiresAt - now > 60) {
+      return this.cached;
+    }
+    const mint = await this.fetchToken(deviceId);
+    if (!mint.chatToken || typeof mint.expiresAt !== "number" || !mint.chatNodeWsUrl) {
+      throw new Error("fetchChatToken must return { chatToken, expiresAt, chatNodeWsUrl }");
+    }
+    this.cached = mint;
+    this.cachedDeviceId = deviceId;
+    return mint;
+  }
+  /** Convenience: just the JWT. Backed by getMint(). */
+  async getToken(deviceId) {
+    return (await this.getMint(deviceId)).chatToken;
+  }
+  /** Convenience: just the discovered node WS URL. Backed by getMint(). */
+  async getNodeWsUrl(deviceId) {
+    return (await this.getMint(deviceId)).chatNodeWsUrl;
+  }
+  // ── authed JSON helpers ────────────────────────────────────────────────────
+  async authedJson(method, path, deviceId, body) {
+    const token = await this.getToken(deviceId);
+    const headers = {
+      authorization: `Bearer ${token}`
+    };
+    let bodyText;
+    if (body !== void 0) {
+      headers["content-type"] = "application/json";
+      bodyText = JSON.stringify(body);
+    }
+    const res = await this.fetchImpl(`${this.apiBase}${path}`, {
+      method,
+      headers,
+      body: bodyText
+    });
+    if (!res.ok) {
+      let code = "http_error";
+      let msg = `${res.status} ${res.statusText}`;
+      try {
+        const errJson = await res.json();
+        if (errJson.error) code = errJson.error;
+        if (errJson.message) msg = errJson.message;
+      } catch {
+      }
+      throw new HttpError(res.status, code, msg);
+    }
+    if (res.status === 204) return void 0;
+    return await res.json();
+  }
+  // ── /api/chat/keys ─────────────────────────────────────────────────────────
+  uploadKeyBundle(deviceId, body) {
+    return this.authedJson("POST", "/api/chat/keys/upload", deviceId, body);
+  }
+  topupOtks(deviceId, keys) {
+    const body = { deviceId, oneTimeKeys: keys };
+    return this.authedJson("POST", "/api/chat/keys/topup", deviceId, body);
+  }
+  otkCount(deviceId) {
+    return this.authedJson(
+      "GET",
+      `/api/chat/keys/count?deviceId=${encodeURIComponent(deviceId)}`,
+      deviceId
+    );
+  }
+  claimAll(deviceId, peerUserId) {
+    return this.authedJson("POST", "/api/chat/keys/claim_all", deviceId, {
+      peerUserId
+    });
+  }
+  listDevices(deviceId, peerUserId) {
+    return this.authedJson(
+      "GET",
+      `/api/chat/keys/list_devices?peerUserId=${encodeURIComponent(peerUserId)}`,
+      deviceId
+    );
+  }
+  // ── /api/chat/envelopes ────────────────────────────────────────────────────
+  pending(deviceId, limit = 100) {
+    return this.authedJson(
+      "GET",
+      `/api/chat/envelopes/pending?deviceId=${encodeURIComponent(deviceId)}&limit=${limit}`,
+      deviceId
+    );
+  }
+  ack(deviceId, envelopeUuids) {
+    const body = { deviceId, envelopeUuids };
+    return this.authedJson("POST", "/api/chat/envelopes/ack", deviceId, body);
+  }
+  // ── /api/chat/blocks ───────────────────────────────────────────────────────
+  blockUser(deviceId, peerUserId) {
+    return this.authedJson("POST", "/api/chat/blocks", deviceId, { peerUserId });
+  }
+  unblockUser(deviceId, peerUserId) {
+    return this.authedJson(
+      "DELETE",
+      `/api/chat/blocks/${encodeURIComponent(peerUserId)}`,
+      deviceId
+    );
+  }
+  listBlocked(deviceId) {
+    return this.authedJson("GET", "/api/chat/blocks", deviceId);
+  }
+};
+
+// src/transport/ws.ts
+var WsClient = class {
+  opts;
+  socket = null;
+  state = "closed";
+  attempt = 0;
+  pingTimer = null;
+  explicitClose = false;
+  constructor(opts) {
+    this.opts = {
+      nodeBaseURL: opts.nodeBaseURL.replace(/\/$/, ""),
+      getToken: opts.getToken,
+      onFrame: opts.onFrame,
+      onState: opts.onState ?? (() => {
+      }),
+      webSocketImpl: opts.webSocketImpl ?? globalThis.WebSocket,
+      reconnect: opts.reconnect ?? true,
+      pingIntervalMs: opts.pingIntervalMs ?? 25e3
+    };
+  }
+  getState() {
+    return this.state;
+  }
+  /** Open a connection. Resolves once the WS reaches `open`. */
+  async connect() {
+    if (this.state === "open" || this.state === "connecting") return;
+    this.explicitClose = false;
+    return this.connectInternal();
+  }
+  /** Send an outbound frame. Throws if not open. */
+  send(frame) {
+    if (!this.socket || this.state !== "open") {
+      throw new Error(`ws not open (state=${this.state})`);
+    }
+    this.socket.send(JSON.stringify(frame));
+  }
+  /** Convenience for a chatSend frame. */
+  sendChat(frame) {
+    this.send({ kind: "chatSend", ...frame });
+  }
+  /** Convenience for a chatPing. */
+  ping() {
+    const f = { kind: "chatPing" };
+    this.send(f);
+  }
+  /** Close the connection. After this, no auto-reconnect happens. */
+  async close() {
+    this.explicitClose = true;
+    this.setState("closing");
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+    if (this.socket && this.socket.readyState === this.opts.webSocketImpl.OPEN) {
+      this.socket.close(1e3, "client closing");
+    }
+  }
+  // ── internal ───────────────────────────────────────────────────────────────
+  async connectInternal() {
+    this.setState("connecting");
+    const token = await this.opts.getToken();
+    const url = `${this.opts.nodeBaseURL}/chat/ws?access_token=${encodeURIComponent(token)}`;
+    const Ctor = this.opts.webSocketImpl;
+    const sock = new Ctor(url);
+    this.socket = sock;
+    return new Promise((resolve, reject) => {
+      sock.onopen = () => {
+        this.attempt = 0;
+        this.setState("open");
+        this.startPing();
+        resolve();
+      };
+      sock.onmessage = (ev) => {
+        let frame;
+        try {
+          frame = JSON.parse(typeof ev.data === "string" ? ev.data : "");
+        } catch {
+          return;
+        }
+        try {
+          const ret = this.opts.onFrame(frame);
+          if (ret && typeof ret.catch === "function") {
+            ret.catch(() => {
+            });
+          }
+        } catch {
+        }
+      };
+      sock.onerror = (_ev) => {
+        if (this.state === "connecting") reject(new Error("ws connect error"));
+      };
+      sock.onclose = () => {
+        this.stopPing();
+        this.socket = null;
+        if (this.explicitClose || !this.opts.reconnect) {
+          this.setState("closed");
+          return;
+        }
+        this.setState("reconnecting");
+        const delay = backoffMs(this.attempt++);
+        setTimeout(() => {
+          this.connectInternal().catch(() => {
+          });
+        }, delay);
+      };
+    });
+  }
+  startPing() {
+    if (this.opts.pingIntervalMs <= 0) return;
+    this.pingTimer = setInterval(() => {
+      try {
+        this.ping();
+      } catch {
+      }
+    }, this.opts.pingIntervalMs);
+  }
+  stopPing() {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+  }
+  setState(s) {
+    if (this.state === s) return;
+    this.state = s;
+    try {
+      this.opts.onState(s);
+    } catch {
+    }
+  }
+};
+function backoffMs(attempt) {
+  const base = Math.min(500 * 2 ** attempt, 3e4);
+  const jitter = base * (0.2 * (Math.random() - 0.5) * 2);
+  return Math.max(250, Math.floor(base + jitter));
+}
+
+// src/typing.ts
+var STARTED_REFRESH_MS = 3e3;
+var AUTO_STOPPED_AFTER_MS = 5e3;
+var TypingManager = class {
+  constructor(emit) {
+    this.emit = emit;
+  }
+  emit;
+  peers = /* @__PURE__ */ new Map();
+  /**
+   * Called by the SDK on every keystroke change.
+   * `isTyping=true` means "user is typing now"; `false` means "user
+   * explicitly stopped (cleared input or blurred)".
+   */
+  setTyping(peerUserId, isTyping) {
+    const now = Date.now();
+    const state = this.peers.get(peerUserId);
+    if (!isTyping) {
+      if (state?.isActive) {
+        this.cancelAutoStop(state);
+        state.isActive = false;
+        this.emit(peerUserId, "stopped");
+      }
+      return;
+    }
+    if (!state) {
+      const fresh = {
+        lastStartedAt: now,
+        autoStopTimer: null,
+        isActive: true
+      };
+      this.peers.set(peerUserId, fresh);
+      this.scheduleAutoStop(peerUserId, fresh);
+      this.emit(peerUserId, "started");
+      return;
+    }
+    if (!state.isActive) {
+      state.isActive = true;
+      state.lastStartedAt = now;
+      this.scheduleAutoStop(peerUserId, state);
+      this.emit(peerUserId, "started");
+      return;
+    }
+    this.cancelAutoStop(state);
+    this.scheduleAutoStop(peerUserId, state);
+    if (now - state.lastStartedAt >= STARTED_REFRESH_MS) {
+      state.lastStartedAt = now;
+      this.emit(peerUserId, "started");
+    }
+  }
+  /**
+   * Called by the SDK when it actually sends a (non-typing) message to
+   * this peer — closes any in-progress typing state silently.
+   */
+  clearOnSend(peerUserId) {
+    const state = this.peers.get(peerUserId);
+    if (!state || !state.isActive) return;
+    this.cancelAutoStop(state);
+    state.isActive = false;
+    this.emit(peerUserId, "stopped");
+  }
+  /** Tear down all timers (called on chat.disconnect()). */
+  shutdown() {
+    for (const state of this.peers.values()) {
+      this.cancelAutoStop(state);
+    }
+    this.peers.clear();
+  }
+  // ── internal ───────────────────────────────────────────────────────────────
+  scheduleAutoStop(peerUserId, state) {
+    state.autoStopTimer = setTimeout(() => {
+      state.autoStopTimer = null;
+      if (!state.isActive) return;
+      state.isActive = false;
+      this.emit(peerUserId, "stopped");
+    }, AUTO_STOPPED_AFTER_MS);
+  }
+  cancelAutoStop(state) {
+    if (state.autoStopTimer) {
+      clearTimeout(state.autoStopTimer);
+      state.autoStopTimer = null;
+    }
+  }
+};
+
+// src/crypto/fake-adapter.ts
+var PREKEY_MARKER = "FAKEPREKEY:";
+var NORMAL_MARKER = "FAKENORMAL:";
+var FakeCryptoAdapter = class {
+  account = null;
+  // session existence — keyed "<peerUser>|<peerDevice>"; value irrelevant
+  sessions = /* @__PURE__ */ new Set();
+  otkCounter = 0;
+  async init() {
+  }
+  async hasAccount() {
+    return this.account !== null;
+  }
+  async generateAccount(otkCount) {
+    if (this.account) throw new Error("account already exists");
+    const id = randomB64(32);
+    this.account = {
+      identityKeyCurve: id,
+      identityKeyEd: randomB64(32),
+      signedPrekey: randomB64(32),
+      signedPrekeySig: randomB64(64),
+      fallbackPrekey: randomB64(32),
+      fallbackPrekeySig: randomB64(64),
+      fingerprint: chunked(id),
+      otkPool: this.makeOtks(otkCount)
+    };
+    return this.snapshot();
+  }
+  async getCurrentBundle() {
+    if (!this.account) throw new Error("no account");
+    return this.snapshot();
+  }
+  async generateOneTimeKeys(n) {
+    if (!this.account) throw new Error("no account");
+    const fresh = this.makeOtks(n);
+    this.account.otkPool.push(...fresh);
+    return fresh;
+  }
+  async unusedOneTimeKeyCount() {
+    return this.account?.otkPool.length ?? 0;
+  }
+  async encryptForPeer(peerUserId, peerDeviceId, _peerBundle, plaintext) {
+    if (!this.account) throw new Error("no account");
+    const key = sessionKey3(peerUserId, peerDeviceId);
+    const isFirst = !this.sessions.has(key);
+    this.sessions.add(key);
+    const marker = isFirst ? PREKEY_MARKER : NORMAL_MARKER;
+    const ciphertext = btoa(marker + plaintext);
+    return { ciphertext, msgType: isFirst ? "prekey" : "normal" };
+  }
+  async decryptFromPeer(peerUserId, peerDeviceId, ciphertext, msgType) {
+    if (!this.account) throw new Error("no account");
+    const key = sessionKey3(peerUserId, peerDeviceId);
+    if (msgType === "prekey") {
+      this.sessions.add(key);
+    } else if (!this.sessions.has(key)) {
+      throw new Error("no session for normal-type ciphertext");
+    }
+    const decoded = atob(ciphertext);
+    const expected = msgType === "prekey" ? PREKEY_MARKER : NORMAL_MARKER;
+    if (!decoded.startsWith(expected)) {
+      throw new Error(`fake decrypt: expected ${expected} prefix, got ${decoded.slice(0, 16)}`);
+    }
+    return decoded.slice(expected.length);
+  }
+  async forgetSession(peerUserId, peerDeviceId) {
+    this.sessions.delete(sessionKey3(peerUserId, peerDeviceId));
+  }
+  async hasSession(peerUserId, peerDeviceId) {
+    return this.sessions.has(sessionKey3(peerUserId, peerDeviceId));
+  }
+  // ── helpers ────────────────────────────────────────────────────────────────
+  snapshot() {
+    if (!this.account) throw new Error("no account");
+    const { otkPool, ...rest } = this.account;
+    return { ...rest, oneTimeKeys: [...otkPool] };
+  }
+  makeOtks(n) {
+    const out = [];
+    for (let i = 0; i < n; i++) {
+      this.otkCounter++;
+      out.push({ id: `fake-otk-${this.otkCounter}`, public: randomB64(32) });
+    }
+    return out;
+  }
+};
+function sessionKey3(peerUserId, peerDeviceId) {
+  return `${peerUserId}|${peerDeviceId}`;
+}
+function randomB64(bytes) {
+  const buf = new Uint8Array(bytes);
+  globalThis.crypto.getRandomValues(buf);
+  return btoa(String.fromCharCode(...buf)).replace(/=+$/, "").replace(/\+/g, "-").replace(/\//g, "_");
+}
+function chunked(b64) {
+  const hex = b64.slice(0, 32);
+  return hex.match(/.{1,4}/g)?.join("-") ?? hex;
+}
+
+// src/store/memory-adapter.ts
+var MemoryKVStore = class {
+  map = /* @__PURE__ */ new Map();
+  async getString(key) {
+    const v = this.map.get(key);
+    return v?.type === "string" ? v.value : null;
+  }
+  async setString(key, value) {
+    this.map.set(key, { type: "string", value });
+  }
+  async getBytes(key) {
+    const v = this.map.get(key);
+    return v?.type === "bytes" ? v.value : null;
+  }
+  async setBytes(key, value) {
+    this.map.set(key, { type: "bytes", value });
+  }
+  async delete(key) {
+    this.map.delete(key);
+  }
+  async listKeys(prefix) {
+    const out = [];
+    for (const k of this.map.keys()) {
+      if (k.startsWith(prefix)) out.push(k);
+    }
+    return out;
+  }
+};
+
+// src/index.ts
+var VERSION2 = "0.0.0";
+var CONTENT_PROTOCOL_VERSION2 = CONTENT_PROTOCOL_VERSION;
+var RECEIVED_BATCH_FLUSH_MS = 500;
+var RECEIVED_BATCH_FLUSH_SIZE = 50;
+var READ_RECEIPTS_KEY = "prefs/readReceiptsEnabled";
+function verifiedKey(peerUserId, peerDeviceId) {
+  return `verifiedDevice/${peerUserId}/${peerDeviceId}`;
+}
+var DTelecomSecureChat = class _DTelecomSecureChat {
+  deviceId;
+  http;
+  ws;
+  crypto;
+  store;
+  keyBundle;
+  sessions;
+  peerDevices;
+  messages;
+  status;
+  outbox = new Outbox();
+  typingMgr;
+  listeners = /* @__PURE__ */ new Map();
+  /** Per-peer-device queue of received-event ids awaiting batch send. */
+  pendingReceived = /* @__PURE__ */ new Map();
+  receivedFlushTimer = null;
+  /** Self user id derived from chat-token claims after first mint. */
+  selfUserId = null;
+  /** Devices we've already emitted `peerNewDevice` for, to avoid duplicates. */
+  announcedNewDevices = /* @__PURE__ */ new Set();
+  /** True after we've reuploaded the bundle once for this connection — set
+   *  after a "peer has zero devices" outcome that suggests the backend
+   *  forgot us (registry mismatch / wipe). Don't loop. */
+  bundleReuploadAttempted = false;
+  /** Cache of the read-receipts preference (loaded lazily). */
+  readReceiptsCache = null;
+  /**
+   * Connect to the dtelecom mesh. Generates an Olm account on first run,
+   * uploads the bundle, opens /chat/ws to the closest discovered node,
+   * and pulls any pending offline envelopes.
+   */
+  static async connect(opts) {
+    const chat = new _DTelecomSecureChat();
+    await chat.bootstrap(opts);
+    return chat;
+  }
+  // The constructor is private-by-convention — use connect().
+  constructor() {
+  }
+  /** Stable per-install device id. Useful for app diagnostics. */
+  get currentDeviceId() {
+    return this.deviceId;
+  }
+  // ── public API: messaging ──────────────────────────────────────────────────
+  async sendText(peerUserId, text, opts) {
+    const event = newText(text, opts?.replyTo);
+    await this.sendContent(peerUserId, event, { ephemeral: false });
+    if (this.selfUserId) {
+      await this.messages.put({
+        id: event.id,
+        peerUserId,
+        senderUserId: this.selfUserId,
+        text: event.text,
+        sentAt: event.clientSentAt,
+        editedAt: null,
+        deletedAt: null,
+        ...event.replyTo !== void 0 ? { replyTo: event.replyTo } : {}
+      });
+    }
+    await this.selfEcho(peerUserId, event);
+    this.typingMgr.clearOnSend(peerUserId);
+    return event.id;
+  }
+  async editMessage(peerUserId, targetId, newText2) {
+    const event = newEdit(targetId, newText2);
+    await this.sendContent(peerUserId, event, { ephemeral: false });
+    if (this.selfUserId) {
+      await this.messages.applyEdit({
+        targetId,
+        editorUserId: this.selfUserId,
+        newText: newText2,
+        editedAt: event.clientSentAt
+      });
+    }
+    await this.selfEcho(peerUserId, event);
+    return event.id;
+  }
+  async deleteMessage(peerUserId, targetId) {
+    const event = newDelete(targetId);
+    await this.sendContent(peerUserId, event, { ephemeral: false });
+    if (this.selfUserId) {
+      await this.messages.applyDelete({
+        targetId,
+        deleterUserId: this.selfUserId,
+        deletedAt: event.clientSentAt
+      });
+    }
+    await this.selfEcho(peerUserId, event);
+    return event.id;
+  }
+  /**
+   * Send a read-watermark to `peerUserId`. No-op when read receipts are
+   * disabled by `setReadReceiptsEnabled(false)` — the local user remains
+   * invisible to senders, but inbound `read` events from peers are still
+   * consumed (the sender's preference is their own call).
+   */
+  async markRead(peerUserId, upToMessageId) {
+    if (!await this.areReadReceiptsEnabled()) return;
+    const event = newRead(upToMessageId);
+    await this.sendContent(peerUserId, event, { ephemeral: false });
+    await this.selfEcho(peerUserId, event);
+  }
+  setTyping(peerUserId, isTyping) {
+    this.typingMgr.setTyping(peerUserId, isTyping);
+  }
+  // ── public API: preferences ───────────────────────────────────────────────
+  /** Enable/disable outbound read receipts. Persisted in the local KV store. */
+  async setReadReceiptsEnabled(enabled) {
+    await this.store.setString(READ_RECEIPTS_KEY, enabled ? "1" : "0");
+    this.readReceiptsCache = enabled;
+  }
+  /** Read the current preference. Default true. */
+  async areReadReceiptsEnabled() {
+    if (this.readReceiptsCache !== null) return this.readReceiptsCache;
+    const raw = await this.store.getString(READ_RECEIPTS_KEY);
+    const enabled = raw === null ? true : raw === "1";
+    this.readReceiptsCache = enabled;
+    return enabled;
+  }
+  // ── public API: peer device verification ──────────────────────────────────
+  /**
+   * Returns the cached peer-device list for `peerUserId`. Refreshes via
+   * `list_devices` if the local cache is empty or stale. Used to render
+   * the "Known Devices" settings panel. Doesn't consume OTKs.
+   */
+  async getKnownPeerDevices(peerUserId) {
+    const devices = await this.peerDevices.getPeerDevices(peerUserId);
+    const out = [];
+    for (const d of devices) {
+      const verified = await this.isPeerDeviceVerified(peerUserId, d.deviceId);
+      out.push({
+        deviceId: d.deviceId,
+        fingerprint: d.fingerprint,
+        lastActiveAt: d.lastActiveAt,
+        verified
+      });
+    }
+    return out;
+  }
+  /** Single-device fingerprint accessor. Returns null if unknown. */
+  async getPeerDeviceFingerprint(peerUserId, peerDeviceId) {
+    const list = await this.peerDevices.getPeerDevices(peerUserId);
+    return list.find((d) => d.deviceId === peerDeviceId)?.fingerprint ?? null;
+  }
+  /**
+   * Mark a peer device as verified (or unverified). Local-only — doesn't
+   * change the protocol's behavior, just exposes a flag the UI can render.
+   */
+  async markPeerDeviceVerified(peerUserId, peerDeviceId, verified) {
+    const key = verifiedKey(peerUserId, peerDeviceId);
+    if (verified) {
+      await this.store.setString(key, "1");
+    } else {
+      await this.store.delete(key);
+    }
+  }
+  async isPeerDeviceVerified(peerUserId, peerDeviceId) {
+    return await this.store.getString(verifiedKey(peerUserId, peerDeviceId)) === "1";
+  }
+  /**
+   * Read persisted message history with `peerUserId`, oldest→newest within
+   * the page. Use `beforeSentAt` + `limit` to paginate older messages.
+   * Returns include local-sent messages (sender = self), inbound messages
+   * (sender = peer), and tombstoned/edited rows reflecting the latest state.
+   */
+  getHistory(peerUserId, opts = {}) {
+    return this.messages.listForPeer(peerUserId, opts);
+  }
+  // ── public API: blocks ─────────────────────────────────────────────────────
+  blockUser(peerUserId) {
+    return this.http.blockUser(this.deviceId, peerUserId);
+  }
+  unblockUser(peerUserId) {
+    return this.http.unblockUser(this.deviceId, peerUserId);
+  }
+  async getBlockedUsers() {
+    const r = await this.http.listBlocked(this.deviceId);
+    return r.blocked;
+  }
+  // ── public API: events ─────────────────────────────────────────────────────
+  on(event, fn) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(fn);
+    return () => set.delete(fn);
+  }
+  // ── lifecycle ──────────────────────────────────────────────────────────────
+  async disconnect() {
+    this.typingMgr.shutdown();
+    this.flushReceivedBatch();
+    await this.ws.close();
+  }
+  // ── internals ──────────────────────────────────────────────────────────────
+  async bootstrap(opts) {
+    this.store = opts.store ?? new WebKVStore();
+    this.crypto = opts.crypto ?? new OlmCryptoAdapter({ store: this.store });
+    await this.crypto.init();
+    this.deviceId = await loadOrCreateDeviceId(this.store);
+    this.http = new HttpClient({
+      apiBaseURL: opts.apiBaseURL,
+      fetchChatToken: opts.fetchChatToken,
+      ...opts.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}
+    });
+    const mint = await this.http.getMint(this.deviceId);
+    this.selfUserId = parseSubFromJwt(mint.chatToken);
+    this.keyBundle = new KeyBundleManager({ http: this.http, crypto: this.crypto, deviceId: this.deviceId });
+    await this.keyBundle.ensureKeyBundle();
+    this.sessions = new SessionManager({
+      http: this.http,
+      crypto: this.crypto,
+      selfDeviceId: this.deviceId,
+      selfUserId: this.selfUserId
+    });
+    this.peerDevices = new PeerDeviceCache({ http: this.http, selfDeviceId: this.deviceId });
+    this.messages = new MessageStore(this.store);
+    this.status = new StatusTracker();
+    this.status.on((messageId, status, peerUserId) => {
+      this.dispatch("statusChange", { peerUserId, messageId, status });
+    });
+    this.typingMgr = new TypingManager((peerUserId, state) => {
+      this.sendContent(peerUserId, newTyping(state), { ephemeral: true }).catch(() => {
+      });
+    });
+    const nodeUrl = mint.chatNodeWsUrl.replace(/\/chat\/ws\/?$/, "");
+    this.ws = new WsClient({
+      nodeBaseURL: nodeUrl,
+      getToken: () => this.http.getToken(this.deviceId),
+      onFrame: (f) => this.onFrame(f),
+      onState: (s) => this.onWsState(s)
+    });
+    await this.ws.connect();
+    await this.drainPending();
+    void this.keyBundle.topUpIfNeeded().catch(() => {
+    });
+    if (this.selfUserId) {
+      void this.sessions.refreshPeerBundles(this.selfUserId).catch(() => {
+      });
+    }
+  }
+  /**
+   * State-listener for the underlying WsClient. On every transition to
+   * "open" (initial connect AND auto-reconnect), drain any queued
+   * outbound sends and re-pull pending offline envelopes — closes the
+   * gap during disconnect.
+   */
+  onWsState(s) {
+    if (s !== "open") return;
+    void this.outbox.tick();
+    void this.drainPending().catch(() => {
+    });
+    void this.keyBundle.topUpIfNeeded().catch(() => {
+    });
+  }
+  /** Set true while drainPending is running to avoid overlapping calls
+   *  (would otherwise hand the same envelope to two concurrent decrypt
+   *  invocations — Olm rejects the second). */
+  drainingPending = false;
+  async drainPending() {
+    if (this.drainingPending) return;
+    this.drainingPending = true;
+    try {
+      while (true) {
+        const r = await this.http.pending(this.deviceId, 100);
+        if (r.envelopes.length === 0) return;
+        const ackUuids = [];
+        for (const env of r.envelopes) {
+          try {
+            await this.handleInboundCiphertext({
+              peerUserId: env.senderUserId,
+              peerDeviceId: env.senderDeviceId,
+              ciphertext: env.ciphertext,
+              msgType: env.msgType
+            });
+            ackUuids.push(env.envelopeUuid);
+          } catch {
+          }
+        }
+        if (ackUuids.length === 0) return;
+        await this.http.ack(this.deviceId, ackUuids);
+      }
+    } finally {
+      this.drainingPending = false;
+    }
+  }
+  async onFrame(frame) {
+    if (frame.kind === "chatEnvelope") {
+      await this.handleInboundCiphertext({
+        peerUserId: frame.senderUserId,
+        peerDeviceId: frame.senderDeviceId,
+        ciphertext: frame.ciphertext,
+        msgType: frame.msgType
+      });
+      return;
+    }
+    if (frame.kind === "chatSendResult") {
+      for (const r of frame.results) {
+        this.status.onSendResult(r.envelopeUuid, r.status);
+      }
+      return;
+    }
+  }
+  async handleInboundCiphertext(opts) {
+    let plaintext;
+    try {
+      plaintext = await this.sessions.decrypt(
+        opts.peerUserId,
+        opts.peerDeviceId,
+        opts.ciphertext,
+        opts.msgType
+      );
+    } catch (firstErr) {
+      await this.sessions.forgetPeerDevice(opts.peerUserId, opts.peerDeviceId);
+      this.peerDevices.invalidate(opts.peerUserId);
+      try {
+        await this.peerDevices.refresh(opts.peerUserId);
+      } catch {
+      }
+      try {
+        plaintext = await this.sessions.decrypt(
+          opts.peerUserId,
+          opts.peerDeviceId,
+          opts.ciphertext,
+          opts.msgType
+        );
+      } catch {
+        throw firstErr;
+      }
+    }
+    await this.maybeAnnouncePeerDevice(opts.peerUserId, opts.peerDeviceId);
+    const event = decodeEventBytes(new TextEncoder().encode(plaintext));
+    if (!event) return;
+    await this.dispatchInboundEvent(opts.peerUserId, opts.peerDeviceId, event);
+  }
+  /**
+   * If `peerDeviceId` is not in our local cache for `peerUserId`, refresh
+   * the peer's device list and emit `peerNewDevice` exactly once. Idempotent
+   * across repeated calls — second message from the same new device is a
+   * cheap cache hit. Failures (HTTP error fetching the device list) are
+   * swallowed; we'll re-attempt on the next inbound from this device.
+   */
+  async maybeAnnouncePeerDevice(peerUserId, peerDeviceId) {
+    const flag = `${peerUserId}|${peerDeviceId}`;
+    if (this.announcedNewDevices.has(flag)) return;
+    let devices;
+    try {
+      devices = await this.peerDevices.getPeerDevices(peerUserId);
+    } catch {
+      return;
+    }
+    let entry = devices.find((d) => d.deviceId === peerDeviceId);
+    if (!entry) {
+      let fresh;
+      try {
+        fresh = await this.peerDevices.refresh(peerUserId);
+      } catch {
+        return;
+      }
+      entry = fresh.find((d) => d.deviceId === peerDeviceId);
+      if (!entry) return;
+    }
+    this.announcedNewDevices.add(flag);
+    try {
+      await this.sessions.refreshPeerBundles(peerUserId);
+    } catch {
+    }
+    this.dispatch("peerNewDevice", {
+      peerUserId,
+      peerDeviceId,
+      fingerprint: entry.fingerprint
+    });
+  }
+  async dispatchInboundEvent(peerUserId, peerDeviceId, event) {
+    switch (event.type) {
+      case "text": {
+        await this.messages.put({
+          id: event.id,
+          peerUserId,
+          senderUserId: peerUserId,
+          text: event.text,
+          sentAt: event.clientSentAt,
+          editedAt: null,
+          deletedAt: null,
+          ...event.replyTo !== void 0 ? { replyTo: event.replyTo } : {}
+        });
+        this.dispatch("message", {
+          peerUserId,
+          peerDeviceId,
+          senderUserId: peerUserId,
+          message: {
+            id: event.id,
+            text: event.text,
+            sentAt: event.clientSentAt,
+            ...event.replyTo !== void 0 ? { replyTo: event.replyTo } : {}
+          }
+        });
+        this.queueReceivedAck(peerUserId, peerDeviceId, event.id);
+        return;
+      }
+      case "edit": {
+        const updated = await this.messages.applyEdit({
+          targetId: event.targetId,
+          editorUserId: peerUserId,
+          newText: event.text,
+          editedAt: event.clientSentAt
+        });
+        if (updated) {
+          this.dispatch("messageEdited", {
+            peerUserId,
+            editorUserId: peerUserId,
+            targetId: event.targetId,
+            newText: event.text,
+            editedAt: event.clientSentAt
+          });
+        }
+        this.queueReceivedAck(peerUserId, peerDeviceId, event.id);
+        return;
+      }
+      case "delete": {
+        const updated = await this.messages.applyDelete({
+          targetId: event.targetId,
+          deleterUserId: peerUserId,
+          deletedAt: event.clientSentAt
+        });
+        if (updated) {
+          this.dispatch("messageDeleted", {
+            peerUserId,
+            deleterUserId: peerUserId,
+            targetId: event.targetId,
+            deletedAt: event.clientSentAt
+          });
+        }
+        this.queueReceivedAck(peerUserId, peerDeviceId, event.id);
+        return;
+      }
+      case "read": {
+        this.status.onRead({ peerUserId, upToId: event.upToId });
+        this.dispatch("readReceipt", { peerUserId, peerDeviceId, upToId: event.upToId });
+        return;
+      }
+      case "received": {
+        this.status.onReceived({ peerUserId, peerDeviceId, messageIds: event.ids });
+        return;
+      }
+      case "typing": {
+        this.dispatch("typing", { peerUserId, peerDeviceId, state: event.state });
+        return;
+      }
+      case "selfEcho": {
+        if (peerUserId !== this.selfUserId) return;
+        const inner = event.original;
+        const originalPeer = event.originalPeer;
+        switch (inner.type) {
+          case "text": {
+            await this.messages.put({
+              id: inner.id,
+              peerUserId: originalPeer,
+              senderUserId: peerUserId,
+              text: inner.text,
+              sentAt: inner.clientSentAt,
+              editedAt: null,
+              deletedAt: null,
+              ...inner.replyTo !== void 0 ? { replyTo: inner.replyTo } : {}
+            });
+            this.dispatch("message", {
+              peerUserId: originalPeer,
+              peerDeviceId,
+              senderUserId: peerUserId,
+              message: {
+                id: inner.id,
+                text: inner.text,
+                sentAt: inner.clientSentAt,
+                ...inner.replyTo !== void 0 ? { replyTo: inner.replyTo } : {}
+              }
+            });
+            return;
+          }
+          case "edit": {
+            const updated = await this.messages.applyEdit({
+              targetId: inner.targetId,
+              editorUserId: peerUserId,
+              newText: inner.text,
+              editedAt: inner.clientSentAt
+            });
+            if (updated) {
+              this.dispatch("messageEdited", {
+                peerUserId: originalPeer,
+                editorUserId: peerUserId,
+                targetId: inner.targetId,
+                newText: inner.text,
+                editedAt: inner.clientSentAt
+              });
+            }
+            return;
+          }
+          case "delete": {
+            const updated = await this.messages.applyDelete({
+              targetId: inner.targetId,
+              deleterUserId: peerUserId,
+              deletedAt: inner.clientSentAt
+            });
+            if (updated) {
+              this.dispatch("messageDeleted", {
+                peerUserId: originalPeer,
+                deleterUserId: peerUserId,
+                targetId: inner.targetId,
+                deletedAt: inner.clientSentAt
+              });
+            }
+            return;
+          }
+          case "read": {
+            this.status.onRead({ peerUserId: originalPeer, upToId: inner.upToId });
+            return;
+          }
+        }
+        return;
+      }
+    }
+  }
+  /**
+   * Multi-device self-echo. Wraps the original event in a `selfEcho`
+   * envelope and ships it to our own user (mesh fanout filters our
+   * own device). Other devices belonging to the same user receive,
+   * unwrap, and persist the event so their local history mirrors this
+   * device's. No-op when:
+   *   - we don't yet know our own user id
+   *   - the original was addressed to ourselves (avoids loops)
+   *   - we have no other devices registered (encryptForPeer returns [])
+   * Best-effort: failures here don't surface to the caller.
+   */
+  async selfEcho(originalPeer, original) {
+    if (!this.selfUserId) return;
+    if (originalPeer === this.selfUserId) return;
+    const echo = newSelfEcho(originalPeer, original);
+    try {
+      const cached = this.sessions.cachedFanoutSize(this.selfUserId);
+      if (cached === null || cached === 0) {
+        try {
+          await this.sessions.refreshPeerBundles(this.selfUserId);
+        } catch {
+          return;
+        }
+      }
+      await this.sendContent(this.selfUserId, echo, { ephemeral: false });
+    } catch {
+    }
+  }
+  async sendContent(peerUserId, event, opts) {
+    const plainBytes = encodeEventBytes(event);
+    const plaintext = new TextDecoder().decode(plainBytes);
+    const encrypted = await this.sessions.encryptForPeer(peerUserId, plaintext);
+    if (encrypted.length === 0) {
+      if (!opts.ephemeral && !this.bundleReuploadAttempted) {
+        const seenBefore = (await this.messages.listForPeer(peerUserId, { limit: 1 })).length > 0;
+        if (seenBefore) {
+          this.bundleReuploadAttempted = true;
+          try {
+            await this.keyBundle.reuploadCurrentBundle();
+          } catch {
+          }
+        }
+      }
+      return;
+    }
+    const targets = encrypted.map((e) => ({
+      deviceId: e.peerDeviceId,
+      ciphertext: e.ciphertext,
+      envelopeUuid: globalThis.crypto.randomUUID()
+    }));
+    if (event.type === "text" || event.type === "edit" || event.type === "delete") {
+      const map = /* @__PURE__ */ new Map();
+      for (const t of targets) map.set(t.envelopeUuid, t.deviceId);
+      this.status.trackOutbound({ messageId: event.id, peerUserId, envelopeToDevice: map });
+    }
+    const msgType = encrypted[0].msgType;
+    const frame = {
+      toUserId: peerUserId,
+      ephemeral: opts.ephemeral || void 0,
+      msgType,
+      targets
+    };
+    if (opts.ephemeral) {
+      if (this.ws.getState() === "open") {
+        try {
+          this.ws.sendChat(frame);
+        } catch {
+        }
+      }
+      return;
+    }
+    this.outbox.enqueue({
+      messageId: event.id,
+      peerUserId,
+      ephemeral: false,
+      attempt: async () => {
+        const outcomes = /* @__PURE__ */ new Map();
+        if (this.ws.getState() !== "open") {
+          for (const t of targets) outcomes.set(t.envelopeUuid, "error");
+          return outcomes;
+        }
+        try {
+          this.ws.sendChat(frame);
+          for (const t of targets) outcomes.set(t.envelopeUuid, "stored");
+        } catch {
+          for (const t of targets) outcomes.set(t.envelopeUuid, "error");
+        }
+        return outcomes;
+      }
+    });
+    void this.outbox.tick();
+    void this.peerDevices;
+  }
+  queueReceivedAck(peerUserId, peerDeviceId, eventId) {
+    const key = `${peerUserId}|${peerDeviceId}`;
+    const list = this.pendingReceived.get(key) ?? [];
+    list.push(eventId);
+    this.pendingReceived.set(key, list);
+    if (list.length >= RECEIVED_BATCH_FLUSH_SIZE) {
+      this.flushReceivedBatch();
+      return;
+    }
+    if (!this.receivedFlushTimer) {
+      this.receivedFlushTimer = setTimeout(() => this.flushReceivedBatch(), RECEIVED_BATCH_FLUSH_MS);
+    }
+  }
+  flushReceivedBatch() {
+    if (this.receivedFlushTimer) {
+      clearTimeout(this.receivedFlushTimer);
+      this.receivedFlushTimer = null;
+    }
+    if (this.pendingReceived.size === 0) return;
+    for (const [key, ids] of this.pendingReceived.entries()) {
+      const [peerUserId] = key.split("|");
+      this.sendContent(peerUserId, newReceived(ids), { ephemeral: false }).catch(() => {
+      });
+    }
+    this.pendingReceived.clear();
+  }
+  dispatch(name, event) {
+    const set = this.listeners.get(name);
+    if (!set) return;
+    for (const fn of set) {
+      try {
+        fn(event);
+      } catch {
+      }
+    }
+  }
+};
+function parseSubFromJwt(jwt) {
+  try {
+    const parts = jwt.split(".");
+    if (parts.length !== 3) return null;
+    const padLen = (4 - parts[1].length % 4) % 4;
+    const padded = parts[1] + "=".repeat(padLen);
+    const std = padded.replace(/-/g, "+").replace(/_/g, "/");
+    const decoded = atob(std);
+    const claims = JSON.parse(decoded);
+    return claims.sub ?? null;
+  } catch {
+    return null;
+  }
+}
+
+exports.CONTENT_PROTOCOL_VERSION = CONTENT_PROTOCOL_VERSION2;
+exports.DTelecomSecureChat = DTelecomSecureChat;
+exports.FakeCryptoAdapter = FakeCryptoAdapter;
+exports.MemoryKVStore = MemoryKVStore;
+exports.OlmCryptoAdapter = OlmCryptoAdapter;
+exports.VERSION = VERSION2;
+exports.WebKVStore = WebKVStore;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map