@glyphteck/veyl 0.73.0 → 0.74.0

package/dist/account.js

@@ -16818,6 +16818,7 @@ var WALLET_PENDING_TRANSFER_STALE_RETRY_MS = 2 * MINUTE_MS;
 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;
+var BITCOIN_FEES_MAX_AGE_MS = 5 * 60000;
 
 // ../../core/calls/wire.js
 var CALL_REQUEST_MAX_BYTES = 192 * 1024;
@@ -17672,7 +17673,8 @@ var domains = Object.freeze({
   veyl: `veyl.${ROOT_DOMAIN}`,
   veylDev: `dev.veyl.${ROOT_DOMAIN}`,
   live: `live.veyl.${ROOT_DOMAIN}`,
-  liveDev: `live.dev.veyl.${ROOT_DOMAIN}`
+  liveDev: `live.dev.veyl.${ROOT_DOMAIN}`,
+  bitcoin: `bitcoin.veyl.${ROOT_DOMAIN}`
 });
 function getVeylDevWebOrigin(port) {
   const value = Number(port);
@@ -17693,6 +17695,7 @@ var liveEndpoints = Object.freeze({
   prod: `wss://${domains.live}`,
   dev: `wss://${domains.liveDev}`
 });
+var bitcoinEndpoint = `https://${domains.bitcoin}/current`;
 var appDomains = Object.freeze([
   domains.veyl
 ]);
@@ -17726,9 +17729,11 @@ function isAddressOnNetwork(address, network) {
 
 // ../../core/settings.js
 var SEND_ON_SCAN_ENABLED = false;
+var WEB_LAYOUTS = ["floating", "sidebar"];
 var WALLET_NETWORKS = new Set([MAINNET_NETWORK, REGTEST_NETWORK]);
 var defaultSettings = {
   glass: true,
+  webLayout: "floating",
   moneyFormat: "usd",
   ghostWallet: true,
   showChatPreviews: true,
@@ -17736,6 +17741,8 @@ var defaultSettings = {
   confirmSend: false,
   faceID: null,
   walletNetwork: null,
+  peerAudio: {},
+  callAudio: { muted: false, deafened: false },
   autolock: {
     timer: "never",
     onHide: false,
@@ -17797,9 +17804,14 @@ function normalizeSettings(settings, base = defaultSettings) {
   };
   next.autolock = normalizeAutolock(settings.autolock, current.autolock);
   next.walletNetwork = normalizeWalletNetworkSetting(next.walletNetwork);
+  next.peerAudio = normalizePeerAudio(settings.peerAudio, current.peerAudio);
+  next.callAudio = normalizeCallAudio(settings.callAudio, current.callAudio);
   if (!MONEY_FORMATS.includes(next.moneyFormat)) {
     throw new Error("bad moneyFormat");
   }
+  if (!WEB_LAYOUTS.includes(next.webLayout)) {
+    throw new Error("bad webLayout");
+  }
   if (typeof next.glass !== "boolean") {
     throw new Error("glass must be boolean");
   }
@@ -17823,6 +17835,32 @@ function normalizeSettings(settings, base = defaultSettings) {
   }
   return next;
 }
+function normalizeCallAudio(patch, base = defaultSettings.callAudio) {
+  if (patch !== undefined && (!patch || typeof patch !== "object" || Array.isArray(patch)))
+    throw new Error("bad call audio settings");
+  const { muted, deafened } = { ...defaultSettings.callAudio, ...base, ...patch };
+  if (typeof muted !== "boolean" || typeof deafened !== "boolean")
+    throw new Error("bad call audio settings");
+  return { muted, deafened };
+}
+function normalizePeerAudio(patch, base = {}) {
+  if (patch === undefined)
+    return base;
+  if (!patch || typeof patch !== "object" || Array.isArray(patch))
+    throw new Error("bad peer audio settings");
+  const entries = new Map(Object.entries(base));
+  for (const [chatPK, audio] of Object.entries(patch)) {
+    if (!/^[a-f0-9]{64}$/u.test(chatPK) || !audio || typeof audio !== "object" || Array.isArray(audio)) {
+      throw new Error("bad peer audio settings");
+    }
+    const { volume = 100, muted = false } = { ...entries.get(chatPK), ...audio };
+    if (!Number.isFinite(volume) || volume < 1 || volume > 200 || typeof muted !== "boolean") {
+      throw new Error("bad peer audio settings");
+    }
+    entries.set(chatPK, { volume, muted });
+  }
+  return Object.fromEntries(entries);
+}
 
 // ../../node_modules/.bun/@noble+ciphers@2.4.0/node_modules/@noble/ciphers/_arx.js
 var encodeStr = (str) => Uint8Array.from(str.split(""), (c) => c.charCodeAt(0));
@@ -18716,6 +18754,9 @@ function normalizeBitcoinPaymentFeeQuote(feeQuote) {
   };
 }
 function getFeeRateSatsPerVbyte(bitcoin, speed = DEFAULT_FEE_RATE_SPEED) {
+  const observedAt = Date.parse(bitcoin?.fees?.updatedAtIso);
+  if (!Number.isFinite(observedAt) || Date.now() - observedAt > BITCOIN_FEES_MAX_AGE_MS || observedAt > Date.now() + 60000)
+    return null;
   const rates = bitcoin?.fees?.satPerVbyte;
   const key = String(speed || DEFAULT_FEE_RATE_SPEED);
   const keys = FEE_RATE_FALLBACKS[key] ?? [key, ...FEE_RATE_FALLBACKS.default];
@@ -19746,6 +19787,9 @@ function readAccountType(profile) {
 function hasPeerKeys(profile) {
   return !!(profile?.walletPK || profile?.chatPK);
 }
+function hasChatIdentity(profile) {
+  return !!(profile?.uid && profile?.chatPK && profile?.chatSigningPK && profile?.notificationPK);
+}
 function readProfileChatIdentity(profile) {
   const chat = profile?.identities?.chat;
   return {
@@ -19760,7 +19804,7 @@ function peerUid(peer) {
   return typeof peer === "string" ? cleanText(peer) : cleanText(peer?.uid);
 }
 function isFullProfile(profile) {
-  return !!(profile?.uid && (("username" in profile) || ("walletPK" in profile) && ("chatPK" in profile)));
+  return !!(profile?.uid && hasPeerKeys(profile) && ["username", "walletPK", "chatPK", "chatSigningPK", "notificationPK"].every((key) => (key in profile)) && (!profile.chatPK || hasChatIdentity(profile)));
 }
 function normalizeProfile(profile, uid = profile?.uid || null) {
   return {
@@ -19861,6 +19905,8 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
   let authSession = 0;
   let userUid = null;
   let settingsKey = null;
+  let settingsWriter = null;
+  let openedSettingsBody;
   let agreementStored = null;
   let agreementOverride = null;
   let agreementAcceptance = null;
@@ -20249,6 +20295,7 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
         settingsBody: privateData.settings ?? null,
         settingsFromCache: false
       }));
+      refreshUnlockedSettings();
     }), current((error) => {
       markError(diag, "user.settings.snapshot", authStartedAt, error);
       if (revokeAuthenticationError(authUser, error, "settings-listener"))
@@ -20464,10 +20511,12 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
       throw new Error("settings key required");
     if (state.settingsBody === undefined)
       throw new Error("settings not available");
-    const nextSettings = state.settingsBody === null ? settingsState() : await openSettings(key, uid, state.settingsBody);
+    const body = state.settingsBody;
+    const nextSettings = body === null ? settingsState() : await openSettings(key, uid, body);
     if (!isCurrentUser(uid, session))
       return nextSettings;
     setSettingsKey(key);
+    openedSettingsBody = body;
     setState((user) => ({
       ...user,
       settings: settingsState(nextSettings)
@@ -20488,15 +20537,59 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
       throw new Error("auth");
     if (!settingsKey)
       throw new Error("settings locked");
-    const nextSettings = await cloud.user.settings.write(uid, patch, { currentSettings: state.settings, key: settingsKey });
-    if (!isCurrentUser(uid, session))
-      return nextSettings;
-    setState((user) => ({
-      ...user,
-      settingsReady: true,
-      settings: settingsState(nextSettings)
-    }));
-    return nextSettings;
+    normalizeSettings(patch, state.settings);
+    if (!settingsWriter || settingsWriter.key !== settingsKey) {
+      settingsWriter = { key: settingsKey, uid, session, pending: [], running: false };
+    }
+    const writer = settingsWriter;
+    const result = new Promise((resolve, reject) => writer.pending.push({ patch, resolve, reject }));
+    writeSettings(writer);
+    return result;
+  }
+  async function writeSettings(writer) {
+    if (writer.running)
+      return;
+    writer.running = true;
+    const current = () => settingsKey === writer.key && isCurrentUser(writer.uid, writer.session);
+    while (writer.pending.length) {
+      const batch = writer.pending.splice(0);
+      try {
+        if (!current())
+          throw new Error("settings locked");
+        const desired = batch.reduce((settings2, { patch }) => normalizeSettings(patch, settings2), state.settings);
+        const { settings, body } = await cloud.user.settings.write(writer.uid, desired, { currentSettings: state.settings, key: writer.key });
+        if (!current())
+          throw new Error("settings locked");
+        openedSettingsBody = body;
+        setState((user) => ({ ...user, settingsReady: true, settings: settingsState(settings), settingsBody: body }));
+        for (const request of batch)
+          request.resolve(settings);
+      } catch (error) {
+        for (const request of batch)
+          request.reject(error);
+      }
+    }
+    writer.running = false;
+    if (settingsWriter === writer)
+      settingsWriter = null;
+    refreshUnlockedSettings();
+  }
+  async function refreshUnlockedSettings() {
+    const key = settingsKey;
+    const body = state.settingsBody;
+    if (!key || body === undefined || body === openedSettingsBody || settingsWriter?.key === key)
+      return;
+    const uid = state.uid;
+    try {
+      const settings = body === null ? settingsState() : await openSettings(key, uid, body);
+      if (settingsKey !== key || state.settingsBody !== body || settingsWriter?.key === key)
+        return;
+      openedSettingsBody = body;
+      setState((user) => ({ ...user, settings: settingsState(settings) }));
+    } catch (error) {
+      if (settingsKey === key && state.settingsBody === body)
+        markError(diag, "user.settings.open", Date.now(), error);
+    }
   }
   function isBlocked(peer) {
     const nextPeerUid = peerUid(peer);
@@ -25059,7 +25152,7 @@ function groupEvidence(messages, byKey, memberStatesByEpoch) {
       const target = byKey.get(reference);
       addEvidence(evidence, messageEpochId(target), actor, messageOrderMs(target), seenAt);
     }
-    if (canShowMsg(message) && !isSystemMsg(message)) {
+    if (canShowMsg(message)) {
       addEvidence(evidence, messageEpochId(message), actor, seenAt, seenAt);
     }
   }
@@ -25087,11 +25180,12 @@ function analyzeMessageExpiry(messages, selfChatPublicKey, _peerChatPublicKey, o
   const shorten = [];
   let nextExpiryAt = null;
   const latestStart = latestCallStartKey(projectedMessages.filter(isServerConfirmedMsg));
+  const endedCalls = new Set(projectedMessages.filter(isServerConfirmedMsg).filter((message) => readCallMessage(message)?.event === "ended").map((message) => message.callId));
   for (const message of projectedMessages) {
     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))
+    if (call?.event === "started" && getMessageKey(message) === latestStart && (options.activeCallId === undefined && !endedCalls.has(call.callId) || options.activeCallId === call.callId))
       continue;
     const messageMs = messageOrderMs(message);
     const epochId = messageEpochId(message);
@@ -26446,7 +26540,7 @@ function partitionExpiredMessageRecords(records, expiredKeys, cache, now = Date.
   return { activeRecords, expiredRecords };
 }
 function canHideExpiredMessage(message, chatPK) {
-  return isServerConfirmedMsg(message) && isPeerMsg(message, chatPK) && canShowMsg(message) && !isControlMsg(message) && !isSystemMsg(message) && message.ttl != null && message.permanent !== true;
+  return isServerConfirmedMsg(message) && isPeerMsg(message, chatPK) && canShowMsg(message) && message.ttl != null && message.permanent !== true;
 }
 function hiddenMessageKeys(messages, chatPK, peerChatPK, options = {}) {
   if (!chatPK || !peerChatPK || !Array.isArray(messages) || !messages.length)
@@ -40686,27 +40780,23 @@ function createChatSessionLaunches({
   const openDirectChat = async (profile) => {
     const operation = operationContext();
     const { chatPK, blocked } = operation.identity;
-    const member = profileMember(profile);
-    if (member.chatPK === chatPK)
+    if (!profile?.uid || !profile?.chatPK)
+      throw new Error("peer identity required");
+    if (profile.chatPK === chatPK)
       return openNotesChat(operation);
-    if (new Set(blocked).has(member.uid))
+    if (new Set(blocked).has(profile.uid))
       throw new Error("blocked peer cannot be opened");
     assertDirectAdmission(profile, operation);
-    const existingChatId = getPeerChatId(member.chatPK, operation);
+    const existingChatId = getPeerChatId(profile.chatPK, operation);
     if (existingChatId) {
       setSelectedChat(existingChatId);
       return existingChatId;
     }
+    const member = { uid: profile.uid, chatPK: profile.chatPK };
     const routeId = directRouteIdForPeer(member.chatPK, operation);
     if (operation.pendingOwner.getPendingLaunch()?.id === routeId)
       return routeId;
-    operation.pendingOwner.showEmpty(routeId, [{
-      ...member,
-      username: profile?.username || null,
-      avatar: profile?.avatar || null,
-      accountType: profile?.accountType || null,
-      chatAdmission: normalizeChatAdmission(profile?.chatAdmission)
-    }], [member], "direct");
+    operation.pendingOwner.showEmpty(routeId, [profile], [member], "direct");
     const materialization = directMaterializations.get(routeId);
     if (materialization && isCurrent(materialization.operation)) {
       materialization.promise.then((chatId) => {
@@ -46189,6 +46279,11 @@ function openCallMailbox({ cloud, capability, endpoint, protocol, onChange, onEr
   }
   return Object.freeze({
     getSnapshot: () => candidate || record,
+    async ready() {
+      const response = await channel.ready();
+      await consume(response.record);
+      return record;
+    },
     async read() {
       const response = await channel.request({ type: "read", cursor, headDigest: record?.headDigest ?? null });
       await consume(response.record);
@@ -46286,6 +46381,7 @@ function openAccountCallLease({ cloud, capability: accountCapability, endpoint,
   let expiry = null;
   let generation = 0;
   let acquiring = false;
+  let rotating = Promise.resolve();
   const attempts = new Set;
   const waiters = new Set;
   const current = () => !closed;
@@ -46386,6 +46482,7 @@ function openAccountCallLease({ cloud, capability: accountCapability, endpoint,
   async function grant(command) {
     if (closed)
       throw new Error("call lease closed");
+    const requestedAt = clock();
     const attempt = createCallLeaseAttempt(command, clock);
     const started = generation;
     attempts.add(attempt);
@@ -46405,6 +46502,8 @@ function openAccountCallLease({ cloud, capability: accountCapability, endpoint,
         onLost?.();
       }, Math.max(0, deadline.wallDeadline - Date.now()));
       clearTimeout(renewal);
+      const now = clock();
+      const elapsed = Math.max(now.wall - requestedAt.wall, now.monotonic - requestedAt.monotonic);
       renewal = setTimeout(() => {
         if (!owned)
           return;
@@ -46416,14 +46515,35 @@ function openAccountCallLease({ cloud, capability: accountCapability, endpoint,
           onLost?.();
           onError?.(error);
         });
-      }, 5000);
+      }, Math.max(0, 5000 - elapsed));
       return value;
     } finally {
       attempts.delete(attempt);
       attempt.cancel();
     }
   }
+  async function rotateMedia() {
+    if (closed || acquiring || !owned || !renewalRemaining(generation))
+      throw new Error("call ownership unavailable");
+    const previous = stop();
+    const started = generation;
+    await request({ type: "release", holder: endpoint.holder, revision: previous.revision });
+    if (closed || started !== generation)
+      throw new Error("call transfer cancelled");
+    return grant({
+      type: "claim",
+      holder: endpoint.holder,
+      expectedRevision: previous.revision,
+      payload: previous.payload,
+      takeover: false
+    });
+  }
   return Object.freeze({
+    rotateMedia() {
+      const next = rotating.then(rotateMedia);
+      rotating = next.catch(() => {});
+      return next;
+    },
     async acquire(descriptor) {
       if (closed)
         throw new Error("call lease closed");
@@ -46432,7 +46552,7 @@ function openAccountCallLease({ cloud, capability: accountCapability, endpoint,
       acquiring = true;
       const started = generation;
       try {
-        await request({ type: "read" });
+        await accept((await channel.ready()).record);
         const payload = await capability.seal(descriptor);
         if (closed || started !== generation)
           throw new Error("call transfer cancelled");
@@ -46872,7 +46992,7 @@ function openCallRoom({
       pulseTimer = setTimeout(pulse, 1e4);
   }
   async function beginStart(create) {
-    const record = await mailbox.read();
+    const record = await mailbox.ready();
     if (closed || departing)
       throw cancelled2();
     if (!create && !record?.head)
@@ -47026,7 +47146,7 @@ function createCallActivity({ holder, onSpeaking, now = Date.now, setTimer = set
       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;
+    direct = mode === "direct" && directPeer !== holder && admitted.has(directPeer) ? directPeer : null;
     const nextSources = new Map(local ? [[holder, "local"]] : []);
     const nextRoutes2 = new Map;
     const ambiguous = new Set;
@@ -47034,7 +47154,7 @@ function createCallActivity({ holder, onSpeaking, now = Date.now, setTimer = set
       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)
+        if (id === holder || !admitted.has(id) || typeof mid !== "string" || !mid)
           continue;
         if (nextRoutes2.has(mid)) {
           nextSources.delete(nextRoutes2.get(mid));
@@ -47101,13 +47221,14 @@ var validMid = (value) => typeof value === "string" && /^[A-Za-z0-9_-]{1,32}$/u.
 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 }) {
+function createCallMediaSession({ port, mode, holder, preparation, provider, signal, publish, onState, onError, onExpired, onSpeaking, diag }) {
   let media = null;
   let closed = false;
   let deadline = null;
   let keys = null;
   let peers = [];
   let sessionId = null;
+  let published = false;
   let started = false;
   let directPeer = null;
   let offered = false;
@@ -47230,7 +47351,11 @@ function createCallMediaSession({ port, mode, holder, provider, signal, publish,
     for (const id of pendingPeerAudio.keys())
       settlePeerAudio(id, new Error("call media closed"));
     pendingSignals.length = incomingSignals.length = 0;
-    const operations = [disposeConnection(previous), retiringConnection];
+    const operations = [
+      disposeConnection(previous),
+      retiringConnection,
+      openingConnection?.then((opened) => opened !== previous ? disposeConnection(opened) : undefined, () => {})
+    ];
     closing = Promise.allSettled(operations).then((results) => {
       const failed = results.find((result) => result.status === "rejected");
       if (failed)
@@ -47243,22 +47368,24 @@ function createCallMediaSession({ port, mode, holder, provider, signal, publish,
     const live = () => !closed && generation === connectionGeneration;
     await retiringConnection;
     current(generation);
-    if (!iceServers) {
-      const configuration = await provider("turn", {});
-      current(generation);
-      iceServers = configuration.iceServers;
-    }
+    const startedAt = Date.now();
+    const prepared = preparation;
+    preparation = null;
     const opening = port.open({
       id: holder,
       mode,
-      iceServers,
+      preparation: prepared,
       onState: (value) => {
         if (!live())
           return;
         connectionState = value.state;
-        if (connectionState === "connected")
+        if (connectionState === "connected") {
           settleConnection();
-        else if (["failed", "closed"].includes(connectionState))
+          serialize(async () => {
+            if (live())
+              await media?.startSource?.();
+          });
+        } else if (["failed", "closed"].includes(connectionState))
           settleConnection(new Error("call connection failed"));
         onState?.(value);
       },
@@ -47295,34 +47422,51 @@ function createCallMediaSession({ port, mode, holder, provider, signal, publish,
       }
     });
     openingConnection = opening;
-    let opened;
+    const preparing = opening.then(async (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);
+      markDone(diag, "call.media.setup", startedAt, { stage: "local" });
+      return opened;
+    });
     try {
-      opened = await opening;
-    } finally {
-      if (openingConnection === opening)
-        openingConnection = null;
-    }
-    if (!live()) {
-      await disposeConnection(opened);
+      const [opened, configuration] = await Promise.all([
+        preparing,
+        Promise.resolve().then(() => iceServers ? { iceServers, sessionId } : provider(mode === "group" ? "session/new" : "turn", {})).then((value) => {
+          current(generation);
+          markDone(diag, "call.media.setup", startedAt, { stage: "provider" });
+          return value;
+        })
+      ]);
       current(generation);
-    }
-    media = opened;
-    await opened.mute(muted);
-    current(generation);
-    await opened.deafen(deafened);
-    current(generation);
-    if (microphoneVolume !== 1) {
-      await opened.setMicrophoneVolume(microphoneVolume);
+      iceServers = configuration.iceServers;
+      if (mode === "group")
+        sessionId = configuration.sessionId;
+      await opened.configure(iceServers);
       current(generation);
-    }
-    await opened.prepare();
-    current(generation);
-    if (deadline) {
-      await opened.grant(deadline);
+      if (deadline) {
+        await opened.grant(deadline);
+        current(generation);
+      }
+      await updateKeys();
       current(generation);
+      markDone(diag, "call.media.setup", startedAt, { stage: "ready" });
+    } catch (error) {
+      await disposeConnection(await opening.catch(() => null));
+      throw error;
+    } finally {
+      if (openingConnection === opening)
+        openingConnection = null;
     }
-    await updateKeys();
-    current(generation);
   }
   async function applyDescription(result, required = false) {
     current();
@@ -47385,10 +47529,7 @@ function createCallMediaSession({ port, mode, holder, provider, signal, publish,
     if (!started || !keys)
       return;
     if (mode === "group") {
-      if (!sessionId) {
-        const session = await provider("session/new", {});
-        current();
-        sessionId = session.sessionId;
+      if (!published) {
         const offer = await media.offer();
         current();
         const sendMid = media.sendMid;
@@ -47407,48 +47548,15 @@ function createCallMediaSession({ port, mode, holder, provider, signal, publish,
         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);
+        await Promise.all([
+          publish({ sessionId, trackName }).then(() => {
+            current();
+            published = true;
+          }),
+          receiveGroupTracks()
+        ]);
+      } else {
+        await receiveGroupTracks();
       }
     } else {
       const peer = peers.find((item) => item.holder !== holder);
@@ -47476,6 +47584,48 @@ function createCallMediaSession({ port, mode, holder, provider, signal, publish,
       }
     }
   }
+  async function receiveGroupTracks() {
+    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);
+    }
+  }
   return Object.freeze({
     async open() {
       current();
@@ -47531,13 +47681,19 @@ function createCallMediaSession({ port, mode, holder, provider, signal, publish,
     },
     mute(value) {
       current();
-      muted = value === true;
+      const next = value === true;
+      if (muted === next)
+        return;
+      muted = next;
       updateActivity();
       return media?.mute(muted);
     },
     deafen(value) {
       current();
-      deafened = value === true;
+      const next = value === true;
+      if (deafened === next)
+        return;
+      deafened = next;
       updateActivity();
       return media?.deafen(deafened);
     },
@@ -47722,7 +47878,7 @@ var initial = () => ({ phase: "idle", chatId: null, callId: null, joiningChatId:
 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 }) {
+function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio, saveAudio, diag }) {
   const listeners = new Set;
   const discoveries = new Map;
   const discoveryReads = new Map;
@@ -47730,11 +47886,16 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
   const retiring = new Set;
   let state = initial();
   const confirmedPeerAudio = new Map;
+  const pendingPeerAudio = new Map;
+  let peerAudioSource = null;
+  let audioSource = normalizeCallAudio();
+  let pendingAudio = null;
   let identity = null;
   let endpoint = null;
   let leaseEndpoint = null;
   let lease = null;
   let active = null;
+  let participation = null;
   let focused = null;
   let generation = 0;
   let joinIntent = 0;
@@ -47809,6 +47970,8 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
       emit({ available: next });
   }
   function closeDiscovery(entry) {
+    if ([...retiring].some((call) => call.discovery === entry))
+      return;
     entry.mailbox.close();
     entry.observation?.close();
     entry.observation = null;
@@ -47934,8 +48097,14 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
         throw Object.assign(new Error("chat unavailable"), { code: "unavailable" });
       if (!epochState)
         throw Object.assign(new Error("chat unavailable"), { code: "calls/chat-not-ready" });
+      if (chat.getSnapshot().getOwnerChat(chatId)?.epochState?.manifest.epochId !== epochId)
+        throw cancelled2();
+      const existing = discoveries.get(chatId);
       const entry = discovery(chatId, epochState);
-      await entry.mailbox.read();
+      if (entry === existing)
+        await entry.mailbox.read();
+      else
+        await entry.mailbox.ready();
       current(token);
       return entry;
     }).finally(() => {
@@ -47969,49 +48138,68 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
       prune();
     };
   }
-  async function joinAttempt(chatId, intent, expectedCallId, onlyExisting) {
+  async function joinAttempt(chatId, intent, expectedCallId, onlyExisting, continuation = null) {
     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 });
+    let preflightActive = true;
     const check = () => {
       current(token);
-      if (intent !== joinIntent || !foreground)
+      if (!preflightActive || intent !== joinIntent)
         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");
+    const operation = joining;
+    let preparation;
     let call;
     try {
-      const epochState = await chat.getSnapshot().prepareCall(chatId);
-      check();
-      const entry = await readDiscovery(chatId, epochState);
+      emit({ ...!active && !continuation ? { phase: "joining", chatId } : {}, error: null });
+      const permission = (async () => {
+        const value = continuation ? undefined : await mediaPort.prepare?.();
+        try {
+          check();
+        } catch (error) {
+          value?.close();
+          throw error;
+        }
+        preparation = value;
+        operation.preparation = value;
+        step("permission");
+      })();
+      const destination = (async () => {
+        if (!onlyExisting && !continuation)
+          chatId = await chat.getSnapshot().materializeChat(chatId);
+        check();
+        joining.chatId = chatId;
+        step("chat");
+        const epochState = continuation ? chat.getSnapshot().getOwnerChat(chatId)?.epochState : await chat.getSnapshot().prepareCall(chatId);
+        check();
+        if (!epochState)
+          throw cancelled2();
+        const entry2 = await readDiscovery(chatId, epochState);
+        check();
+        step("discovery");
+        return entry2;
+      })();
+      const [, entry] = await Promise.all([permission, destination]);
       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)),
+        callId: continuation?.callId || toHex(randomBytes3(32)),
         secret: toHex(randomBytes3(32)),
         mode: entry.epochState.manifest.lineage,
         participants: 1,
-        startedAt: Date.now()
+        startedAt: continuation?.startedAt ?? Date.now()
       };
-      const callEndpoint = createCallEndpoint();
+      if (continuation && descriptor.callId !== continuation.callId)
+        throw ended();
+      const callEndpoint = continuation?.endpoint || createCallEndpoint();
       call = {
         chatId,
         callId: descriptor.callId,
@@ -48032,6 +48220,7 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
         muteTail: Promise.resolve()
       };
       joining.candidate = call;
+      call.owner = continuation?.owner || createLease(identity, callEndpoint);
       const protocol = createCallProtocol({ realm: cloud.environment, epochState: entry.epochState, identity, endpoint: callEndpoint, callId: descriptor.callId });
       call.protocol = protocol;
       const ownMember = (value) => {
@@ -48051,6 +48240,7 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
       if (!create)
         cleanBytes(callMember.snapshot);
       check();
+      step("identity");
       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]);
@@ -48082,8 +48272,10 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
       };
       call.media = createCallMediaSession({
         port: mediaPort,
+        preparation,
         mode: descriptor.mode,
         holder: callEndpoint.holder,
+        diag,
         provider: (...args) => call.owner.provider(...args),
         signal: (...args) => call.room.signal(...args),
         publish: (value) => call.room.publishMedia(value),
@@ -48098,6 +48290,8 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
             participants: call.participants.length
           });
           if (value.state === "connected") {
+            if (state.phase !== "connected")
+              step("connected");
             clearTimeout(call.joinTimer);
             call.joinTimer = null;
             emit({ phase: "connected", transport: value.transport || (descriptor.mode === "group" ? "relay" : null) });
@@ -48194,7 +48388,8 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
           throw error;
         }
         checkCall();
-        announce(chatId, descriptor.callId, "started");
+        if (!continuation)
+          announce(chatId, descriptor.callId, "started");
       } else {
         await entry.mailbox.read();
         checkCall();
@@ -48204,16 +48399,21 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
           throw Object.assign(new Error("the call room changed"), { code: "calls/discovery-conflict" });
         }
       }
+      step("publication");
       call.published = true;
-      await stopCall();
-      checkCall();
-      mountLease(identity, callEndpoint);
-      call.owner = lease;
+      if (!continuation) {
+        await stopCall();
+        checkCall();
+        mountLease(identity, callEndpoint, call.owner);
+        participation = { chatId, callId: descriptor.callId, startedAt: descriptor.startedAt, endpoint: callEndpoint, owner: lease };
+      }
+      step("predecessor");
+      call.owner = participation.owner;
       active = call;
       observeRoster(entry);
       available();
       emit({
-        phase: state.elsewhere ? "transferring" : "joining",
+        phase: continuation ? "connecting" : state.elsewhere ? "transferring" : "joining",
         chatId,
         callId: descriptor.callId,
         mode: descriptor.mode,
@@ -48226,7 +48426,10 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
         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 });
+      if (continuation)
+        await participation.owner.rotateMedia();
+      else
+        await lease.acquire({ chatId, callId: descriptor.callId });
       check();
       step("ownership");
       if (!valid())
@@ -48286,6 +48489,11 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
         throw Object.assign(new Error("the call room is restarting"), { code: "calls/discovery-conflict" });
       }
       throw error;
+    } finally {
+      preflightActive = false;
+      preparation?.close();
+      if (operation.preparation === preparation)
+        operation.preparation = null;
     }
   }
   async function join(chatId, expectedCallId = null, onlyExisting = false) {
@@ -48294,21 +48502,31 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
         throw ended();
       return chatId;
     }
+    if (!foreground)
+      throw new Error("open veyl to join a call");
+    return runJoin(chatId, expectedCallId, onlyExisting);
+  }
+  async function runJoin(chatId, expectedCallId = null, onlyExisting = false, continuation = null) {
     const intent = ++joinIntent;
-    const operation = { predecessor: active, chatId, candidate: null };
+    const operation = { predecessor: active, chatId, candidate: null, continuation };
     const previous = joining;
     joining = operation;
+    previous?.preparation?.close();
     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);
+          return await joinAttempt(chatId, intent, expectedCallId, onlyExisting, continuation);
         } catch (error) {
           if (intent !== joinIntent || !identity || closed)
             throw cancelled2();
           if (error?.code !== "calls/discovery-conflict" || attempt === 2) {
+            if (continuation) {
+              fail(error);
+              throw error;
+            }
             const target = operation.chatId;
             emit({ ...!active ? { phase: "error", chatId: target } : {}, error: callError(chatId, error) });
             throw error;
@@ -48325,6 +48543,7 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
   }
   function leave() {
     joinIntent += 1;
+    joining?.preparation?.close();
     const candidate = joining?.candidate;
     joining = null;
     emit({ joiningChatId: null });
@@ -48339,6 +48558,7 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
     if (!operation)
       return Promise.resolve();
     joinIntent += 1;
+    operation.preparation?.close();
     joining = null;
     emit({ joiningChatId: null });
     const pending = operation.candidate && operation.candidate !== active ? disposeCall(operation.candidate) : null;
@@ -48348,6 +48568,14 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
   }
   function stopCall() {
     const call = active;
+    const authority = participation;
+    participation = null;
+    if (!call && authority) {
+      authority.owner.retire();
+      const retired = [...retiring].filter((room) => room.endpoint === authority.endpoint);
+      const released = Promise.all(retired.map((room) => room.stopped)).then(() => authority.owner.release());
+      leaving = retired.length ? Promise.race([released, Promise.all(retired.map((room) => room.closing))]) : released;
+    }
     if (!call) {
       emit({ phase: "idle", chatId: null, callId: null, mode: null, transport: null, participants: [], speaking: [] });
       return leaving;
@@ -48367,7 +48595,9 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
       return;
     try {
       await entry.mailbox.commit(null, [], { expectedRevision: snapshot.revision });
-      announce(call.chatId, call.callId, "ended");
+      if (chat.getSnapshot().getOwnerChat(call.chatId)?.epochState?.manifest.epochId === entry.epochState.manifest.epochId) {
+        announce(call.chatId, call.callId, "ended");
+      }
     } catch (error) {
       if (error?.code !== "calls/conflict")
         throw error;
@@ -48387,11 +48617,13 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
     clearTimeout(call.timer);
     clearTimeout(call.joinTimer);
     const stopping = call.media?.close();
-    call.owner?.retire();
+    call.stopped = Promise.resolve(stopping);
+    const releasedOwner = participation?.endpoint === call.endpoint ? null : call.owner;
+    releasedOwner?.retire();
     const departing = call.room?.leave();
     const draining = (async () => {
       try {
-        const [, departure] = await Promise.allSettled([Promise.resolve(stopping).then(() => call.owner?.release()), departing]);
+        const [, departure] = await Promise.allSettled([Promise.resolve(stopping).then(() => releasedOwner?.release()), departing]);
         if (departure.status === "fulfilled" && departure.value?.ended && call.published && call.discovery.descriptor?.callId === call.callId) {
           await retireDiscovery(call);
         }
@@ -48411,9 +48643,13 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
       call.room?.close();
       call.protocol?.close();
       cleanBytes(call.member?.snapshot);
+      if (call.owner !== lease && call.owner !== participation?.owner)
+        call.owner?.close();
       if (call.endpoint !== leaseEndpoint)
         call.endpoint.close();
       retiring.delete(call);
+      if (discoveries.get(call.chatId) !== call.discovery)
+        closeDiscovery(call.discovery);
       prune();
     });
     return call.closing;
@@ -48429,6 +48665,27 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
     return result;
   }
   async function setAudio(patch) {
+    const value = normalizeCallAudio(patch, state);
+    if (value.muted === state.muted && value.deafened === state.deafened && value.muted === audioSource.muted && value.deafened === audioSource.deafened)
+      return;
+    const token = generation;
+    pendingAudio = value;
+    const saving = Promise.resolve().then(() => {
+      if (generation !== token)
+        throw cancelled2();
+      return saveAudio(value);
+    }).then(() => {
+      if (generation === token)
+        audioSource = value;
+    });
+    try {
+      await Promise.all([saving, applyAudioPreferences(value)]);
+    } finally {
+      if (generation === token && pendingAudio === value)
+        pendingAudio = null;
+    }
+  }
+  async function applyAudioPreferences(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) => {
@@ -48439,6 +48696,13 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
       throw error;
     })));
   }
+  function syncAudio(source) {
+    audioSource = normalizeCallAudio(source);
+    const value = pendingAudio || audioSource;
+    if (state.muted === value.muted && state.deafened === value.deafened)
+      return;
+    applyAudioPreferences(value).catch((error) => diag?.("call.audio.settings.error", { code: error?.code || "calls/audio" }));
+  }
   async function setPeerAudio(chatPK, patch) {
     const call = active;
     if (!identity || typeof chatPK !== "string" || !chatPK || chatPK === identity.chatPK)
@@ -48447,11 +48711,15 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
     const peer = call?.participants.find((peer2) => peer2.chatPK === chatPK);
     const previous = state.peerAudio[chatPK];
     const value = { volume: 100, muted: false, ...previous, ...patch };
+    pendingPeerAudio.set(chatPK, value);
     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)
+      if (generation !== token || pendingPeerAudio.get(chatPK) !== value)
+        return;
+      await savePeerAudio(chatPK, value);
+      if (generation === token)
         confirmedPeerAudio.set(chatPK, value);
     } catch (error) {
       if (generation === token && state.peerAudio[chatPK] === value) {
@@ -48462,8 +48730,39 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
         else
           delete peerAudio[chatPK];
         emit({ peerAudio });
+        if (peer && active === call)
+          call.media.setPeerAudio(peer.holder, {
+            volume: (confirmed?.volume ?? 100) / 100,
+            muted: confirmed?.muted ?? false
+          }).catch(() => {});
       }
       throw error;
+    } finally {
+      if (generation === token && pendingPeerAudio.get(chatPK) === value)
+        pendingPeerAudio.delete(chatPK);
+    }
+  }
+  function syncPeerAudio(source = {}) {
+    if (source === peerAudioSource)
+      return;
+    peerAudioSource = source;
+    const peerAudio = { ...source };
+    for (const [chatPK, value] of pendingPeerAudio)
+      peerAudio[chatPK] = value;
+    confirmedPeerAudio.clear();
+    for (const [chatPK, value] of Object.entries(source))
+      confirmedPeerAudio.set(chatPK, value);
+    const changed = new Set([...Object.keys(state.peerAudio), ...Object.keys(peerAudio)].filter((chatPK) => state.peerAudio[chatPK]?.volume !== peerAudio[chatPK]?.volume || state.peerAudio[chatPK]?.muted !== peerAudio[chatPK]?.muted));
+    if (!changed.size)
+      return;
+    emit({ peerAudio });
+    for (const call of new Set([active, joining?.candidate].filter((call2) => call2?.media && !call2.leaving))) {
+      for (const peer of call.participants) {
+        if (!changed.has(peer.chatPK))
+          continue;
+        const audio = peerAudio[peer.chatPK];
+        call.media.setPeerAudio(peer.holder, { volume: (audio?.volume ?? 100) / 100, muted: audio?.muted ?? false }).catch((error) => diag?.("call.peer.audio.error", { code: error?.code || "calls/audio" }));
+      }
     }
   }
   async function setMicrophoneVolume(volume) {
@@ -48481,13 +48780,9 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
       throw error;
     }
   }
-  function mountLease(session, callEndpoint = endpoint) {
-    lease?.close();
-    if (leaseEndpoint && leaseEndpoint !== endpoint && leaseEndpoint !== callEndpoint)
-      leaseEndpoint.close();
-    leaseEndpoint = callEndpoint;
+  function createLease(session, callEndpoint) {
     const ownsLease = () => identity === session && leaseEndpoint === callEndpoint;
-    lease = openAccountCallLease({
+    return openAccountCallLease({
       cloud,
       capability: session.callIdentity,
       endpoint: callEndpoint,
@@ -48512,9 +48807,22 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
       }
     });
   }
-  function setSources(session) {
-    if (identity === session)
+  function mountLease(session, callEndpoint = endpoint, prepared = null) {
+    lease?.close();
+    if (leaseEndpoint && leaseEndpoint !== endpoint && leaseEndpoint !== callEndpoint)
+      leaseEndpoint.close();
+    leaseEndpoint = callEndpoint;
+    lease = prepared || createLease(session, callEndpoint);
+  }
+  function setSources(session, settings = {}) {
+    const peerAudio = settings.peerAudio || {};
+    if (identity === session) {
+      if (session) {
+        syncPeerAudio(peerAudio);
+        syncAudio(settings.callAudio);
+      }
       return drainingSources;
+    }
     const token = ++generation;
     const previousLease = lease;
     const previousEndpoint = endpoint;
@@ -48546,7 +48854,13 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
     if (generation !== token || identity !== session)
       return retirement;
     confirmedPeerAudio.clear();
-    emit(initial());
+    pendingPeerAudio.clear();
+    pendingAudio = null;
+    audioSource = normalizeCallAudio(settings.callAudio);
+    peerAudioSource = session ? peerAudio : null;
+    for (const [chatPK, value] of Object.entries(peerAudioSource || {}))
+      confirmedPeerAudio.set(chatPK, value);
+    emit({ ...initial(), ...session ? audioSource : {}, peerAudio: peerAudioSource || {} });
     available();
     if (generation !== token || identity !== session)
       return retirement;
@@ -48567,10 +48881,35 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
     if (!identity)
       return;
     for (const [chatId, entry] of discoveries) {
-      const epoch = chat.getSnapshot().getOwnerChat(chatId)?.epochState?.manifest.epochId;
-      if (epoch === entry.epochState.manifest.epochId)
+      const epochState = chat.getSnapshot().getOwnerChat(chatId)?.epochState;
+      if (epochState?.manifest.epochId === entry.epochState.manifest.epochId)
         continue;
-      if (active?.chatId === chatId)
+      const retained = epochState?.manifest.members.some((member) => member.chatSigningPK === identity.chatSigningPK);
+      if (participation?.chatId === chatId && retained) {
+        const continuation = participation;
+        const intent = ++joinIntent;
+        const previous = active || joining?.candidate;
+        active = null;
+        joining = null;
+        if (previous)
+          disposeCall(previous);
+        const members = new Set(epochState.manifest.members.map((member) => member.chatPK));
+        emit({
+          phase: "connecting",
+          joiningChatId: chatId,
+          speaking: [],
+          participants: state.participants.filter((member) => members.has(member.chatPK))
+        });
+        diag?.("call.epoch.transition", { stage: "starting", participants: state.participants.length });
+        Promise.resolve(previous?.stopped).then(() => {
+          if (intent !== joinIntent || participation !== continuation)
+            return;
+          return runJoin(chatId, null, false, continuation);
+        }).catch((error) => {
+          if (intent === joinIntent && participation === continuation)
+            fail(error);
+        });
+      } else if (active?.chatId === chatId || participation?.chatId === chatId)
         leave();
       else if (joining?.chatId === chatId)
         cancelJoin();
@@ -48629,8 +48968,6 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, diag }) {
     },
     setForeground(value) {
       foreground = value === true;
-      if (!foreground && joining)
-        cancelJoin();
     },
     setOnline(value) {
       const reconnecting = !online && value === true;
@@ -51652,15 +51989,17 @@ var DEFAULT_BITCOIN = Object.freeze({
   ready: false,
   error: null
 });
-function normalizeBitcoinData(data, current = DEFAULT_BITCOIN, info = {}) {
+function normalizeBitcoinData(data, current = DEFAULT_BITCOIN) {
   if (!data)
     return current;
+  const observedAt = timestampMs(data.priceUpdatedAt, null, { positive: true });
+  const usePrice = hasBitcoinPrice(data.price) && observedAt != null && observedAt >= (current.priceUpdatedAt ?? 0);
   return {
-    price: hasBitcoinPrice(data.price) ? data.price : current.price,
-    priceUpdatedAt: hasBitcoinPrice(data.price) ? timestampMs(data.updatedAt, Date.now()) : current.priceUpdatedAt,
-    priceFromCache: hasBitcoinPrice(data.price) ? info.fromCache === true : current.priceFromCache,
+    price: usePrice ? data.price : current.price,
+    priceUpdatedAt: usePrice ? observedAt : current.priceUpdatedAt,
+    priceFromCache: usePrice ? false : current.priceFromCache,
     block: data.block ?? current?.block ?? null,
-    fees: data.fees ?? current?.fees ?? null,
+    fees: data.fees ?? null,
     updatedAt: data.updatedAt ?? current?.updatedAt ?? null,
     ready: true,
     error: null
@@ -51710,20 +52049,15 @@ function createBitcoin({ cloud, priceStorage = null, diag = null }) {
       const priceUpdatedAt = timestampMs(cached.updatedAt, null, { positive: true });
       if (!priceUpdatedAt)
         return;
-      if (bitcoin.priceUpdatedAt != null && (!bitcoin.priceFromCache || bitcoin.priceUpdatedAt >= priceUpdatedAt))
+      if (bitcoin.priceUpdatedAt != null && bitcoin.priceUpdatedAt >= priceUpdatedAt)
         return;
       publish({ ...bitcoin, price: cached.price, priceUpdatedAt, priceFromCache: true });
     }).catch((error) => diag?.("bitcoin.price.cache.read.error", { code: error?.code || "" }));
-    unsubscribe = cloud.bitcoin.watch((data, info = {}) => {
-      if (session !== generation || info.pending)
+    unsubscribe = cloud.bitcoin.watch((data) => {
+      if (session !== generation)
         return;
-      const next = normalizeBitcoinData(data, bitcoin, info);
-      if (info.fromCache && bitcoin.priceUpdatedAt != null && next.priceUpdatedAt <= bitcoin.priceUpdatedAt) {
-        next.price = bitcoin.price;
-        next.priceUpdatedAt = bitcoin.priceUpdatedAt;
-        next.priceFromCache = bitcoin.priceFromCache;
-      }
-      if (priceStorage && hasBitcoinPrice(data?.price) && !info.fromCache && (next.price !== bitcoin.price || next.priceUpdatedAt !== bitcoin.priceUpdatedAt || bitcoin.priceFromCache)) {
+      const next = normalizeBitcoinData(data, bitcoin);
+      if (priceStorage && next.priceUpdatedAt != null && !next.priceFromCache && (next.price !== bitcoin.price || next.priceUpdatedAt !== bitcoin.priceUpdatedAt || bitcoin.priceFromCache)) {
         const cached = { price: next.price, updatedAt: next.priceUpdatedAt };
         priceWrite = priceWrite.catch(NOOP3).then(() => priceStorage.write(cached));
         priceWrite.catch((error) => diag?.("bitcoin.price.cache.write.error", { code: error?.code || "" }));
@@ -52854,8 +53188,9 @@ function createPeersApi({ cloud, network, avatarCache = null }) {
   async function fetchProfileByUid(uid) {
     if (!uid)
       return null;
-    if (profileCache.has(uid))
-      return profileCache.get(uid);
+    const cached = profileCache.get(uid);
+    if (isFullProfile(cached))
+      return cached;
     try {
       const record = await cloud.peer.read(uid);
       if (!record)
@@ -52903,11 +53238,11 @@ function createPeersApi({ cloud, network, avatarCache = null }) {
       return null;
     if (field === "walletPK" && walletToUid.has(value)) {
       const uid = walletToUid.get(value);
-      return profileCache.get(uid) ?? null;
+      return fetchProfileByUid(uid);
     }
     if (field === "chatPK" && chatToUid.has(value)) {
       const uid = chatToUid.get(value);
-      return profileCache.get(uid) ?? null;
+      return fetchProfileByUid(uid);
     }
     try {
       const record = field === "walletPK" ? await cloud.search.peer.byWalletPK(value, { network: walletNetwork }) : field === "chatPK" ? await cloud.search.peer.byChatPK(value) : await cloud.search.peer.byUsername(value);
@@ -60309,7 +60644,14 @@ function openAccount(options = {}) {
     maintenance: messageMaintenance,
     resolveActiveCall: (chatId) => calls.resolveActiveCall(chatId)
   }, chatSources());
-  const calls = createCallSession({ cloud, chat, ...options.calls, diag });
+  const calls = createCallSession({
+    cloud,
+    chat,
+    ...options.calls,
+    diag,
+    savePeerAudio: (chatPK, audio) => user.getSnapshot().updateSettings({ peerAudio: { [chatPK]: audio } }),
+    saveAudio: (callAudio) => user.getSnapshot().updateSettings({ callAudio })
+  });
   const wallet = openWallet({
     ...options.wallet || {},
     network: state.network,
@@ -60383,7 +60725,7 @@ function openAccount(options = {}) {
     syncPresence();
     syncPeers();
     calls.setOnline(state.online);
-    calls.setSources(state.lockState === "unlocked" ? state.session : null);
+    calls.setSources(state.lockState === "unlocked" ? state.session : null, state.user?.settings);
   }
   function syncPresence() {
     const session = state.session;