@glyphteck/veyl 0.72.0 → 0.73.0

package/dist/account.js

@@ -16676,17 +16676,6 @@ function canonicalBytes(value, label = "value") {
   return encoder.encode(canonicalJson(value, label));
 }
 
-// ../../core/utils/text.js
-function cleanText(value) {
-  return typeof value === "string" ? value.trim() : "";
-}
-function lowerText(value) {
-  return cleanText(value).toLowerCase();
-}
-function sameText(left, right) {
-  return lowerText(left) === lowerText(right);
-}
-
 // ../../core/config.js
 var MS_PER_SECOND = 1000;
 var MINUTE_MS = 60 * MS_PER_SECOND;
@@ -16708,6 +16697,8 @@ var AUTOLOCK_MAX_MINUTES = 60;
 var BTC_PRICE_FALLBACK = 80000;
 var CHAT_MESSAGE_EDIT_WINDOW_MS = 10 * MINUTE_MS;
 var CHAT_SEND_CONNECTION_WAIT_MS = 30 * MS_PER_SECOND;
+var CALL_SPEAKING_THRESHOLD = 0.02;
+var CALL_SPEAKING_HOLD_MS = 320;
 var LOCAL_MEDIA_CACHE_MAX_BYTES = 512 * MIB_BYTES;
 var LOCAL_PROFILE_CACHE_MAX_ITEMS = 500;
 var LOCAL_PROFILE_CACHE_MAX_AGE_MS = 30 * DAY_MS;
@@ -16828,6 +16819,340 @@ var WALLET_PENDING_TRANSFER_STUCK_RETRY_MS = 10 * MINUTE_MS;
 var WALLET_PENDING_TRANSFER_DORMANT_RETRY_MS = HOUR_MS;
 var WALLET_TRANSFER_CACHE_WRITE_DELAY_MS = 3 * MS_PER_SECOND;
 
+// ../../core/calls/wire.js
+var CALL_REQUEST_MAX_BYTES = 192 * 1024;
+var CALL_HEAD_MAX_BYTES = 64 * 1024;
+var CALL_HEAD_PROOF_MAX_BYTES = 2048;
+var CALL_EVENT_MAX_BYTES = 48 * 1024;
+var CALL_LOG_MAX_BYTES = 512 * 1024;
+var CALL_LOG_MAX_EVENTS = 128;
+var CALL_RESPONSE_MAX_BYTES = Math.ceil((CALL_HEAD_MAX_BYTES + CALL_HEAD_PROOF_MAX_BYTES + CALL_LOG_MAX_BYTES) / 3) * 4 + CALL_LOG_MAX_EVENTS * 128 + 4096;
+var CALL_SCOPE_KINDS = ["ownership", "discovery", "signaling"];
+var SCOPE_SOCKETS = Object.freeze({ ownership: 8, discovery: CHAT_MAX_MEMBERS * 4, signaling: 32 });
+var SCOPE_LIMITS = Object.freeze(Object.fromEntries(Object.entries(SCOPE_SOCKETS).map(([kind, sockets]) => [
+  kind,
+  Object.freeze({ sockets, readsPerMinute: (kind === "signaling" ? SCOPE_SOCKETS.discovery : sockets) * 4, writesPerMinute: 600 })
+])));
+var HEX_KEY = /^[a-f0-9]{64}$/u;
+function callWireError(code = "invalid-request") {
+  const error = new Error(`call ${code}`);
+  error.code = `calls/${code}`;
+  return error;
+}
+function encodeCallBytes(value) {
+  if (!(value instanceof Uint8Array))
+    throw callWireError();
+  let text = "";
+  for (const byte of value)
+    text += String.fromCharCode(byte);
+  return btoa(text);
+}
+function callHeadDigest(value) {
+  if (!(value instanceof Uint8Array) || !value.length || value.length > CALL_HEAD_MAX_BYTES)
+    throw callWireError();
+  return toHex(sha256(value));
+}
+function decodeCallBytes(value, maximum = CALL_HEAD_MAX_BYTES) {
+  if (typeof value !== "string" || value.length > Math.ceil(maximum / 3) * 4 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u.test(value))
+    throw callWireError();
+  const bytes = Uint8Array.from(atob(value), (char) => char.charCodeAt(0));
+  if (bytes.length > maximum || encodeCallBytes(bytes) !== value)
+    throw callWireError();
+  return bytes;
+}
+function callScope(realm, kind, publicKey) {
+  if (!["prod", "dev"].includes(realm) || !CALL_SCOPE_KINDS.includes(kind) || !HEX_KEY.test(publicKey))
+    throw callWireError();
+  return toHex(sha256(canonicalBytes(["veyl.call.scope.v1", realm, kind, publicKey])));
+}
+function decodeCallRecord(record) {
+  return {
+    ...record,
+    active: record.active ? { ...record.active, payload: decodeCallBytes(record.active.payload, 4096) } : null,
+    pending: record.pending ? { ...record.pending, payload: decodeCallBytes(record.pending.payload, 4096) } : null
+  };
+}
+
+// ../../core/calls/identity.js
+var REALMS = new Set(["prod", "dev"]);
+var KINDS = new Set(["ownership", "discovery", "signaling"]);
+var MAX_SEALED_BYTES = 64 * 1024;
+function createCallCapability(seed, realm, kind, parts = []) {
+  if (!REALMS.has(realm) || !KINDS.has(kind))
+    throw new Error("invalid call capability");
+  const signing = deriveKey(toBytes32(seed, "call root"), "veyl.call.capability.signing.v1", [realm, kind, ...parts]);
+  const sealing = deriveKey(toBytes32(seed, "call root"), "veyl.call.capability.sealing.v1", [realm, kind, ...parts]);
+  const publicKey = toHex(ed25519.getPublicKey(signing));
+  const scope = callScope(realm, kind, publicKey);
+  const aad = canonicalBytes(["veyl.call.sealed.v1", realm, kind, scope]);
+  let owners = 0;
+  function retain() {
+    owners += 1;
+    let closed = false;
+    function current() {
+      if (closed)
+        throw new Error("call capability closed");
+    }
+    return Object.freeze({
+      realm,
+      kind,
+      scope,
+      publicKey,
+      sign(bytes) {
+        current();
+        return toHex(ed25519.sign(toBytes(bytes), signing));
+      },
+      async seal(value) {
+        current();
+        const plain = canonicalBytes(value, "call payload");
+        if (plain.length + 28 > MAX_SEALED_BYTES)
+          throw new Error("call payload too large");
+        try {
+          const { iv, ct } = await sealAes(sealing, plain, aad);
+          current();
+          const result = new Uint8Array(iv.length + ct.length);
+          result.set(iv);
+          result.set(ct, iv.length);
+          return result;
+        } finally {
+          cleanBytes(plain);
+        }
+      },
+      async open(value) {
+        current();
+        const bytes = toBytes(value);
+        if (bytes.length < 28 || bytes.length > MAX_SEALED_BYTES)
+          throw new Error("invalid call payload");
+        const plain = await openAes(sealing, bytes.subarray(0, 12), bytes.subarray(12), aad);
+        try {
+          current();
+          return JSON.parse(decoder.decode(plain));
+        } finally {
+          cleanBytes(plain);
+        }
+      },
+      retain() {
+        current();
+        return retain();
+      },
+      close() {
+        if (closed)
+          return;
+        closed = true;
+        if (--owners === 0)
+          cleanBytes(signing, sealing);
+      }
+    });
+  }
+  return retain();
+}
+function createCallIdentity(masterSeed, realm) {
+  const root = deriveKey(toBytes32(masterSeed, "vault root"), "veyl.call.account.v1", [realm]);
+  try {
+    return createCallCapability(root, realm, "ownership");
+  } finally {
+    cleanBytes(root);
+  }
+}
+function createCallEndpoint() {
+  const secret = randomBytes3(32);
+  const publicKey = toHex(ed25519.getPublicKey(secret));
+  let closed = false;
+  return Object.freeze({
+    publicKey,
+    holder: toHex(randomBytes3(16)),
+    sign(bytes) {
+      if (closed)
+        throw new Error("call endpoint closed");
+      return toHex(ed25519.sign(toBytes(bytes), secret));
+    },
+    close() {
+      closed = true;
+      cleanBytes(secret);
+    }
+  });
+}
+function createCallDiscovery(epochState, realm) {
+  const manifest = epochState?.manifest;
+  if (!manifest?.chatId || !manifest?.epochId || !epochState?.epochSecret)
+    throw new Error("current chat epoch required");
+  return createCallCapability(toBytes32(epochState.epochSecret), realm, "discovery", [manifest.chatId, manifest.epochId]);
+}
+
+// ../../core/utils/text.js
+function cleanText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function lowerText(value) {
+  return cleanText(value).toLowerCase();
+}
+function sameText(left, right) {
+  return lowerText(left) === lowerText(right);
+}
+
+// ../../core/utils/time.js
+function timestampMs(value, fallback = null, options = {}) {
+  let ms = null;
+  if (typeof value?.toMillis === "function") {
+    ms = value.toMillis();
+  } else if (value instanceof Date) {
+    ms = value.getTime();
+  } else if (typeof value?.seconds === "number") {
+    ms = value.seconds * 1000 + Math.floor((value.nanoseconds || 0) / 1e6);
+  } else if (typeof value?._seconds === "number") {
+    ms = value._seconds * 1000 + Math.floor((value._nanoseconds || 0) / 1e6);
+  } else if (Number.isFinite(value)) {
+    ms = value;
+  } else if (options.parseString && typeof value === "string") {
+    const numberMs = Number(value);
+    ms = Number.isFinite(numberMs) ? numberMs : Date.parse(value);
+  }
+  if (!Number.isFinite(ms) || options.positive && ms <= 0) {
+    return fallback;
+  }
+  return ms;
+}
+function timestampKey(value) {
+  if (value == null) {
+    return null;
+  }
+  return timestampMs(value, null) ?? String(value);
+}
+function makeTimestamp(ms) {
+  return {
+    toMillis() {
+      return ms;
+    },
+    toDate() {
+      return new Date(ms);
+    }
+  };
+}
+function twoDigits(value) {
+  return String(value).padStart(2, "0");
+}
+function dayKey(date) {
+  return `${date.getFullYear()}-${twoDigits(date.getMonth() + 1)}-${twoDigits(date.getDate())}`;
+}
+function localDayKey(value) {
+  const ms = timestampMs(value, null, { parseString: true });
+  if (!Number.isFinite(ms))
+    return "";
+  return dayKey(new Date(ms));
+}
+function hourKey(dateOrHour) {
+  const hour = dateOrHour instanceof Date ? dateOrHour.getHours() : dateOrHour;
+  return twoDigits(hour);
+}
+function dayHourKey(date) {
+  return `${dayKey(date)}-${hourKey(date)}`;
+}
+var MINUTE_MS2 = 60000;
+var HOUR_MS2 = 60 * MINUTE_MS2;
+function nextLocalDayStartMs(ms) {
+  const date = new Date(ms);
+  date.setDate(date.getDate() + 1);
+  date.setHours(0, 0, 0, 0);
+  return date.getTime();
+}
+function nextRowDateTimeRefreshMs(value, now = Date.now()) {
+  const ms = timestampMs(value, null, { parseString: true });
+  const nowMs2 = timestampMs(now, Date.now(), { parseString: true });
+  if (!Number.isFinite(ms) || !Number.isFinite(nowMs2))
+    return null;
+  const age = nowMs2 - ms;
+  if (age < -MINUTE_MS2)
+    return ms - MINUTE_MS2;
+  if (age < MINUTE_MS2)
+    return ms + MINUTE_MS2;
+  if (age < HOUR_MS2)
+    return ms + (Math.floor(age / MINUTE_MS2) + 1) * MINUTE_MS2;
+  if (localDayKey(ms) === localDayKey(nowMs2))
+    return nextLocalDayStartMs(nowMs2);
+  return null;
+}
+
+// ../../core/chat/state.js
+function makeCid() {
+  return `${Date.now().toString(36)}${toHex(randomBytes3(3))}`;
+}
+function getMessageKey(message) {
+  return message?.cid || message?.id || null;
+}
+function getCidMs(cid) {
+  if (typeof cid !== "string" || !/^[0-9a-z]+[0-9a-f]{6}$/u.test(cid)) {
+    return null;
+  }
+  const base = cid.slice(0, -6);
+  const ms = Number.parseInt(base, 36);
+  return Number.isSafeInteger(ms) && ms > 0 ? ms : null;
+}
+function getMessageOrderMs(message) {
+  return getCidMs(message?.cid) ?? timestampMs(message?.ts, Infinity);
+}
+function sortMessages(messages) {
+  return [...messages].sort((a, b) => {
+    const aMs = getMessageOrderMs(a);
+    const bMs = getMessageOrderMs(b);
+    if (aMs !== bMs) {
+      return aMs - bMs;
+    }
+    return String(a?.id || "").localeCompare(String(b?.id || ""));
+  });
+}
+function mergeMessages(...groups) {
+  const merged = new Map;
+  for (const group of groups) {
+    for (const message of group || []) {
+      const key = getMessageKey(message);
+      if (!key) {
+        continue;
+      }
+      merged.set(key, message);
+    }
+  }
+  return sortMessages([...merged.values()]);
+}
+
+// ../../core/chat/messages/call.js
+var CALL_MSG_TYPE = "call";
+function readCallMessage(message) {
+  if (message?.t !== CALL_MSG_TYPE || typeof message.callId !== "string" || !/^[0-9a-f]{64}$/u.test(message.callId) || !["started", "ended"].includes(message.event))
+    return null;
+  return { callId: message.callId, event: message.event };
+}
+function makeCallMessage(callId, event) {
+  const message = { t: CALL_MSG_TYPE, callId, event };
+  if (!readCallMessage(message))
+    throw new Error("invalid call message");
+  return message;
+}
+function callMessageText(message) {
+  const call = readCallMessage(message);
+  return call ? `call ${call.event}` : "";
+}
+function latestCallStartKey(messages) {
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    if (readCallMessage(messages[index])?.event === "started")
+      return getMessageKey(messages[index]);
+  }
+  return "";
+}
+
+// ../../core/chat/messages/types.js
+var ATTACHMENT_MSG_TYPES = ["img", "gif", "m4a", "mp4", "file"];
+var MAX_TXT_CHARS = CHAT_MAX_TEXT_CHARS;
+var REACTION_MSG_TYPE = "rxn";
+var DELETE_MSG_TYPE = "del";
+var SYSTEM_MSG_TYPE = "sys";
+var EPOCH_TRANSITION_MSG_TYPE = "epoch";
+var EPOCH_PROPOSAL_MSG_TYPE = "epoch_proposal";
+var SYSTEM_SETTINGS_KIND = "settings";
+var DEFAULT_REACTION_EMOJI = "❤️";
+var MAX_REACTIONS = CHAT_MAX_REACTIONS;
+var HOLD_VISIBLE_KEY = "__holdVisible";
+var SOURCE_GONE_VISIBLE_KEY = "__sourceGoneVisible";
+
 // ../../core/notifications.js
 "use client";
 var NOTIFICATION_DESCRIPTOR_VERSION = 1;
@@ -16843,10 +17168,47 @@ var CHAT_ATTENTION_KINDS = Object.freeze({
   ROTATION: "rotation",
   SILENT: "silent"
 });
+var NOTIFICATION_PRESENTATION_KINDS = Object.freeze({
+  MESSAGE: 0,
+  REACTION: 1,
+  ACTIVITY: 2,
+  PHOTO: 3,
+  VIDEO: 4,
+  AUDIO: 5,
+  FILE: 6,
+  CALL_STARTED: 7,
+  CALL_ENDED: 8
+});
+function notificationMessageKind(message) {
+  switch (message?.t) {
+    case SYSTEM_MSG_TYPE:
+    case EPOCH_TRANSITION_MSG_TYPE:
+      return NOTIFICATION_PRESENTATION_KINDS.ACTIVITY;
+    case "img":
+    case "gif":
+      return NOTIFICATION_PRESENTATION_KINDS.PHOTO;
+    case "mp4":
+      return NOTIFICATION_PRESENTATION_KINDS.VIDEO;
+    case "m4a":
+      return NOTIFICATION_PRESENTATION_KINDS.AUDIO;
+    case "file":
+      return NOTIFICATION_PRESENTATION_KINDS.FILE;
+    case "call": {
+      const call = readCallMessage(message);
+      return !call ? NOTIFICATION_PRESENTATION_KINDS.ACTIVITY : call.event === "started" ? NOTIFICATION_PRESENTATION_KINDS.CALL_STARTED : NOTIFICATION_PRESENTATION_KINDS.CALL_ENDED;
+    }
+    default:
+      return NOTIFICATION_PRESENTATION_KINDS.MESSAGE;
+  }
+}
+function notificationMessageIsSilent(message) {
+  return message?.t === SYSTEM_MSG_TYPE && message.sys === SYSTEM_SETTINGS_KIND || readCallMessage(message)?.event === "ended";
+}
 var HEX_32_RE = /^[0-9a-f]{64}$/u;
 var PEER_TAG_RE = /^[0-9a-f]{32}$/u;
 var ATTENTION_KINDS = new Set(Object.values(CHAT_ATTENTION_KINDS));
 var NOTIFICATION_MODES = new Set(Object.values(CHAT_NOTIFICATION_MODES));
+var PRESENTATION_KINDS = new Set(Object.values(NOTIFICATION_PRESENTATION_KINDS));
 function hasCurrentChatAttentionRegistration(value) {
   return value?.deliveryRegistered === true && value?.attentionRegistrationVersion === CHAT_ATTENTION_REGISTRATION_VERSION;
 }
@@ -17002,13 +17364,30 @@ function notificationRouteTag(envelope) {
     cleanBytes(input);
   }
 }
-async function sealNotificationDescriptor(recipientNotificationPK, descriptor = {}) {
-  const recipientPK = cleanHex32(recipientNotificationPK, "recipient notification key");
+function notificationDescriptorClaims(descriptor) {
   const peerTag = cleanText(descriptor.peerTag).toLowerCase();
   const eventId = cleanText(descriptor.eventId);
-  if (!PEER_TAG_RE.test(peerTag) || !eventId || eventId.length > 256) {
+  const senderChatPK = cleanHex32(descriptor.senderChatPK, "notification sender key");
+  const kind = descriptor.kind;
+  if (!PEER_TAG_RE.test(peerTag) || !eventId || eventId.length > 256 || !PRESENTATION_KINDS.has(kind)) {
     throw new Error("notification descriptor required");
   }
+  return { v: NOTIFICATION_DESCRIPTOR_VERSION, peerTag, eventId, senderChatPK, kind };
+}
+function notificationDescriptorSignatureInput(recipientPK, descriptor) {
+  return encoder.encode([
+    "veyl-notification-presentation-v1",
+    recipientPK,
+    descriptor.peerTag,
+    descriptor.senderChatPK,
+    descriptor.kind,
+    descriptor.eventId
+  ].join("\x00"));
+}
+async function sealNotificationDescriptor(recipientNotificationPK, descriptor, sender) {
+  const recipientPK = cleanHex32(recipientNotificationPK, "recipient notification key");
+  const claims = notificationDescriptorClaims({ ...descriptor, senderChatPK: sender?.chatPK });
+  const signature = signChatBytes(sender?.signingKey, notificationDescriptorSignatureInput(recipientPK, claims));
   let eph = null;
   let shared = null;
   let key = null;
@@ -17019,9 +17398,8 @@ async function sealNotificationDescriptor(recipientNotificationPK, descriptor =
     const epk = toHex(eph.pub);
     key = deriveKey(shared.subarray(0, 32), "notification-descriptor-v1", [epk, recipientPK]);
     plaintext = encoder.encode(JSON.stringify({
-      v: NOTIFICATION_DESCRIPTOR_VERSION,
-      peerTag,
-      eventId
+      ...claims,
+      signature
     }));
     const { iv, ct } = await sealAes(key, plaintext, descriptorAad(epk, recipientPK));
     return {
@@ -18060,7 +18438,7 @@ function packRegistryData(registry) {
   }
   return concatBytes4(new Uint8Array([SECRET_REGISTRY_ENVELOPE_VERSION]), registry.iv, registry.ct);
 }
-var packSeedData = ({ crypto = VAULT_CRYPTO, salt, iv, ciphertext, ct, registry, kdf = VAULT_KDF }) => {
+var packSeedData = ({ crypto: crypto2 = VAULT_CRYPTO, salt, iv, ciphertext, ct, registry, kdf = VAULT_KDF }) => {
   const body = ciphertext || ct;
   if (!salt || !iv || !body || !registry) {
     throw new Error("seed data missing");
@@ -18068,7 +18446,7 @@ var packSeedData = ({ crypto = VAULT_CRYPTO, salt, iv, ciphertext, ct, registry,
   if (toBytes(salt, "seed salt").byteLength !== VAULT_SALT_BYTES || toBytes(iv, "seed iv").byteLength !== VAULT_IV_BYTES || toBytes(body, "seed ciphertext").byteLength !== VAULT_SEED_CIPHERTEXT_BYTES) {
     throw new Error("invalid seed data");
   }
-  const magic = encoder.encode(crypto);
+  const magic = encoder.encode(crypto2);
   const header = new Uint8Array(1 + magic.length + 8);
   header[0] = magic.length;
   header.set(magic, 1);
@@ -18532,7 +18910,7 @@ function walletPubkey(value) {
   }
   return key;
 }
-function closeSessionResources({ wallet, chatPK, chatPrivateKey, chatSigningSecret, notificationPrivateKey, notificationPublicKey, localCache, vaultAccess, vaultSigner } = {}) {
+function closeSessionResources({ wallet, chatPK, chatPrivateKey, chatSigningSecret, notificationPrivateKey, notificationPublicKey, localCache, vaultAccess, vaultSigner, callIdentity } = {}) {
   const pending = [];
   const close = (owner) => {
     try {
@@ -18543,6 +18921,7 @@ function closeSessionResources({ wallet, chatPK, chatPrivateKey, chatSigningSecr
   };
   close(vaultAccess);
   close(vaultSigner);
+  close(callIdentity);
   close(localCache);
   lockWallet(wallet);
   lockChat(chatPrivateKey, chatPK);
@@ -18598,6 +18977,7 @@ function createAccountSession(resources = {}) {
       session.localCache = null;
       session.vaultAccess = null;
       session.vaultSigner = null;
+      session.callIdentity = null;
       closePromise = Promise.allSettled(pending).then(() => {
         return;
       });
@@ -18737,6 +19117,7 @@ async function openVaultAccountSession(vault, password, options = {}) {
   let cacheKey = null;
   let settingsKey = null;
   let vaultSigner = null;
+  let callIdentity = null;
   let vaultAccess = null;
   let walletBoot = null;
   let network;
@@ -18777,6 +19158,7 @@ async function openVaultAccountSession(vault, password, options = {}) {
     notificationPK = toHex(notificationPublicKey);
     cacheKey = getCacheSeed(registry);
     vaultSigner = createVaultSigner(masterSeed);
+    callIdentity = createCallIdentity(masterSeed, cloud.environment);
     settingsKey = deriveSettingsKey(cacheKey, uid);
     mark(diag, "vault.unlock.derive.done", { elapsedMs: Date.now() - deriveStartedAt, source });
     cleanBytes(masterSeed);
@@ -18825,6 +19207,7 @@ async function openVaultAccountSession(vault, password, options = {}) {
       notificationPublicKey,
       localCache,
       vaultSigner,
+      callIdentity,
       vaultAccess,
       vaultPK: vaultSigner.publicKey
     });
@@ -18925,7 +19308,7 @@ async function openVaultAccountSession(vault, password, options = {}) {
     return session;
   } catch (error) {
     walletBoot?.close();
-    await closeSessionResources({ wallet, chatPK, chatPrivateKey, chatSigningSecret, notificationPrivateKey, notificationPublicKey, localCache, vaultAccess, vaultSigner });
+    await closeSessionResources({ wallet, chatPK, chatPrivateKey, chatSigningSecret, notificationPrivateKey, notificationPublicKey, localCache, vaultAccess, vaultSigner, callIdentity });
     throw error;
   } finally {
     cleanBytes(masterSeed, walletEntropy, chatSeed, cacheKey, settingsKey);
@@ -18962,88 +19345,6 @@ function hasAgreement(user, contract = CURRENT_AGREEMENT) {
   return isAgreementAccepted(user?.agreement, contract);
 }
 
-// ../../core/utils/time.js
-function timestampMs(value, fallback = null, options = {}) {
-  let ms = null;
-  if (typeof value?.toMillis === "function") {
-    ms = value.toMillis();
-  } else if (value instanceof Date) {
-    ms = value.getTime();
-  } else if (typeof value?.seconds === "number") {
-    ms = value.seconds * 1000 + Math.floor((value.nanoseconds || 0) / 1e6);
-  } else if (typeof value?._seconds === "number") {
-    ms = value._seconds * 1000 + Math.floor((value._nanoseconds || 0) / 1e6);
-  } else if (Number.isFinite(value)) {
-    ms = value;
-  } else if (options.parseString && typeof value === "string") {
-    const numberMs = Number(value);
-    ms = Number.isFinite(numberMs) ? numberMs : Date.parse(value);
-  }
-  if (!Number.isFinite(ms) || options.positive && ms <= 0) {
-    return fallback;
-  }
-  return ms;
-}
-function timestampKey(value) {
-  if (value == null) {
-    return null;
-  }
-  return timestampMs(value, null) ?? String(value);
-}
-function makeTimestamp(ms) {
-  return {
-    toMillis() {
-      return ms;
-    },
-    toDate() {
-      return new Date(ms);
-    }
-  };
-}
-function twoDigits(value) {
-  return String(value).padStart(2, "0");
-}
-function dayKey(date) {
-  return `${date.getFullYear()}-${twoDigits(date.getMonth() + 1)}-${twoDigits(date.getDate())}`;
-}
-function localDayKey(value) {
-  const ms = timestampMs(value, null, { parseString: true });
-  if (!Number.isFinite(ms))
-    return "";
-  return dayKey(new Date(ms));
-}
-function hourKey(dateOrHour) {
-  const hour = dateOrHour instanceof Date ? dateOrHour.getHours() : dateOrHour;
-  return twoDigits(hour);
-}
-function dayHourKey(date) {
-  return `${dayKey(date)}-${hourKey(date)}`;
-}
-var MINUTE_MS2 = 60000;
-var HOUR_MS2 = 60 * MINUTE_MS2;
-function nextLocalDayStartMs(ms) {
-  const date = new Date(ms);
-  date.setDate(date.getDate() + 1);
-  date.setHours(0, 0, 0, 0);
-  return date.getTime();
-}
-function nextRowDateTimeRefreshMs(value, now = Date.now()) {
-  const ms = timestampMs(value, null, { parseString: true });
-  const nowMs2 = timestampMs(now, Date.now(), { parseString: true });
-  if (!Number.isFinite(ms) || !Number.isFinite(nowMs2))
-    return null;
-  const age = nowMs2 - ms;
-  if (age < -MINUTE_MS2)
-    return ms - MINUTE_MS2;
-  if (age < MINUTE_MS2)
-    return ms + MINUTE_MS2;
-  if (age < HOUR_MS2)
-    return ms + (Math.floor(age / MINUTE_MS2) + 1) * MINUTE_MS2;
-  if (localDayKey(ms) === localDayKey(nowMs2))
-    return nextLocalDayStartMs(nowMs2);
-  return null;
-}
-
 // ../../core/moderation.js
 function banUntilMs(ban) {
   if (!ban || typeof ban !== "object" || Array.isArray(ban) || ban.until == null) {
@@ -20954,48 +21255,6 @@ function readAccountBootstrap(value, uid) {
   };
 }
 
-// ../../core/chat/state.js
-function makeCid() {
-  return `${Date.now().toString(36)}${toHex(randomBytes3(3))}`;
-}
-function getMessageKey(message) {
-  return message?.cid || message?.id || null;
-}
-function getCidMs(cid) {
-  if (typeof cid !== "string" || !/^[0-9a-z]+[0-9a-f]{6}$/u.test(cid)) {
-    return null;
-  }
-  const base = cid.slice(0, -6);
-  const ms = Number.parseInt(base, 36);
-  return Number.isSafeInteger(ms) && ms > 0 ? ms : null;
-}
-function getMessageOrderMs(message) {
-  return getCidMs(message?.cid) ?? timestampMs(message?.ts, Infinity);
-}
-function sortMessages(messages) {
-  return [...messages].sort((a, b) => {
-    const aMs = getMessageOrderMs(a);
-    const bMs = getMessageOrderMs(b);
-    if (aMs !== bMs) {
-      return aMs - bMs;
-    }
-    return String(a?.id || "").localeCompare(String(b?.id || ""));
-  });
-}
-function mergeMessages(...groups) {
-  const merged = new Map;
-  for (const group of groups) {
-    for (const message of group || []) {
-      const key = getMessageKey(message);
-      if (!key) {
-        continue;
-      }
-      merged.set(key, message);
-    }
-  }
-  return sortMessages([...merged.values()]);
-}
-
 // ../../core/chat/ids.js
 function isChatMessageForParticipants(message, chatPK, peerChatPK, memberChatPKs = null) {
   const members = Array.isArray(memberChatPKs) ? new Set(memberChatPKs.filter(Boolean)) : null;
@@ -21381,16 +21640,16 @@ function normalizeOpenedAction(epoch, head, action) {
   };
 }
 async function openMsgPlaintext(epoch, nonce, ct, aad, options) {
-  const crypto = options?.crypto;
-  if (typeof crypto?.openBox === "function" && (typeof crypto.isAvailable !== "function" || crypto.isAvailable())) {
-    return crypto.openBox(epoch.bodyKey, nonce, ct, aad);
+  const crypto2 = options?.crypto;
+  if (typeof crypto2?.openBox === "function" && (typeof crypto2.isAvailable !== "function" || crypto2.isAvailable())) {
+    return crypto2.openBox(epoch.bodyKey, nonce, ct, aad);
   }
   return openBox(epoch.bodyKey, nonce, ct, aad);
 }
 async function verifyMsgSignature(publicKey, sig, bytes, options) {
-  const crypto = options?.crypto;
-  if (typeof crypto?.verifyChatBytes === "function" && (typeof crypto.isAvailable !== "function" || crypto.isAvailable())) {
-    return crypto.verifyChatBytes(publicKey, sig, bytes);
+  const crypto2 = options?.crypto;
+  if (typeof crypto2?.verifyChatBytes === "function" && (typeof crypto2.isAvailable !== "function" || crypto2.isAvailable())) {
+    return crypto2.verifyChatBytes(publicKey, sig, bytes);
   }
   return verifyChatBytes(publicKey, toHex(sig), bytes);
 }
@@ -21473,9 +21732,9 @@ async function openMessageBatchV3(epoch, records, options = {}) {
   if (!epoch?.chatId || !epoch?.epochId || !epoch?.bodyKey || !epoch?.manifest) {
     throw new Error("chat batch epoch required");
   }
-  const crypto = options.crypto;
-  if (typeof crypto?.openMessageBatchV3 === "function" && (typeof crypto.isAvailable !== "function" || crypto.isAvailable())) {
-    const opened = await crypto.openMessageBatchV3(makeBatchOpenRequest(epoch, source));
+  const crypto2 = options.crypto;
+  if (typeof crypto2?.openMessageBatchV3 === "function" && (typeof crypto2.isAvailable !== "function" || crypto2.isAvailable())) {
+    const opened = await crypto2.openMessageBatchV3(makeBatchOpenRequest(epoch, source));
     if (!Array.isArray(opened) || opened.length !== source.length) {
       throw new Error("invalid chat message batch result");
     }
@@ -22831,20 +23090,6 @@ async function readChatFile(readChatMedia, file) {
   }
 }
 
-// ../../core/chat/messages/types.js
-var ATTACHMENT_MSG_TYPES = ["img", "gif", "m4a", "mp4", "file"];
-var MAX_TXT_CHARS = CHAT_MAX_TEXT_CHARS;
-var REACTION_MSG_TYPE = "rxn";
-var DELETE_MSG_TYPE = "del";
-var SYSTEM_MSG_TYPE = "sys";
-var EPOCH_TRANSITION_MSG_TYPE = "epoch";
-var EPOCH_PROPOSAL_MSG_TYPE = "epoch_proposal";
-var SYSTEM_SETTINGS_KIND = "settings";
-var DEFAULT_REACTION_EMOJI = "❤️";
-var MAX_REACTIONS = CHAT_MAX_REACTIONS;
-var HOLD_VISIBLE_KEY = "__holdVisible";
-var SOURCE_GONE_VISIBLE_KEY = "__sourceGoneVisible";
-
 // ../../core/username.js
 var MAX_USERNAME = USERNAME_MAX_CHARS;
 var usernameKeyRegex = /^[a-z0-9]$/i;
@@ -24493,7 +24738,7 @@ function getChatSettingsEventAvatar(msg) {
   return chatAvatarFile(msg?.avatarRef) ? msg.avatarRef : "";
 }
 function isSystemMsg(msg) {
-  return !!getSystemMsgText(msg) && (msg?.t === SYSTEM_MSG_TYPE || isMembershipEventMsg(msg));
+  return !!getSystemMsgText(msg) && (msg?.t === SYSTEM_MSG_TYPE || msg?.t === CALL_MSG_TYPE || isMembershipEventMsg(msg));
 }
 function makeChatInviteNotice(profiles) {
   const names = [...new Map(profiles.map((profile) => [profile.chatPK, formatUserDisplay(profile, true)])).values()];
@@ -24528,6 +24773,8 @@ function isMembershipEventMsg(msg) {
   return !!getMembershipEvent(msg);
 }
 function getSystemMsgText(msg) {
+  if (msg?.t === CALL_MSG_TYPE)
+    return callMessageText(msg);
   if (isChatInviteNotice(msg)) {
     const names = msg.names.length < 2 ? msg.names[0] : `${msg.names.slice(0, -1).join(", ")} and ${msg.names.at(-1)}`;
     return `${names} ${msg.names.length === 1 ? "is" : "are"} not accepting chat invitations right now`;
@@ -24625,6 +24872,8 @@ function canShowMsg(msg) {
       return hasText(msg.a);
     case "pay":
       return isChatPayment(msg) || isPendingChatPayment(msg);
+    case CALL_MSG_TYPE:
+      return !!readCallMessage(msg);
     case SYSTEM_MSG_TYPE:
       return !!getSystemMsgText(msg);
     default:
@@ -24837,8 +25086,12 @@ function analyzeMessageExpiry(messages, selfChatPublicKey, _peerChatPublicKey, o
   const heldExpired = [];
   const shorten = [];
   let nextExpiryAt = null;
+  const latestStart = latestCallStartKey(projectedMessages.filter(isServerConfirmedMsg));
   for (const message of projectedMessages) {
-    if (!isServerConfirmedMsg(message) || isControlMsg(message) || isSystemMsg(message) || !canShowMsg(message) || message.ttl == null)
+    if (!isServerConfirmedMsg(message) || !canShowMsg(message) || message.ttl == null)
+      continue;
+    const call = readCallMessage(message);
+    if (call?.event === "started" && getMessageKey(message) === latestStart && (options.activeCallId === undefined || options.activeCallId === call.callId))
       continue;
     const messageMs = messageOrderMs(message);
     const epochId = messageEpochId(message);
@@ -24875,7 +25128,7 @@ function analyzeMessageExpiry(messages, selfChatPublicKey, _peerChatPublicKey, o
     if (expiresAt == null)
       continue;
     const currentTtlMs = Number.isFinite(message.ttl) ? message.ttl : Number(message.ttl?.toMillis?.());
-    if (!Number.isFinite(currentTtlMs) || currentTtlMs > expiresAt)
+    if (!isControlMsg(message) && (!Number.isFinite(currentTtlMs) || currentTtlMs > expiresAt))
       shorten.push({ message, expiresAt });
     if (expiresAt > now) {
       nextExpiryAt = nextExpiryAt == null ? expiresAt : Math.min(nextExpiryAt, expiresAt);
@@ -25028,6 +25281,8 @@ async function compactMessages({ chatId, maintenance, messages, deletedKeys, pro
 function sendableMsgPayload(message) {
   if (isChatInviteNotice(message))
     throw new Error("local chat notices cannot be sent");
+  if (message?.t === CALL_MSG_TYPE && !readCallMessage(message))
+    throw new Error("invalid call message");
   const { localData, localUri, pending, failed, peerChatPK, id, from, ts, chatId, chatDraft, protocol, editedAt, editId, editStatus, editOriginal, ...payload } = message || {};
   return payload;
 }
@@ -25074,6 +25329,8 @@ function canRenderPreviewContent(preview) {
   if (preview.t === "pay") {
     return isChatPayment(preview) || isPendingChatPayment(preview);
   }
+  if (preview.t === CALL_MSG_TYPE)
+    return !!readCallMessage(preview);
   if (isAttachmentMsgType(preview?.t)) {
     return true;
   }
@@ -25701,8 +25958,9 @@ async function makeChatRecipientDeliveries(identity, epochState, routes, message
     const route = routes[member.chatPK] || {};
     const descriptor = await sealNotificationDescriptor(member.notificationPK, {
       peerTag: notificationChatTag(epochState.stateCapability, epochState.manifest.chatId, member.chatPK),
-      eventId: messageId
-    });
+      eventId: messageId,
+      kind: fields.presentationKind ?? NOTIFICATION_PRESENTATION_KINDS.ACTIVITY
+    }, identity);
     const ping = await sealPing(identity, member.chatPK, {
       kind: fields.kind,
       chatId: epochState.manifest.chatId,
@@ -25776,6 +26034,7 @@ async function prepareMsgRecord(identity, epochState, message, options = {}) {
       cid: head.cid,
       record: { lane: epoch.messageLane, head, body, ttlMs },
       message: ownerPreview(epoch, identity.chatPK, messagePayload, messageId, head, tsMs, ttlMs),
+      actionOp,
       mentionRecipientChatPKs: mentionTargets.recipientChatPKs,
       tsMs
     };
@@ -25809,6 +26068,7 @@ async function sendMsg(cloud, senderChatPK, senderPrivateKey, _receiverChatPK, m
       msgId: messageId,
       record,
       message: sentMessage,
+      actionOp,
       mentionRecipientChatPKs,
       tsMs
     } = prepared;
@@ -25839,8 +26099,9 @@ async function sendMsg(cloud, senderChatPK, senderPrivateKey, _receiverChatPK, m
       shouldPing,
       deliverRecipients: options.deliverRecipients !== false,
       kind: pingKind,
+      presentationKind: isReactionMsg(sentMessage) && sentMessage.emoji ? NOTIFICATION_PRESENTATION_KINDS.REACTION : actionOp !== CHAT_ACTION_OPS.CREATE || isControlMsg(sentMessage) ? NOTIFICATION_PRESENTATION_KINDS.ACTIVITY : notificationMessageKind(sentMessage),
       ownDeliveryCapability: routeState.capability,
-      silent: options.notify === false,
+      silent: options.notify === false || notificationMessageIsSilent(sentMessage),
       recipientChatPKs: deliveryRecipientChatPKs,
       attentionRecipientChatPKs: mentionRecipientChatPKs,
       tsMs
@@ -27806,8 +28067,9 @@ async function makeMlsWelcomeDeliveries(identity, nextState2, addedMembers, opti
     }
     const descriptor = await sealNotificationDescriptor(member.notificationPK, {
       peerTag: notificationChatTag(nextState2.stateCapability, nextState2.manifest.chatId, member.chatPK),
-      eventId: nextState2.mlsPackageId
-    });
+      eventId: nextState2.mlsPackageId,
+      kind: NOTIFICATION_PRESENTATION_KINDS.ACTIVITY
+    }, identity);
     const ping = await sealPing(identity, member.chatPK, {
       kind: "welcome",
       chatId: nextState2.manifest.chatId,
@@ -37904,6 +38166,8 @@ function createChatListIndex({ cache, filterHiddenChats, getSources, isHiddenCha
     const boundary = authorityBoundaries.get(chat?.id);
     if (boundary?.terminal)
       return false;
+    if (boundary?.leftEpoch != null && !(chat?.epochVersion > boundary.leftEpoch))
+      return false;
     if (!chat?.id || !Number.isSafeInteger(sourceRevision))
       return true;
     if (sourceRevision < sourceRevisionFloor)
@@ -38067,7 +38331,7 @@ function createChatListIndex({ cache, filterHiddenChats, getSources, isHiddenCha
         continue;
       if (!sourceCanRemove(chatId, sourceRevision))
         continue;
-      if (entry.announcement && !authorityBoundaries.get(chatId)?.owner) {
+      if (entry.announcement && !ownerCoversAnnouncement(authorityBoundaries.get(chatId)?.owner, entry.announcement)) {
         entry.cache = null;
         continue;
       }
@@ -38153,6 +38417,9 @@ function createChatListIndex({ cache, filterHiddenChats, getSources, isHiddenCha
       return false;
     if (authorityBoundaries.get(announcement.chatId)?.terminal)
       return false;
+    const leftEpoch = authorityBoundaries.get(announcement.chatId)?.leftEpoch;
+    if (leftEpoch != null && !(announcement.epochVersion > leftEpoch))
+      return false;
     const sources = getSources();
     if (sources.pendingDeleteIdsRef.current.has(announcement.chatId))
       return false;
@@ -38211,6 +38478,26 @@ function createChatListIndex({ cache, filterHiddenChats, getSources, isHiddenCha
       return false;
     return removeOwner(chatId, options);
   };
+  const leaveOwner = (chatId, epochVersion) => {
+    if (!chatId || !Number.isSafeInteger(epochVersion) || epochVersion < 1)
+      return false;
+    const previous = authorityBoundaries.get(chatId);
+    if (previous?.terminal)
+      return false;
+    if (previous?.owner?.epochVersion > epochVersion)
+      return false;
+    authorityRevision += 1;
+    authorityBoundaries.set(chatId, {
+      owner: previous?.owner || structuralChat(ownerFor(entries.get(chatId))),
+      revision: authorityRevision,
+      terminal: false,
+      leftEpoch: Math.max(previous?.leftEpoch || 0, epochVersion)
+    });
+    entries.delete(chatId);
+    clearRemovedOwners([chatId]);
+    publishOwners({ warm: false });
+    return true;
+  };
   const getOwnerChat = (chatId) => {
     if (!chatId || isHiddenChatId(chatId))
       return null;
@@ -38397,6 +38684,7 @@ function createChatListIndex({ cache, filterHiddenChats, getSources, isHiddenCha
     observeMessages,
     patchRowSettings,
     removeOwner,
+    leaveOwner,
     removeInboxOwner,
     render,
     reset,
@@ -41712,10 +42000,10 @@ function createChatSessionMembership({
         await cloud.delivery.revoke(capability).catch(() => false);
         assertCurrent(operation);
         if (retirementStarted) {
-          operation.deleteActions.commitLeftChat(chatId);
+          operation.deleteActions.commitLeftChat(chatId, chat.epochVersion);
           retirementStarted = false;
         } else
-          operation.deleteActions.dropLeftChat(chatId);
+          operation.deleteActions.dropLeftChat(chatId, chat.epochVersion);
         return { left: true, message: proposal.message };
       } catch (error) {
         if (retirementStarted && isCurrent(operation)) {
@@ -41967,8 +42255,9 @@ async function deliverChatDeletedPings(cloud, identityValue, epochState, members
       continue;
     const descriptor = await sealNotificationDescriptor(member.notificationPK, {
       peerTag: notificationChatTag(epochState.stateCapability, manifest.chatId, member.chatPK),
-      eventId
-    });
+      eventId,
+      kind: NOTIFICATION_PRESENTATION_KINDS.ACTIVITY
+    }, identity);
     const ping = await sealPing(identity, member.chatPK, {
       kind: "chat_deleted",
       chatId: manifest.chatId,
@@ -42121,20 +42410,20 @@ function createChatDelete({
       return;
     listActionsRef.current?.removeOwner?.(chatId, { warm: false });
   };
-  const dropLeftChat = (chatId) => {
+  const dropLeftChat = (chatId, epochVersion) => {
     if (!chatId)
       return false;
-    dropChat(chatId);
+    listActionsRef.current?.leaveOwner?.(chatId, epochVersion);
     return true;
   };
-  const commitLeftChat = (chatId) => {
+  const commitLeftChat = (chatId, epochVersion) => {
     if (!chatId)
       return false;
     pendingDeleteIdsRef.current.delete(chatId);
     locallyDeletedChatIdsRef.current.delete(chatId);
     deletedChatIdsRef.current.delete(chatId);
     keepSelectedDeletedChatIdsRef.current.delete(chatId);
-    confirmDeletedChats([chatId]);
+    dropLeftChat(chatId, epochVersion);
     return true;
   };
   const dropUnavailableChat = (chatId) => {
@@ -43699,6 +43988,7 @@ function createChatSession({
   mls = null,
   live = null,
   maintenance,
+  resolveActiveCall,
   incomingChatDecision = null,
   getPeerProfile = null,
   refreshPeerProfile = null,
@@ -44474,7 +44764,6 @@ function createChatSession({
         assertBulkOperationCurrent(operation);
         await cloud.user.chats.unlink(identity.uid, chat.entryId);
         assertBulkOperationCurrent(operation);
-        operation.deleteActions.commitRetirement(chat.id);
       } else {
         await operation.deleteActions.deleteChat(chat, { cleanup: false });
       }
@@ -44561,6 +44850,26 @@ function createChatSession({
       return false;
     }
   };
+  const prepareCall = async (chatId) => {
+    const generation = authGeneration;
+    const current = () => generation === authGeneration && online && pendingOwner.canSendToChat(chatId);
+    if (!current())
+      throw new Error("chat unavailable");
+    await pendingOwner.assertChatAdmission(chatId);
+    if (!getOwnerChat(chatId)?.epochState)
+      await ensureChat(chatId);
+    if (!current())
+      throw new Error("chat unavailable");
+    const reconciliation = await chatListOwner.reconcileChatEpoch(chatId);
+    if (!current() || reconciliation?.removed)
+      throw new Error("chat unavailable");
+    await pendingOwner.assertChatAdmission(chatId);
+    const chat = getVisibleOwnerChat(chatId);
+    if (!current() || !chat?.epochState)
+      throw new Error("chat unavailable");
+    return chat.epochState;
+  };
+  const materializeChat = (chatId) => pendingOwner.runChatMutation(chatId, (canonicalId) => canonicalId);
   const flushChatReadFrontier = (chatId) => {
     if (!online)
       return false;
@@ -44843,6 +45152,8 @@ function createChatSession({
     markChatTyping,
     hasChat: hasVisibleChat,
     getOwnerChat: getVisibleOwnerChat,
+    prepareCall,
+    materializeChat,
     sendOptionsForPeer,
     getLocalMessages,
     wasChatDeletedLocally,
@@ -44876,6 +45187,7 @@ function createChatSession({
     deleteMessage,
     deleteMessages,
     deleteMessageDocs,
+    resolveActiveCall,
     setChatTtl,
     makeMessagePermanent,
     makeMessageTemporary,
@@ -44933,6 +45245,7 @@ function createChatSession({
   stateOwner.setListSnapshot(chatListOwner.getSnapshot());
   deleteListActionsRef.current = {
     removeOwner: (...args) => chatListOwner.removeOwner(...args),
+    leaveOwner: (...args) => chatListOwner.leaveOwner(...args),
     render: (...args) => chatListOwner.render(...args)
   };
   actionOwner.createActionOwners();
@@ -45654,6 +45967,2695 @@ function createPresence({ cloud, diag = null, now = Date.now } = {}) {
   });
 }
 
+// ../../core/calls/protocol.js
+var CALL_MAX_PARTICIPANTS = 16;
+var CALL_TTL_MS = 120000;
+var CALL_ADMISSION_TIMEOUT_MS = 30000;
+var HEX16 = /^[0-9a-f]{32}$/u;
+var HEX32 = /^[0-9a-f]{64}$/u;
+function bytes(packet) {
+  const { signature: _signature, ...body } = packet;
+  return canonicalBytes(["veyl.call.packet.v1", body]);
+}
+function createCallProtocol({ realm: realm2, epochState, identity, endpoint, callId = "" }) {
+  const { manifest } = epochState;
+  const members = new Map(manifest.members.map((member) => [member.chatSigningPK, member]));
+  if (!members.has(identity.chatSigningPK))
+    throw new Error("not a chat member");
+  const actor = identity.chatSigningPK;
+  const secret = identity.chatSigningSecret.slice();
+  let closed = false;
+  const context = { v: 1, realm: realm2, chatId: manifest.chatId, epochId: manifest.epochId, callId };
+  return Object.freeze({
+    sign(kind, data) {
+      if (closed)
+        throw new Error("call protocol closed");
+      const packet = {
+        ...context,
+        actor,
+        holder: endpoint.holder,
+        endpoint: endpoint.publicKey,
+        nonce: toHex(randomBytes3(16)),
+        at: Date.now(),
+        kind,
+        data
+      };
+      return { ...packet, signature: signChatBytes({ secret, publicKey: actor }, bytes(packet)) };
+    },
+    verify(packet, { fresh = true } = {}) {
+      if (!packet || Object.keys(context).some((key) => packet[key] !== context[key]) || !members.has(packet.actor) || !HEX16.test(packet.holder) || !HEX32.test(packet.endpoint) || !HEX16.test(packet.nonce) || !Number.isSafeInteger(packet.at) || fresh && (packet.at > Date.now() + 5000 || packet.at < Date.now() - CALL_TTL_MS) || !verifyChatBytes(packet.actor, packet.signature, bytes(packet)))
+        throw new Error("invalid call participant proof");
+      return members.get(packet.actor);
+    },
+    close() {
+      if (!closed) {
+        closed = true;
+        cleanBytes(secret);
+      }
+    }
+  });
+}
+function verifyCallAdmissions(admissions, protocol) {
+  if (!Array.isArray(admissions) || !admissions.length || admissions.length > CALL_MAX_PARTICIPANTS)
+    throw new Error("call membership mismatch");
+  const holders = new Set;
+  const identities = new Set;
+  const members = new Map;
+  for (const admission of admissions) {
+    const identity = protocol.verify(admission, { fresh: false });
+    if (admission.kind !== "join" || !HEX32.test(admission.data?.signaturePK) || admission.data.replaces != null && !HEX16.test(admission.data.replaces) || holders.has(admission.holder) || identities.has(admission.actor))
+      throw new Error("invalid call participant");
+    holders.add(admission.holder);
+    identities.add(admission.actor);
+    members.set(admission.holder, identity);
+  }
+  return members;
+}
+function verifyCallMembers(mlsState, admissions, protocol) {
+  const members = verifyCallAdmissions(admissions, protocol);
+  if (mlsState.members.length !== admissions.length)
+    throw new Error("call membership mismatch");
+  for (const admission of admissions) {
+    const member = mlsState.members.find((item) => toHex(item.leafId) === admission.holder);
+    if (!member || toHex(member.signaturePK) !== admission.data.signaturePK)
+      throw new Error("call leaf identity mismatch");
+  }
+  return members;
+}
+function verifyCallReplacement(packet, currentHead, protocol) {
+  protocol.verify(packet, { fresh: false });
+  const previous = packet.data?.previous;
+  const replacement = packet.data?.participant;
+  protocol.verify(previous, { fresh: false });
+  if (packet.kind !== "replace" || previous.kind !== "head" || previous.data?.participants?.length !== 1)
+    throw new Error("invalid call replacement");
+  verifyCallAdmissions(previous.data.participants, protocol);
+  verifyCallAdmissions([replacement], protocol);
+  const original = previous.data.participants[0];
+  if (previous.actor !== original.actor || previous.holder !== original.holder || previous.endpoint !== original.endpoint || packet.actor !== original.actor || replacement.actor !== original.actor || packet.holder !== replacement.holder || packet.endpoint !== replacement.endpoint || replacement.holder === original.holder || replacement.data.replaces !== original.holder)
+    throw new Error("invalid call replacement");
+  if (currentHead && (currentHead.epoch !== previous.data.epoch || currentHead.participants.length !== 1 || currentHead.participants[0].signature !== original.signature))
+    throw new Error("stale call replacement");
+  return { epoch: 0, participants: [replacement] };
+}
+
+// ../../core/calls/mailbox.js
+function openCallMailbox({ cloud, capability, endpoint, protocol, onChange, onError, stream = true }) {
+  let closed = false;
+  let record = null;
+  let candidate = null;
+  let tail = Promise.resolve();
+  let cursor = 0;
+  const decode = async (value, fresh = true, maximum) => {
+    const packet = await capability.open(decodeCallBytes(value, maximum));
+    protocol.verify(packet, { fresh });
+    return packet;
+  };
+  const accept = async (value) => {
+    if (closed)
+      return;
+    if (!Number.isSafeInteger(value?.revision) || !Number.isSafeInteger(value?.cursor) || value.revision < 0 || value.cursor < 0 || !Array.isArray(value.events))
+      throw new Error("invalid call mailbox");
+    if (record && value.revision < record.revision)
+      return;
+    if (value.cursor < cursor)
+      throw new Error("invalid call event order");
+    if (value.events.some((item) => !Number.isSafeInteger(item?.cursor) || item.cursor < 1 || item.cursor > value.cursor))
+      throw new Error("invalid call event order");
+    const empty = value.headDigest === null && value.payload === null && value.proof === null && value.events.length === 0;
+    const unseen = value.events.filter((item) => item.cursor > cursor);
+    const historyLost = !!(!empty && cursor && value.cursor > cursor && (!unseen.length || unseen[0].cursor !== cursor + 1));
+    if (historyLost && (stream || value.truncated !== true))
+      throw new Error("call signaling history unavailable");
+    let head = null;
+    let payload = null;
+    if (value.headDigest !== null) {
+      if (typeof value.headDigest !== "string" || !/^[a-f0-9]{64}$/u.test(value.headDigest))
+        throw new Error("invalid call head digest");
+      const proof = await decode(value.proof, true, CALL_HEAD_PROOF_MAX_BYTES);
+      if (proof.kind !== "head-proof" || proof.data?.digest !== value.headDigest)
+        throw new Error("invalid call head proof");
+      if (record?.headDigest === value.headDigest && record.head) {
+        if (Object.hasOwn(value, "payload") && callHeadDigest(decodeCallBytes(value.payload)) !== value.headDigest)
+          throw new Error("invalid call head digest");
+        head = record.head;
+        payload = record.payload;
+      } else {
+        if (!value.payload || callHeadDigest(decodeCallBytes(value.payload)) !== value.headDigest)
+          throw new Error("missing call head");
+        head = await decode(value.payload, false);
+        if (head.kind !== "head")
+          throw new Error("invalid call head");
+        payload = value.payload;
+      }
+    } else if (value.payload !== null || value.proof !== null)
+      throw new Error("invalid empty call head");
+    const events = [];
+    let nextCursor = empty ? value.cursor : historyLost ? 0 : cursor;
+    for (const item of unseen) {
+      if (!Number.isSafeInteger(item.cursor) || item.cursor < 1 || nextCursor && item.cursor !== nextCursor + 1)
+        throw new Error("invalid call event order");
+      const packet = await decode(item.payload, false, CALL_EVENT_MAX_BYTES);
+      events.push(packet);
+      nextCursor = item.cursor;
+    }
+    if (nextCursor !== value.cursor)
+      throw new Error("call signaling history unavailable");
+    if (closed)
+      return;
+    candidate = { ...value, payload, head, events, historyLost };
+    try {
+      await onChange?.(candidate);
+      if (closed)
+        return;
+      cursor = nextCursor;
+      record = candidate;
+    } finally {
+      candidate = null;
+    }
+  };
+  const consume = (value) => {
+    const result = tail.then(() => accept(value));
+    tail = result.catch((error) => {
+      if (!closed)
+        onError?.(error);
+    });
+    return result;
+  };
+  let channel;
+  try {
+    channel = cloud.calls.connect({
+      capability,
+      endpoint,
+      onSnapshot: consume,
+      onError,
+      stream,
+      getCheckpoint: () => ({ cursor, headDigest: record?.headDigest ?? null })
+    });
+  } catch (error) {
+    capability.close();
+    protocol.close?.();
+    throw error;
+  }
+  async function mutate(headDigest, payload, events, { expectedRevision = (candidate || record)?.revision ?? 0, ttlMs = CALL_TTL_MS } = {}) {
+    if (!stream)
+      throw new Error("read-only call mailbox");
+    const proof = encodeCallBytes(await capability.seal(protocol.sign("head-proof", { digest: headDigest })));
+    const packets = await Promise.all(events.map(async (packet) => encodeCallBytes(await capability.seal(packet))));
+    if (closed)
+      throw new Error("call mailbox closed");
+    const command = {
+      type: "commit",
+      expectedRevision,
+      operation: toHex(randomBytes3(16)),
+      headDigest,
+      proof,
+      ...payload !== undefined ? { payload } : {},
+      events: packets,
+      ttlMs
+    };
+    let response;
+    try {
+      response = await channel.request(command);
+    } catch (error) {
+      if (closed || !["calls/connection", "calls/timeout"].includes(error?.code))
+        throw error;
+      response = await channel.request(command);
+    }
+    if (closed)
+      throw new Error("call mailbox closed");
+    consume(response.record).catch(() => {});
+    return response.record;
+  }
+  return Object.freeze({
+    getSnapshot: () => candidate || record,
+    async read() {
+      const response = await channel.request({ type: "read", cursor, headDigest: record?.headDigest ?? null });
+      await consume(response.record);
+      return record;
+    },
+    async commit(head, events = [], options) {
+      const bytes2 = await capability.seal(protocol.sign("head", head));
+      return mutate(callHeadDigest(bytes2), encodeCallBytes(bytes2), events, options);
+    },
+    async append(events, options) {
+      const current = candidate || record;
+      if (!current?.headDigest || !current.head)
+        throw new Error("call ended");
+      return mutate(current.headDigest, undefined, events, options);
+    },
+    close() {
+      closed = true;
+      channel.close();
+      capability.close();
+      protocol.close?.();
+    }
+  });
+}
+
+// ../../core/calls/ownership.js
+var CALL_OWNERSHIP_LEASE_MS = 15000;
+
+// ../../core/calls/clock.js
+function callLeaseClock() {
+  return {
+    wall: Date.now(),
+    monotonic: globalThis.performance.timeOrigin + globalThis.performance.now()
+  };
+}
+
+// ../../core/calls/leaseattempt.js
+var STOP_MARGIN_MS = 250;
+function validTime(value) {
+  return Number.isFinite(value) && value >= 0;
+}
+function createCallLeaseAttempt(command, clock = callLeaseClock) {
+  if (!["claim", "activate", "renew"].includes(command?.type))
+    throw new Error("call lease command required");
+  if (command.operation !== undefined)
+    throw new Error("reuse the original call lease attempt");
+  const revision = command.type === "claim" ? command.expectedRevision + 1 : command.revision;
+  const sequence = command.type === "renew" ? command.sequence : 0;
+  if (!/^[a-f0-9]{32}$/u.test(command.holder || "") || !Number.isSafeInteger(revision) || revision < 1 || !Number.isSafeInteger(sequence) || sequence < (command.type === "renew" ? 1 : 0))
+    throw new Error("invalid call lease command");
+  const started = clock();
+  if (!validTime(started?.wall) || !validTime(started?.monotonic))
+    throw new Error("call lease clock unavailable");
+  const deadline = Object.freeze({
+    sessionId: command.holder,
+    revision,
+    wallDeadline: started.wall + CALL_OWNERSHIP_LEASE_MS - STOP_MARGIN_MS,
+    monotonicDeadline: started.monotonic + CALL_OWNERSHIP_LEASE_MS - STOP_MARGIN_MS
+  });
+  const startWall = started.wall;
+  const startMonotonic = started.monotonic;
+  const operation = toHex(randomBytes3(16));
+  const request = Object.freeze({ ...command, ...command.payload ? { payload: command.payload.slice() } : {}, operation });
+  let cancelled2 = false;
+  return Object.freeze({
+    command: request,
+    cancel() {
+      cancelled2 = true;
+    },
+    grant(record) {
+      if (cancelled2)
+        return null;
+      const now = clock();
+      if (!validTime(now?.wall) || !validTime(now?.monotonic) || now.wall < startWall || now.monotonic < startMonotonic || now.wall >= deadline.wallDeadline || now.monotonic >= deadline.monotonicDeadline) {
+        cancelled2 = true;
+        return null;
+      }
+      const active = record?.active;
+      if (record?.pending || record?.revision !== revision || active?.revision !== revision || active.holder !== deadline.sessionId || active.sequence !== sequence || active.operation !== operation)
+        return null;
+      return deadline;
+    }
+  });
+}
+
+// ../../core/calls/accountlease.js
+var transient = (error) => ["calls/connection", "calls/timeout"].includes(error?.code);
+function openAccountCallLease({ cloud, capability: accountCapability, endpoint, clock = callLeaseClock, onRecord, onGrant, onLost, onError }) {
+  const capability = accountCapability.retain();
+  let closed = false;
+  let record = null;
+  let owned = null;
+  let ownedDeadline = null;
+  let retiring = null;
+  let renewal = null;
+  let expiry = null;
+  let generation = 0;
+  let acquiring = false;
+  const attempts = new Set;
+  const waiters = new Set;
+  const current = () => !closed;
+  const wake = () => {
+    for (const resolve of [...waiters])
+      resolve();
+  };
+  function waitForChange(milliseconds) {
+    return new Promise((resolve) => {
+      const finish = () => {
+        clearTimeout(timer);
+        waiters.delete(finish);
+        resolve();
+      };
+      const timer = setTimeout(finish, milliseconds);
+      waiters.add(finish);
+    });
+  }
+  function stop() {
+    generation++;
+    clearTimeout(renewal);
+    clearTimeout(expiry);
+    renewal = expiry = null;
+    for (const attempt of attempts)
+      attempt.cancel();
+    attempts.clear();
+    const previous = owned;
+    owned = ownedDeadline = null;
+    wake();
+    return previous;
+  }
+  async function accept(value) {
+    if (closed)
+      return;
+    const next = decodeCallRecord(value);
+    if (!Number.isSafeInteger(next?.version) || next.version < 0)
+      throw new Error("invalid call ownership version");
+    if (record && next.version <= record.version)
+      return;
+    record = next;
+    wake();
+    if (owned && (next.pending || next.active?.holder !== endpoint.holder || next.active?.revision !== owned.revision)) {
+      retiring = stop();
+      onLost?.();
+    }
+    const active = next.pending || next.active;
+    const descriptor = active ? await capability.open(active.payload) : null;
+    if (current() && record === next)
+      onRecord?.(next, descriptor);
+  }
+  let channel;
+  try {
+    channel = cloud.calls.connect({
+      capability,
+      endpoint,
+      onSnapshot: (value) => accept(value).catch(onError),
+      onError(error) {
+        if (!transient(error))
+          onError?.(error);
+      }
+    });
+  } catch (error) {
+    capability.close();
+    throw error;
+  }
+  async function request(command) {
+    const response = await channel.request({ ...command, ...command.payload ? { payload: encodeCallBytes(command.payload) } : {} });
+    await accept(response.record);
+    return decodeCallRecord(response.record);
+  }
+  function renewalRemaining(started) {
+    if (!current() || started !== generation || !owned || !ownedDeadline)
+      return 0;
+    const now = clock();
+    if (!Number.isFinite(now?.wall) || !Number.isFinite(now?.monotonic) || now.wall < 0 || now.monotonic < 0)
+      return 0;
+    return Math.max(0, Math.min(ownedDeadline.wallDeadline - now.wall, ownedDeadline.monotonicDeadline - now.monotonic));
+  }
+  async function requestGrant(attempt, started) {
+    let delay = 250;
+    for (;; ) {
+      if (attempt.command.type === "renew" && !renewalRemaining(started))
+        throw new Error("call ownership expired");
+      try {
+        const value = await request(attempt.command);
+        if (attempt.command.type === "renew" && !renewalRemaining(started))
+          throw new Error("call ownership expired");
+        return value;
+      } catch (error) {
+        const remaining = renewalRemaining(started);
+        if (attempt.command.type !== "renew" || !transient(error) || !remaining)
+          throw error;
+        await waitForChange(Math.min(delay, remaining));
+        delay = Math.min(delay * 2, 1000);
+      }
+    }
+  }
+  async function grant(command) {
+    if (closed)
+      throw new Error("call lease closed");
+    const attempt = createCallLeaseAttempt(command, clock);
+    const started = generation;
+    attempts.add(attempt);
+    try {
+      const value = await requestGrant(attempt, started);
+      const deadline = attempt.grant(value);
+      if (!current() || started !== generation || !deadline || record.version !== value.version)
+        throw new Error("call ownership unavailable");
+      owned = value.active;
+      await onGrant(deadline);
+      if (!current() || owned !== value.active)
+        throw new Error("call ownership changed");
+      ownedDeadline = deadline;
+      clearTimeout(expiry);
+      expiry = setTimeout(() => {
+        stop();
+        onLost?.();
+      }, Math.max(0, deadline.wallDeadline - Date.now()));
+      clearTimeout(renewal);
+      renewal = setTimeout(() => {
+        if (!owned)
+          return;
+        const renewing = generation;
+        grant({ type: "renew", holder: endpoint.holder, revision: owned.revision, sequence: owned.sequence + 1 }).catch((error) => {
+          if (closed || renewing !== generation)
+            return;
+          stop();
+          onLost?.();
+          onError?.(error);
+        });
+      }, 5000);
+      return value;
+    } finally {
+      attempts.delete(attempt);
+      attempt.cancel();
+    }
+  }
+  return Object.freeze({
+    async acquire(descriptor) {
+      if (closed)
+        throw new Error("call lease closed");
+      if (owned || acquiring)
+        throw new Error("already in a call");
+      acquiring = true;
+      const started = generation;
+      try {
+        await request({ type: "read" });
+        const payload = await capability.seal(descriptor);
+        if (closed || started !== generation)
+          throw new Error("call transfer cancelled");
+        const claim = { type: "claim", holder: endpoint.holder, expectedRevision: record.revision, payload, takeover: true };
+        if (!record.active && !record.pending)
+          return await grant(claim);
+        const pending = createCallLeaseAttempt(claim, clock);
+        attempts.add(pending);
+        try {
+          await request(pending.command);
+          const until = Date.now() + 20000;
+          while (current() && started === generation && record.pending?.holder === endpoint.holder && record.active && Date.now() < until) {
+            await waitForChange(Math.max(1, Math.min(until - Date.now(), record.active.expiresAt - Date.now() + 50)));
+            if (current() && started === generation && record.active?.expiresAt <= Date.now())
+              await request({ type: "read" });
+          }
+          if (!current() || started !== generation || record.pending?.holder !== endpoint.holder)
+            throw new Error("call transfer cancelled");
+          return await grant({ type: "activate", holder: endpoint.holder, revision: record.pending.revision });
+        } finally {
+          attempts.delete(pending);
+          pending.cancel();
+        }
+      } finally {
+        acquiring = false;
+      }
+    },
+    provider(action, payload) {
+      if (!owned || closed)
+        return Promise.reject(new Error("call ownership required"));
+      return channel.provider({ holder: endpoint.holder, revision: owned.revision, action, payload }).then((result) => result.record);
+    },
+    async release() {
+      const previous = stop() || retiring;
+      retiring = null;
+      if (previous && !closed)
+        await request({ type: "release", holder: endpoint.holder, revision: previous.revision });
+      else if (record?.pending?.holder === endpoint.holder && !closed)
+        await request({ type: "cancel", holder: endpoint.holder, revision: record.pending.revision });
+    },
+    retire() {
+      retiring = stop() || retiring;
+    },
+    close() {
+      closed = true;
+      stop();
+      channel.close();
+      capability.close();
+    }
+  });
+}
+
+// ../../core/calls/room.js
+function openCallRoom({
+  cloud,
+  capability,
+  protocol,
+  endpoint,
+  mls,
+  member,
+  admission,
+  callId,
+  onKeys,
+  onParticipants,
+  onSignal,
+  onRemoved,
+  onError
+}) {
+  let closed = false;
+  let state = null;
+  let head = null;
+  let verifiedHead = null;
+  let admittedIdentities = new Map;
+  let pulseTimer = null;
+  let changing = false;
+  let reconcileAgain = false;
+  let joined = false;
+  let departing = false;
+  let pendingCandidate = null;
+  let ownMedia = null;
+  let audio = { muted: false, deafened: false };
+  let startTask = null;
+  let startPromise = null;
+  let admissionTimer = null;
+  let admissionResult = null;
+  let admissionFailure = null;
+  let pendingInitial = null;
+  let submittedJoin = false;
+  let predecessorHolder = null;
+  let eventTail = Promise.resolve();
+  let retryWait = null;
+  const pendingJoins = new Map;
+  const leaving = new Set;
+  const seen = new Map;
+  const published = new Map;
+  const localHolder = endpoint.holder;
+  function disposeState(value) {
+    cleanBytes(value?.snapshot, value?.baseKey);
+  }
+  const alive = (holder) => !leaving.has(holder) && Date.now() - (seen.get(holder) || 0) < 30000;
+  const replacementFor = (item) => [...pendingJoins.values()].find((packet) => packet.actor === item.actor && packet.holder !== item.holder && packet.data.replaces === item.holder && alive(packet.holder));
+  const leader = () => {
+    const candidates = head?.participants.filter((item) => alive(item.holder)) || [];
+    return (candidates.filter((item) => !replacementFor(item)).length ? candidates.filter((item) => !replacementFor(item)) : candidates).map((item) => item.holder).sort()[0];
+  };
+  function admissionError(code, message) {
+    return Object.assign(new Error(message), { code });
+  }
+  const cancelled2 = () => admissionError("calls/cancelled", "call cancelled");
+  const empty = () => admissionError("calls/room-empty", "this call is empty");
+  function settleAdmission(error) {
+    if (error)
+      admissionFailure ||= error;
+    if (!admissionResult)
+      return;
+    const result = admissionResult;
+    admissionResult = null;
+    clearTimeout(admissionTimer);
+    admissionTimer = null;
+    if (error)
+      result.reject(error);
+    else
+      result.resolve();
+  }
+  function checkAdmission() {
+    if (closed || departing || !head)
+      return;
+    if (!joined && head.participants.every((item) => leaving.has(item.holder)))
+      settleAdmission(empty());
+    else if (joined && head.participants.some((item) => item.holder === localHolder && item.actor === admission.actor))
+      settleAdmission();
+    else if (!joined && head.participants.length >= CALL_MAX_PARTICIPANTS && !head.participants.some((item) => item.actor === admission.actor)) {
+      settleAdmission(admissionError("calls/full", "this call is full"));
+    } else if (!joined && submittedJoin && head.participants.some((item) => item.actor === admission.actor && item.holder !== localHolder && item.holder !== predecessorHolder)) {
+      settleAdmission(admissionError("calls/taken-over", "call moved to another device"));
+    }
+  }
+  async function adopt(next, admissions) {
+    verifyCallMembers(next, admissions, protocol);
+    if (closed) {
+      disposeState(next);
+      return;
+    }
+    const previous = state;
+    state = next;
+    disposeState(previous);
+    const self = next.members.find((item) => toHex(item.leafId) === localHolder);
+    if (!self) {
+      onRemoved?.();
+      return;
+    }
+    if (!admissions.some((item) => item.holder === localHolder && item.actor === admission.actor && item.endpoint === endpoint.publicKey))
+      throw new Error("call endpoint identity mismatch");
+    joined = true;
+    await onKeys({ baseKey: next.baseKey, epoch: next.epoch, members: next.members, leafIndex: self.leafIndex });
+  }
+  function participants() {
+    return (head?.participants || []).filter((item) => !leaving.has(item.holder)).map((item) => ({
+      ...admittedIdentities.get(item.holder),
+      holder: item.holder,
+      muted: published.get(item.holder)?.muted === true || published.get(item.holder)?.deafened === true,
+      deafened: published.get(item.holder)?.deafened === true,
+      media: published.get(item.holder)?.media || null
+    }));
+  }
+  function prune() {
+    const admitted = new Set(head?.participants.map((item) => item.holder));
+    for (const [holder, packet] of pendingJoins) {
+      const predecessor = head?.participants.find((item) => item.actor === packet.actor);
+      if (admitted.has(holder) || Date.now() - packet.at >= CALL_ADMISSION_TIMEOUT_MS || predecessor && packet.data.replaces !== predecessor.holder || !predecessor && packet.data.replaces)
+        pendingJoins.delete(holder);
+    }
+    for (const holder of seen.keys())
+      if (!admitted.has(holder) && !pendingJoins.has(holder))
+        seen.delete(holder);
+    for (const holder of published.keys())
+      if (!admitted.has(holder))
+        published.delete(holder);
+    for (const holder of leaving)
+      if (!admitted.has(holder))
+        leaving.delete(holder);
+  }
+  async function consume(record) {
+    if (closed)
+      return;
+    prune();
+    const nextHead = record.head?.data;
+    const signals = [];
+    let membershipChanged = false;
+    if (nextHead && (!Array.isArray(nextHead.participants) || nextHead.participants.length > CALL_MAX_PARTICIPANTS))
+      throw new Error("invalid call room");
+    for (const packet of record.events) {
+      const roster = head?.participants || nextHead?.participants || [];
+      const bound = roster.some((item) => item.holder === packet.holder && item.actor === packet.actor && item.endpoint === packet.endpoint);
+      const pending = pendingJoins.get(packet.holder);
+      const pendingBound = pending?.actor === packet.actor && pending?.endpoint === packet.endpoint;
+      if (!["join", "replace"].includes(packet.kind) && !bound && !(packet.kind === "leave" && pendingBound))
+        continue;
+      if (packet.kind === "join" && roster.some((item) => item.holder === packet.holder) && !bound)
+        continue;
+      if (packet.kind === "join") {
+        if (Date.now() - packet.at >= CALL_ADMISSION_TIMEOUT_MS)
+          continue;
+        const predecessor = roster.find((item) => item.actor === packet.actor && item.holder !== packet.holder);
+        if (predecessor && packet.data.replaces !== predecessor.holder)
+          continue;
+        if (!predecessor && packet.data.replaces && !bound)
+          continue;
+        const previous = [...pendingJoins.values()].find((item) => item.actor === packet.actor && item.holder !== packet.holder);
+        if (previous) {
+          pendingJoins.delete(previous.holder);
+          seen.delete(previous.holder);
+        }
+        if (!pendingJoins.has(packet.holder) && pendingJoins.size >= CALL_MAX_PARTICIPANTS)
+          continue;
+        pendingJoins.set(packet.holder, packet);
+      } else if (packet.kind === "leave") {
+        if (pendingBound)
+          pendingJoins.delete(packet.holder);
+        if (bound)
+          leaving.add(packet.holder);
+      } else if (packet.kind === "pulse") {
+        published.set(packet.holder, packet.data);
+      } else if (packet.kind === "signal") {
+        if (packet.data.to === localHolder && head?.participants.some((item) => item.holder === packet.holder && item.actor === packet.actor)) {
+          signals.push(packet);
+        }
+      } else if (packet.kind === "replace") {
+        const replacement = verifyCallReplacement(packet, head, protocol);
+        membershipChanged = true;
+        if (state && !replacement.participants.some((item) => item.holder === localHolder)) {
+          settleAdmission(cancelled2());
+          onRemoved?.();
+          return;
+        }
+        head = replacement;
+      } else if (packet.kind === "change") {
+        membershipChanged = true;
+        const change = packet.data;
+        if (!Array.isArray(change.participants) || !Number.isSafeInteger(change.epoch))
+          throw new Error("invalid call epoch");
+        if (state && change.epoch === state.epoch + 1) {
+          if (!bound)
+            throw new Error("unadmitted call commit");
+          const next = pendingCandidate?.commit === change.commit ? pendingCandidate.state : await mls.processCommit(state.snapshot, decodeCallBytes(change.commit));
+          pendingCandidate = null;
+          if (next.removed) {
+            disposeState(next);
+            onRemoved?.();
+            return;
+          }
+          await adopt(next, change.participants);
+        } else if (!state && change.participants.some((item) => item.holder === localHolder && item.actor === admission.actor && item.endpoint === endpoint.publicKey)) {
+          const next = await mls.join(member.snapshot, decodeCallBytes(change.welcome), decodeCallBytes(change.tree), fromHexBytes(callId));
+          await adopt(next, change.participants);
+        }
+        head = { epoch: change.epoch, participants: change.participants };
+        for (const item of change.participants) {
+          pendingJoins.delete(item.holder);
+          if (!seen.has(item.holder))
+            seen.set(item.holder, packet.at);
+        }
+      }
+      seen.set(packet.holder, Math.max(seen.get(packet.holder) || 0, packet.at));
+    }
+    if (!state && pendingInitial && nextHead?.epoch === 0 && nextHead.participants.length === 1 && nextHead.participants[0].signature === pendingInitial.admission.signature) {
+      const initial = pendingInitial.state;
+      pendingInitial = null;
+      await adopt(initial, nextHead.participants);
+    }
+    if (nextHead && (verifiedHead !== record.head || membershipChanged)) {
+      admittedIdentities = state ? verifyCallMembers(state, nextHead.participants, protocol) : verifyCallAdmissions(nextHead.participants, protocol);
+      for (const item of nextHead.participants) {
+        if (!seen.has(item.holder))
+          seen.set(item.holder, record.head.at);
+      }
+      if (state && nextHead.epoch !== state.epoch)
+        throw new Error("call epoch history unavailable");
+      head = nextHead;
+      verifiedHead = record.head;
+    } else if (!nextHead) {
+      head = null;
+      verifiedHead = null;
+      admittedIdentities.clear();
+      if (joined) {
+        onRemoved?.();
+        return;
+      }
+      if (submittedJoin)
+        settleAdmission(empty());
+    }
+    prune();
+    if (closed)
+      return;
+    onParticipants?.(participants());
+    checkAdmission();
+    for (const packet of signals) {
+      try {
+        Promise.resolve(onSignal?.(packet.data.signal, packet.holder)).catch(fail);
+      } catch (error) {
+        fail(error);
+      }
+    }
+    reconcile().catch(fail);
+  }
+  function fail(error) {
+    if (!closed) {
+      if (admissionResult)
+        settleAdmission(error);
+      onError?.(error);
+    }
+  }
+  const mailbox = openCallMailbox({ cloud, capability, protocol, endpoint, onChange: consume, onError: fail });
+  async function reconcile() {
+    reconcileAgain = true;
+    if (changing)
+      return;
+    changing = true;
+    try {
+      do {
+        reconcileAgain = false;
+        await reconcilePass();
+      } while (reconcileAgain && !closed);
+    } finally {
+      changing = false;
+    }
+  }
+  async function reconcilePass() {
+    if (closed || departing || !state || leader() !== localHolder)
+      return;
+    const current = mailbox.getSnapshot();
+    if (!current || !head)
+      return;
+    const removals = head.participants.filter((item) => item.holder !== localHolder && (!alive(item.holder) || replacementFor(item)));
+    const retained = head.participants.filter((item) => !removals.includes(item));
+    const admittedActors = new Set(retained.map((item) => item.actor));
+    const additions = [...pendingJoins.values()].filter((item) => {
+      if (head.participants.some((existing) => existing.holder === item.holder) || admittedActors.has(item.actor) || !alive(item.holder))
+        return false;
+      admittedActors.add(item.actor);
+      return true;
+    }).slice(0, CALL_MAX_PARTICIPANTS - retained.length);
+    if (!removals.length && !additions.length)
+      return;
+    let candidate;
+    try {
+      for (const item of additions)
+        protocol.verify(item);
+      candidate = await mls.stageChange(state.snapshot, {
+        adds: additions.map((item) => decodeCallBytes(item.data.keyPackage)),
+        removes: removals.map((item) => fromHexBytes(item.holder))
+      });
+      if (closed || departing) {
+        disposeState(candidate);
+        return;
+      }
+      const admissions = [...retained, ...additions];
+      verifyCallMembers(candidate, admissions, protocol);
+      const change = {
+        epoch: candidate.epoch,
+        participants: admissions,
+        commit: encodeCallBytes(candidate.commit),
+        welcome: encodeCallBytes(candidate.welcome),
+        tree: encodeCallBytes(candidate.tree)
+      };
+      pendingCandidate = { commit: change.commit, state: candidate };
+      await mailbox.commit({ epoch: candidate.epoch, participants: admissions }, [protocol.sign("change", change)], { expectedRevision: current.revision });
+      candidate = null;
+    } catch (error) {
+      if (pendingCandidate?.state === candidate)
+        pendingCandidate = null;
+      disposeState(candidate);
+      if (String(error.code).endsWith("conflict")) {
+        await mailbox.read();
+        return;
+      }
+      throw error;
+    }
+  }
+  function event(kind, data) {
+    const result = eventTail.then(() => appendEvent(kind, data));
+    eventTail = result.catch(() => {});
+    return result;
+  }
+  async function appendEvent(kind, data) {
+    const deadline = performance.now() + CALL_ADMISSION_TIMEOUT_MS;
+    for (let attempt = 0;!closed && performance.now() < deadline; attempt += 1) {
+      if (kind === "join" && departing)
+        throw cancelled2();
+      const current = mailbox.getSnapshot();
+      if (!current?.head)
+        throw kind === "join" ? empty() : new Error("call ended");
+      if (kind === "join") {
+        checkAdmission();
+        if (admissionFailure)
+          throw admissionFailure;
+      }
+      try {
+        if (kind === "join")
+          submittedJoin = true;
+        return await mailbox.append([protocol.sign(kind, data)], { expectedRevision: current.revision });
+      } catch (error) {
+        if (closed)
+          throw cancelled2();
+        if (!String(error.code).endsWith("conflict"))
+          throw error;
+        const delay = Math.min(250, 25 * 2 ** Math.min(attempt, 4)) * (0.5 + Math.random() / 2);
+        await new Promise((resolve) => {
+          const timer = setTimeout(() => {
+            retryWait = null;
+            resolve();
+          }, delay);
+          retryWait = () => {
+            clearTimeout(timer);
+            retryWait = null;
+            resolve();
+          };
+        });
+        if (closed)
+          throw cancelled2();
+        await mailbox.read();
+      }
+    }
+    if (closed)
+      throw cancelled2();
+    throw admissionError("calls/signaling-conflict", "call changed, try again");
+  }
+  async function pulse() {
+    if (closed || departing || !joined)
+      return;
+    try {
+      await event("pulse", { ...audio, media: ownMedia });
+    } catch (error) {
+      fail(error);
+    }
+    if (!closed && !departing)
+      pulseTimer = setTimeout(pulse, 1e4);
+  }
+  async function beginStart(create) {
+    const record = await mailbox.read();
+    if (closed || departing)
+      throw cancelled2();
+    if (!create && !record?.head)
+      throw empty();
+    checkAdmission();
+    if (admissionFailure)
+      throw admissionFailure;
+    const solePredecessor = record?.head?.data.participants.length === 1 && record.head.data.participants[0].actor === admission.actor && record.head.data.participants[0].holder !== localHolder;
+    if (create || solePredecessor) {
+      if (create && record?.head)
+        throw new Error("call already exists");
+      let initialMember = member;
+      let initialAdmission = admission;
+      if (solePredecessor)
+        initialMember = await mls.createMember(fromHexBytes(localHolder));
+      let initial;
+      try {
+        if (closed || departing)
+          throw cancelled2();
+        if (solePredecessor)
+          initialAdmission = protocol.sign("join", {
+            signaturePK: toHex(initialMember.signaturePK),
+            keyPackage: "",
+            replaces: record.head.data.participants[0].holder
+          });
+        initial = await mls.createGroup(initialMember.snapshot, fromHexBytes(callId));
+      } finally {
+        if (solePredecessor)
+          disposeState(initialMember);
+      }
+      if (closed || departing) {
+        disposeState(initial);
+        throw cancelled2();
+      }
+      if (admissionFailure) {
+        disposeState(initial);
+        throw admissionFailure;
+      }
+      pendingInitial = { state: initial, admission: initialAdmission };
+      const initialHead = { epoch: initial.epoch, participants: [initialAdmission] };
+      const packet = solePredecessor ? protocol.sign("replace", { previous: record.head, participant: initialAdmission }) : protocol.sign("pulse", { ...audio, media: null });
+      submittedJoin = true;
+      await mailbox.commit(initialHead, [packet], { expectedRevision: record.revision });
+    } else {
+      const predecessor = head.participants.find((item) => item.actor === admission.actor);
+      predecessorHolder = predecessor?.holder || null;
+      await event("join", { ...admission.data, replaces: predecessor?.holder || null });
+      checkAdmission();
+    }
+  }
+  return Object.freeze({
+    start({ create = false } = {}) {
+      if (startPromise)
+        return startPromise;
+      const admitted = new Promise((resolve, reject) => {
+        admissionResult = { resolve, reject };
+      });
+      admissionTimer = setTimeout(() => settleAdmission(admissionError("calls/admission-timeout", "could not join the call")), CALL_ADMISSION_TIMEOUT_MS);
+      startTask = beginStart(create);
+      startPromise = Promise.race([startTask.then(() => admitted), admitted]).then(() => {
+        if (closed || departing)
+          throw cancelled2();
+        pulseTimer = setTimeout(pulse, 1e4);
+      }).catch((error) => {
+        settleAdmission(error);
+        throw error;
+      });
+      return startPromise;
+    },
+    signal(to, signal) {
+      return event("signal", { to, signal });
+    },
+    async publishMedia(media) {
+      ownMedia = media;
+      await event("pulse", { ...audio, media });
+    },
+    async setAudio(value) {
+      audio = { muted: value.muted === true || value.deafened === true, deafened: value.deafened === true };
+      if (joined && !departing && !closed)
+        await event("pulse", { ...audio, media: ownMedia });
+    },
+    async leave() {
+      if (closed)
+        return { ended: false };
+      departing = true;
+      settleAdmission(cancelled2());
+      clearTimeout(pulseTimer);
+      await startTask?.catch(() => {});
+      if (closed || !joined && !submittedJoin || !mailbox.getSnapshot()?.head)
+        return { ended: false };
+      await event("leave", {});
+      await mailbox.read();
+      return { ended: !!head && head.participants.every((item) => !alive(item.holder)) };
+    },
+    close() {
+      if (closed)
+        return;
+      closed = true;
+      retryWait?.();
+      settleAdmission(cancelled2());
+      clearTimeout(pulseTimer);
+      mailbox.close();
+      disposeState(state);
+      disposeState(member);
+      disposeState(pendingCandidate?.state);
+      disposeState(pendingInitial?.state);
+      pendingJoins.clear();
+      published.clear();
+      seen.clear();
+    }
+  });
+}
+
+// ../../core/calls/activity.js
+var positive = (value) => Number.isFinite(value) && value >= CALL_SPEAKING_THRESHOLD && value <= 1;
+function createCallActivity({ holder, onSpeaking, now = Date.now, setTimer = setTimeout, clearTimer = clearTimeout }) {
+  let closed = false;
+  let timer = null;
+  let local = false;
+  let direct = null;
+  let routes = new Map;
+  let sources = new Map;
+  let published = [];
+  const speaking = new Map;
+  function publish() {
+    const next = [...speaking.keys()].sort();
+    if (published.length === next.length && published.every((value, index) => value === next[index]))
+      return;
+    published = next;
+    onSpeaking?.(next);
+  }
+  function schedule() {
+    clearTimer(timer);
+    timer = null;
+    if (!closed && speaking.size)
+      timer = setTimer(expire, Math.max(0, Math.min(...speaking.values()) - now()));
+  }
+  function expire() {
+    timer = null;
+    if (closed)
+      return;
+    const time = now();
+    for (const [id, deadline] of speaking)
+      if (deadline <= time)
+        speaking.delete(id);
+    publish();
+    schedule();
+  }
+  function update({ peers, received, directPeer, mode, muted, deafened }) {
+    if (closed)
+      return;
+    const admitted = new Map(peers.map((peer) => [peer.holder, peer]));
+    local = admitted.has(holder) && !muted && !deafened;
+    direct = mode === "direct" && directPeer !== holder && admitted.has(directPeer) && !admitted.get(directPeer).muted ? directPeer : null;
+    const nextSources = new Map(local ? [[holder, "local"]] : []);
+    const nextRoutes2 = new Map;
+    const ambiguous = new Set;
+    if (direct)
+      nextSources.set(direct, "direct");
+    if (mode === "group") {
+      for (const [id, mid] of received) {
+        if (id === holder || !admitted.has(id) || admitted.get(id).muted || typeof mid !== "string" || !mid)
+          continue;
+        if (nextRoutes2.has(mid)) {
+          nextSources.delete(nextRoutes2.get(mid));
+          nextRoutes2.delete(mid);
+          ambiguous.add(mid);
+        }
+        if (ambiguous.has(mid))
+          continue;
+        nextRoutes2.set(mid, id);
+        nextSources.set(id, mid);
+      }
+    }
+    const time = now();
+    for (const [id, deadline] of speaking) {
+      if (deadline <= time || !nextSources.has(id) || nextSources.get(id) !== sources.get(id))
+        speaking.delete(id);
+    }
+    routes = nextRoutes2;
+    sources = nextSources;
+    publish();
+    schedule();
+  }
+  function sample(value) {
+    if (closed)
+      return;
+    const time = now();
+    for (const [id, deadline] of speaking)
+      if (deadline <= time)
+        speaking.delete(id);
+    if (local && positive(value.local))
+      speaking.set(holder, time + CALL_SPEAKING_HOLD_MS);
+    for (const item of value.receive) {
+      if (typeof item.mid !== "string" || !item.mid || !positive(item.level))
+        continue;
+      const id = direct || routes.get(item.mid);
+      if (id)
+        speaking.set(id, time + CALL_SPEAKING_HOLD_MS);
+    }
+    publish();
+    schedule();
+  }
+  function reset() {
+    clearTimer(timer);
+    timer = null;
+    speaking.clear();
+    publish();
+  }
+  function close() {
+    if (closed)
+      return;
+    closed = true;
+    reset();
+    local = false;
+    direct = null;
+    routes.clear();
+    sources.clear();
+  }
+  return Object.freeze({ update, sample, reset, close });
+}
+
+// ../../core/calls/media.js
+var sdp = (value) => ({ type: value.type, sdp: value.sdp });
+var validMid = (value) => typeof value === "string" && /^[A-Za-z0-9_-]{1,32}$/u.test(value);
+var MAX_PENDING_SIGNALS = 128;
+var CONNECTION_TIMEOUT_MS = 15000;
+var retiredConnection = new Error("call connection retired");
+function createCallMediaSession({ port, mode, holder, provider, signal, publish, onState, onError, onExpired, onSpeaking }) {
+  let media = null;
+  let closed = false;
+  let deadline = null;
+  let keys = null;
+  let peers = [];
+  let sessionId = null;
+  let started = false;
+  let directPeer = null;
+  let offered = false;
+  let muted = false;
+  let deafened = false;
+  let microphoneVolume = 1;
+  let closing = null;
+  let connectionState = "new";
+  let connectionWait = null;
+  let tail = Promise.resolve();
+  let connectionGeneration = 0;
+  let openingConnection = null;
+  let retiringConnection = Promise.resolve();
+  let iceServers = null;
+  const received = new Map;
+  const peerAudio = new Map;
+  const pendingPeerAudio = new Map;
+  const activity = createCallActivity({ holder, onSpeaking });
+  const updateActivity = () => activity.update({ peers, received, directPeer, mode, muted, deafened });
+  const pendingSignals = [];
+  const incomingSignals = [];
+  function settlePeerAudio(id, error) {
+    const pending = pendingPeerAudio.get(id);
+    if (!pending)
+      return;
+    pendingPeerAudio.delete(id);
+    if (error)
+      pending.reject(error);
+    else
+      pending.resolve();
+  }
+  function current(generation = connectionGeneration) {
+    if (closed)
+      throw new Error("call media closed");
+    if (generation !== connectionGeneration)
+      throw retiredConnection;
+  }
+  async function disposeConnection(previous) {
+    const results = await Promise.allSettled([() => previous?.revoke(), () => previous?.close()].map((operation) => {
+      try {
+        return Promise.resolve(operation());
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    }));
+    const failed = results.find((result) => result.status === "rejected");
+    if (failed)
+      throw failed.reason;
+  }
+  function retireDirectConnection(nextPeer) {
+    connectionGeneration++;
+    const previous = media;
+    media = null;
+    received.clear();
+    directPeer = nextPeer;
+    activity.reset();
+    updateActivity();
+    offered = false;
+    connectionState = "new";
+    pendingSignals.length = 0;
+    const opening = openingConnection;
+    retiringConnection = Promise.all([
+      retiringConnection,
+      disposeConnection(previous),
+      opening?.then(disposeConnection, () => {})
+    ]).then(() => {});
+    retiringConnection.catch(() => {});
+    onState?.({ state: "connecting" });
+  }
+  function settleConnection(error) {
+    if (!connectionWait)
+      return;
+    const wait2 = connectionWait;
+    connectionWait = null;
+    clearTimeout(wait2.timer);
+    if (error)
+      wait2.reject(error);
+    else
+      wait2.resolve();
+  }
+  function connected() {
+    current();
+    if (connectionState === "connected")
+      return Promise.resolve();
+    if (["failed", "closed"].includes(connectionState))
+      return Promise.reject(new Error("call connection failed"));
+    if (!connectionWait) {
+      const wait2 = {};
+      wait2.promise = new Promise((resolve, reject) => {
+        wait2.resolve = resolve;
+        wait2.reject = reject;
+      });
+      wait2.timer = setTimeout(() => settleConnection(new Error("call connection timed out")), CONNECTION_TIMEOUT_MS);
+      connectionWait = wait2;
+    }
+    return connectionWait.promise;
+  }
+  function serialize(work) {
+    const result = tail.then(() => {
+      current();
+      return work();
+    });
+    tail = result.catch((error) => {
+      if (!closed)
+        onError?.(error);
+    });
+    return result;
+  }
+  function close() {
+    if (closed)
+      return closing;
+    closed = true;
+    activity.close();
+    connectionGeneration++;
+    settleConnection(new Error("call media closed"));
+    const previous = media;
+    media = keys = deadline = iceServers = null;
+    received.clear();
+    peerAudio.clear();
+    for (const id of pendingPeerAudio.keys())
+      settlePeerAudio(id, new Error("call media closed"));
+    pendingSignals.length = incomingSignals.length = 0;
+    const operations = [disposeConnection(previous), retiringConnection];
+    closing = Promise.allSettled(operations).then((results) => {
+      const failed = results.find((result) => result.status === "rejected");
+      if (failed)
+        throw failed.reason;
+    });
+    return closing;
+  }
+  async function openConnection() {
+    const generation = connectionGeneration;
+    const live = () => !closed && generation === connectionGeneration;
+    await retiringConnection;
+    current(generation);
+    if (!iceServers) {
+      const configuration = await provider("turn", {});
+      current(generation);
+      iceServers = configuration.iceServers;
+    }
+    const opening = port.open({
+      id: holder,
+      mode,
+      iceServers,
+      onState: (value) => {
+        if (!live())
+          return;
+        connectionState = value.state;
+        if (connectionState === "connected")
+          settleConnection();
+        else if (["failed", "closed"].includes(connectionState))
+          settleConnection(new Error("call connection failed"));
+        onState?.(value);
+      },
+      onExpired: () => {
+        if (live())
+          onExpired?.();
+      },
+      onSignal(value) {
+        if (mode !== "direct" || !live())
+          return;
+        if (directPeer)
+          signal(directPeer, value).catch((error) => {
+            if (live())
+              onError?.(error);
+          });
+        else if (pendingSignals.length < MAX_PENDING_SIGNALS)
+          pendingSignals.push(value);
+        else
+          onError?.(new Error("too many pending media signals"));
+      },
+      onTrack({ mid }) {
+        if (!live())
+          return;
+        if (mode === "direct" && directPeer && validMid(mid))
+          received.set(directPeer, mid);
+        Promise.all([updateKeys(), applyPeerAudio()]).catch((error) => {
+          if (live())
+            onError?.(error);
+        });
+      },
+      onActivity(value) {
+        if (live())
+          activity.sample(value);
+      }
+    });
+    openingConnection = opening;
+    let opened;
+    try {
+      opened = await opening;
+    } finally {
+      if (openingConnection === opening)
+        openingConnection = null;
+    }
+    if (!live()) {
+      await disposeConnection(opened);
+      current(generation);
+    }
+    media = opened;
+    await opened.mute(muted);
+    current(generation);
+    await opened.deafen(deafened);
+    current(generation);
+    if (microphoneVolume !== 1) {
+      await opened.setMicrophoneVolume(microphoneVolume);
+      current(generation);
+    }
+    await opened.prepare();
+    current(generation);
+    if (deadline) {
+      await opened.grant(deadline);
+      current(generation);
+    }
+    await updateKeys();
+    current(generation);
+  }
+  async function applyDescription(result, required = false) {
+    current();
+    if (!result || result.errorCode || result.tracks?.some((track) => track.errorCode))
+      throw new Error("call negotiation failed");
+    const description = result.sessionDescription;
+    if (!description) {
+      if (required || result.requiresImmediateRenegotiation)
+        throw new Error("missing call description");
+      return;
+    }
+    if (!["offer", "answer"].includes(description.type) || typeof description.sdp !== "string" || !description.sdp.length)
+      throw new Error("invalid call description");
+    if (description.type === "offer") {
+      const answer = await media.answer(description);
+      current();
+      await provider("renegotiate", { sessionId, sessionDescription: sdp(answer) });
+      current();
+    } else {
+      await media.remote(description);
+      current();
+    }
+  }
+  async function updateKeys() {
+    if (!media || !keys || mode !== "group")
+      return;
+    const receive = [];
+    for (const peer of peers) {
+      const mid = received.get(peer.holder);
+      const member = keys.members.find((item) => toHex(item.leafId) === peer.holder);
+      if (mid != null && member)
+        receive.push({
+          mid,
+          baseKey: keys.baseKey,
+          epoch: keys.epoch,
+          leafIndex: member.leafIndex,
+          contextId: 0
+        });
+    }
+    await media.setKeys({ send: { baseKey: keys.baseKey, epoch: keys.epoch, leafIndex: keys.leafIndex, contextId: 0 }, receive });
+  }
+  function applyPeerAudio() {
+    return Promise.all([...peerAudio].map(async ([id, entry]) => {
+      const mid = received.get(id);
+      if (!media || mid == null)
+        return;
+      const value = entry.value;
+      try {
+        await media.setPeerAudio({ mid, ...value });
+        settlePeerAudio(id);
+      } catch (error) {
+        if (pendingPeerAudio.has(id))
+          settlePeerAudio(id, error);
+        else
+          throw error;
+      }
+    }));
+  }
+  async function negotiate() {
+    if (!started || !keys)
+      return;
+    if (mode === "group") {
+      if (!sessionId) {
+        const session = await provider("session/new", {});
+        current();
+        sessionId = session.sessionId;
+        const offer = await media.offer();
+        current();
+        const sendMid = media.sendMid;
+        if (!validMid(sendMid))
+          throw new Error("microphone track unavailable");
+        const trackName = toHex(randomBytes3(16));
+        const result = await provider("tracks/new", {
+          sessionId,
+          sessionDescription: sdp(offer),
+          tracks: [{ location: "local", mid: sendMid, trackName }]
+        });
+        current();
+        if (!Array.isArray(result.tracks) || result.tracks.length !== 1 || result.tracks[0].mid !== sendMid || result.tracks[0].trackName !== trackName)
+          throw new Error("microphone publication failed");
+        await applyDescription(result, true);
+        current();
+        await connected();
+        current();
+        await publish({ sessionId, trackName });
+        current();
+      }
+      const additions = peers.filter((peer) => peer.holder !== holder && peer.media?.sessionId && peer.media?.trackName && !received.has(peer.holder));
+      if (additions.length) {
+        await connected();
+        current();
+        const result = await provider("tracks/new", { sessionId, tracks: additions.map((peer) => ({
+          location: "remote",
+          sessionId: peer.media.sessionId,
+          trackName: peer.media.trackName
+        })) });
+        current();
+        if (!Array.isArray(result.tracks) || result.tracks.length !== additions.length)
+          throw new Error("peer audio subscription failed");
+        const mappings = [];
+        const occupied = new Set([media.sendMid, ...received.values()]);
+        for (const peer of additions) {
+          const track = result.tracks?.find((item) => item.sessionId === peer.media.sessionId && item.trackName === peer.media.trackName);
+          if (!validMid(track?.mid) || track.errorCode || occupied.has(track.mid))
+            throw new Error("peer audio subscription failed");
+          occupied.add(track.mid);
+          mappings.push([peer.holder, track.mid]);
+        }
+        for (const [peer, mid] of mappings)
+          received.set(peer, mid);
+        updateActivity();
+        await applyPeerAudio();
+        current();
+        await updateKeys();
+        current();
+        await applyDescription(result);
+      }
+      const removals = [...received].filter(([peer]) => !peers.some((item) => item.holder === peer));
+      if (removals.length) {
+        for (const [peer] of removals)
+          received.delete(peer);
+        updateActivity();
+        await updateKeys();
+        current();
+        const result = await provider("tracks/close", { sessionId, tracks: removals.map(([, mid]) => ({ mid })) });
+        await applyDescription(result);
+      }
+    } else {
+      const peer = peers.find((item) => item.holder !== holder);
+      if (!peer)
+        return;
+      directPeer = peer.holder;
+      updateActivity();
+      const generation = connectionGeneration;
+      try {
+        if (!media)
+          await openConnection();
+        current(generation);
+        if (holder < peer.holder && !offered) {
+          offered = true;
+          const offer = await media.offer();
+          current(generation);
+          await signal(peer.holder, { type: "description", description: sdp(offer) });
+          current(generation);
+        }
+      } catch (error) {
+        if (!closed && generation !== connectionGeneration)
+          return;
+        await close();
+        throw error;
+      }
+    }
+  }
+  return Object.freeze({
+    async open() {
+      current();
+      try {
+        await openConnection();
+        started = true;
+        await serialize(negotiate);
+        for (const [value, from] of incomingSignals.splice(0))
+          await handleSignal(value, from);
+      } catch (error) {
+        await close();
+        throw error;
+      }
+    },
+    grant(value) {
+      current();
+      deadline = value;
+      return media?.grant(value);
+    },
+    async setKeys(value) {
+      current();
+      keys = value;
+      await updateKeys();
+      current();
+      return serialize(negotiate);
+    },
+    async setParticipants(value) {
+      current();
+      peers = value;
+      for (const id of peerAudio.keys())
+        if (!peers.some((peer) => peer.holder === id)) {
+          peerAudio.delete(id);
+          settlePeerAudio(id, new Error("call participant unavailable"));
+        }
+      updateActivity();
+      const nextPeer = peers.find((peer) => peer.holder !== holder)?.holder || null;
+      if (mode === "direct" && started && directPeer && nextPeer !== directPeer)
+        retireDirectConnection(nextPeer);
+      await updateKeys();
+      current();
+      return serialize(negotiate);
+    },
+    signal(value, from) {
+      if (closed)
+        return Promise.reject(new Error("call media closed"));
+      if (!started) {
+        if (incomingSignals.length >= MAX_PENDING_SIGNALS)
+          return Promise.reject(new Error("too many pending media signals"));
+        incomingSignals.push([value, from]);
+        return Promise.resolve();
+      }
+      return handleSignal(value, from);
+    },
+    mute(value) {
+      current();
+      muted = value === true;
+      updateActivity();
+      return media?.mute(muted);
+    },
+    deafen(value) {
+      current();
+      deafened = value === true;
+      updateActivity();
+      return media?.deafen(deafened);
+    },
+    async setMicrophoneVolume(value) {
+      current();
+      const previous = microphoneVolume;
+      microphoneVolume = value;
+      try {
+        if (media)
+          await media.setMicrophoneVolume(value);
+      } catch (error) {
+        if (microphoneVolume === value)
+          microphoneVolume = previous;
+        throw error;
+      }
+    },
+    async setPeerAudio(id, value) {
+      current();
+      const mid = received.get(id);
+      if (id === holder || !peers.some((peer) => peer.holder === id))
+        throw new Error("call participant unavailable");
+      let entry = peerAudio.get(id);
+      if (!entry) {
+        entry = { value: null, applied: null };
+        peerAudio.set(id, entry);
+      }
+      entry.value = value;
+      try {
+        if (media && mid != null)
+          await media.setPeerAudio({ mid, ...value });
+        else {
+          let pending = pendingPeerAudio.get(id);
+          if (!pending) {
+            pending = {};
+            pending.promise = new Promise((resolve, reject) => {
+              pending.resolve = resolve;
+              pending.reject = reject;
+            });
+            pendingPeerAudio.set(id, pending);
+          }
+          await pending.promise;
+        }
+        if (peerAudio.get(id) === entry && entry.value === value)
+          entry.applied = value;
+      } catch (error) {
+        if (peerAudio.get(id) === entry && entry.value === value) {
+          if (entry.applied)
+            entry.value = entry.applied;
+          else
+            peerAudio.delete(id);
+        }
+        throw error;
+      }
+    },
+    close
+  });
+  function handleSignal(value, from) {
+    return serialize(async () => {
+      if (mode !== "direct")
+        throw new Error("unadmitted media signal");
+      if (from === holder || !peers.some((peer) => peer.holder === from))
+        return;
+      const generation = connectionGeneration;
+      try {
+        await negotiate();
+        current(generation);
+        if (value.type === "description") {
+          if (value.description.type === "offer") {
+            if (holder < from)
+              throw new Error("unexpected direct offer");
+            offered = true;
+            const answer = await media.answer(value.description);
+            current(generation);
+            await signal(from, { type: "description", description: sdp(answer) });
+          } else
+            await media.remote(value.description);
+        } else if (value.type === "ice")
+          await media.ice(value.candidate);
+        else
+          throw new Error("invalid media signal");
+        current(generation);
+        for (const pending of pendingSignals.splice(0)) {
+          await signal(from, pending);
+          current(generation);
+        }
+      } catch (error) {
+        if (!closed && generation !== connectionGeneration)
+          return;
+        throw error;
+      }
+    });
+  }
+}
+
+// ../../core/calls/observation.js
+function openCallObservation({ cloud, capability, endpoint, protocol, onChange, onEmpty, onError }) {
+  let verified = null;
+  let identities = new Map;
+  const audio = new Map;
+  const departed = new Set;
+  let last = "";
+  let pending = null;
+  let dirty = false;
+  let closed = false;
+  const mailbox = openCallMailbox({
+    cloud,
+    capability,
+    endpoint,
+    protocol,
+    onError,
+    stream: false,
+    onChange(record) {
+      const head = record.head;
+      const admissions = head?.data?.participants || [];
+      if (head && head !== verified) {
+        if (!Number.isSafeInteger(head.data?.epoch) || head.data.epoch < 0)
+          throw new Error("invalid call observation");
+        const nextIdentities = verifyCallAdmissions(admissions, protocol);
+        if (!admissions.some((item) => item.actor === head.actor && item.holder === head.holder && item.endpoint === head.endpoint)) {
+          throw new Error("unadmitted call head");
+        }
+        identities = nextIdentities;
+      } else if (!head)
+        identities.clear();
+      verified = head;
+      if (record.historyLost) {
+        audio.clear();
+        departed.clear();
+      }
+      const holders = new Set(admissions.map((item) => item.holder));
+      for (const holder of audio.keys())
+        if (!holders.has(holder))
+          audio.delete(holder);
+      for (const holder of departed)
+        if (!holders.has(holder))
+          departed.delete(holder);
+      for (const packet of record.events) {
+        if (!admissions.some((item) => item.holder === packet.holder && item.actor === packet.actor && item.endpoint === packet.endpoint))
+          continue;
+        if (packet.kind === "leave")
+          departed.add(packet.holder);
+        if (packet.kind === "pulse")
+          audio.set(packet.holder, { muted: packet.data.muted === true, deafened: packet.data.deafened === true });
+      }
+      const roster = admissions.filter((item) => !departed.has(item.holder)).map((item) => ({
+        ...identities.get(item.holder),
+        holder: item.holder,
+        muted: audio.get(item.holder)?.muted === true || audio.get(item.holder)?.deafened === true,
+        deafened: audio.get(item.holder)?.deafened === true
+      }));
+      const fingerprint = JSON.stringify(roster);
+      if (fingerprint !== last) {
+        last = fingerprint;
+        onChange(roster);
+      }
+      if (!head || admissions.length && roster.length === 0)
+        onEmpty?.();
+    }
+  });
+  function read() {
+    if (closed)
+      return Promise.resolve();
+    dirty = true;
+    pending ||= (async () => {
+      while (dirty && !closed) {
+        dirty = false;
+        await mailbox.read();
+      }
+    })().finally(() => {
+      pending = null;
+    });
+    return pending;
+  }
+  return Object.freeze({ read, close() {
+    closed = true;
+    mailbox.close();
+  } });
+}
+
+// ../../core/calls/session.js
+var initial = () => ({ phase: "idle", chatId: null, callId: null, joiningChatId: null, mode: null, transport: null, available: null, elsewhere: null, participants: [], speaking: [], peerAudio: {}, muted: false, deafened: false, microphoneVolume: 100, error: null });
+var cancelled2 = () => Object.assign(new Error("call cancelled"), { code: "calls/cancelled" });
+var ended = () => Object.assign(new Error("this call has ended"), { code: "calls/ended" });
+var callError = (chatId, error) => ({ chatId, code: error?.code || "calls/failed", message: error?.message || "could not connect the call" });
+function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
+  const listeners = new Set;
+  const discoveries = new Map;
+  const discoveryReads = new Map;
+  const observers = new Map;
+  const retiring = new Set;
+  let state = initial();
+  const confirmedPeerAudio = new Map;
+  let identity = null;
+  let endpoint = null;
+  let leaseEndpoint = null;
+  let lease = null;
+  let active = null;
+  let focused = null;
+  let generation = 0;
+  let joinIntent = 0;
+  let joining = null;
+  let closed = false;
+  let foreground = true;
+  let online = true;
+  let leaving = Promise.resolve();
+  let drainingSources = Promise.resolve();
+  let closingSession = null;
+  const emit = (patch) => {
+    if (Object.entries(patch).every(([field, value]) => Object.is(state[field], value)))
+      return;
+    if (patch.phase && patch.phase !== state.phase) {
+      diag?.("call.phase", {
+        phase: patch.phase,
+        previous: state.phase,
+        mode: patch.mode || state.mode,
+        participants: (patch.participants || state.participants).length
+      });
+    }
+    state = { ...state, ...patch };
+    for (const listener of listeners)
+      listener();
+  };
+  function announce(chatId, callId, event) {
+    chat.getSnapshot().sendChatMessage(chatId, makeCallMessage(callId, event)).catch((error) => {
+      diag?.("call.message.error", { event, code: error?.code || "" });
+    });
+  }
+  function current(token) {
+    if (closed || !identity || token !== generation)
+      throw cancelled2();
+  }
+  function fail(error) {
+    if (!identity || closed)
+      return;
+    diag?.("call.error", {
+      code: error?.code || "calls/failed",
+      phase: state.phase,
+      mode: state.mode,
+      participants: state.participants.length,
+      message: error?.message || "call failed"
+    });
+    const chatId = active?.chatId || state.chatId;
+    leave();
+    emit({ phase: "error", chatId, error: callError(chatId, error) });
+  }
+  function available() {
+    const entry = discoveries.get(focused);
+    const value = (chatId, current2) => current2?.descriptor ? {
+      chatId,
+      callId: current2.descriptor.callId,
+      startedAt: current2.descriptor.startedAt,
+      participants: current2.descriptor.participants || 1,
+      roster: (active?.discovery === current2 ? active.participants : current2.roster).filter((peer) => ![...retiring].some((call) => call.callId === current2.descriptor.callId && call.endpoint.holder === peer.holder))
+    } : null;
+    for (const observer of observers.values()) {
+      if (!observer.onAvailable)
+        continue;
+      const next2 = value(observer.chatId, discoveries.get(observer.chatId));
+      const fingerprint = JSON.stringify(next2);
+      if (observer.fingerprint === fingerprint)
+        continue;
+      observer.fingerprint = fingerprint;
+      try {
+        observer.onAvailable(next2);
+      } catch {}
+    }
+    const next = value(focused, entry);
+    if (JSON.stringify(next) !== JSON.stringify(state.available))
+      emit({ available: next });
+  }
+  function closeDiscovery(entry) {
+    entry.mailbox.close();
+    entry.observation?.close();
+    entry.observation = null;
+    entry.observedCallId = null;
+  }
+  function observeRoster(entry, refresh = false) {
+    const descriptor = entry.descriptor;
+    const callId = descriptor?.callId;
+    if (!callId || active?.discovery === entry || ![...observers.values()].some((item) => item.chatId === entry.epochState.manifest.chatId)) {
+      entry.observation?.close();
+      entry.observation = null;
+      entry.observedCallId = null;
+      return;
+    }
+    if (entry.observedCallId === callId) {
+      if (refresh)
+        entry.observation.read().catch((error) => diag?.("call.discovery.error", { code: error?.code || "calls/roster" }));
+      return;
+    }
+    entry.observation?.close();
+    entry.roster = [];
+    entry.observedCallId = callId;
+    const token = generation;
+    const protocol = createCallProtocol({ realm: cloud.environment, epochState: entry.epochState, identity, endpoint, callId });
+    const secret = fromHexBytes(descriptor.secret);
+    const capability = createCallCapability(secret, cloud.environment, "signaling", [callId]);
+    cleanBytes(secret);
+    entry.observation = openCallObservation({
+      cloud,
+      capability,
+      endpoint,
+      protocol,
+      onChange(roster) {
+        if (generation !== token || entry.observedCallId !== callId || discoveries.get(entry.epochState.manifest.chatId) !== entry)
+          return;
+        entry.roster = roster;
+        available();
+      },
+      onError(error) {
+        if (generation === token)
+          diag?.("call.discovery.error", { code: error?.code || "calls/roster" });
+      },
+      onEmpty() {
+        if (generation === token && entry.observedCallId === callId)
+          finishDiscovery(entry, descriptor);
+      }
+    });
+    entry.observation.read().catch(() => {});
+  }
+  function prune() {
+    for (const [chatId, value] of discoveries) {
+      if (![...observers.values()].some((item) => item.chatId === chatId) && chatId !== active?.chatId && chatId !== joining?.chatId && ![...retiring].some((call) => call.chatId === chatId)) {
+        closeDiscovery(value);
+        discoveries.delete(chatId);
+      } else
+        observeRoster(value);
+    }
+  }
+  function discovery(chatId, epochState) {
+    const token = generation;
+    const existing = discoveries.get(chatId);
+    if (existing?.epochState.manifest.epochId === epochState.manifest.epochId)
+      return existing;
+    if (existing)
+      closeDiscovery(existing);
+    const protocol = createCallProtocol({ realm: cloud.environment, epochState, identity, endpoint });
+    const entry = {
+      epochState,
+      protocol,
+      descriptor: null,
+      mailbox: null,
+      observation: null,
+      observedCallId: null,
+      roster: [],
+      revision: null,
+      expiredCallId: null,
+      finishing: new Map
+    };
+    entry.mailbox = openCallMailbox({
+      cloud,
+      capability: createCallDiscovery(epochState, cloud.environment),
+      endpoint,
+      protocol,
+      onChange(record) {
+        if (token !== generation || discoveries.get(chatId) !== entry)
+          return;
+        const descriptor = record.head?.data || null;
+        if (descriptor && (!/^[a-f0-9]{64}$/u.test(descriptor.callId) || !/^[a-f0-9]{64}$/u.test(descriptor.secret) || descriptor.mode !== epochState.manifest.lineage || !Number.isSafeInteger(descriptor.startedAt) || descriptor.startedAt < 0 || descriptor.startedAt > Date.now() + 5000))
+          throw new Error("invalid call discovery");
+        const previous = entry.descriptor;
+        entry.expiredCallId = !record.head ? previous?.callId || entry.expiredCallId : null;
+        entry.descriptor = descriptor;
+        if (!record.head && previous)
+          finishDiscovery(entry, previous);
+        const changed = entry.revision !== record.revision;
+        entry.revision = record.revision;
+        if (active?.discovery === entry && active.published && descriptor?.callId !== active.callId) {
+          leave();
+        }
+        observeRoster(entry, changed);
+        available();
+      },
+      onError(error) {
+        if (token !== generation || discoveries.get(chatId) !== entry)
+          return;
+        diag?.("call.discovery.error", { code: error?.code || "calls/discovery" });
+      }
+    });
+    discoveries.set(chatId, entry);
+    return entry;
+  }
+  function readDiscovery(chatId, preparedEpoch) {
+    const epochState = preparedEpoch || chat.getSnapshot().getOwnerChat(chatId)?.epochState;
+    const epochId = epochState?.manifest.epochId;
+    const pending = discoveryReads.get(chatId);
+    if (pending && pending.epochId === epochId)
+      return pending.promise;
+    const slot = { epochId, promise: null };
+    const token = generation;
+    const reading = Promise.resolve().then(async () => {
+      current(token);
+      if (!online)
+        throw Object.assign(new Error("chat unavailable"), { code: "unavailable" });
+      if (!epochState)
+        throw Object.assign(new Error("chat unavailable"), { code: "calls/chat-not-ready" });
+      const entry = discovery(chatId, epochState);
+      await entry.mailbox.read();
+      current(token);
+      return entry;
+    }).finally(() => {
+      if (discoveryReads.get(chatId) === slot)
+        discoveryReads.delete(chatId);
+      prune();
+    });
+    slot.promise = reading;
+    discoveryReads.set(chatId, slot);
+    return reading;
+  }
+  function observe(chatId, onAvailable) {
+    if (!chatId || closed)
+      return () => {};
+    const observer = { chatId, onAvailable, fingerprint: undefined };
+    observers.set(observer, observer);
+    focused = chatId;
+    if (state.error?.chatId === chatId)
+      emit({ error: null });
+    available();
+    const entry = discoveries.get(chatId);
+    if (entry)
+      observeRoster(entry);
+    else if (identity && online)
+      readDiscovery(chatId).catch((error) => diag?.("call.discovery.error", { stage: "prepare", code: error?.code || "calls/admission" }));
+    return () => {
+      if (!observers.delete(observer))
+        return;
+      focused = [...observers.values()].at(-1)?.chatId || null;
+      available();
+      prune();
+    };
+  }
+  async function joinAttempt(chatId, intent, expectedCallId, onlyExisting) {
+    if (!identity || !mediaPort || !mls || !cloud.calls)
+      throw new Error("calling unavailable");
+    if (!foreground)
+      throw new Error("open veyl to join a call");
+    if (active?.chatId === chatId)
+      return chatId;
+    const token = generation;
+    const startedAt = Date.now();
+    const step = (stage) => diag?.("call.join.stage", { stage, elapsedMs: Date.now() - startedAt });
+    const check = () => {
+      current(token);
+      if (intent !== joinIntent || !foreground)
+        throw cancelled2();
+    };
+    emit({ ...!active ? { phase: "joining", chatId } : {}, error: null });
+    await mediaPort.prepare?.();
+    check();
+    step("permission");
+    if (!onlyExisting)
+      chatId = await chat.getSnapshot().materializeChat(chatId);
+    check();
+    joining.chatId = chatId;
+    step("chat");
+    let call;
+    try {
+      const epochState = await chat.getSnapshot().prepareCall(chatId);
+      check();
+      const entry = await readDiscovery(chatId, epochState);
+      check();
+      const discoveryRecord = entry.mailbox.getSnapshot();
+      step("discovery");
+      const create = !entry.descriptor;
+      if (expectedCallId && (onlyExisting || entry.epochState.manifest.lineage === "direct") && entry.descriptor?.callId !== expectedCallId)
+        throw ended();
+      const descriptor = entry.descriptor || {
+        callId: toHex(randomBytes3(32)),
+        secret: toHex(randomBytes3(32)),
+        mode: entry.epochState.manifest.lineage,
+        participants: 1,
+        startedAt: Date.now()
+      };
+      const callEndpoint = createCallEndpoint();
+      call = {
+        chatId,
+        callId: descriptor.callId,
+        discovery: entry,
+        descriptor,
+        endpoint: callEndpoint,
+        published: false,
+        room: null,
+        member: null,
+        media: null,
+        owner: null,
+        participants: [],
+        error: null,
+        timer: null,
+        joinTimer: null,
+        mediaReady: false,
+        leaving: false,
+        muteTail: Promise.resolve()
+      };
+      joining.candidate = call;
+      const protocol = createCallProtocol({ realm: cloud.environment, epochState: entry.epochState, identity, endpoint: callEndpoint, callId: descriptor.callId });
+      call.protocol = protocol;
+      const ownMember = (value) => {
+        try {
+          check();
+          if (call.leaving)
+            throw cancelled2();
+        } catch (error) {
+          cleanBytes(value.snapshot);
+          throw error;
+        }
+        call.member = value;
+        return value;
+      };
+      const callMember = ownMember(await mls.createMember(fromHexBytes(callEndpoint.holder)));
+      const member = create ? callMember : ownMember(await mls.createKeyPackage(callMember.snapshot));
+      if (!create)
+        cleanBytes(callMember.snapshot);
+      check();
+      const admission = protocol.sign("join", { keyPackage: member.keyPackage ? encodeCallBytes(member.keyPackage) : "", signaturePK: toHex(member.signaturePK) });
+      const secret = fromHexBytes(descriptor.secret);
+      const capability = createCallCapability(secret, cloud.environment, "signaling", [descriptor.callId]);
+      cleanBytes(secret);
+      const valid = () => token === generation && active === call && !call.leaving;
+      const preparing = () => token === generation && intent === joinIntent && !call.leaving;
+      const checkCall = () => {
+        check();
+        if (call.leaving)
+          throw cancelled2();
+        if (call.error)
+          throw call.error;
+      };
+      const connectionProgress = () => {
+        if (!valid() || state.phase === "connected")
+          return;
+        if (call.mediaReady && descriptor.mode === "direct" && state.participants.length < 2) {
+          clearTimeout(call.joinTimer);
+          call.joinTimer = null;
+          emit({ phase: "waiting" });
+        } else {
+          emit({ phase: "connecting" });
+          if (!call.joinTimer)
+            call.joinTimer = setTimeout(() => {
+              if (valid())
+                fail(new Error("call did not connect"));
+            }, 30000);
+        }
+      };
+      call.media = createCallMediaSession({
+        port: mediaPort,
+        mode: descriptor.mode,
+        holder: callEndpoint.holder,
+        provider: (...args) => call.owner.provider(...args),
+        signal: (...args) => call.room.signal(...args),
+        publish: (value) => call.room.publishMedia(value),
+        onState(value) {
+          if (!valid())
+            return;
+          diag?.("call.media.state", {
+            state: value.state,
+            reason: value.reason || "",
+            mode: descriptor.mode,
+            transport: value.transport || "",
+            participants: call.participants.length
+          });
+          if (value.state === "connected") {
+            clearTimeout(call.joinTimer);
+            call.joinTimer = null;
+            emit({ phase: "connected", transport: value.transport || (descriptor.mode === "group" ? "relay" : null) });
+          } else if (value.state === "connecting") {
+            emit({ phase: "connecting" });
+            connectionProgress();
+          } else if (["failed", "closed"].includes(value.state))
+            fail(Object.assign(new Error("call connection ended"), { code: "calls/media-ended" }));
+        },
+        onExpired() {
+          if (valid())
+            fail(new Error("call connection lost"));
+        },
+        onSpeaking(speaking) {
+          if (valid())
+            emit({ speaking });
+        },
+        onError(error) {
+          if (valid())
+            fail(error);
+          else
+            call.error = error;
+        }
+      });
+      call.room = openCallRoom({
+        cloud,
+        capability,
+        protocol,
+        endpoint: callEndpoint,
+        mls,
+        member,
+        admission,
+        callId: descriptor.callId,
+        onKeys(value) {
+          if (!valid() && !preparing())
+            return;
+          call.media.setKeys(value).catch((error) => {
+            if (valid())
+              fail(error);
+            else
+              call.error = error;
+          });
+        },
+        onParticipants(value) {
+          if (!valid() && !preparing())
+            return;
+          call.participants = value;
+          call.media.setParticipants(value).catch((error) => {
+            if (valid())
+              fail(error);
+            else
+              call.error = error;
+          });
+          if (!valid())
+            return;
+          for (const peer of value) {
+            const preference = state.peerAudio[peer.chatPK];
+            if (preference)
+              call.media.setPeerAudio(peer.holder, { volume: preference.volume / 100, muted: preference.muted }).catch((error) => diag?.("call.peer.audio.error", { code: error?.code || "calls/audio" }));
+          }
+          emit({ participants: value });
+          available();
+          call.refresh?.();
+          if (call.mediaReady)
+            connectionProgress();
+        },
+        onSignal: (value, from) => valid() || preparing() ? call.media.signal(value, from) : undefined,
+        onRemoved() {
+          if (valid())
+            leave();
+          else
+            call.error = cancelled2();
+        },
+        onError(error) {
+          if (valid())
+            fail(error);
+          else
+            call.error = error;
+        }
+      });
+      await applyAudio(call);
+      checkCall();
+      await call.media.setMicrophoneVolume(state.microphoneVolume / 100);
+      checkCall();
+      await call.room.start({ create });
+      checkCall();
+      step("admission");
+      if (create) {
+        try {
+          await entry.mailbox.commit(descriptor, [], { expectedRevision: discoveryRecord.revision });
+        } catch (error) {
+          if (error?.code === "calls/conflict")
+            throw Object.assign(new Error("another call started"), { code: "calls/discovery-conflict" });
+          throw error;
+        }
+        checkCall();
+        announce(chatId, descriptor.callId, "started");
+      } else {
+        await entry.mailbox.read();
+        checkCall();
+        if (entry.descriptor?.callId !== descriptor.callId) {
+          if (expectedCallId && (onlyExisting || descriptor.mode === "direct"))
+            throw ended();
+          throw Object.assign(new Error("the call room changed"), { code: "calls/discovery-conflict" });
+        }
+      }
+      call.published = true;
+      await stopCall();
+      checkCall();
+      mountLease(identity, callEndpoint);
+      call.owner = lease;
+      active = call;
+      observeRoster(entry);
+      available();
+      emit({
+        phase: state.elsewhere ? "transferring" : "joining",
+        chatId,
+        callId: descriptor.callId,
+        mode: descriptor.mode,
+        error: null,
+        speaking: [],
+        participants: call.participants
+      });
+      for (const peer of call.participants) {
+        const preference = state.peerAudio[peer.chatPK];
+        if (preference)
+          call.media.setPeerAudio(peer.holder, { volume: preference.volume / 100, muted: preference.muted }).catch((error) => diag?.("call.peer.audio.error", { code: error?.code || "calls/audio" }));
+      }
+      await lease.acquire({ chatId, callId: descriptor.callId });
+      check();
+      step("ownership");
+      if (!valid())
+        throw cancelled2();
+      connectionProgress();
+      await call.media.open();
+      check();
+      step("media");
+      call.mediaReady = true;
+      connectionProgress();
+      let publishedRoster = "";
+      let refreshing = null;
+      let requested = false;
+      const rosterFingerprint = () => JSON.stringify(call.participants.map(({ holder, muted, deafened }) => ({ holder, muted, deafened })).sort((a, b) => a.holder.localeCompare(b.holder)));
+      const refresh = (heartbeat = false) => {
+        if (!valid() || !heartbeat && publishedRoster === rosterFingerprint())
+          return;
+        requested = true;
+        if (refreshing)
+          return;
+        clearTimeout(call.timer);
+        refreshing = (async () => {
+          while (requested && valid()) {
+            requested = false;
+            const fingerprint = rosterFingerprint();
+            const ordered = call.participants.map((item) => item.holder).sort();
+            if (ordered[0] === callEndpoint.holder) {
+              const snapshot = await entry.mailbox.read();
+              if (valid() && entry.descriptor?.callId === descriptor.callId) {
+                await entry.mailbox.commit({ ...descriptor, participants: call.participants.length }, [], { expectedRevision: snapshot.revision });
+              }
+            }
+            publishedRoster = fingerprint;
+          }
+        })().catch((error) => {
+          if (valid() && error?.code !== "calls/conflict")
+            fail(error);
+        }).finally(() => {
+          refreshing = null;
+          if (valid())
+            call.timer = setTimeout(() => refresh(true), 30000);
+        });
+      };
+      call.refresh = refresh;
+      refresh(true);
+      return chatId;
+    } catch (error) {
+      const cleanup = active === call ? stopCall() : call ? disposeCall(call) : null;
+      if (["calls/room-empty", "calls/discovery-conflict"].includes(error?.code))
+        await cleanup;
+      if (error?.code === "calls/room-empty" && call) {
+        check();
+        if (expectedCallId && (onlyExisting || call.descriptor.mode === "direct"))
+          throw ended();
+        await retireDiscovery(call);
+        check();
+        throw Object.assign(new Error("the call room is restarting"), { code: "calls/discovery-conflict" });
+      }
+      throw error;
+    }
+  }
+  async function join(chatId, expectedCallId = null, onlyExisting = false) {
+    if (active?.chatId === chatId) {
+      if (expectedCallId && (onlyExisting || active.descriptor.mode === "direct") && active.callId !== expectedCallId)
+        throw ended();
+      return chatId;
+    }
+    const intent = ++joinIntent;
+    const operation = { predecessor: active, chatId, candidate: null };
+    const previous = joining;
+    joining = operation;
+    emit({ joiningChatId: chatId });
+    if (previous?.candidate && previous.candidate !== active)
+      disposeCall(previous.candidate);
+    try {
+      for (let attempt = 0;attempt < 3; attempt += 1) {
+        try {
+          return await joinAttempt(chatId, intent, expectedCallId, onlyExisting);
+        } catch (error) {
+          if (intent !== joinIntent || !identity || closed)
+            throw cancelled2();
+          if (error?.code !== "calls/discovery-conflict" || attempt === 2) {
+            const target = operation.chatId;
+            emit({ ...!active ? { phase: "error", chatId: target } : {}, error: callError(chatId, error) });
+            throw error;
+          }
+        }
+      }
+    } finally {
+      if (joining === operation) {
+        joining = null;
+        emit({ joiningChatId: null });
+      }
+      prune();
+    }
+  }
+  function leave() {
+    joinIntent += 1;
+    const candidate = joining?.candidate;
+    joining = null;
+    emit({ joiningChatId: null });
+    const pending = candidate && candidate !== active ? disposeCall(candidate) : null;
+    const stopped = stopCall();
+    return Promise.all([pending, stopped, ...[...retiring].map((call) => call.closing)]).then(() => {
+      return;
+    });
+  }
+  function cancelJoin() {
+    const operation = joining;
+    if (!operation)
+      return Promise.resolve();
+    joinIntent += 1;
+    joining = null;
+    emit({ joiningChatId: null });
+    const pending = operation.candidate && operation.candidate !== active ? disposeCall(operation.candidate) : null;
+    return Promise.all([pending, active && active === operation.predecessor ? null : stopCall()]).then(() => {
+      return;
+    });
+  }
+  function stopCall() {
+    const call = active;
+    if (!call) {
+      emit({ phase: "idle", chatId: null, callId: null, mode: null, transport: null, participants: [], speaking: [] });
+      return leaving;
+    }
+    active = null;
+    leaving = disposeCall(call);
+    if (identity && discoveries.get(call.chatId) === call.discovery)
+      observeRoster(call.discovery);
+    available();
+    emit({ phase: "idle", chatId: null, callId: null, mode: null, transport: null, participants: [], speaking: [] });
+    return leaving;
+  }
+  async function retireDiscovery(call) {
+    const entry = call.discovery;
+    const snapshot = await entry.mailbox.read();
+    if (snapshot.head?.data?.callId !== call.callId && !(snapshot.head === null && entry.expiredCallId === call.callId))
+      return;
+    try {
+      await entry.mailbox.commit(null, [], { expectedRevision: snapshot.revision });
+      announce(call.chatId, call.callId, "ended");
+    } catch (error) {
+      if (error?.code !== "calls/conflict")
+        throw error;
+    }
+  }
+  function finishDiscovery(entry, descriptor) {
+    if (entry.finishing.has(descriptor.callId))
+      return;
+    const finishing = retireDiscovery({ discovery: entry, callId: descriptor.callId, chatId: entry.epochState.manifest.chatId }).catch((error) => diag?.("call.close.error", { code: error?.code || "calls/discovery" })).finally(() => entry.finishing.delete(descriptor.callId));
+    entry.finishing.set(descriptor.callId, finishing);
+  }
+  function disposeCall(call) {
+    if (call.closing)
+      return call.closing;
+    call.leaving = true;
+    retiring.add(call);
+    clearTimeout(call.timer);
+    clearTimeout(call.joinTimer);
+    const stopping = call.media?.close();
+    call.owner?.retire();
+    const departing = call.room?.leave();
+    const draining = (async () => {
+      try {
+        const [, departure] = await Promise.allSettled([Promise.resolve(stopping).then(() => call.owner?.release()), departing]);
+        if (departure.status === "fulfilled" && departure.value?.ended && call.published && call.discovery.descriptor?.callId === call.callId) {
+          await retireDiscovery(call);
+        }
+      } catch (error) {
+        diag?.("call.close.error", { code: error?.code || "" });
+      }
+    })();
+    let expiry;
+    const expired = new Promise((resolve) => {
+      expiry = setTimeout(() => {
+        diag?.("call.close.error", { code: "calls/retirement-timeout" });
+        resolve();
+      }, CALL_OWNERSHIP_LEASE_MS);
+    });
+    call.closing = Promise.race([draining, expired]).finally(() => {
+      clearTimeout(expiry);
+      call.room?.close();
+      call.protocol?.close();
+      cleanBytes(call.member?.snapshot);
+      if (call.endpoint !== leaseEndpoint)
+        call.endpoint.close();
+      retiring.delete(call);
+      prune();
+    });
+    return call.closing;
+  }
+  function applyAudio(call) {
+    const audio = { muted: state.muted || state.deafened, deafened: state.deafened };
+    const applied = Promise.all([call.media.mute(audio.muted), call.media.deafen(audio.deafened)]);
+    const result = Promise.all([applied, call.muteTail]).then(() => {
+      if (!call.leaving)
+        return call.room.setAudio(audio);
+    });
+    call.muteTail = result.catch(() => {});
+    return result;
+  }
+  async function setAudio(patch) {
+    emit(patch);
+    const calls = new Set([active, joining?.candidate].filter((call) => call?.media && call.room && !call.leaving));
+    await Promise.all([...calls].map((call) => applyAudio(call).catch((error) => {
+      if (active === call)
+        fail(error);
+      else if (!call.leaving)
+        call.error = error;
+      throw error;
+    })));
+  }
+  async function setPeerAudio(chatPK, patch) {
+    const call = active;
+    if (!identity || typeof chatPK !== "string" || !chatPK || chatPK === identity.chatPK)
+      throw new Error("peer identity required");
+    const token = generation;
+    const peer = call?.participants.find((peer2) => peer2.chatPK === chatPK);
+    const previous = state.peerAudio[chatPK];
+    const value = { volume: 100, muted: false, ...previous, ...patch };
+    emit({ peerAudio: { ...state.peerAudio, [chatPK]: value } });
+    try {
+      if (peer)
+        await call.media.setPeerAudio(peer.holder, { volume: value.volume / 100, muted: value.muted });
+      if (generation === token && state.peerAudio[chatPK] === value)
+        confirmedPeerAudio.set(chatPK, value);
+    } catch (error) {
+      if (generation === token && state.peerAudio[chatPK] === value) {
+        const peerAudio = { ...state.peerAudio };
+        const confirmed = confirmedPeerAudio.get(chatPK);
+        if (confirmed)
+          peerAudio[chatPK] = confirmed;
+        else
+          delete peerAudio[chatPK];
+        emit({ peerAudio });
+      }
+      throw error;
+    }
+  }
+  async function setMicrophoneVolume(volume) {
+    if (!Number.isFinite(volume) || volume < 1 || volume > 200)
+      throw new Error("microphone volume must be between 1 and 200");
+    const previous = state.microphoneVolume;
+    const token = generation;
+    emit({ microphoneVolume: volume });
+    const calls = new Set([active, joining?.candidate].filter((call) => call?.media && !call.leaving));
+    try {
+      await Promise.all([...calls].map((call) => call.media.setMicrophoneVolume(volume / 100)));
+    } catch (error) {
+      if (generation === token && state.microphoneVolume === volume)
+        emit({ microphoneVolume: previous });
+      throw error;
+    }
+  }
+  function mountLease(session, callEndpoint = endpoint) {
+    lease?.close();
+    if (leaseEndpoint && leaseEndpoint !== endpoint && leaseEndpoint !== callEndpoint)
+      leaseEndpoint.close();
+    leaseEndpoint = callEndpoint;
+    const ownsLease = () => identity === session && leaseEndpoint === callEndpoint;
+    lease = openAccountCallLease({
+      cloud,
+      capability: session.callIdentity,
+      endpoint: callEndpoint,
+      clock: mediaPort.clock,
+      onRecord(record, descriptor) {
+        if (!ownsLease())
+          return;
+        const holder = (record.pending || record.active)?.holder;
+        const elsewhere = descriptor && holder !== callEndpoint.holder ? descriptor : null;
+        if (elsewhere && state.elsewhere?.chatId === elsewhere.chatId && state.elsewhere.callId === elsewhere.callId)
+          return;
+        emit({ elsewhere });
+      },
+      onGrant: (value) => ownsLease() && active?.endpoint === callEndpoint ? active.media?.grant(value) : undefined,
+      onLost: () => {
+        if (ownsLease())
+          leave();
+      },
+      onError(error) {
+        if (ownsLease() && active)
+          fail(error);
+      }
+    });
+  }
+  function setSources(session) {
+    if (identity === session)
+      return drainingSources;
+    const token = ++generation;
+    const previousLease = lease;
+    const previousEndpoint = endpoint;
+    const previousLeaseEndpoint = leaseEndpoint;
+    const previousDiscoveries = [...discoveries.values()];
+    let finishDrain, rejectDrain;
+    const drained = new Promise((resolve, reject) => {
+      finishDrain = resolve;
+      rejectDrain = reject;
+    });
+    const retirement = Promise.all([drainingSources, drained]).then(() => {
+      return;
+    });
+    drainingSources = retirement;
+    lease = null;
+    leaseEndpoint = null;
+    endpoint = null;
+    discoveries.clear();
+    discoveryReads.clear();
+    identity = session;
+    const stopped = leave();
+    Promise.resolve(stopped).finally(() => {
+      previousLease?.close();
+      previousLeaseEndpoint?.close();
+      previousEndpoint?.close();
+      for (const entry of previousDiscoveries)
+        closeDiscovery(entry);
+    }).then(finishDrain, rejectDrain);
+    if (generation !== token || identity !== session)
+      return retirement;
+    confirmedPeerAudio.clear();
+    emit(initial());
+    available();
+    if (generation !== token || identity !== session)
+      return retirement;
+    if (!session || closed || !mediaPort || !mls || !cloud.calls)
+      return retirement;
+    endpoint = createCallEndpoint();
+    mountLease(session);
+    if (online)
+      refreshObserved();
+    return retirement;
+  }
+  function refreshObserved() {
+    for (const chatId of new Set([...observers.values()].map((item) => item.chatId))) {
+      readDiscovery(chatId).catch((error) => diag?.("call.discovery.error", { stage: "prepare", code: error?.code || "calls/admission" }));
+    }
+  }
+  const unsubscribe = chat.subscribe(() => {
+    if (!identity)
+      return;
+    for (const [chatId, entry] of discoveries) {
+      const epoch = chat.getSnapshot().getOwnerChat(chatId)?.epochState?.manifest.epochId;
+      if (epoch === entry.epochState.manifest.epochId)
+        continue;
+      if (active?.chatId === chatId)
+        leave();
+      else if (joining?.chatId === chatId)
+        cancelJoin();
+      closeDiscovery(entry);
+      discoveries.delete(chatId);
+      available();
+      if (online && [...observers.values()].some((item) => item.chatId === chatId))
+        readDiscovery(chatId).catch(() => {});
+    }
+    if (online)
+      for (const chatId of new Set([...observers.values()].map((item) => item.chatId))) {
+        if (!discoveries.has(chatId) && !discoveryReads.has(chatId) && chat.getSnapshot().getOwnerChat(chatId)?.epochState) {
+          readDiscovery(chatId).catch((error) => diag?.("call.discovery.error", { stage: "prepare", code: error?.code || "calls/admission" }));
+        }
+      }
+  });
+  return Object.freeze({
+    getSnapshot: () => state,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    setSources,
+    observe,
+    join,
+    leave,
+    cancelJoin,
+    setMicrophoneVolume,
+    async resolveActiveCall(chatId) {
+      const entry = await readDiscovery(chatId);
+      return entry.descriptor?.callId || null;
+    },
+    joinFromMessage(chatId, callId) {
+      if (!/^[a-f0-9]{64}$/u.test(callId))
+        return Promise.reject(ended());
+      return join(chatId, callId);
+    },
+    joinExisting(chatId, callId) {
+      if (!/^[a-f0-9]{64}$/u.test(callId))
+        return Promise.reject(ended());
+      return join(chatId, callId, true);
+    },
+    setMuted(value) {
+      return setAudio({ muted: value === true });
+    },
+    setDeafened(value) {
+      return setAudio({ deafened: value === true });
+    },
+    setPeerVolume(chatPK, volume) {
+      if (!Number.isFinite(volume) || volume < 1 || volume > 200)
+        return Promise.reject(new Error("peer volume must be between 1 and 200"));
+      return setPeerAudio(chatPK, { volume });
+    },
+    setPeerMuted(chatPK, muted) {
+      return setPeerAudio(chatPK, { muted: muted === true });
+    },
+    setForeground(value) {
+      foreground = value === true;
+      if (!foreground && joining)
+        cancelJoin();
+    },
+    setOnline(value) {
+      const reconnecting = !online && value === true;
+      online = value === true;
+      if (reconnecting && identity && !closed)
+        refreshObserved();
+    },
+    close() {
+      if (closed)
+        return closingSession;
+      let finish, reject;
+      closingSession = new Promise((resolve, fail2) => {
+        finish = resolve;
+        reject = fail2;
+      });
+      closed = true;
+      const stopped = setSources(null);
+      unsubscribe();
+      listeners.clear();
+      Promise.resolve(stopped).finally(() => Promise.all([mls?.close?.(), mediaPort?.close?.()])).then(finish, reject);
+      return closingSession;
+    }
+  });
+}
+
 // ../../node_modules/.bun/@zxcvbn-ts+core@4.2.0/node_modules/@zxcvbn-ts/core/dist/utils/helper.mjs
 var extend = (listToExtend, list) => listToExtend.push.apply(listToExtend, list);
 var sorted = (matches) => matches.sort((m1, m2) => m1.i - m2.i || m1.j - m2.j);
@@ -49657,11 +52659,11 @@ function createPeersApi({ cloud, network, avatarCache = null }) {
       return null;
     }
   }
-  async function writeCachedAvatar(uid, version, bytes) {
-    if (!uid || version == null || !bytes || typeof avatarCache?.write !== "function")
+  async function writeCachedAvatar(uid, version, bytes2) {
+    if (!uid || version == null || !bytes2 || typeof avatarCache?.write !== "function")
       return null;
     try {
-      const cached = await avatarCache.write(uid, { version, bytes });
+      const cached = await avatarCache.write(uid, { version, bytes: bytes2 });
       return typeof cached === "string" && cached ? cached : typeof cached?.url === "string" && cached.url ? cached.url : typeof cached?.source === "string" && cached.source ? cached.source : null;
     } catch {
       return null;
@@ -49675,8 +52677,8 @@ function createPeersApi({ cloud, network, avatarCache = null }) {
     }
     if (avatarVersion != null && typeof cloud.peer.avatar.read === "function") {
       try {
-        const bytes = await cloud.peer.avatar.read(uid, { version: avatarVersion });
-        const cachedSource = await writeCachedAvatar(uid, avatarVersion, bytes);
+        const bytes2 = await cloud.peer.avatar.read(uid, { version: avatarVersion });
+        const cachedSource = await writeCachedAvatar(uid, avatarVersion, bytes2);
         if (cachedSource) {
           return cachedSource;
         }
@@ -55084,12 +58086,12 @@ function createWalletTransferSession({ wallet, walletPK, claimIncomingTransfers,
       reason,
       active: sdkActivityCountRef.current
     });
-    let ended = false;
+    let ended2 = false;
     return () => {
-      if (ended) {
+      if (ended2) {
         return;
       }
-      ended = true;
+      ended2 = true;
       sdkActivityCountRef.current = Math.max(0, sdkActivityCountRef.current - 1);
       sdkActivityQuietUntilRef.current = Math.max(sdkActivityQuietUntilRef.current, Date.now() + SDK_BACKGROUND_QUIET_MS);
       markDiag(diag, "wallet.sdkActivity.done", {
@@ -57304,8 +60306,10 @@ function openAccount(options = {}) {
     getPeerProfile: getChatPeerProfile,
     refreshPeerProfile: refreshChatPeerProfile,
     resolvePeerProfile: resolveChatPeerProfile,
-    maintenance: messageMaintenance
+    maintenance: messageMaintenance,
+    resolveActiveCall: (chatId) => calls.resolveActiveCall(chatId)
   }, chatSources());
+  const calls = createCallSession({ cloud, chat, ...options.calls, diag });
   const wallet = openWallet({
     ...options.wallet || {},
     network: state.network,
@@ -57378,6 +60382,8 @@ function openAccount(options = {}) {
     syncWallet();
     syncPresence();
     syncPeers();
+    calls.setOnline(state.online);
+    calls.setSources(state.lockState === "unlocked" ? state.session : null);
   }
   function syncPresence() {
     const session = state.session;
@@ -57413,7 +60419,7 @@ function openAccount(options = {}) {
       connected: !closed && state.internetAvailable !== false && state.cloudAvailable !== false && state.user.authSessionReady && state.user.authSessionActive && !state.user.authSessionError && state.user.profileReady && !state.user.profileFromCache && !state.user.profileError
     }),
     preview: (value) => user.previewAvatar(value),
-    write: (uid, bytes) => cloud.user.profile.avatar.set(uid, bytes),
+    write: (uid, bytes2) => cloud.user.profile.avatar.set(uid, bytes2),
     commit: (change) => user.confirmAvatar(change),
     onError: (error) => diag?.("account.avatar.update.error", { code: error?.code || "" })
   });
@@ -57427,11 +60433,11 @@ function openAccount(options = {}) {
       await cloud.user.username.get(username);
       return { username };
     },
-    async setAvatar(bytes) {
+    async setAvatar(bytes2) {
       profileUid();
-      if (!bytes)
+      if (!bytes2)
         throw new Error("avatar data required");
-      return avatarUpdate.set(sanitizeAvatar(bytes));
+      return avatarUpdate.set(sanitizeAvatar(bytes2));
     },
     async clearAvatar() {
       profileUid();
@@ -57562,13 +60568,32 @@ function openAccount(options = {}) {
       return;
     foreground = value === true;
     syncPresence();
+    calls.setForeground(foreground);
   }
   function closeSession({ notify: notify2 = true } = {}) {
-    avatarUpdate.reset();
-    attempt += 1;
-    chat.setInboxEnabled(false);
     const session = state.session;
+    attempt += 1;
     chatSession = null;
+    const patch = {
+      session: null,
+      wallet: null,
+      walletError: null,
+      lockState: "locked",
+      online: false,
+      onlineError: null,
+      agreementSession: null
+    };
+    state = { ...state, ...patch };
+    const callRetirement = calls.setSources(null);
+    if (callRetirement) {
+      const work = Promise.resolve(callRetirement).catch((error) => {
+        diag?.("account.calls.close.error", { code: error?.code || "" });
+      });
+      sessionCloseWork.add(work);
+      work.finally(() => sessionCloseWork.delete(work));
+    }
+    avatarUpdate.reset();
+    chat.setInboxEnabled(false);
     closeAccountSession(session);
     if (session && typeof options.onSessionClosed === "function") {
       let result;
@@ -57588,19 +60613,9 @@ function openAccount(options = {}) {
     }
     state.user.lockSettings?.();
     peers.setSources({});
-    const patch = {
-      session: null,
-      wallet: null,
-      walletError: null,
-      lockState: "locked",
-      online: false,
-      onlineError: null,
-      agreementSession: null
-    };
     if (notify2) {
-      emitDomains(patch);
+      emitDomains({});
     } else {
-      state = { ...state, ...patch };
       syncDomains();
     }
     return session;
@@ -58162,12 +61177,14 @@ function openAccount(options = {}) {
       stopPeerAdmissionProjection();
       stopPresence();
       presence.close();
+      const callClosing = calls.close();
       clearMissingPeers();
       wallet.close();
       chat.close();
       peers.close();
       listeners.clear();
       operationBarrier.finishClose();
+      return callClosing;
     });
     return closePromise;
   }
@@ -58183,6 +61200,7 @@ function openAccount(options = {}) {
     messageMaintenance,
     peers,
     presence,
+    calls,
     closeBarrier: Object.freeze({
       acquire: operationBarrier.acquireClose,
       release: operationBarrier.releaseClose,