npm - @glyphteck/veyl - Versions diffs - 0.77.1 → 0.78.0 - Mend

@glyphteck/veyl 0.77.1 → 0.78.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/dist/account.js CHANGED Viewed

@@ -16835,6 +16835,8 @@ 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;
+var CALL_MAX_VIDEO_SOURCES = 4;
+var CALL_MAX_VIDEO_SOURCES_PER_PARTICIPANT = 1;
 // ../../core/calls/wire.js
 var CALL_REQUEST_MAX_BYTES = 192 * 1024;
@@ -17007,144 +17009,6 @@ 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;
-}
-function nextRelativeTimeRefreshMs(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 = Math.max(0, nowMs2 - ms);
-  if (age < 30000)
-    return ms + 30000;
-  if (age < 60 * 60000)
-    return ms + (Math.floor(age / 60000) + 1) * 60000;
-  if (age < 24 * 60 * 60000)
-    return ms + (Math.floor(age / (60 * 60000)) + 1) * 60 * 60000;
-  return ms + (Math.floor(age / (24 * 60 * 60000)) + 1) * 24 * 60 * 60000;
-}
-// ../../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) {
@@ -17162,13 +17026,6 @@ 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"];
@@ -17701,6 +17558,7 @@ var domains = Object.freeze({
   root: ROOT_DOMAIN,
   rootDev: `dev.${ROOT_DOMAIN}`,
   veyl: `veyl.${ROOT_DOMAIN}`,
+  veylOpen: `open.veyl.${ROOT_DOMAIN}`,
   veylDev: `dev.veyl.${ROOT_DOMAIN}`,
   live: `live.veyl.${ROOT_DOMAIN}`,
   liveDev: `live.dev.veyl.${ROOT_DOMAIN}`,
@@ -17719,6 +17577,7 @@ var origins = Object.freeze({
   root: `https://${domains.root}`,
   rootDev: `https://${domains.rootDev}`,
   veyl: `https://${domains.veyl}`,
+  veylOpen: `https://${domains.veylOpen}`,
   veylDev: `https://${domains.veylDev}`,
   veylDevWeb: getVeylDevWebOrigin(VEYL_DEV_WEB_PORT_MIN)
 });
@@ -17733,7 +17592,8 @@ var appDomains = Object.freeze([
 ]);
 var appLinkDomains = Object.freeze([
   domains.veyl,
-  domains.veylDev
+  domains.veylDev,
+  domains.veylOpen
 ]);
 // ../../core/network.js
@@ -17761,7 +17621,6 @@ function isAddressOnNetwork(address, network) {
 // ../../core/settings.js
 var SEND_ON_SCAN_ENABLED = false;
-var WEB_LAYOUTS = ["floating", "sidebar"];
 var WEB_SIDEBAR_WIDTH = { default: 320, min: 64, max: 480 };
 var DEFAULT_WEB_CHAT_LAYOUT = Object.freeze({ open: null, width: null });
 var WALLET_NETWORKS = new Set([MAINNET_NETWORK, REGTEST_NETWORK]);
@@ -17774,7 +17633,6 @@ class SettingsValidationError extends Error {
 }
 var defaultSettings = {
   glass: true,
-  webLayout: "floating",
   sidebarWidth: WEB_SIDEBAR_WIDTH.default,
   walletChartHeight: null,
   webChatLayouts: [],
@@ -17889,9 +17747,6 @@ function normalizeSettings(settings, base = defaultSettings) {
   if (!MONEY_FORMATS.includes(next.moneyFormat)) {
     throw new SettingsValidationError("money-format", "bad moneyFormat");
   }
-  if (!WEB_LAYOUTS.includes(next.webLayout)) {
-    throw new SettingsValidationError("web-layout", "bad webLayout");
-  }
   if (typeof next.glass !== "boolean") {
     throw new SettingsValidationError("glass", "glass must be boolean");
   }
@@ -17913,7 +17768,7 @@ function normalizeSettings(settings, base = defaultSettings) {
   if (next.faceID !== null && typeof next.faceID !== "boolean") {
     throw new SettingsValidationError("face-id", "faceID must be boolean or null");
   }
-  return next;
+  return Object.fromEntries(Object.keys(defaultSettings).map((key) => [key, next[key]]));
 }
 function normalizeCallAudio(patch, base = defaultSettings.callAudio) {
   if (patch !== undefined && (!patch || typeof patch !== "object" || Array.isArray(patch)))
@@ -19360,7 +19215,14 @@ async function openVaultAccountSession(vault, password, options = {}) {
         return Promise.reject(new Error("account session closed"));
       if (connecting)
         return connecting;
+      let releaseBoot;
       connecting = (async () => {
+        const walletStartedAt = Date.now();
+        mark(diag, "vault.unlock.wallet.start", { source });
+        const boot = startWalletBoot(bootWallet, mnemonicFromWalletEntropy(sessionWalletEntropy), currentUser, { network, diag });
+        walletBoot = boot;
+        releaseBoot = session.own(boot);
+        boot.result.catch(() => {});
         const authStartedAt = Date.now();
         mark(diag, "vault.unlock.session.start", { source });
         await cloud.auth.user.getIdToken(true);
@@ -19394,11 +19256,6 @@ async function openVaultAccountSession(vault, password, options = {}) {
           requireCurrent(isCurrent);
           chatIdentitiesRegistered = true;
         }
-        const walletStartedAt = Date.now();
-        mark(diag, "vault.unlock.wallet.start", { source });
-        const boot = startWalletBoot(bootWallet, mnemonicFromWalletEntropy(sessionWalletEntropy), currentUser, { network, diag });
-        walletBoot = boot;
-        const releaseBoot = session.own(boot);
         const walletReady = boot.result.then(async (walletIdentity) => {
           if (session.closed)
             throw new Error("account session closed");
@@ -19430,6 +19287,7 @@ async function openVaultAccountSession(vault, password, options = {}) {
         walletReady.catch(() => {});
         return { walletReady };
       })().catch((error) => {
+        releaseBoot?.();
         connecting = null;
         throw error;
       });
@@ -19475,6 +19333,102 @@ 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;
+}
+function nextRelativeTimeRefreshMs(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 = Math.max(0, nowMs2 - ms);
+  if (age < 30000)
+    return ms + 30000;
+  if (age < 60 * 60000)
+    return ms + (Math.floor(age / 60000) + 1) * 60000;
+  if (age < 24 * 60 * 60000)
+    return ms + (Math.floor(age / (60 * 60000)) + 1) * 60 * 60000;
+  return ms + (Math.floor(age / (24 * 60 * 60000)) + 1) * 24 * 60 * 60000;
+}
 // ../../core/moderation.js
 function banUntilMs(ban) {
   if (!ban || typeof ban !== "object" || Array.isArray(ban) || ban.until == null) {
@@ -20003,6 +19957,7 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
   let avatarPreview;
   let blockedSource = state.blocked;
   let blockedSet = new Set(blockedSource);
+  const blockedChanges = new Map;
   let banTimer = null;
   let unsubscribeAuth = NOOP;
   let userWatches = [];
@@ -20016,11 +19971,27 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
   function makeSnapshot() {
     const bans = banState(state.banned);
     const userBan = bans.full || bans.chat;
+    const visibleBlocked = new Set(state.blocked);
+    const blockedPending = [];
+    for (const [uid, change] of blockedChanges) {
+      if (change.blocked)
+        visibleBlocked.add(uid);
+      else
+        visibleBlocked.delete(uid);
+      if (!change.written)
+        blockedPending.push(uid);
+    }
+    if (visibleBlocked.size !== blockedSet.size || [...visibleBlocked].some((uid) => !blockedSet.has(uid))) {
+      blockedSet = visibleBlocked;
+    }
+    const blocked = snapshot?.blocked && snapshot.blocked.length === blockedSet.size && snapshot.blocked.every((uid) => blockedSet.has(uid)) ? snapshot.blocked : [...blockedSet];
     return {
       ...state,
       avatar: avatarPreview === undefined ? state.avatar : avatarPreview,
       network: activeNetwork,
       blockedSet,
+      blocked,
+      blockedPending: snapshot?.blockedPending && snapshot.blockedPending.length === blockedPending.length && snapshot.blockedPending.every((uid, index) => uid === blockedPending[index]) ? snapshot.blockedPending : blockedPending,
       chatBanned: bans.chatBanned,
       avatarBanned: bans.avatarBanned,
       chatBanUntil: userBan?.until ?? null,
@@ -20304,6 +20275,7 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
     const authStartedAt = Date.now();
     const session = authSession + 1;
     authSession = session;
+    blockedChanges.clear();
     closeUserWatches();
     markDiag(diag, "user.auth.state", { signedIn: !!authUser });
     if (!authUser) {
@@ -20403,6 +20375,20 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
       setState((user) => ({ ...user, banned: null }));
     })));
     userWatches.push(cloud.user.blocked.watch(authUser.uid, current((blocked, info = {}) => {
+      if (info.pending || info.fromCache && state.blockedReady)
+        return;
+      const confirmed = new Set(blocked);
+      for (const [uid, change] of blockedChanges) {
+        if (!change.written)
+          continue;
+        if (!info.fromCache && confirmed.has(uid) === change.blocked)
+          blockedChanges.delete(uid);
+        else if (state.blocked.includes(uid))
+          confirmed.add(uid);
+        else
+          confirmed.delete(uid);
+      }
+      blocked = [...confirmed];
       setState((user) => {
         const blockedReady = user.blockedReady || !info.fromCache;
         if (user.blockedReady === blockedReady && user.blocked.length === blocked.length && user.blocked.every((id, index) => id === blocked[index])) {
@@ -20478,6 +20464,7 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
     if (!started)
       return;
     authSession += 1;
+    blockedChanges.clear();
     closeUserWatches();
     unsubscribeAuth();
     setState((user) => ({ ...user, authError: null, authSessionError: null, profileError: null, settingsError: null }));
@@ -20499,6 +20486,7 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
     agreementStored = null;
     agreementOverride = null;
     agreementAcceptance = null;
+    blockedChanges.clear();
     userUid = null;
     avatarFetch = { uid: null, key: null, promise: null };
     avatarPreview = undefined;
@@ -20507,25 +20495,63 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
     blockedSet = new Set(blockedSource);
     snapshot = makeSnapshot();
   }
-  function blockPeer(peer) {
+  function changePeerBlock(peer, blocked, { beforeCommit } = {}) {
     const nextPeerUid = peerUid(peer);
     const uid = cloud.auth.user?.uid;
+    const session = authSession;
     if (!uid)
       throw new Error("auth");
     if (!nextPeerUid)
       throw new Error("peer uid required");
-    if (nextPeerUid === uid)
+    if (blocked && nextPeerUid === uid)
       return;
-    return cloud.user.blocked.add(uid, nextPeerUid);
+    const prior = blockedChanges.get(nextPeerUid);
+    if (prior && prior.blocked === blocked)
+      return prior.promise;
+    const current = () => isCurrentUser(uid, session);
+    const assertCurrent = () => {
+      if (!current())
+        throw new Error("account changed during block update");
+    };
+    const change = { blocked, written: false, promise: null };
+    change.promise = Promise.resolve().then(async () => {
+      try {
+        await prior?.promise.catch(NOOP);
+        assertCurrent();
+        await beforeCommit?.();
+        assertCurrent();
+        const result = await cloud.user.blocked[blocked ? "add" : "remove"](uid, nextPeerUid);
+        assertCurrent();
+        change.written = true;
+        if (blockedChanges.get(nextPeerUid) === change && state.blocked.includes(nextPeerUid) === blocked) {
+          blockedChanges.delete(nextPeerUid);
+        }
+        const confirmed = new Set(state.blocked);
+        if (blocked)
+          confirmed.add(nextPeerUid);
+        else
+          confirmed.delete(nextPeerUid);
+        setState((user) => ({ ...user, blocked: [...confirmed] }));
+        return result;
+      } catch (error) {
+        if (current() && blockedChanges.get(nextPeerUid) === change) {
+          blockedChanges.delete(nextPeerUid);
+          if (prior?.written)
+            blockedChanges.set(nextPeerUid, prior);
+          setState(state, true);
+        }
+        throw error;
+      }
+    });
+    blockedChanges.set(nextPeerUid, change);
+    setState(state, true);
+    return change.promise;
   }
-  function unblockPeer(peer) {
-    const nextPeerUid = peerUid(peer);
-    const uid = cloud.auth.user?.uid;
-    if (!uid)
-      throw new Error("auth");
-    if (!nextPeerUid)
-      throw new Error("peer uid required");
-    return cloud.user.blocked.remove(uid, nextPeerUid);
+  function blockPeer(peer, options) {
+    return changePeerBlock(peer, true, options);
+  }
+  function unblockPeer(peer, options) {
+    return changePeerBlock(peer, false, options);
   }
   async function acceptAgreement(requestedAgreement = CURRENT_AGREEMENT) {
     const uid = cloud.auth.user?.uid;
@@ -20739,6 +20765,13 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
     syncAvatar();
     return true;
   }
+  function restoreBlocked({ uid, blocked }) {
+    if (!started || !uid || uid !== state.uid || cloud.auth.user?.uid !== uid)
+      return;
+    if (state.blockedReady || !Array.isArray(blocked))
+      return;
+    setState((user) => ({ ...user, blocked: [...blocked], blockedReady: true }));
+  }
   snapshot = makeSnapshot();
   return {
     getSnapshot() {
@@ -20764,6 +20797,7 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
     previewAvatar,
     confirmAvatar,
     restoreBootstrap,
+    restoreBlocked,
     retry
   };
 }
@@ -21463,6 +21497,48 @@ 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;
@@ -24023,6 +24099,24 @@ async function openStateRecordsWithEvidence(epochState, records) {
     closeStateEpoch(opened);
   }
 }
+async function readChatMemberState(cloud, epochState, actorChatPK) {
+  if (!chatEpochCapabilities(epochState).sharedReceipts)
+    return null;
+  const member = epochState?.manifest?.members?.find((value) => value.chatPK === actorChatPK);
+  if (!member)
+    return null;
+  const opened = openStateEpoch(epochState);
+  try {
+    const slotId = deriveChatMemberStateSlot(opened.epoch, member.chatSigningPK);
+    const record = await cloud.chat.memberState.readSlot(opened.epoch.epochId, slotId);
+    if (!record || !stateRecordActive(record))
+      return null;
+    const state = await openChatMemberState(opened.epoch, record);
+    return state.actor === actorChatPK ? stateRecordProjection(opened.epoch.epochId, record, state) : null;
+  } finally {
+    closeStateEpoch(opened);
+  }
+}
 function watchChatMemberStateEvidence(cloud, epochState, onUpdate, onError) {
   if (!chatEpochCapabilities(epochState).sharedReceipts)
     return () => {};
@@ -25178,8 +25272,6 @@ function cleanChatPayment(message, { requireTx }) {
     } catch {
       return null;
     }
-    if (message.mode || message.transfers?.length !== 1)
-      return null;
   } else if (message.tokenIdentifier != null)
     return null;
   const transfers = cleanChatPaymentTransfers(message?.transfers, { requireTx, token });
@@ -25191,6 +25283,13 @@ function cleanChatPayment(message, { requireTx }) {
   if (transfers.length > 1 && !mode || rawMode && !mode)
     return null;
   const total = transfers.reduce((sum, transfer) => sum + BigInt(transfer.a), 0n);
+  if (token) {
+    try {
+      tokenUnits(total);
+    } catch {
+      return null;
+    }
+  }
   if (!mode && (transfers.length !== 1 || BigInt(transfers[0].a) !== amount))
     return null;
   if (mode === GROUP_SEND_MODES.EACH && transfers.some((transfer) => BigInt(transfer.a) !== amount))
@@ -25216,14 +25315,14 @@ function makeChatPaymentPayload({ amountSats, amountUnits, tokenIdentifier, tran
   if (token) {
     tokenAsset(tokenIdentifier, paymentNetwork);
     tokenUnits(amount);
-    if (mode || transfers.length !== 1)
-      throw new Error("token payments require one direct recipient");
   }
   const rawMode = cleanText(mode);
   const groupMode = GROUP_PAYMENT_MODES.has(rawMode) ? rawMode : null;
   if (transfers.length > 1 && !groupMode || rawMode && !groupMode)
     throw new Error("chat payment mode required");
   const total = transfers.reduce((sum, transfer) => sum + BigInt(transfer.a), 0n);
+  if (token)
+    tokenUnits(total);
   if (!groupMode && (transfers.length !== 1 || BigInt(transfers[0].a) !== amount)) {
     throw new Error("direct payment amount must match its transfer");
   }
@@ -25260,8 +25359,6 @@ function chatPaymentMembersValid(message, payment) {
   if (sender && recipients.includes(sender))
     return false;
   const epochMembers = Array.isArray(message?.epochMemberChatPKs) ? new Set(message.epochMemberChatPKs.map((member) => cleanText(member).toLowerCase()).filter(Boolean)) : null;
-  if (message.tokenIdentifier != null && epochMembers?.size > 2)
-    return false;
   return !epochMembers?.size || recipients.every((recipient) => epochMembers.has(recipient));
 }
 function isChatPayment(message) {
@@ -25870,17 +25967,10 @@ function analyzeMessageExpiry(messages, selfChatPublicKey, _peerChatPublicKey, o
   const heldExpired = [];
   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 && !endedCalls.has(call.callId) || options.activeCallId === call.callId))
-      continue;
-    const readTarget = isPaymentRequest(message) ? message.paymentConfirmation : message;
-    if (!readTarget)
-      continue;
+    const readTarget = isPaymentRequest(message) && message.paymentConfirmation ? message.paymentConfirmation : message;
     const originalSeenAt = allReadersSeenAt(message, members, evidence, options.memberStatesByEpoch);
     const resultSeenAt = readTarget === message ? originalSeenAt : allReadersSeenAt(readTarget, members, evidence, options.memberStatesByEpoch);
     if (originalSeenAt == null || resultSeenAt == null)
@@ -29858,6 +29948,20 @@ function uniqueValues(items) {
 function sortedUniqueValues(items) {
   return uniqueValues(items).sort();
 }
+function sameArray(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) {
+    return false;
+  }
+  for (let index = 0;index < a.length; index += 1) {
+    if (a[index] !== b[index]) {
+      return false;
+    }
+  }
+  return true;
+}
 // ../../core/chat/chats.js
 "use client";
@@ -31115,7 +31219,8 @@ function writeCachedChats(cache, chats, options = {}) {
       }
     }
     for (const item of items) {
-      byId.set(item.id, item);
+      const previous = reviveChat(payload.chatsById?.[item.id]);
+      byId.set(item.id, previous ? serializeChat(mergeChatActivity(item, previous, options.chatPK)) : item);
     }
     const merged = [...byId.values()];
     const capped = merged.length > LOCAL_CHAT_CACHE_MAX_ITEMS;
@@ -31273,18 +31378,24 @@ function readCachedReadFrontiers(cache, chatId) {
     return [];
   return Object.values(source).map(cleanFrontier2).filter(Boolean);
 }
-function writeCachedReadFrontier(cache, chatId, value) {
+function writeCachedChatRead(cache, chatId, { frontier: value, message, openedAt, chatPK } = {}) {
   const frontier = cleanFrontier2(value);
-  if (!cache?.patch || !chatId || !frontier)
+  if (!cache?.patch || !chatId || !frontier && !message)
     return Promise.resolve(false);
   return cache.patch((payload) => {
-    const chats = payload.pendingReadFrontiersByChat || {};
-    const current = chats[chatId] || {};
-    chats[chatId] = {
-      ...current,
-      [frontier.epochId]: laterFrontier(cleanFrontier2(current[frontier.epochId]), frontier)
-    };
-    payload.pendingReadFrontiersByChat = chats;
+    if (frontier) {
+      const chats = payload.pendingReadFrontiersByChat || {};
+      const current = chats[chatId] || {};
+      chats[chatId] = {
+        ...current,
+        [frontier.epochId]: laterFrontier(cleanFrontier2(current[frontier.epochId]), frontier)
+      };
+      payload.pendingReadFrontiersByChat = chats;
+    }
+    const chat = payload.chatsById?.[chatId];
+    if (chat && message) {
+      [payload.chatsById[chatId]] = markChatsRead([chat], chatId, message, { openedAt, chatPK });
+    }
     return payload;
   }, { flush: true }).then(() => true);
 }
@@ -31640,6 +31751,15 @@ function createPendingSendQueue({ diag = null } = {}) {
   const generationRef = { current: 0 };
   const sentAtRef = { current: [] };
   const timerRef = { current: null };
+  let active = true;
+  let scheduleVersion = 0;
+  function clearSchedule() {
+    scheduleVersion += 1;
+    if (timerRef.current !== null)
+      clearTimeout(timerRef.current);
+    timerRef.current = null;
+    scheduledRef.current = false;
+  }
   function nextRateDelay() {
     const now = Date.now();
     const since = now - CHAT_SEND_QUEUE_RATE_LIMIT_WINDOW_MS;
@@ -31681,6 +31801,8 @@ function createPendingSendQueue({ diag = null } = {}) {
     }
   }
   const flush = () => {
+    if (!active)
+      return;
     if (scheduledRef.current || !queueRef.current.length) {
       markDiag(diag, "chat.send.queue.flush.skip", {
         scheduled: !!scheduledRef.current,
@@ -31706,7 +31828,10 @@ function createPendingSendQueue({ diag = null } = {}) {
       running: runningJobsRef.current.size,
       sentWindow: sentAtRef.current.length
     });
+    const version = ++scheduleVersion;
     timerRef.current = setTimeout(() => {
+      if (!active || version !== scheduleVersion)
+        return;
       timerRef.current = null;
       scheduledRef.current = false;
       const nextIndex = nextRunnableJobIndex();
@@ -31801,6 +31926,7 @@ function createPendingSendQueue({ diag = null } = {}) {
   };
   const resetPendingSendQueue = () => {
     generationRef.current += 1;
+    clearSchedule();
     if (queueRef.current.length) {
       const error = new Error("chat reset");
       queueRef.current.forEach((job) => {
@@ -31809,16 +31935,18 @@ function createPendingSendQueue({ diag = null } = {}) {
       });
     }
     queueRef.current = [];
-    scheduledRef.current = false;
     sentAtRef.current = [];
-    if (timerRef.current) {
-      clearTimeout(timerRef.current);
-      timerRef.current = null;
-    }
   };
   return {
     enqueuePendingSendJob,
     resetPendingSendQueue,
+    setActive(value) {
+      active = value === true;
+      clearSchedule();
+      markDiag(diag, "chat.send.queue.activity", { active, queued: queueRef.current.length, running: runningJobsRef.current.size });
+      if (active)
+        flush();
+    },
     close: resetPendingSendQueue
   };
 }
@@ -33454,6 +33582,7 @@ ${cid}` : "";
   };
   return {
     resetSending,
+    setActive: pendingSendQueueRef.current.setActive,
     ackMessages,
     stageMessage: showLocalMessage,
     discardLocalMessage: (chatId, cid) => ackMessages(chatId, [cid], { remove: true }),
@@ -36097,7 +36226,7 @@ function createChatListCache({ getSources, state }) {
     const pending = pendingWrite;
     pendingWrite = null;
     if (pending?.cache && Array.isArray(pending.chats)) {
-      writeCachedChats(pending.cache, pending.chats, { ownerListToken: pending.ownerListToken });
+      writeCachedChats(pending.cache, pending.chats, { ownerListToken: pending.ownerListToken, chatPK: pending.chatPK });
     }
   };
   const queue = (nextChats, options = {}) => {
@@ -36109,6 +36238,7 @@ function createChatListCache({ getSources, state }) {
     const requestedToken = requestedCoverage === CACHE_COVERAGE.COMPLETE ? cleanOwnerListToken(options.ownerListToken) : requestedCoverage === CACHE_COVERAGE.INCOMPLETE ? null : pendingWrite?.ownerListToken;
     pendingWrite = {
       cache: sources.localCache,
+      chatPK: sources.chatPK,
       chats: nextChats,
       ownerListToken: requestedToken
     };
@@ -36135,6 +36265,11 @@ function createChatListCache({ getSources, state }) {
       state.setHasMoreChats(false);
     }
     hydrateReadCache(cachedChats, sources.readCacheRef.current);
+    for (const chatId of Object.keys(cachedPayload?.pendingReadFrontiersByChat || {})) {
+      const at = Math.max(0, ...readCachedReadFrontiers(sources.localCache, chatId).map((frontier) => frontier.at));
+      if (at > (sources.readCacheRef.current.get(chatId) || 0))
+        sources.readCacheRef.current.set(chatId, at);
+    }
     const cachedChatsWithRead = applyReadCache(cachedChats, sources.chatPK, sources.readCacheRef.current);
     if (hasSavedChatSnapshot) {
       const shownCachedChats = hydrateRows(cachedChatsWithRead);
@@ -38907,6 +39042,14 @@ function createChatListEpochOwner({ getGeneration, getSources, index }) {
 }
 // ../../core/chat/listindex.js
+function sameRecord(left, right) {
+  if (left === right)
+    return true;
+  if (!left || !right)
+    return false;
+  const keys = Object.keys(left);
+  return keys.length === Object.keys(right).length && keys.every((key) => Object.hasOwn(right, key) && Object.is(left[key], right[key]));
+}
 function ownerRevision(chat) {
   return Number.isSafeInteger(chat?.ownEntry?.ownerRevision) ? chat.ownEntry.ownerRevision : 0;
 }
@@ -38936,11 +39079,26 @@ function activityFromChat(chat) {
     unseen: chat.unseen === true
   };
 }
-function structuralChat(chat) {
+function structuralChat(chat, previous) {
   if (!chat)
     return null;
+  const structure = {};
+  if (previous && previous.epochId === chat.epochId && previous.epochVersion === chat.epochVersion) {
+    for (const key of ["memberChatPKs", "memberUids"]) {
+      if (sameArray(previous[key], chat[key]))
+        structure[key] = previous[key];
+    }
+    for (const key of ["signingKeysByChatKey", "settings"]) {
+      if (sameRecord(previous[key], chat[key]))
+        structure[key] = previous[key];
+    }
+    if (Array.isArray(previous.members) && Array.isArray(chat.members) && previous.members.length === chat.members.length && previous.members.every((member, index) => sameRecord(member, chat.members[index]))) {
+      structure.members = previous.members;
+    }
+  }
   return {
     ...chat,
+    ...structure,
     preview: null,
     readMs: null,
     inboxMessageId: null,
@@ -39004,7 +39162,7 @@ function sourceEntry() {
     presentation: null
   };
 }
-function createChatListIndex({ cache, filterHiddenChats, getSources, isHiddenChatId, state }) {
+function createChatListIndex({ cache, filterHiddenChats, getSources, isHiddenChatId, state, onOwnersChanged }) {
   const entries = new Map;
   const authorityBoundaries = new Map;
   let authorityRevision = 0;
@@ -39125,8 +39283,14 @@ function createChatListIndex({ cache, filterHiddenChats, getSources, isHiddenCha
     const visible = sources.blockedReady ? filterBlockedChats(composedRows()) : [];
     const trimmed = trimExpiredChatPreviews(visible);
     const shown = sources.blockedReady ? sortedChats(filterBlockedChats(setLocalChats(trimmed, sources.localByChatRef.current))) : [];
-    sources.chatsRef.current = shown;
-    state.setChats((current) => sameChats(current, shown) ? current : shown);
+    state.setChats((current) => {
+      const byId = new Map(current.map((chat) => [chat.id, chat]));
+      const next = shown.map((chat) => {
+        const previous = byId.get(chat.id);
+        return previous && sameChats([previous], [chat]) ? previous : chat;
+      });
+      return sameArray(current, next) ? current : next;
+    });
     const last = getLastChat(shown);
     state.setLastChat((current) => sameLastChat(current, last) ? current : last);
     updatePeers(shown);
@@ -39144,6 +39308,7 @@ function createChatListIndex({ cache, filterHiddenChats, getSources, isHiddenCha
     if (options.warm !== false) {
       sources.warmChats(sources.blockedReady ? filterBlockedChats(owners) : []);
     }
+    onOwnersChanged?.(owners);
     return owners;
   };
   const applyBlockedFilter = () => {
@@ -39169,7 +39334,7 @@ function createChatListIndex({ cache, filterHiddenChats, getSources, isHiddenCha
     for (const chat of filterHiddenChats(rows)) {
       const entry = entryFor(chat.id);
       captureActivity(entry, chat);
-      entry.cache = structuralChat(chat);
+      entry.cache = structuralChat(chat, entry.cache);
     }
     const shown = render();
     updatePeers(shown);
@@ -39219,7 +39384,7 @@ function createChatListIndex({ cache, filterHiddenChats, getSources, isHiddenCha
     for (const chat of incoming) {
       const entry = entryFor(chat.id);
       captureActivity(entry, chat);
-      entry.observedOwner = selectOwner(entry.observedOwner, structuralChat(chat));
+      entry.observedOwner = selectOwner(entry.observedOwner, structuralChat(chat, structuralOwnerFor(entry) || entry.cache));
       if (entry.committedOwner && compareOwners(entry.observedOwner, entry.committedOwner) >= 0) {
         entry.committedOwner = null;
       }
@@ -39237,7 +39402,7 @@ function createChatListIndex({ cache, filterHiddenChats, getSources, isHiddenCha
     for (const chat of (rows || []).filter((item) => item?.id && sourceCanPublish(item, options.sourceRevision))) {
       const entry = entryFor(chat.id);
       captureActivity(entry, chat);
-      entry.observedOwner = selectOwner(entry.observedOwner, structuralChat(chat));
+      entry.observedOwner = selectOwner(entry.observedOwner, structuralChat(chat, structuralOwnerFor(entry) || entry.cache));
       if (entry.committedOwner && compareOwners(entry.observedOwner, entry.committedOwner) >= 0) {
         entry.committedOwner = null;
       }
@@ -39257,7 +39422,7 @@ function createChatListIndex({ cache, filterHiddenChats, getSources, isHiddenCha
       return false;
     const entry = entryFor(chat.id);
     captureActivity(entry, chat);
-    entry.committedOwner = selectOwner(entry.committedOwner, structuralChat(chat));
+    entry.committedOwner = selectOwner(entry.committedOwner, structuralChat(chat, structuralOwnerFor(entry) || entry.cache));
     if (ownerCoversAnnouncement(ownerFor(entry), entry.announcement))
       entry.announcement = null;
     entry.cache = null;
@@ -39433,6 +39598,9 @@ function createChatListIndex({ cache, filterHiddenChats, getSources, isHiddenCha
     });
     if (next === current)
       return false;
+    const readCache = getSources().readCacheRef.current;
+    if (next.readMs > (readCache.get(chatId) || 0))
+      readCache.set(chatId, next.readMs);
     replaceActivity(entry, next);
     publishOwners();
     return true;
@@ -40085,6 +40253,75 @@ function createChatListPreview({ index, isListening, state }) {
   };
 }
+// ../../core/chat/listreads.js
+function createChatListReads({ getSources, index }) {
+  const attempted = new Set;
+  let queue = [];
+  let generation = 0;
+  let running = false;
+  const admitted = (chat, sources) => !sources.chatBanned && !(chat?.memberUids || []).some((uid) => sources.blockedUidSet.has(uid)) && chat?.unseen && chat.ownEntry && !isChatMembershipRemoved(chat);
+  const eligible = (chat, sources) => sources.isActive && admitted(chat, sources);
+  const pump = async () => {
+    if (running)
+      return;
+    running = true;
+    const run = generation;
+    try {
+      while (queue.length && run === generation) {
+        const { chatId, epochId, key } = queue.shift();
+        const sources = getSources();
+        const chat = index.getOwnerChat(chatId);
+        if (!eligible(chat, sources)) {
+          attempted.delete(key);
+          continue;
+        }
+        try {
+          const epoch = epochId === chat.epochId ? chat.epochState : await sources.getEpochState(chat, epochId);
+          if (run !== generation)
+            return;
+          const state = epoch ? await readChatMemberState(sources.cloud, epoch, sources.chatPK) : null;
+          if (run !== generation || !admitted(index.getOwnerChat(chatId), getSources()))
+            continue;
+          const frontier = state?.readFrontier;
+          if (frontier)
+            index.markChatRead(chatId, { id: frontier.id, ts: frontier.at }, frontier.seenAt);
+        } catch (error) {
+          if (run !== generation)
+            return;
+          markError(sources.diag, "chat.list.read.restore", Date.now(), error);
+        }
+      }
+    } finally {
+      if (run === generation)
+        running = false;
+    }
+  };
+  return {
+    restore(chats) {
+      const sources = getSources();
+      if (typeof sources.cloud?.chat?.memberState?.readSlot !== "function")
+        return;
+      for (const chat of chats) {
+        if (!eligible(chat, sources))
+          continue;
+        const epochId = chat.preview?.epochId || chat.epochId;
+        const key = `${chat.id}:${epochId}`;
+        if (attempted.has(key))
+          continue;
+        attempted.add(key);
+        queue.push({ chatId: chat.id, epochId, key });
+      }
+      return pump();
+    },
+    reset() {
+      generation += 1;
+      attempted.clear();
+      queue = [];
+      running = false;
+    }
+  };
+}
 // ../../core/chat/liststate.js
 function nextValue(current, next) {
   return typeof next === "function" ? next(current) : next;
@@ -40263,7 +40500,16 @@ function createChatList(initialSources) {
   const filterHiddenChats = (chats) => (chats || []).filter((chatItem) => chatItem?.id && !isHiddenChatId(chatItem.id));
   const state = createChatListState({ getSources });
   const cache = createChatListCache({ getSources, state });
-  const index = createChatListIndex({ cache, filterHiddenChats, getSources, isHiddenChatId, state });
+  let reads = null;
+  const index = createChatListIndex({
+    cache,
+    filterHiddenChats,
+    getSources,
+    isHiddenChatId,
+    state,
+    onOwnersChanged: (chats) => reads?.restore(chats)
+  });
+  reads = createChatListReads({ getSources, index });
   const epoch = createChatListEpochOwner({ getGeneration, getSources, index });
   const paging = createChatListPaging({ cache, getGeneration, getSources, index, isHiddenChatId, state });
   const invalidateRuntimeTasks = () => {
@@ -40272,6 +40518,7 @@ function createChatList(initialSources) {
     epoch.reset();
   };
   const resetChatList = (ready = false) => {
+    reads.reset();
     invalidateRuntimeTasks();
     index.reset(ready);
   };
@@ -40322,6 +40569,7 @@ function createChatList(initialSources) {
       index.applyBlockedFilter();
       paging.fillVisibleChatPage();
     }
+    reads.restore(index.getOwnerChats());
   };
   const start2 = () => {
     if (listener.isListening())
@@ -40330,6 +40578,7 @@ function createChatList(initialSources) {
     preview.schedule();
   };
   const close = () => {
+    reads.reset();
     listener.close();
     preview.close();
     cache.flush();
@@ -42456,9 +42705,6 @@ function createChatSessionPending({
     return track(launchId, previousOperation.then((result) => sendDurableSharedAttachment(result?.chatId || launchId, queuedAttachment, options)));
   };
   const sendChatMessage = (chatId, message, options = {}) => {
-    const chat = getOwnerChat(resolvePendingChatId(chatId)) || launchForChat(chatId)?.chat;
-    if (message?.tokenIdentifier != null && chat?.lineage === "group")
-      throw new Error("group payments support bitcoin only");
     const operation = operationForChat(chatId);
     if (operation?.discarding)
       throw makeChatUnavailableError();
@@ -43862,7 +44108,6 @@ function createChatSeen({
   const scheduleRead = (chatId, message, previewMs, frontierMessage, messages = []) => {
     const frontier = Number.isSafeInteger(frontierMessage?.at) && frontierMessage?.epochId ? frontierMessage : readFrontierFromMessage(frontierMessage, { seenAt: previewMs });
     if (frontier) {
-      writeCachedReadFrontier(localCache, chatId, frontier);
       onReadFrontier?.(chatId, frontier);
     }
     const timing = getReadWriteTiming?.(chatId) || {};
@@ -43896,6 +44141,12 @@ function createChatSeen({
     const frontier = readFrontierFromMessage(frontierMessage, { seenAt: read?.previewMs || Date.now() });
     if (!read && !frontier && !cachedFrontiers.length)
       return false;
+    const savedRead = writeCachedChatRead(localCache, chatId, {
+      frontier,
+      message: read?.preview,
+      openedAt: read?.previewMs,
+      chatPK
+    }).catch((error) => markError(diag, "chat.read.cache", Date.now(), error));
     if (read) {
       markChatRead?.(chatId, read.preview, read.previewMs);
       readCacheRef.current.set(chatId, read.readMs);
@@ -43905,6 +44156,7 @@ function createChatSeen({
     for (const cached of cachedFrontiers)
       scheduleRead(chatId, preview, previewMs, cached, messages);
     scheduleRead(chatId, preview, previewMs, frontierMessage, messages);
+    await savedRead;
     return true;
   };
   const markChatReadState = async (chatId, message, options = {}) => {
@@ -43992,6 +44244,7 @@ function createChatSessionActions({
   diag,
   readWriteInterval,
   adoptLocalMessageMedia,
+  getActive,
   getIdentity,
   getLiveActivity,
   getOwnerChat,
@@ -44123,6 +44376,7 @@ function createChatSessionActions({
       reconcileEpoch: (chatId) => getChatListOwner().reconcileChatEpoch(chatId),
       diag
     });
+    sendActions.setActive(getActive());
     reactionActions = createChatReaction({
       cloud,
       uid: identity().uid,
@@ -44267,10 +44521,10 @@ function sameReadFrontier(left, right) {
   return left.actor === right.actor && left.readFrontier?.epochId === right.readFrontier?.epochId && left.readFrontier?.id === right.readFrontier?.id && left.readFrontier?.at === right.readFrontier?.at && left.readFrontier?.seenAt === right.readFrontier?.seenAt;
 }
 function sameActivity2(left, right) {
-  return left.connected === right.connected && left.activeChatPKs.length === right.activeChatPKs.length && left.compositions.length === right.compositions.length && left.readFrontiers.length === right.readFrontiers.length && left.activeChatPKs.every((value, index) => value === right.activeChatPKs[index]) && left.compositions.every((value, index) => sameComposition(value, right.compositions[index])) && left.readFrontiers.every((value, index) => sameReadFrontier(value, right.readFrontiers[index]));
+  return left.connected === right.connected && left.lastObservedAtByChatPK === right.lastObservedAtByChatPK && left.activeChatPKs.length === right.activeChatPKs.length && left.compositions.length === right.compositions.length && left.readFrontiers.length === right.readFrontiers.length && left.activeChatPKs.every((value, index) => value === right.activeChatPKs[index]) && left.compositions.every((value, index) => sameComposition(value, right.compositions[index])) && left.readFrontiers.every((value, index) => sameReadFrontier(value, right.readFrontiers[index]));
 }
 function hasActivity(activity) {
-  return !!(activity?.connected || activity?.activeChatPKs?.length || activity?.compositions?.length || activity?.readFrontiers?.length);
+  return !!(activity?.connected || activity?.activeChatPKs?.length || activity?.compositions?.length || activity?.readFrontiers?.length || Object.keys(activity?.lastObservedAtByChatPK || {}).length);
 }
 function summarizeLocalMessage(summary, message) {
   summary.messages += 1;
@@ -44411,6 +44665,17 @@ function createChatSessionState({
       return;
     const next = new Map(liveActivityByChat);
     const previous = next.get(chatId);
+    let lastObservedAtByChatPK = previous?.lastObservedAtByChatPK;
+    const departed = previous?.connected ? previous.activeChatPKs.filter((actor) => !activity?.connected || !activity.activeChatPKs.includes(actor)) : [];
+    if (departed.length) {
+      const now = Date.now();
+      lastObservedAtByChatPK = { ...lastObservedAtByChatPK };
+      for (const actor of departed)
+        lastObservedAtByChatPK[actor] = Math.max(lastObservedAtByChatPK[actor] || 0, now);
+      Object.freeze(lastObservedAtByChatPK);
+    }
+    if (lastObservedAtByChatPK)
+      activity = { ...activity, lastObservedAtByChatPK };
     if (previous?.connected && !activity?.connected)
       onLiveDisconnect(chatId);
     if (hasActivity(activity)) {
@@ -44805,6 +45070,7 @@ function normalizeChatSessionSources(sources = {}) {
     uid: sources.uid || "",
     online: sources.online !== false,
     blocked: Array.isArray(sources.blocked) ? sources.blocked : [],
+    blockedPending: Array.isArray(sources.blockedPending) ? sources.blockedPending : [],
     blockedReady: sources.blockedReady === true,
     chatPK: sources.chatPK || "",
     chatBanned: sources.chatBanned === true,
@@ -44853,7 +45119,6 @@ function createChatSession({
   mls = null,
   live = null,
   maintenance,
-  resolveActiveCall,
   incomingChatDecision = null,
   getPeerProfile = null,
   refreshPeerProfile = null,
@@ -44871,6 +45136,7 @@ function createChatSession({
     uid = "",
     online = true,
     blocked = [],
+    blockedPending = [],
     blockedReady = false,
     chatPK = "",
     chatSigningPK = "",
@@ -44887,6 +45153,7 @@ function createChatSession({
   let inboxEnabled = initialSources.inboxEnabled === true;
   let started = false;
   let appStateSubscription = null;
+  const messageListeners = new Set;
   let mlsPoolReplenishment = null;
   let mlsPoolReplenishQueued = false;
   let mlsPoolNeedsReplenish = true;
@@ -45061,6 +45328,13 @@ function createChatSession({
   };
   const handleBatchMessages = (chatId, messages) => {
     chatListOwner.observeMessages(chatId, messages);
+    for (const listener of messageListeners) {
+      try {
+        listener(chatId, messages);
+      } catch (error) {
+        diag?.("chat.message.observer.error", { code: error?.code || "chat/observer" });
+      }
+    }
     if (![...messages || []].reverse().some(isEpochTransitionMsg))
       return;
     const startedAt = Date.now();
@@ -45493,8 +45767,6 @@ function createChatSession({
     const chat = getOwnerChat(chatId);
     if (!chat)
       throw makeChatUnavailableError();
-    if (payment.tokenIdentifier != null && chat.lineage !== "direct")
-      throw new Error("group payments support bitcoin only");
     const members = Array.isArray(chat?.memberChatPKs) ? chat.memberChatPKs.map((memberChatPK) => cleanText(memberChatPK).toLowerCase()) : (chat?.members || []).map((member) => cleanText(member?.chatPK).toLowerCase());
     const message = pending ? makePendingChatPayment(payment) : makeChatPayment(payment);
     const recipients = chatPaymentRecipients(message);
@@ -45521,6 +45793,7 @@ function createChatSession({
   };
   const getLocalMessages = (chatId) => isChatPendingDelete(chatId) || !isChatIdVisible(chatId) ? EMPTY_LOCAL_MESSAGES : localByChatRef.current.get(chatId) ?? EMPTY_LOCAL_MESSAGES;
   const blockedAuthority = (values) => [...values || []].sort().join("|");
+  const committedBlocked = () => blocked.filter((uid2) => !blockedPending.includes(uid2));
   const bulkOperation = (blockedUids = null) => ({
     generation: authGeneration,
     identity: {
@@ -45536,7 +45809,7 @@ function createChatSession({
     deleteActions: actionOwner.deleteActions,
     blockedKey: blockedUids ? blockedAuthority(blockedUids) : null
   });
-  const isBulkOperationCurrent = (operation) => operation.generation === authGeneration && operation.deleteActions === actionOwner.deleteActions && (operation.blockedKey == null || operation.blockedKey === blockedAuthority(blocked));
+  const isBulkOperationCurrent = (operation) => operation.generation === authGeneration && operation.deleteActions === actionOwner.deleteActions && (operation.blockedKey == null || operation.blockedKey === blockedAuthority(committedBlocked()));
   const assertBulkOperationCurrent = (operation) => {
     requireOnline();
     if (!isBulkOperationCurrent(operation))
@@ -45550,32 +45823,42 @@ function createChatSession({
       return 0;
     let allChats = await loadOwnerChats(cloud, identity.uid, identity.chatPK, identity.chatPrivateKey);
     assertBulkOperationCurrent(operation);
-    let processedInbox = true;
-    while (processedInbox) {
-      processedInbox = await processInbox(cloud, identity.uid, identity.chatPK, identity.chatPrivateKey, {
-        currentChats: allChats,
-        chatSigningPK: identity.chatSigningPK,
-        chatSigningSecret: identity.chatSigningSecret,
-        notificationPK: identity.notificationPK,
-        notificationPrivateKey: identity.notificationPrivateKey,
-        mls,
-        blockedUids: new Set(identity.blocked),
-        chatAdmission,
-        incomingChatDecision,
-        scanAllSlots: true,
-        requireComplete: true
-      });
-      assertBulkOperationCurrent(operation);
-      if (processedInbox) {
-        allChats = await loadOwnerChats(cloud, identity.uid, identity.chatPK, identity.chatPrivateKey);
-        assertBulkOperationCurrent(operation);
-      }
-    }
+    await processInbox(cloud, identity.uid, identity.chatPK, identity.chatPrivateKey, {
+      currentChats: allChats,
+      chatSigningPK: identity.chatSigningPK,
+      chatSigningSecret: identity.chatSigningSecret,
+      notificationPK: identity.notificationPK,
+      notificationPrivateKey: identity.notificationPrivateKey,
+      mls,
+      blockedUids: new Set(identity.blocked),
+      chatAdmission,
+      incomingChatDecision,
+      scanAllSlots: true,
+      requireComplete: true,
+      isCurrent: () => isBulkOperationCurrent(operation),
+      diag
+    });
+    assertBulkOperationCurrent(operation);
+    allChats = await loadOwnerChats(cloud, identity.uid, identity.chatPK, identity.chatPrivateKey);
+    assertBulkOperationCurrent(operation);
     if (!allChats.length)
       return 0;
     let retired = 0;
-    for (const chat of allChats) {
+    for (const ownedChat of allChats) {
       assertBulkOperationCurrent(operation);
+      let chat = ownedChat;
+      if (!isChatMembershipRemoved(chat)) {
+        chatListOwner.commitOwner(chat);
+        const reconciliation = await chatListOwner.reconcileChatEpoch(chat.id);
+        assertBulkOperationCurrent(operation);
+        chat = getOwnerChat(chat.id);
+        if (!chat) {
+          if (!reconciliation.removed)
+            throw makeChatUnavailableError();
+          retired += 1;
+          continue;
+        }
+      }
       if (isChatMembershipRemoved(chat)) {
         await operation.deleteActions.deleteChat(chat, { cleanup: false });
         assertBulkOperationCurrent(operation);
@@ -45717,9 +46000,10 @@ function createChatSession({
       return false;
     }
   };
-  const prepareCall = async (chatId) => {
+  const prepareCall = async (chatId, options = {}) => {
     const generation = authGeneration;
-    const current = () => generation === authGeneration && online && pendingOwner.canSendToChat(chatId);
+    await sendReadiness.wait(chatId, options);
+    const current = () => generation === authGeneration && !options.signal?.aborted && online && pendingOwner.canSendToChat(chatId);
     if (!current())
       throw new Error("chat unavailable");
     await pendingOwner.assertChatAdmission(chatId);
@@ -45736,7 +46020,13 @@ function createChatSession({
       throw new Error("chat unavailable");
     return chat.epochState;
   };
-  const materializeChat = (chatId) => pendingOwner.runChatMutation(chatId, (canonicalId) => canonicalId);
+  const materializeChat = async (chatId, options = {}) => {
+    const generation = authGeneration;
+    await sendReadiness.wait(chatId, options);
+    if (generation !== authGeneration || options.signal?.aborted)
+      throw makeChatUnavailableError();
+    return pendingOwner.runChatMutation(chatId, (canonicalId) => canonicalId);
+  };
   const flushChatReadFrontier = (chatId) => {
     if (!online)
       return false;
@@ -45928,6 +46218,7 @@ function createChatSession({
     lastHydratedCacheKeyRef,
     chatsRef,
     reconcileMessageBatches: (...args) => messageBatchOwner.reconcileChats(...args),
+    getEpochState: (...args) => historyOwner.getEpochState(...args),
     warmChats: (...args) => messageBatchOwner.warm(...args),
     onOwnerRemoved: (chatIds) => {
       for (const chatId of chatIds)
@@ -45986,6 +46277,7 @@ function createChatSession({
     });
   };
   stateOwner.setActions({
+    ensureChat,
     loadMoreChats: loadMoreChats2,
     selectChat,
     resolveChatRequest,
@@ -46054,7 +46346,6 @@ function createChatSession({
     deleteMessage,
     deleteMessages,
     deleteMessageDocs,
-    resolveActiveCall,
     setChatTtl,
     makeMessagePermanent,
     makeMessageTemporary,
@@ -46071,6 +46362,7 @@ function createChatSession({
     diag,
     readWriteInterval,
     adoptLocalMessageMedia,
+    getActive: () => isActive,
     getIdentity: () => ({
       uid,
       chatPK,
@@ -46120,6 +46412,7 @@ function createChatSession({
   const setActive = (nextActive) => {
     foreground = nextActive === true;
     const value = foreground && online;
+    actionOwner.sendActions.setActive(value);
     if (isActive === value)
       return;
     if (!value) {
@@ -46147,7 +46440,7 @@ function createChatSession({
     inboxTransport.setSource(inboxSource());
   };
   const setSources = (nextSources = {}) => {
-    const previousBlockedKey = [...blocked].sort().join("|");
+    const previousBlockedKey = blockedAuthority(committedBlocked());
     const current = { uid, chatPK, chatBanned, chatPrivateKey, chatSigningPK, chatSigningSecret, notificationPK, notificationPrivateKey, chatAdmission, localCache };
     const next = normalizeChatSessionSources(nextSources);
     const admissionChanged = !sameChatAdmission(chatAdmission, next.chatAdmission);
@@ -46164,6 +46457,7 @@ function createChatSession({
       uid,
       online,
       blocked,
+      blockedPending,
       blockedReady,
       chatPK,
       chatBanned,
@@ -46198,9 +46492,9 @@ function createChatSession({
       drainMembershipOutbox();
       replenishMlsPool({ force: true });
     }
-    const nextBlockedKey = [...blocked].sort().join("|");
+    const nextBlockedKey = blockedAuthority(committedBlocked());
     if (online && blockedReady && nextBlockedKey && nextBlockedKey !== previousBlockedKey) {
-      retireBlockedChats(new Set(blocked)).catch((error) => {
+      retireBlockedChats(new Set(committedBlocked())).catch((error) => {
         markDiag(diag, "chat.block.retire.failed", { message: error?.message || String(error) });
       });
     }
@@ -46220,8 +46514,8 @@ function createChatSession({
     publish();
     inboxTransport.start(inboxSource());
     chatListOwner.start();
-    if (blockedReady && blocked.length) {
-      retireBlockedChats(new Set(blocked)).catch((error) => {
+    if (blockedReady && committedBlocked().length) {
+      retireBlockedChats(new Set(committedBlocked())).catch((error) => {
         markDiag(diag, "chat.block.retire.failed", { message: error?.message || String(error) });
       });
     }
@@ -46234,6 +46528,7 @@ function createChatSession({
   };
   const close = () => {
     authGeneration += 1;
+    messageListeners.clear();
     sendReadiness.reset();
     pendingOwner.reset();
     maintenance.close();
@@ -46259,7 +46554,20 @@ function createChatSession({
   const subscribeFields = stateOwner.subscribeFields;
   const getSnapshot = stateOwner.getSnapshot;
   publish();
-  return { close, getSnapshot, refreshAdmissionProjection, setInboxEnabled, setSources, start: start2, subscribe, subscribeFields };
+  return {
+    close,
+    getSnapshot,
+    refreshAdmissionProjection,
+    setInboxEnabled,
+    setSources,
+    start: start2,
+    subscribe,
+    subscribeFields,
+    subscribeMessages(listener) {
+      messageListeners.add(listener);
+      return () => messageListeners.delete(listener);
+    }
+  };
 }
 // ../../core/presence/protocol.js
@@ -46433,6 +46741,7 @@ function createPresence({ cloud, diag = null, now = Date.now } = {}) {
   const peerListeners = new Set;
   const records = new Map;
   const peers = new Map;
+  const peersByUid = new Map;
   const readyShards = new Map;
   let sources = { uid: null, identity: null, enabled: false };
   let channel = null;
@@ -46444,11 +46753,13 @@ function createPresence({ cloud, diag = null, now = Date.now } = {}) {
   let seq = 0;
   let renewTimer = null;
   let expiryTimer = null;
+  let expiryAt = Infinity;
+  let ownTopic = null;
   let command = null;
   let authenticating = null;
   let snapshot = Object.freeze({ visibility: null, ready: false, pending: false, pendingVisibility: null, error: null, ...UNKNOWN_PRESENCE });
   function topic() {
-    return sources.uid ? derivePresenceTopic(realm2, sources.uid) : null;
+    return ownTopic;
   }
   function isReady() {
     return Boolean(channel && challenge && policy && sources.enabled && !closed);
@@ -46481,17 +46792,19 @@ function createPresence({ cloud, diag = null, now = Date.now } = {}) {
     const latest = fresh.reduce((selected, lease) => !selected || lease.issuedAt > selected.issuedAt || lease.issuedAt === selected.issuedAt && lease.session > selected.session ? lease : selected, null);
     return { availability: fresh.length ? "online" : "offline", status: latest?.status ?? null, lastActiveAt };
   }
-  function refresh() {
-    clearTimeout(expiryTimer);
-    expiryTimer = null;
-    let changed = false;
+  function refresh(keys = records.keys(), changedUids = new Set) {
     let deadline = Infinity;
     const timestamp = now();
-    for (const record of records.values()) {
+    for (const key of keys) {
+      const record = records.get(key);
+      if (!record)
+        continue;
       const next = projection(record);
       if (!samePresence(record.view, next)) {
         record.view = Object.freeze(next);
-        changed = true;
+        const uid = peers.get(key)?.uid;
+        if (uid)
+          changedUids.add(uid);
       }
       if (record.ready) {
         for (const lease of record.leases)
@@ -46504,11 +46817,18 @@ function createPresence({ cloud, diag = null, now = Date.now } = {}) {
     }
     const own = records.get(topic())?.view || UNKNOWN_PRESENCE;
     publish(policy?.visibility === "private" ? OFFLINE_PRESENCE : own);
-    if (changed)
+    if (changedUids.size)
       for (const listener of peerListeners)
-        listener();
-    if (Number.isFinite(deadline) && deadline > timestamp)
-      expiryTimer = setTimeout(refresh, deadline - timestamp + 1);
+        listener(changedUids);
+    if (deadline < expiryAt && deadline > timestamp) {
+      clearTimeout(expiryTimer);
+      expiryAt = deadline;
+      expiryTimer = setTimeout(() => {
+        expiryAt = Infinity;
+        expiryTimer = null;
+        refresh();
+      }, deadline - timestamp + 1);
+    }
   }
   function finishCommand(error = null) {
     if (!command)
@@ -46523,7 +46843,7 @@ function createPresence({ cloud, diag = null, now = Date.now } = {}) {
       pending.resolve(snapshot);
   }
   function expected(identity, extra = {}) {
-    return { realm: realm2, topic: derivePresenceTopic(realm2, identity.uid), signingPK: identity.chatSigningPK, now: now(), ...extra };
+    return { realm: realm2, topic: identity.topic, signingPK: identity.chatSigningPK, now: now(), ...extra };
   }
   function receive(frame) {
     const identity = peers.get(frame.topic);
@@ -46548,6 +46868,15 @@ function createPresence({ cloud, diag = null, now = Date.now } = {}) {
             lastActiveAt = verifyPresenceObservation(frame.lastObservation, scope).lastActiveAt;
           } catch {}
         }
+        const timestamp = now();
+        if (previous?.revision === currentPolicy.revision) {
+          lastActiveAt = Math.max(lastActiveAt || 0, previous.lastActiveAt || 0) || null;
+          if (!frame.leases?.length && previous.ready && previous.leases.some((lease) => lease.expiresAt > timestamp)) {
+            lastActiveAt = Math.max(lastActiveAt || 0, timestamp);
+          }
+        }
+        for (const lease of leases)
+          lastActiveAt = Math.max(lastActiveAt || 0, Math.min(lease.issuedAt, timestamp));
       }
       records.set(frame.topic, {
         ready: true,
@@ -46556,7 +46885,7 @@ function createPresence({ cloud, diag = null, now = Date.now } = {}) {
         revision: currentPolicy?.revision ?? previous?.revision ?? 0,
         view: previous?.view || UNKNOWN_PRESENCE
       });
-      refresh();
+      refresh([frame.topic]);
     } catch (error) {
       report(error);
     }
@@ -46574,10 +46903,10 @@ function createPresence({ cloud, diag = null, now = Date.now } = {}) {
     if (!session || !policy || policy.visibility !== "public" || command)
       return;
     const timestamp = now();
-    const ownTopic = topic();
+    const ownTopic2 = topic();
     const lease = signPresenceLease(sources.identity, {
       realm: realm2,
-      topic: ownTopic,
+      topic: ownTopic2,
       session,
       challenge,
       policyRevision: policy.revision,
@@ -46588,11 +46917,11 @@ function createPresence({ cloud, diag = null, now = Date.now } = {}) {
     });
     const observation = signPresenceObservation(sources.identity, {
       realm: realm2,
-      topic: ownTopic,
+      topic: ownTopic2,
       policyRevision: policy.revision,
       lastActiveAt: Math.floor(timestamp / PRESENCE_LAST_ACTIVE_BUCKET_MS) * PRESENCE_LAST_ACTIVE_BUCKET_MS
     });
-    channel.send(presenceShard(ownTopic), { type: "lease", lease, observation });
+    channel.send(presenceShard(ownTopic2), { type: "lease", lease, observation });
   }
   function receiveOwner(frame) {
     if (frame.topic !== topic() || !sources.identity)
@@ -46614,7 +46943,7 @@ function createPresence({ cloud, diag = null, now = Date.now } = {}) {
       if (policy.visibility === "private") {
         const previous = records.get(topic());
         records.set(topic(), { ready: true, leases: [], lastActiveAt: null, revision: policy.revision, view: previous?.view || UNKNOWN_PRESENCE });
-        refresh();
+        refresh([topic()]);
       }
       if (command && policy.revision >= command.policy.revision) {
         finishCommand(policy.signature === command.policy.signature ? null : new Error("activity setting changed on another device; try again"));
@@ -46725,7 +47054,7 @@ function createPresence({ cloud, diag = null, now = Date.now } = {}) {
   function setPeers(profiles) {
     const next = new Map;
     if (sources.uid && sources.identity)
-      next.set(topic(), { uid: sources.uid, chatSigningPK: sources.identity.publicKey });
+      next.set(topic(), { uid: sources.uid, topic: topic(), chatSigningPK: sources.identity.publicKey });
     for (const profile of profiles || []) {
       if (next.size >= PRESENCE_MAX_SUBSCRIPTIONS)
         break;
@@ -46733,27 +47062,34 @@ function createPresence({ cloud, diag = null, now = Date.now } = {}) {
         continue;
       if (profile.uid === sources.uid)
         continue;
-      next.set(derivePresenceTopic(realm2, profile.uid), { uid: profile.uid, chatSigningPK: profile.chatSigningPK });
+      const key = peersByUid.get(profile.uid)?.topic || derivePresenceTopic(realm2, profile.uid);
+      next.set(key, { uid: profile.uid, topic: key, chatSigningPK: profile.chatSigningPK });
     }
     let changed = peers.size !== next.size;
+    const changedUids = new Set;
     for (const [key, identity] of next) {
       if (peers.get(key)?.chatSigningPK !== identity.chatSigningPK) {
         changed = true;
+        changedUids.add(identity.uid);
         records.delete(key);
       }
     }
+    for (const [key, identity] of peers)
+      if (!next.has(key))
+        changedUids.add(identity.uid);
     if (!changed)
       return;
     peers.clear();
-    for (const [key, value] of next)
+    peersByUid.clear();
+    for (const [key, value] of next) {
       peers.set(key, value);
+      peersByUid.set(value.uid, value);
+    }
     for (const key of records.keys())
       if (!peers.has(key))
         records.delete(key);
     sync();
-    refresh();
-    for (const listener of peerListeners)
-      listener();
+    refresh([], changedUids);
   }
   function update(next) {
     const accountChanged = sources.uid !== next.uid;
@@ -46762,11 +47098,15 @@ function createPresence({ cloud, diag = null, now = Date.now } = {}) {
       stop();
       policy = null;
       records.clear();
-      if (accountChanged)
+      if (accountChanged) {
         peers.clear();
+        peersByUid.clear();
+      }
       publish({ visibility: null, error: null, ...UNKNOWN_PRESENCE });
     }
     sources = next;
+    if (accountChanged)
+      ownTopic = next.uid ? derivePresenceTopic(realm2, next.uid) : null;
     setPeers([...peers.values()]);
     sync();
   }
@@ -46807,10 +47147,10 @@ function createPresence({ cloud, diag = null, now = Date.now } = {}) {
     getPeer(profile) {
       if (!profile?.uid)
         return UNKNOWN_PRESENCE;
-      const key = derivePresenceTopic(realm2, profile.uid);
-      if (peers.get(key)?.chatSigningPK !== profile.chatSigningPK)
+      const identity = peersByUid.get(profile.uid);
+      if (!identity || identity.chatSigningPK !== profile.chatSigningPK)
         return UNKNOWN_PRESENCE;
-      return records.get(key)?.view || UNKNOWN_PRESENCE;
+      return records.get(identity.topic)?.view || UNKNOWN_PRESENCE;
     },
     subscribe(listener) {
       listeners.add(listener);
@@ -46829,6 +47169,7 @@ function createPresence({ cloud, diag = null, now = Date.now } = {}) {
       listeners.clear();
       peerListeners.clear();
       peers.clear();
+      peersByUid.clear();
       records.clear();
     }
   });
@@ -47089,6 +47430,10 @@ function openCallMailbox({ cloud, capability, endpoint, protocol, onChange, onEr
   }
   return Object.freeze({
     getSnapshot: () => candidate || record,
+    async settled() {
+      await tail;
+      return record;
+    },
     async ready() {
       const response = await channel.ready();
       await consume(response.record);
@@ -47427,6 +47772,20 @@ function openAccountCallLease({ cloud, capability: accountCapability, endpoint,
   });
 }
+// ../../core/calls/sources.js
+function callVideoCapacity(participants, holder, count = 1) {
+  return participants.filter((peer) => peer.holder !== holder).reduce((count2, peer) => count2 + (peer.media?.sources?.length || 0), 0) + count <= CALL_MAX_VIDEO_SOURCES;
+}
+function assertCallVideoSources(participants, holder, media) {
+  const sources = media?.sources || [];
+  if (!Array.isArray(sources) || sources.length > CALL_MAX_VIDEO_SOURCES_PER_PARTICIPANT || sources.some((source) => !/^[A-Za-z0-9_-]{1,64}$/u.test(source?.id || "") || !["screen", "camera"].includes(source.kind) || !Number.isInteger(source.contextId) || source.contextId < 1 || source.contextId >= 2 ** 24) || new Set(sources.map((source) => source.id)).size !== sources.length || new Set(sources.map((source) => source.contextId)).size !== sources.length) {
+    throw Object.assign(new Error("invalid call video sources"), { code: "calls/invalid-source" });
+  }
+  if (sources.length && !callVideoCapacity(participants, holder, sources.length)) {
+    throw Object.assign(new Error(`this call already has ${CALL_MAX_VIDEO_SOURCES} cameras or screens`), { code: "calls/video-full" });
+  }
+}
 // ../../core/calls/room.js
 function openCallRoom({
   cloud,
@@ -47513,6 +47872,14 @@ function openCallRoom({
       settleAdmission(admissionError("calls/taken-over", "call moved to another device"));
     }
   }
+  function retireMembership() {
+    departing = true;
+    joined = false;
+    clearTimeout(pulseTimer);
+    disposeState(state);
+    state = null;
+    onRemoved?.();
+  }
   async function adopt(next, admissions) {
     verifyCallMembers(next, admissions, protocol);
     if (closed) {
@@ -47524,7 +47891,7 @@ function openCallRoom({
     disposeState(previous);
     const self = next.members.find((item) => toHex(item.leafId) === localHolder);
     if (!self) {
-      onRemoved?.();
+      retireMembership();
       return;
     }
     if (!admissions.some((item) => item.holder === localHolder && item.actor === admission.actor && item.endpoint === endpoint.publicKey))
@@ -47598,7 +47965,15 @@ function openCallRoom({
         if (bound)
           leaving.add(packet.holder);
       } else if (packet.kind === "pulse") {
-        published.set(packet.holder, packet.data);
+        let media = packet.data.media;
+        try {
+          assertCallVideoSources(participants(), packet.holder, media);
+        } catch {
+          media = published.get(packet.holder)?.media || null;
+        }
+        published.set(packet.holder, { ...packet.data, media });
+        if (packet.holder === localHolder)
+          ownMedia = media;
       } 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);
@@ -47608,7 +47983,7 @@ function openCallRoom({
         membershipChanged = true;
         if (state && !replacement.participants.some((item) => item.holder === localHolder)) {
           settleAdmission(cancelled2());
-          onRemoved?.();
+          retireMembership();
           return;
         }
         head = replacement;
@@ -47624,7 +47999,7 @@ function openCallRoom({
           pendingCandidate = null;
           if (next.removed) {
             disposeState(next);
-            onRemoved?.();
+            retireMembership();
             return;
           }
           await adopt(next, change.participants);
@@ -47661,7 +48036,7 @@ function openCallRoom({
       verifiedHead = null;
       admittedIdentities.clear();
       if (joined) {
-        onRemoved?.();
+        retireMembership();
         return;
       }
       if (submittedJoin)
@@ -47765,7 +48140,7 @@ function openCallRoom({
     for (let attempt = 0;!closed && performance.now() < deadline; attempt += 1) {
       if (kind === "join" && departing)
         throw cancelled2();
-      const current = mailbox.getSnapshot();
+      const current = await mailbox.settled();
       if (!current?.head)
         throw kind === "join" ? empty() : new Error("call ended");
       if (kind === "join") {
@@ -47774,9 +48149,14 @@ function openCallRoom({
           throw admissionFailure;
       }
       try {
+        const value = typeof data === "function" ? data() : data;
+        if (kind === "pulse")
+          assertCallVideoSources(participants(), localHolder, value.media);
         if (kind === "join")
           submittedJoin = true;
-        return await mailbox.append([protocol.sign(kind, data)], { expectedRevision: current.revision });
+        const result = await mailbox.append([protocol.sign(kind, value)], { expectedRevision: current.revision });
+        await mailbox.settled();
+        return result;
       } catch (error) {
         if (closed)
           throw cancelled2();
@@ -47807,7 +48187,7 @@ function openCallRoom({
     if (closed || departing || !joined)
       return;
     try {
-      await event("pulse", { ...audio, media: ownMedia });
+      await event("pulse", () => ({ ...audio, media: ownMedia }));
     } catch (error) {
       fail(error);
     }
@@ -47889,13 +48269,12 @@ function openCallRoom({
       return event("signal", { to, signal });
     },
     async publishMedia(media) {
-      ownMedia = media;
-      await event("pulse", { ...audio, 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 });
+        await event("pulse", () => ({ ...audio, media: ownMedia }));
     },
     async leave() {
       if (closed)
@@ -48092,15 +48471,15 @@ function createCallMediaSession({ port, mode, holder, preparation, provider, sig
   const pendingSignals = [];
   const incomingSignals = [];
   function sourcesFor(peer) {
-    if (!port.capabilities?.video || !videoCapable(peer) || !Array.isArray(peer.media.sources) || peer.media.sources.length > 2)
+    if (!port.capabilities?.video || !videoCapable(peer) || !Array.isArray(peer.media.sources) || peer.media.sources.length > CALL_MAX_VIDEO_SOURCES_PER_PARTICIPANT)
       return [];
-    const sources = peer.media.sources;
+    const sources = peer.media.sources.filter((source) => mode === "group" ? source?.trackName != null : source?.mid != null);
     if (sources.some((source) => !validSourceId(source?.id) || !["screen", "camera"].includes(source.kind) || !validContext(source.contextId) || (mode === "group" ? !/^[a-f0-9]{32}$/u.test(source.trackName || "") : !validMid(source.mid))) || new Set(sources.map((source) => source.id)).size !== sources.length || new Set(sources.map((source) => source.contextId)).size !== sources.length || new Set(sources.map((source) => mode === "group" ? source.trackName : source.mid)).size !== sources.length)
       return [];
     return sources;
   }
   function videoProjection() {
-    const next = [...localSources.values()].map((source) => ({ id: source.id, holder, kind: source.kind, stream: source.stream, local: true }));
+    const next = [...localSources.values()].filter((source) => source.admitted).map((source) => ({ id: source.id, holder, kind: source.kind, stream: source.stream, local: true }));
     for (const peer of peers) {
       if (peer.holder === holder)
         continue;
@@ -48120,11 +48499,11 @@ function createCallMediaSession({ port, mode, holder, preparation, provider, sig
     const base2 = mode === "group" ? { sessionId, trackName: microphoneTrack } : {};
     if (!port.capabilities?.video)
       return base2;
-    return { ...base2, capabilities: ["video"], sources: [...localSources.values()].filter((source) => source.published).map((source) => ({
+    return { ...base2, capabilities: ["video"], sources: [...localSources.values()].map((source) => ({
       id: source.id,
       kind: source.kind,
       contextId: source.contextId,
-      ...mode === "group" ? { trackName: source.trackName } : { mid: source.mid }
+      ...source.published ? mode === "group" ? { trackName: source.trackName } : { mid: source.mid } : {}
     })) };
   }
   async function publishMedia() {
@@ -48579,7 +48958,7 @@ function createCallMediaSession({ port, mode, holder, preparation, provider, sig
         current(generation);
         if (videoCapable(peer))
           for (const source of localSources.values()) {
-            if (source.attached)
+            if (!source.admitted || source.attached)
               continue;
             media.addSource(source);
             source.attached = true;
@@ -48708,68 +49087,101 @@ function createCallMediaSession({ port, mode, holder, preparation, provider, sig
     current();
     videoProjection();
   }
+  function detachSource(source) {
+    localSources.delete(source.id);
+    source.stream.getTracks().forEach((track) => track.stop());
+    if (source.attached)
+      media?.removeSource(source.id);
+    videoProjection();
+  }
+  async function closeSourceTrack(source) {
+    if (mode === "group" && source.published) {
+      await applyDescription(await provider("tracks/close", { sessionId, tracks: [{ mid: source.mid }] }));
+    }
+  }
   return Object.freeze({
-    supportsScreen() {
-      return port.capabilities?.screen === true && port.capabilities?.video === true;
+    supportsSource(kind) {
+      return port.capabilities?.[kind] === true && port.capabilities?.video === true;
     },
-    async addSource(source) {
+    async addSource(source, replaceId = null) {
       current();
       if (!started || !media?.addSource || !port.capabilities?.video)
         throw new Error("video sharing unavailable");
-      if (!validSourceId(source?.id) || !["screen", "camera"].includes(source.kind) || !validContext(source.contextId) || sourceContexts.has(source.contextId) || localSources.has(source.id) || localSources.size >= 2)
+      const previous = localSources.get(replaceId);
+      if (!validSourceId(source?.id) || !["screen", "camera"].includes(source.kind) || !validContext(source.contextId) || sourceContexts.has(source.contextId) || localSources.has(source.id) || localSources.size - (previous ? 1 : 0) >= CALL_MAX_VIDEO_SOURCES_PER_PARTICIPANT)
         throw new Error("invalid call source");
       const generation = connectionGeneration;
-      if (mode === "group")
-        media.addSource(source);
-      const local = { ...source, attached: mode === "group", published: false };
+      if (previous)
+        detachSource(previous);
+      const local = { ...source, attached: false, admitted: false, published: false };
       localSources.set(source.id, local);
       sourceContexts.add(source.contextId);
-      videoProjection();
-      await updateKeys();
-      current(generation);
-      return serialize(async () => {
-        current(generation);
-        if (localSources.get(source.id) !== local)
-          return;
-        if (mode === "group") {
-          const offer = await media.offer();
+      const result = await serialize(async () => {
+        try {
           current(generation);
-          local.mid = media.sourceMid(source.id);
-          local.trackName = toHex(randomBytes3(16));
-          if (!validMid(local.mid))
-            throw new Error("video track unavailable");
-          const result = await provider("tracks/new", { sessionId, sessionDescription: sdp(offer), tracks: [{ location: "local", mid: local.mid, trackName: local.trackName }] });
+          if (previous)
+            await closeSourceTrack(previous);
+          if (localSources.get(source.id) !== local)
+            return;
+          await publishMedia();
           current(generation);
-          if (result?.tracks?.length !== 1 || result.tracks[0].mid !== local.mid || result.tracks[0].trackName !== local.trackName)
-            throw new Error("video publication failed");
-          await applyDescription(result, true);
+          if (localSources.get(source.id) !== local)
+            return;
+          local.admitted = true;
+          if (mode === "group") {
+            media.addSource(local);
+            local.attached = true;
+          }
+          videoProjection();
+          await updateKeys();
           current(generation);
-          local.published = true;
+          if (localSources.get(source.id) !== local)
+            return;
+          if (mode === "group") {
+            const offer = await media.offer();
+            current(generation);
+            local.mid = media.sourceMid(source.id);
+            local.trackName = toHex(randomBytes3(16));
+            if (!validMid(local.mid))
+              throw new Error("video track unavailable");
+            const response = await provider("tracks/new", { sessionId, sessionDescription: sdp(offer), tracks: [{ location: "local", mid: local.mid, trackName: local.trackName }] });
+            current(generation);
+            if (response?.tracks?.length !== 1 || response.tracks[0].mid !== local.mid || response.tracks[0].trackName !== local.trackName)
+              throw new Error("video publication failed");
+            await applyDescription(response, true);
+            current(generation);
+            local.published = true;
+            await publishMedia();
+          } else
+            await negotiate();
+        } catch (error) {
+          if (closed || generation !== connectionGeneration || !["calls/video-full", "calls/invalid-source"].includes(error?.code))
+            throw error;
+          if (localSources.get(source.id) === local)
+            detachSource(local);
+          await updateKeys();
           await publishMedia();
-        } else
-          await negotiate();
+          await closeSourceTrack(local);
+          return { error };
+        }
       });
+      if (result?.error)
+        throw result.error;
     },
     removeSource(id) {
       current();
       const local = localSources.get(id);
       if (!local)
         return Promise.resolve();
-      localSources.delete(id);
-      local.stream.getTracks().forEach((track) => track.stop());
-      if (local.attached)
-        media?.removeSource(id);
-      videoProjection();
+      detachSource(local);
       const removedKeys = updateKeys();
       removedKeys.catch(() => {});
       return serialize(async () => {
         await removedKeys;
         current();
         await publishMedia();
-        if (mode === "group") {
-          if (local.published)
-            await applyDescription(await provider("tracks/close", { sessionId, tracks: [{ mid: local.mid }] }));
-        } else if (local.attached) {
+        await closeSourceTrack(local);
+        if (mode === "direct" && local.attached) {
           directDirty = true;
           await negotiate();
         }
@@ -49045,15 +49457,17 @@ function openCallObservation({ cloud, capability, endpoint, protocol, onChange,
 }
 // ../../core/calls/session.js
-var initial = () => ({ phase: "idle", chatId: null, callId: null, joiningChatId: null, mode: null, transport: null, available: null, elsewhere: null, participants: [], speaking: [], videoSources: [], sharingScreen: false, screenShareAvailable: false, peerAudio: {}, muted: false, deafened: false, microphoneVolume: 100, error: null });
+var initial = () => ({ phase: "idle", chatId: null, callId: null, joiningChatId: null, mode: null, transport: null, available: null, elsewhere: null, participants: [], speaking: [], videoSources: [], sharingScreen: false, screenShareAvailable: false, sharingCamera: false, cameraAvailable: false, 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 RECENT_CALL_HINT_LIMIT = 32;
 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, savePeerAudio, saveAudio, diag }) {
   const listeners = new Set;
   const discoveries = new Map;
   const discoveryReads = new Map;
   const observers = new Map;
+  const messageHints = new Map;
   const retiring = new Set;
   let state = initial();
   const confirmedPeerAudio = new Map;
@@ -49061,6 +49475,7 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
   let peerAudioSource = null;
   let audioSource = normalizeCallAudio();
   let pendingAudio = null;
+  let audioSaveTail = Promise.resolve();
   let identity = null;
   let endpoint = null;
   let leaseEndpoint = null;
@@ -49097,7 +49512,27 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
       diag?.("call.message.error", { event, code: error?.code || "" });
     });
   }
-  const canShareScreen = (call) => !!call && !call.leaving && call.mediaReady && !!mediaPort?.captureScreen && ["connecting", "connected", "waiting"].includes(state.phase) && call.media?.supportsScreen() === true;
+  const captureFor = (kind) => kind === "camera" ? mediaPort?.captureCamera : mediaPort?.captureScreen;
+  const canShare = (call, kind) => !!call && !call.leaving && call.mediaReady && !!captureFor(kind) && ["connecting", "connected", "waiting"].includes(state.phase) && call.media?.supportsSource(kind) === true && callVideoCapacity(call.participants, call.endpoint.holder);
+  const sourceState = (call) => ({
+    sharingScreen: call?.visual?.kind === "screen",
+    sharingCamera: call?.visual?.kind === "camera",
+    screenShareAvailable: canShare(call, "screen"),
+    cameraAvailable: canShare(call, "camera")
+  });
+  async function captureVisual(operation) {
+    while (operation.visual) {
+      const source = operation.visual;
+      try {
+        await source.capture;
+      } catch (error) {
+        if (operation.visual === source)
+          throw error;
+      }
+      if (operation.visual === source)
+        return;
+    }
+  }
   function current(token) {
     if (closed || !identity || token !== generation)
       throw cancelled2();
@@ -49118,17 +49553,29 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
   }
   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;
+    const value = (chatId, current2) => {
+      if (!current2?.descriptor)
+        return null;
+      const roster = (active?.discovery === current2 ? active.participants : current2.roster)?.filter((peer) => ![...retiring].some((call) => call.callId === current2.descriptor.callId && call.endpoint.holder === peer.holder));
+      if (roster?.length === 0)
+        return null;
+      return {
+        chatId,
+        callId: current2.descriptor.callId,
+        startedAt: current2.descriptor.startedAt,
+        participants: roster?.length ?? (current2.descriptor.participants || 1),
+        roster: roster || []
+      };
+    };
     for (const observer of observers.values()) {
+      const observed = discoveries.get(observer.chatId);
+      if (!observer.resolved && observed?.revision !== null && observed?.revision !== undefined) {
+        observer.resolved = true;
+        diag?.("call.discovery.observed", { elapsedMs: Date.now() - observer.startedAt, active: !!observed.descriptor });
+      }
       if (!observer.onAvailable)
         continue;
-      const next2 = value(observer.chatId, discoveries.get(observer.chatId));
+      const next2 = value(observer.chatId, observed);
       const fingerprint = JSON.stringify(next2);
       if (observer.fingerprint === fingerprint)
         continue;
@@ -49164,7 +49611,6 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
       return;
     }
     entry.observation?.close();
-    entry.roster = [];
     entry.observedCallId = callId;
     const token = generation;
     const protocol = createCallProtocol({ realm: cloud.environment, epochState: entry.epochState, identity, endpoint, callId });
@@ -49195,7 +49641,7 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
   }
   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)) {
+      if (!messageHints.get(chatId)?.watch && !discoveryReads.has(chatId) && !value.finishing.size && ![...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
@@ -49217,7 +49663,7 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
       mailbox: null,
       observation: null,
       observedCallId: null,
-      roster: [],
+      roster: null,
       revision: null,
       expiredCallId: null,
       finishing: new Map
@@ -49234,17 +49680,25 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
         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;
+        if (previous?.callId !== descriptor?.callId)
+          entry.roster = null;
         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 (!descriptor) {
+          const hint = messageHints.get(chatId);
+          if (hint)
+            hint.watch = false;
+        }
         if (active?.discovery === entry && active.published && descriptor?.callId !== active.callId) {
           leave();
         }
         observeRoster(entry, changed);
         available();
+        prune();
       },
       onError(error) {
         if (token !== generation || discoveries.get(chatId) !== entry)
@@ -49291,7 +49745,7 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
   function observe(chatId, onAvailable) {
     if (!chatId || closed)
       return () => {};
-    const observer = { chatId, onAvailable, fingerprint: undefined };
+    const observer = { chatId, onAvailable, fingerprint: undefined, startedAt: Date.now(), resolved: false };
     observers.set(observer, observer);
     focused = chatId;
     if (state.error?.chatId === chatId)
@@ -49343,11 +49797,11 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
       })();
       const destination = (async () => {
         if (!onlyExisting && !continuation)
-          chatId = await chat.getSnapshot().materializeChat(chatId);
+          chatId = await chat.getSnapshot().materializeChat(chatId, { signal: operation.controller.signal });
         check();
         joining.chatId = chatId;
         step("chat");
-        const epochState = continuation ? chat.getSnapshot().getOwnerChat(chatId)?.epochState : await chat.getSnapshot().prepareCall(chatId);
+        const epochState = continuation ? chat.getSnapshot().getOwnerChat(chatId)?.epochState : await chat.getSnapshot().prepareCall(chatId, { signal: operation.controller.signal });
         check();
         if (!epochState)
           throw cancelled2();
@@ -49356,7 +49810,7 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
         step("discovery");
         return entry2;
       })();
-      const [, entry] = await Promise.all([permission, destination, operation.screen?.capture]);
+      const [, entry] = await Promise.all([permission, destination, captureVisual(operation)]);
       check();
       const discoveryRecord = entry.mailbox.getSnapshot();
       const create = !entry.descriptor;
@@ -49392,7 +49846,8 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
         wasReady: false,
         signalingReady: true,
         ownershipReady: true,
-        screen: null,
+        visual: null,
+        capturing: null,
         sourceContext: 0,
         leaving: false,
         muteTail: Promise.resolve()
@@ -49438,7 +49893,7 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
         const waiting = call.mediaReady && descriptor.mode === "direct" && state.participants.length < 2;
         const ready = call.mediaState === "connected" || waiting;
         if (ready && call.signalingReady && call.ownershipReady) {
-          call.wasReady = true;
+          call.wasReady = !waiting;
           clearTimeout(call.joinTimer);
           call.joinTimer = null;
           emit({ phase: waiting ? "waiting" : "connected" });
@@ -49452,7 +49907,7 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
                 fail(new Error("call did not connect"));
             }, 30000);
         }
-        emit({ screenShareAvailable: canShareScreen(call) });
+        emit(sourceState(call));
       };
       call.connectionProgress = connectionProgress;
       call.media = createCallMediaSession({
@@ -49499,8 +49954,8 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
             emit({ videoSources });
         },
         onSourceEnded(id) {
-          if (valid() && call.screen?.id === id)
-            stopScreenShare().catch(() => {});
+          if (valid() && call.visual?.id === id)
+            stopVisual().catch(() => {});
         },
         onError(error) {
           if (valid())
@@ -49545,7 +50000,7 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
             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, screenShareAvailable: canShareScreen(call) });
+          emit({ participants: value, ...sourceState(call) });
           available();
           call.refresh?.();
           if (call.mediaReady)
@@ -49576,6 +50031,8 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
       checkCall();
       await call.room.start({ create });
       checkCall();
+      if (operation.visual)
+        assertCallVideoSources(call.participants, callEndpoint.holder, { sources: [{ ...operation.visual, contextId: 1 }] });
       step("admission");
       if (create) {
         try {
@@ -49677,12 +50134,14 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
       };
       call.refresh = refresh;
       refresh(true);
-      if (operation.screen) {
-        await operation.screen.capture;
+      while (operation.visual) {
+        await captureVisual(operation);
         check();
-        await publishScreen(call, operation.screen);
+        const source = operation.visual;
+        await publishVisual(call, source);
         check();
-        operation.screen = null;
+        if (operation.visual === source)
+          operation.visual = null;
       }
       return chatId;
     } catch (error) {
@@ -49715,20 +50174,21 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
       throw new Error("open veyl to join a call");
     return runJoin(chatId, expectedCallId, onlyExisting);
   }
-  function runJoin(chatId, expectedCallId = null, onlyExisting = false, continuation = null, screen = null) {
+  function runJoin(chatId, expectedCallId = null, onlyExisting = false, continuation = null, visual = null) {
     const intent = ++joinIntent;
-    const operation = { predecessor: active, chatId, candidate: null, continuation, screen };
+    const operation = { predecessor: active, chatId, candidate: null, continuation, visual, controller: new AbortController };
     let resolve, reject;
     operation.promise = new Promise((done, fail2) => {
       resolve = done;
       reject = fail2;
     });
-    if (screen)
-      screen.promise = operation.promise;
+    if (visual)
+      visual.promise = operation.promise;
     const previous = joining;
     joining = operation;
+    previous?.controller.abort();
     previous?.preparation?.close();
-    previous?.screen?.stop();
+    previous?.visual?.stop();
     emit({ joiningChatId: chatId });
     if (previous?.candidate && previous.candidate !== active)
       disposeCall(previous.candidate);
@@ -49752,7 +50212,8 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
           }
         }
       } finally {
-        operation.screen?.stop();
+        operation.controller.abort();
+        operation.visual?.stop();
         if (joining === operation) {
           joining = null;
           emit({ joiningChatId: null });
@@ -49764,8 +50225,9 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
   }
   function leave() {
     joinIntent += 1;
+    joining?.controller.abort();
     joining?.preparation?.close();
-    joining?.screen?.stop();
+    joining?.visual?.stop();
     const candidate = joining?.candidate;
     joining = null;
     emit({ joiningChatId: null });
@@ -49780,8 +50242,9 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
     if (!operation)
       return Promise.resolve();
     joinIntent += 1;
+    operation.controller.abort();
     operation.preparation?.close();
-    operation.screen?.stop();
+    operation.visual?.stop();
     joining = null;
     emit({ joiningChatId: null });
     const pending = operation.candidate && operation.candidate !== active ? disposeCall(operation.candidate) : null;
@@ -49800,15 +50263,17 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
       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: [], videoSources: [], sharingScreen: false, screenShareAvailable: false });
+      emit({ phase: "idle", chatId: null, callId: null, mode: null, transport: null, participants: [], speaking: [], videoSources: [], sharingScreen: false, screenShareAvailable: false, sharingCamera: false, cameraAvailable: false });
       return leaving;
     }
+    if (call.discovery.descriptor?.callId === call.callId)
+      call.discovery.roster = call.participants;
     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: [], videoSources: [], sharingScreen: false, screenShareAvailable: false });
+    emit({ phase: "idle", chatId: null, callId: null, mode: null, transport: null, participants: [], speaking: [], videoSources: [], sharingScreen: false, screenShareAvailable: false, sharingCamera: false, cameraAvailable: false });
     return leaving;
   }
   async function retireDiscovery(call) {
@@ -49829,15 +50294,20 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
   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));
+    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);
+      prune();
+    });
     entry.finishing.set(descriptor.callId, finishing);
   }
   function disposeCall(call) {
     if (call.closing)
       return call.closing;
     call.leaving = true;
-    call.screen?.stop();
-    call.screen = null;
+    call.capturing?.stop();
+    call.capturing = null;
+    call.visual?.stop();
+    call.visual = null;
     retiring.add(call);
     clearTimeout(call.timer);
     clearTimeout(call.joinTimer);
@@ -49879,28 +50349,40 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
     });
     return call.closing;
   }
-  function startScreenShare(chatId = active?.chatId) {
-    if (!identity || closed || !mediaPort?.captureScreen || !mediaPort.capabilities?.screen || !mediaPort.capabilities?.video || !mls || !cloud.calls || !chatId)
-      return Promise.reject(new Error("screen sharing is unavailable in this call"));
+  function startVisual(kind, chatId = active?.chatId) {
+    if (!identity || closed || !captureFor(kind) || !mediaPort.capabilities?.[kind] || !mediaPort.capabilities?.video || !mls || !cloud.calls || !chatId)
+      return Promise.reject(new Error(`${kind === "camera" ? "camera" : "screen sharing"} is unavailable in this call`));
     const operation = joining && [joining.chatId, state.joiningChatId].includes(chatId) ? joining : null;
-    if (operation?.screen)
-      return operation.screen.promise;
     const call = active?.chatId === chatId ? active : null;
-    if (call && !operation && !canShareScreen(call))
-      return Promise.reject(new Error("screen sharing is unavailable in this call"));
+    const pending = operation?.visual || call?.capturing;
+    if (pending?.kind === kind)
+      return pending.promise;
+    if (!pending && call?.visual?.kind === kind)
+      return call.visual.promise;
+    if (call && !operation && !canShare(call, kind)) {
+      try {
+        assertCallVideoSources(call.participants, call.endpoint.holder, { sources: [{ id: "capture", kind, contextId: 1 }] });
+      } catch (error) {
+        return Promise.reject(error);
+      }
+      return Promise.reject(new Error(`${kind} is unavailable in this call`));
+    }
     if (!call && !foreground)
       return Promise.reject(new Error("open veyl to join a call"));
-    if (call?.screen)
-      return call.screen.promise;
+    let rejectCapture;
+    const cancellation = new Promise((_, reject) => {
+      rejectCapture = reject;
+    });
     const source = {
       id: toHex(randomBytes3(16)),
       contextId: null,
-      kind: "screen",
+      kind,
       stream: null,
       promise: null,
       cancelled: false,
       stop() {
         source.cancelled = true;
+        rejectCapture(cancelled2());
         for (const track of source.stream?.getTracks() || []) {
           track.removeEventListener?.("ended", sourceEnded);
           track.stop();
@@ -49908,18 +50390,18 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
       }
     };
     const sourceEnded = () => {
-      if (joining?.screen === source)
+      if (joining?.visual === source)
         cancelJoin();
-      else if (active?.screen === source)
-        stopScreenShare().catch(() => {});
+      else if (active?.visual === source || active?.capturing === source)
+        stopVisual().catch(() => {});
     };
     let capturing;
     try {
-      capturing = mediaPort.captureScreen();
+      capturing = captureFor(kind).call(mediaPort);
     } catch (error) {
       return Promise.reject(error);
     }
-    source.capture = Promise.resolve(capturing).then((stream) => {
+    source.capture = Promise.race([cancellation, Promise.resolve(capturing).then((stream) => {
       if (source.cancelled || stream.getTracks().some((track) => track.readyState === "ended")) {
         stream.getTracks().forEach((track) => track.stop());
         throw cancelled2();
@@ -49927,64 +50409,78 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
       source.stream = stream;
       for (const track of stream.getTracks())
         track.addEventListener?.("ended", sourceEnded, { once: true });
-    });
+    })]);
     if (operation) {
+      operation.visual = source;
+      if (pending !== call?.visual)
+        pending?.stop();
       source.promise = Promise.all([source.capture, operation.promise]).then(() => {
         return;
       });
-      operation.screen = source;
       return source.promise;
     }
     if (!call) {
       source.promise = runJoin(chatId, null, false, null, source);
       return source.promise;
     }
-    call.screen = source;
+    call.capturing = source;
+    if (pending !== call.visual)
+      pending?.stop();
     source.promise = source.capture.then(() => {
-      if (!canShareScreen(call))
+      if (source.cancelled || active !== call || call.capturing !== source || call.leaving || !call.mediaReady)
         throw cancelled2();
-      return publishScreen(call, source);
+      return publishVisual(call, source);
     }).catch(async (error) => {
       source.stop();
-      if (call.screen === source) {
-        call.screen = null;
+      if (call.visual === source) {
+        call.visual = null;
         if (active === call)
-          emit({ sharingScreen: false });
+          emit(sourceState(call));
         if (!call.leaving && source.stream)
           await call.media.removeSource(source.id).catch(() => {});
       }
       throw error;
+    }).finally(() => {
+      if (call.capturing === source)
+        call.capturing = null;
     });
     return source.promise;
   }
-  async function publishScreen(call, source) {
-    if (source.cancelled || active !== call || call.leaving || !call.mediaReady || !call.media.supportsScreen())
+  async function publishVisual(call, source) {
+    if (source.cancelled || active !== call || call.leaving || !call.mediaReady || !call.media.supportsSource(source.kind))
       throw cancelled2();
+    const previous = call.visual;
     source.contextId = ++call.sourceContext;
-    call.screen = source;
-    emit({ sharingScreen: true });
-    await call.media.addSource(source);
-    if (active !== call || call.screen !== source)
+    previous?.stop();
+    call.visual = source;
+    emit(sourceState(call));
+    await call.media.addSource(source, previous?.id);
+    if (active !== call || call.visual !== source)
       throw cancelled2();
   }
-  async function stopScreenShare() {
-    if (joining?.screen)
+  async function stopVisual(kind) {
+    if (joining?.visual && (!kind || joining.visual.kind === kind))
       return cancelJoin();
     const call = active;
-    const source = call?.screen;
-    if (!source)
+    if (call?.capturing && (!kind || call.capturing.kind === kind || call.visual?.kind === kind)) {
+      call.capturing.stop();
+      call.capturing = null;
+    }
+    const source = call?.visual;
+    if (!source || kind && source.kind !== kind)
       return;
-    call.screen = null;
+    call.visual = null;
     source.stop();
-    emit({ sharingScreen: false });
+    emit(sourceState(call));
     if (source.stream)
       await call.media.removeSource(source.id);
   }
   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)]);
+    call.pendingAudio = audio;
     const result = Promise.all([applied, call.muteTail]).then(() => {
-      if (!call.leaving)
+      if (!call.leaving && call.pendingAudio === audio)
         return call.room.setAudio(audio);
     });
     call.muteTail = result.catch(() => {});
@@ -49996,14 +50492,16 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
       return;
     const token = generation;
     pendingAudio = value;
-    const saving = Promise.resolve().then(() => {
+    const saving = audioSaveTail.then(async () => {
       if (generation !== token)
         throw cancelled2();
-      return saveAudio(value);
-    }).then(() => {
+      if (pendingAudio !== value)
+        return;
+      await saveAudio(value);
       if (generation === token)
         audioSource = value;
     });
+    audioSaveTail = saving.catch(() => {});
     try {
       await Promise.all([saving, applyAudioPreferences(value)]);
     } finally {
@@ -50174,6 +50672,7 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
     endpoint = null;
     discoveries.clear();
     discoveryReads.clear();
+    messageHints.clear();
     identity = session;
     const stopped = leave();
     Promise.resolve(stopped).finally(() => {
@@ -50188,6 +50687,7 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
     confirmedPeerAudio.clear();
     pendingPeerAudio.clear();
     pendingAudio = null;
+    audioSaveTail = Promise.resolve();
     audioSource = normalizeCallAudio(settings.callAudio);
     peerAudioSource = session ? peerAudio : null;
     for (const [chatPK, value] of Object.entries(peerAudioSource || {}))
@@ -50205,10 +50705,41 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
     return retirement;
   }
   function refreshObserved() {
-    for (const chatId of new Set([...observers.values()].map((item) => item.chatId))) {
+    for (const chatId of observedChatIds()) {
       readDiscovery(chatId).catch((error) => diag?.("call.discovery.error", { stage: "prepare", code: error?.code || "calls/admission" }));
     }
   }
+  function observedChatIds() {
+    return new Set([...observers.values()].map((item) => item.chatId).concat([...messageHints].filter(([, hint]) => hint.watch).map(([chatId]) => chatId)));
+  }
+  const unsubscribeMessages = chat.subscribeMessages((chatId, messages) => {
+    if (!identity || closed)
+      return;
+    let latest = null;
+    for (const message of messages) {
+      if (!isServerConfirmedMsg(message) || !readCallMessage(message))
+        continue;
+      if (!latest || getMessageOrderMs(message) > getMessageOrderMs(latest) || getMessageOrderMs(message) === getMessageOrderMs(latest) && getMessageKey(message) > getMessageKey(latest))
+        latest = message;
+    }
+    if (!latest)
+      return;
+    const at = getMessageOrderMs(latest), key = getMessageKey(latest);
+    if (!Number.isFinite(at) || !key)
+      return;
+    const previous = messageHints.get(chatId);
+    if (previous && (previous.at > at || previous.at === at && previous.key >= key))
+      return;
+    const entry = discoveries.get(chatId);
+    const watch = latest.event === "started" || previous?.watch === true || !!entry?.descriptor;
+    messageHints.delete(chatId);
+    messageHints.set(chatId, { at, key, watch });
+    while (messageHints.size > RECENT_CALL_HINT_LIMIT)
+      messageHints.delete(messageHints.keys().next().value);
+    prune();
+    if (watch && online)
+      readDiscovery(chatId).catch((error) => diag?.("call.discovery.error", { stage: "message", code: error?.code || "calls/discovery" }));
+  });
   const unsubscribe = chat.subscribe(() => {
     if (!identity)
       return;
@@ -50222,6 +50753,7 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
         const intent = ++joinIntent;
         const previous = active || joining?.candidate;
         active = null;
+        joining?.controller.abort();
         joining = null;
         if (previous)
           disposeCall(previous);
@@ -50233,6 +50765,8 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
           videoSources: [],
           sharingScreen: false,
           screenShareAvailable: false,
+          sharingCamera: false,
+          cameraAvailable: false,
           participants: state.participants.filter((member) => members.has(member.chatPK))
         });
         diag?.("call.epoch.transition", { stage: "starting", participants: state.participants.length });
@@ -50251,11 +50785,11 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
       closeDiscovery(entry);
       discoveries.delete(chatId);
       available();
-      if (online && [...observers.values()].some((item) => item.chatId === chatId))
+      if (online && observedChatIds().has(chatId))
         readDiscovery(chatId).catch(() => {});
     }
     if (online)
-      for (const chatId of new Set([...observers.values()].map((item) => item.chatId))) {
+      for (const chatId of observedChatIds()) {
         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" }));
         }
@@ -50273,8 +50807,10 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
     leave,
     cancelJoin,
     setMicrophoneVolume,
-    startScreenShare,
-    stopScreenShare,
+    startScreenShare: (chatId) => startVisual("screen", chatId),
+    stopScreenShare: () => stopVisual("screen"),
+    startCamera: (chatId) => startVisual("camera", chatId),
+    stopCamera: () => stopVisual("camera"),
     async resolveActiveCall(chatId) {
       const entry = await readDiscovery(chatId);
       return entry.descriptor?.callId || null;
@@ -50289,6 +50825,7 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
         return Promise.reject(ended());
       return join(chatId, callId, true);
     },
+    setAudio,
     setMuted(value) {
       return setAudio({ muted: value === true });
     },
@@ -50322,6 +50859,7 @@ function createCallSession({ cloud, chat, media: mediaPort, mls, savePeerAudio,
       });
       closed = true;
       const stopped = setSources(null);
+      unsubscribeMessages();
       unsubscribe();
       listeners.clear();
       Promise.resolve(stopped).finally(() => Promise.all([mls?.close?.(), mediaPort?.close?.()])).then(finish, reject);
@@ -53524,6 +54062,18 @@ function stablePeerMap(previous, next) {
   }
   return previous;
 }
+function replaceIndexedPeers(index, updates, field) {
+  let next = index;
+  for (const peer of updates.values()) {
+    const key = peer[field];
+    if (!key || index.get(key)?.uid !== peer.uid)
+      continue;
+    if (next === index)
+      next = new Map(index);
+    next.set(key, peer);
+  }
+  return next;
+}
 function stableValueSet(previous, next) {
   if (previous === next)
     return previous;
@@ -53551,12 +54101,11 @@ function peerProfileSnapshot(peer) {
     active: !!peer.active,
     presence: peer.presence,
     accountType: peer.accountType || null,
-    blocked: !!peer.blocked,
-    hidden: !!peer.hidden
+    blocked: !!peer.blocked
   };
 }
 function samePeerProfile(left, right) {
-  return left === right || !!left && !!right && left.uid === right.uid && left.username === right.username && left.chatPK === right.chatPK && left.chatSigningPK === right.chatSigningPK && left.notificationPK === right.notificationPK && sameChatAdmission(left.chatAdmission, right.chatAdmission) && left.walletPK === right.walletPK && left.avatar === right.avatar && left.avatarVersion === right.avatarVersion && left.active === right.active && left.presence === right.presence && left.accountType === right.accountType && left.blocked === right.blocked && left.hidden === right.hidden;
+  return left === right || !!left && !!right && left.uid === right.uid && left.username === right.username && left.chatPK === right.chatPK && left.chatSigningPK === right.chatSigningPK && left.notificationPK === right.notificationPK && sameChatAdmission(left.chatAdmission, right.chatAdmission) && left.walletPK === right.walletPK && left.avatar === right.avatar && left.avatarVersion === right.avatarVersion && left.active === right.active && left.presence === right.presence && left.accountType === right.accountType && left.blocked === right.blocked;
 }
 function normalizeProfileIdentity(identity = {}) {
   const uid = String(identity?.uid || "").trim();
@@ -53646,7 +54195,6 @@ function createPeerList({ peerApi, presence, diag, onMissingPeers }) {
   let blockedUids = [];
   let blockedUidsKey = "";
   let blockedUidSet = new Set;
-  let hiddenPeerUidSet = new Set;
   let seenWalletPKs = new Set;
   let seenChatPKs = new Set;
   let walletPKs = [];
@@ -53680,7 +54228,7 @@ function createPeerList({ peerApi, presence, diag, onMissingPeers }) {
     subscriberCount += 1;
     if (!firstSubscriber)
       return;
-    unsubscribePresence = presence.subscribePeers(() => rebuild({ projection: true, persist: false }));
+    unsubscribePresence = presence.subscribePeers(updatePresence);
     hydrateLocalAvatars();
     const becameReady = startProfileLoad();
     if (becameReady) {
@@ -53712,7 +54260,7 @@ function createPeerList({ peerApi, presence, diag, onMissingPeers }) {
   function resolveProfile(identity) {
     if (!identity)
       return null;
-    const peer = (identity.uid ? peerByUid.get(identity.uid) : null) ?? (identity.username ? peerByUsername.get(identity.username) : null) ?? (identity.chatPK ? peerByChatPK.get(identity.chatPK) : null) ?? (identity.walletPK ? peerByWalletPK.get(identity.walletPK) : null) ?? null;
+    const peer = (identity.uid ? allPeerByUid.get(identity.uid) : null) ?? (identity.username ? peerByUsername.get(identity.username) : null) ?? (identity.chatPK ? peerByChatPK.get(identity.chatPK) : null) ?? (identity.walletPK ? peerByWalletPK.get(identity.walletPK) : null) ?? null;
     return peer?.uid ? peerProfilesByUid.get(peer.uid) || null : null;
   }
   function emitProfiles() {
@@ -53743,8 +54291,6 @@ function createPeerList({ peerApi, presence, diag, onMissingPeers }) {
       primePeer,
       findPeer,
       updatePeer,
-      dropPeer,
-      restorePeer,
       loadBlockedPeers
     };
   }
@@ -53822,7 +54368,7 @@ function createPeerList({ peerApi, presence, diag, onMissingPeers }) {
   function syncPresencePeers() {
     const candidates = new Map;
     const add2 = (profile) => {
-      if (!profile?.uid || profile.blocked || profile.hidden || candidates.size >= RECENT_PEER_REFRESH_LIMIT)
+      if (!profile?.uid || profile.blocked || candidates.size >= RECENT_PEER_REFRESH_LIMIT)
         return;
       candidates.set(profile.uid, profile);
     };
@@ -53846,33 +54392,61 @@ function createPeerList({ peerApi, presence, diag, onMissingPeers }) {
   function buildBasePeers() {
     allPeers = assemblePeers(walletPeerSet, sources.chatPeers, discoveredPeerUids);
   }
-  function buildPeerProjection() {
-    const blockedPeerUidSet = new Set(blockedUids);
-    for (const peer of blockedPeers) {
-      if (peer?.uid)
-        blockedPeerUidSet.add(peer.uid);
+  function projectPeer(peer) {
+    const activity = presence.getPeer(peer);
+    const next = {
+      ...peer,
+      active: activity.availability === "online",
+      presence: activity,
+      blocked: blockedUidSet.has(peer.uid)
+    };
+    const previous = allPeerByUid.get(peer.uid);
+    return samePeerRecord(previous, next) ? previous : next;
+  }
+  function updatePresence(changedUids) {
+    const updates = new Map;
+    for (const uid of changedUids) {
+      const previous = allPeerByUid.get(uid);
+      if (!previous)
+        continue;
+      const next = projectPeer(previous);
+      if (next !== previous)
+        updates.set(uid, next);
+    }
+    if (!updates.size)
+      return;
+    allPeerByUid = replaceIndexedPeers(allPeerByUid, updates, "uid");
+    peerByUid = replaceIndexedPeers(peerByUid, updates, "uid");
+    peerByWalletPK = replaceIndexedPeers(peerByWalletPK, updates, "walletPK");
+    peerByChatPK = replaceIndexedPeers(peerByChatPK, updates, "chatPK");
+    peerByUsername = replaceIndexedPeers(peerByUsername, updates, "username");
+    const replaceList = (list) => stablePeerList(list, list.map((peer) => updates.get(peer.uid) || peer));
+    visiblePeers = replaceList(visiblePeers);
+    blockedPeerItems = replaceList(blockedPeerItems);
+    const all = replaceList(recentPeers.all);
+    const wallet = replaceList(recentPeers.wallet);
+    const chat = replaceList(recentPeers.chat);
+    if (all !== recentPeers.all || wallet !== recentPeers.wallet || chat !== recentPeers.chat)
+      recentPeers = { all, wallet, chat };
+    peerProfilesByUid = new Map(peerProfilesByUid);
+    for (const peer of updates.values()) {
+      const next = peerProfileSnapshot(peer);
+      const previous = peerProfilesByUid.get(peer.uid);
+      peerProfilesByUid.set(peer.uid, samePeerProfile(previous, next) ? previous : next);
     }
+    publish();
+  }
+  function buildPeerProjection() {
     const peerMap = new Map;
     for (const peer of allPeers)
       mergePeerRecord(peerMap, peer);
     for (const peer of blockedPeers)
       mergePeerRecord(peerMap, peer);
-    const taggedPeers = Array.from(peerMap.values()).map((peer) => {
-      const activity = presence.getPeer(peer);
-      const next = {
-        ...peer,
-        active: activity.availability === "online",
-        presence: activity,
-        blocked: blockedPeerUidSet.has(peer.uid) || hiddenPeerUidSet.has(peer.uid),
-        hidden: hiddenPeerUidSet.has(peer.uid)
-      };
-      const previous = allPeerByUid.get(peer.uid);
-      return samePeerRecord(previous, next) ? previous : next;
-    });
-    visiblePeers = stablePeerList(visiblePeers, taggedPeers.filter((peer) => !peer.blocked && !peer.hidden));
+    const taggedPeers = Array.from(peerMap.values()).map(projectPeer);
+    visiblePeers = stablePeerList(visiblePeers, taggedPeers.filter((peer) => !peer.blocked));
     const blockedByUid = new Map(taggedPeers.filter((peer) => peer?.uid && peer.blocked).map((peer) => [peer.uid, peer]));
     const orderedBlocked = blockedUids.map((uid) => blockedByUid.get(uid)).filter((peer) => peer?.uid);
-    blockedPeerItems = stablePeerList(blockedPeerItems, orderedBlocked.length || blockedUids.length ? orderedBlocked : Array.from(blockedByUid.values()));
+    blockedPeerItems = stablePeerList(blockedPeerItems, orderedBlocked);
     blockedChatPKSet = stableValueSet(blockedChatPKSet, new Set(taggedPeers.filter((peer) => peer.blocked && peer.chatPK).map((peer) => peer.chatPK)));
     const allIndexes = indexPeers(taggedPeers);
     const visibleIndexes = indexPeers(visiblePeers);
@@ -53985,7 +54559,6 @@ function createPeerList({ peerApi, presence, diag, onMissingPeers }) {
     blockedPeersReady = false;
     discoveredPeerUids = new Set;
     blockedPeers = [];
-    hiddenPeerUidSet = new Set;
     seenWalletPKs = new Set;
     seenChatPKs = new Set;
     allPeers = [];
@@ -54098,6 +54671,10 @@ function createPeerList({ peerApi, presence, diag, onMissingPeers }) {
       blockedUids = nextBlockedUids;
       blockedUidsKey = nextBlockedUidsKey;
       blockedUidSet = new Set(blockedUids);
+      for (const uid of blockedUids) {
+        if (allPeerByUid.has(uid))
+          discoveredPeerUids.add(uid);
+      }
       if (blockedPeersReady) {
         blockedPeers = blockedPeers.filter((peer) => blockedUidSet.has(peer?.uid));
       }
@@ -54139,7 +54716,7 @@ function createPeerList({ peerApi, presence, diag, onMissingPeers }) {
     const enrichedPeer = await fetchAndCachePeer(partialProfile);
     if (!isCurrent(session) || !enrichedPeer)
       return null;
-    if (blockedUidSet.has(enrichedPeer.uid) || hiddenPeerUidSet.has(enrichedPeer.uid))
+    if (blockedUidSet.has(enrichedPeer.uid))
       return null;
     if (!discoveredPeerUids.has(enrichedPeer.uid)) {
       discoveredPeerUids.add(enrichedPeer.uid);
@@ -54198,37 +54775,14 @@ function createPeerList({ peerApi, presence, diag, onMissingPeers }) {
       if (requestedKey !== blockedUidsKey)
         continue;
       blockedPeers = requestedUids.map((uid) => nextByUid.get(uid)).filter((peer) => peer?.uid);
+      for (const peer of blockedPeers)
+        discoveredPeerUids.add(peer.uid);
       blockedPeersReady = true;
-      rebuild({ projection: true });
+      rebuild({ base: true });
       return blockedPeers;
     }
     return blockedPeers;
   }
-  function dropPeer(peer) {
-    const uid = peerUid(peer);
-    if (!uid)
-      return;
-    const discovered = discoveredPeerUids.has(uid);
-    if (!hiddenPeerUidSet.has(uid)) {
-      hiddenPeerUidSet.add(uid);
-    }
-    if (discovered) {
-      discoveredPeerUids.delete(uid);
-    }
-    if (typeof peer === "object" && peer?.uid) {
-      blockedPeers = [...blockedPeers.filter((item) => item?.uid !== uid), peer];
-    }
-    rebuild(discovered ? { base: true } : { projection: true });
-  }
-  function restorePeer(peer) {
-    const uid = peerUid(peer);
-    if (!uid)
-      return;
-    hiddenPeerUidSet.delete(uid);
-    blockedPeers = blockedPeers.filter((item) => item?.uid !== uid);
-    discoveredPeerUids.add(uid);
-    rebuild({ base: true });
-  }
   snapshot = makeSnapshot();
   return {
     getSnapshot() {
@@ -56868,7 +57422,7 @@ function compareRecentTransfer(a, b) {
   return String(b?.id || "").localeCompare(String(a?.id || ""));
 }
 function sameTransfer(left, right) {
-  return left?.id === right?.id && left?.status === right?.status && txCreatedMs(left) === txCreatedMs(right) && txUpdatedMs(left) === txUpdatedMs(right) && left?.totalValue === right?.totalValue && left?.type === right?.type && left?.transferDirection === right?.transferDirection && left?.senderIdentityPublicKey === right?.senderIdentityPublicKey && left?.receiverIdentityPublicKey === right?.receiverIdentityPublicKey && left?.bitcoinAddress === right?.bitcoinAddress && left?.bitcoinTxid === right?.bitcoinTxid && left?.lightningAddress === right?.lightningAddress;
+  return left?.id === right?.id && left?.status === right?.status && txCreatedMs(left) === txCreatedMs(right) && txUpdatedMs(left) === txUpdatedMs(right) && left?.totalValue === right?.totalValue && left?.tokenIdentifier === right?.tokenIdentifier && left?.amountUnits === right?.amountUnits && left?.network === right?.network && left?.type === right?.type && left?.transferDirection === right?.transferDirection && left?.senderIdentityPublicKey === right?.senderIdentityPublicKey && left?.receiverIdentityPublicKey === right?.receiverIdentityPublicKey && left?.bitcoinAddress === right?.bitcoinAddress && left?.bitcoinTxid === right?.bitcoinTxid && left?.lightningAddress === right?.lightningAddress;
 }
 function sameTransfers(a = [], b = []) {
   if (a === b) {
@@ -56926,7 +57480,7 @@ function compactTransfer(tx, { incoming = false, bitcoinAddress = null, bitcoinT
     senderIdentityPublicKey: hexKey(tx.senderIdentityPublicKey),
     receiverIdentityPublicKey: hexKey(tx.receiverIdentityPublicKey),
     status: enumName(tx.status, TRANSFER_STATUS_BY_CODE),
-    totalValue: satValue(tx.totalValue),
+    ...type === "TOKEN_TRANSFER" ? { tokenIdentifier: tx.tokenIdentifier, amountUnits: tx.amountUnits, network: tx.network } : { totalValue: satValue(tx.totalValue) },
     createdTime: tx.createdTime,
     updatedTime: tx.updatedTime,
     type,
@@ -57160,32 +57714,6 @@ function mergeTransferPageForWallet(currentTransfers = [], pageTransfers = [], w
   const page = compactTransfersForWallet(pageTransfers, walletPK);
   return mergeCompactedTransferPage(current, page, position);
 }
-function mergeRecentSnapshotForWallet(currentTransfers = [], latestTransfers = [], walletPK) {
-  const currentById = new Map(currentTransfers.map((tx) => [String(tx?.id || ""), tx]));
-  const latest = mergeTransferPageForWallet([], latestTransfers, walletPK, "append").map((tx) => mergeTransferDetails(currentById.get(String(tx?.id || "")), tx));
-  if (!latest.length) {
-    return filterTransfersForWallet(currentTransfers, walletPK);
-  }
-  const latestIds = new Set(latest.map((tx) => String(tx.id)));
-  const latestById = new Map(latest.map((tx) => [String(tx.id), tx]));
-  const oldestLatestMs = getOldestTransferMs(latest);
-  const olderCurrent = filterTransfersForWallet(currentTransfers, walletPK).filter((tx) => {
-    const id = String(tx?.id || "");
-    if (latestIds.has(id)) {
-      const latestTx = latestById.get(id);
-      if (isPendingTransfer(latestTx) && !isPendingTransfer(tx)) {
-        return true;
-      }
-      return false;
-    }
-    if (isPendingTransfer(tx)) {
-      return false;
-    }
-    const createdMs = txCreatedMs(tx);
-    return oldestLatestMs == null || createdMs > 0 && createdMs < oldestLatestMs;
-  });
-  return mergeTransferPage(latest, olderCurrent, "append");
-}
 function markClaimedTransfersCompleted(transfers = [], ids = []) {
   const claimedIds = new Set((Array.isArray(ids) ? ids : [ids]).map((id) => String(id || "")).filter(Boolean));
   if (!claimedIds.size)
@@ -57404,7 +57932,7 @@ async function refreshRequestedTransfers(owner, ids = []) {
         const resolvedIds = requestedTransfers.filter((transfer) => !isPendingTransfer(transfer)).map((transfer) => String(transfer.id));
         forgetPending(owner, resolvedIds);
         if (nextTransfers !== currentTransfers) {
-          await owner.snapshot.commitConfirmed(requestedTransfers.filter((transfer) => !isPendingTransfer(transfer)), { position: "prepend" });
+          await owner.snapshot.commitHistory(overlayPending(owner, updates.map((transfer) => compactTransfer(transfer))), { position: "prepend" });
           if (!isCurrentGeneration(owner, generation))
             return [];
           owner.snapshot.replace(mergeTransferPageForWallet(owner.snapshot.getTransfers(), updates, owner.walletPK, "append"));
@@ -57522,8 +58050,7 @@ async function commitPendingReconciliation(owner, plan, result, generation) {
   const nextTransfers = result.updates.length ? overlayPending(owner, mergeTransferPageForWallet(current, result.updates, owner.walletPK, "append")) : current;
   forgetPending(owner, result.resolvedIds);
   if (nextTransfers !== current) {
-    const selectedIds = new Set(plan.selectedIds);
-    await owner.snapshot.commitConfirmed(nextTransfers.filter((transfer) => selectedIds.has(String(transfer?.id)) && !isPendingTransfer(transfer)), { position: "prepend" });
+    await owner.snapshot.commitHistory(overlayPending(owner, result.updates.map((transfer) => compactTransfer(transfer))), { position: "prepend" });
     if (!isCurrentGeneration(owner, generation))
       return null;
     owner.snapshot.replace(mergeTransferPageForWallet(owner.snapshot.getTransfers(), result.updates, owner.walletPK, "append"));
@@ -57725,13 +58252,17 @@ function hydrateRecentHistory(owner) {
     return owner.hydratePromise;
   const generation = owner.generation;
   const startedAt = Date.now();
-  const request = owner.historyStore.query({ limit: WORKING_CONFIRMED_TRANSFER_LIMIT }).then((result) => {
-    if (!isCurrentGeneration2(owner, generation) || owner.snapshot.getTransfers().length || !result.transfers.length)
+  const request = owner.historyStore.query({ limit: WORKING_CONFIRMED_TRANSFER_LIMIT }).then(async (result) => {
+    const loadedIds = new Set(result.transfers.map((tx) => String(tx.id)));
+    const missingPending = Object.keys(owner.historyStore.getSnapshot().projection?.pending || {}).filter((id) => !loadedIds.has(id));
+    const pending = await Promise.all(missingPending.map((id) => owner.historyStore.getById(id)));
+    const transfers = pending.length ? mergeTransferPage(result.transfers, pending.filter(Boolean), "prepend") : result.transfers;
+    if (!isCurrentGeneration2(owner, generation) || owner.snapshot.getTransfers().length || !transfers.length)
       return false;
     owner.nextOffset = owner.historyStore.getSnapshot().nextOffset;
-    owner.snapshot.replace(result.transfers);
+    owner.snapshot.replace(transfers);
     owner.snapshot.setReady();
-    markDone(owner.diag, "wallet.history.hydrate", startedAt, { count: result.transfers.length });
+    markDone(owner.diag, "wallet.history.hydrate", startedAt, { count: transfers.length, pending: pendingTransfers(transfers).length });
     return true;
   }).catch((error) => {
     if (isCurrentGeneration2(owner, generation))
@@ -57790,13 +58321,12 @@ async function fetchHistoryPages(owner, options, generation) {
     completeOnStop: !!completeOnStop
   });
   try {
-    let stagedTransfers = owner.snapshot.getTransfers();
     let oldestFetchedMs = null;
     let stoppedAtKnownTransfer = false;
     while ((!owner.historyStore.getSnapshot().complete || force) && pages < maxPages) {
       if (!isCurrentGeneration2(owner, generation) || owner.backgroundSignal?.aborted === true)
         break;
-      if (!allHistory && Number.isFinite(sinceMs) && stagedHistoryCoverage(owner, stagedTransfers, oldestFetchedMs, sinceMs, force))
+      if (!allHistory && Number.isFinite(sinceMs) && stagedHistoryCoverage(owner, owner.snapshot.getTransfers(), oldestFetchedMs, sinceMs, force))
         break;
       const offset = owner.nextOffset;
       const rawPage = await owner.readPage(TRANSFER_PAGE_LIMIT, offset, undefined, new Date(boundaryMs));
@@ -57807,12 +58337,11 @@ async function fetchHistoryPages(owner, options, generation) {
       const pageHitStopId = stopIds.size > 0 && page.transfers.some((transfer) => stopIds.has(String(transfer?.id)));
       if (page.transfers.length) {
         owner.pending.forgetResolvedFetched(page.transfers);
-        stagedTransfers = boundedWorkingTransfers(mergeTransferPageForWallet(stagedTransfers, page.transfers, owner.walletPK, "append"));
         const oldestPageMs = getOldestTransferMs(page.transfers);
         if (oldestPageMs != null)
           oldestFetchedMs = oldestFetchedMs == null ? oldestPageMs : Math.min(oldestFetchedMs, oldestPageMs);
       }
-      await owner.commitConfirmed(page.transfers, {
+      await owner.commitHistory(page.transfers, {
         position: "append",
         nextOffset: page.nextOffset,
         boundaryMs,
@@ -57820,6 +58349,7 @@ async function fetchHistoryPages(owner, options, generation) {
       });
       if (!isCurrentGeneration2(owner, generation))
         break;
+      owner.snapshot.replace(mergeTransferPageForWallet(owner.snapshot.getTransfers(), page.transfers, owner.walletPK, "append"));
       owner.nextOffset = Math.max(owner.nextOffset, page.nextOffset);
       await yieldToUi();
       if (pageHitStopId) {
@@ -57830,7 +58360,6 @@ async function fetchHistoryPages(owner, options, generation) {
         break;
     }
     if (isCurrentGeneration2(owner, generation)) {
-      owner.snapshot.replace(stagedTransfers);
       markDone(owner.diag, label, startedAt, {
         pages,
         loaded: owner.snapshot.getTransfers().length,
@@ -57927,13 +58456,12 @@ async function refreshCachedHistory(owner, includePending = true, reason = "cach
       deltaAfterMs = Math.max(0, deltaState.newestMs - 1);
       deltaBeforeMs = Date.now();
       offset = 0;
-      await owner.commitConfirmed([], { deltaAfterMs, deltaBeforeMs, deltaNextOffset: 0 });
+      await owner.commitHistory([], { deltaAfterMs, deltaBeforeMs, deltaNextOffset: 0 });
       if (!isCurrentGeneration2(owner, generation))
         return null;
     }
     const createdAfter = new Date(deltaAfterMs);
     const createdBefore = new Date(deltaBeforeMs);
-    let stagedTransfers = owner.snapshot.getTransfers();
     let rawCount = 0;
     let pages = 0;
     let complete = false;
@@ -57945,10 +58473,7 @@ async function refreshCachedHistory(owner, includePending = true, reason = "cach
       rawCount += page.transfers.length;
       pages += 1;
       complete = !page.hasMore;
-      if (page.transfers.length) {
-        stagedTransfers = boundedWorkingTransfers(mergeTransferPageForWallet(stagedTransfers, page.transfers, walletKey, "prepend"));
-      }
-      await owner.commitConfirmed(page.transfers, {
+      await owner.commitHistory(page.transfers, {
         position: "prepend",
         deltaAfterMs: complete ? null : deltaAfterMs,
         deltaBeforeMs: complete ? null : deltaBeforeMs,
@@ -57956,6 +58481,8 @@ async function refreshCachedHistory(owner, includePending = true, reason = "cach
       });
       if (!isCurrentGeneration2(owner, generation))
         return null;
+      owner.pending.forgetResolvedFetched(page.transfers);
+      owner.snapshot.replace(mergeTransferPageForWallet(owner.snapshot.getTransfers(), page.transfers, walletKey, "prepend"));
       offset = page.nextOffset;
       if (complete)
         break;
@@ -57964,10 +58491,14 @@ async function refreshCachedHistory(owner, includePending = true, reason = "cach
     if (!isCurrentGeneration2(owner, generation) || owner.backgroundSignal?.aborted === true)
       return null;
     const pending = includePending ? await owner.pending.query() : [];
+    if (!isCurrentGeneration2(owner, generation))
+      return null;
+    if (pending.length)
+      await owner.commitHistory(pending, { position: "prepend" });
     if (!isCurrentGeneration2(owner, generation))
       return null;
     owner.pending.remember(pending.map((transfer) => transfer.id));
-    const nextTransfers = pending.length ? mergeTransferPageForWallet(stagedTransfers, pending, walletKey, "prepend") : stagedTransfers;
+    const nextTransfers = pending.length ? mergeTransferPageForWallet(owner.snapshot.getTransfers(), pending, walletKey, "prepend") : owner.snapshot.getTransfers();
     owner.snapshot.replace(nextTransfers);
     const visibleCount = Math.min(nextTransfers.length, Math.max(owner.snapshot.getTransfers().length, RECENT_TRANSFER_LIMIT));
     owner.snapshot.publish(nextTransfers.slice(0, visibleCount));
@@ -58056,7 +58587,7 @@ async function loadRecentTransfers(owner, options = {}, generation = owner.gener
     const loadedPendingIncoming = includePending ? owner.pending.claimCandidates(latestTransfers) : [];
     const latestIds = new Set(latestTransfers.map((transfer) => String(transfer?.id)).filter(Boolean));
     const reconcileIds = previousHistoryComplete ? [] : previousTransfers.filter((transfer) => transfer?.id && !latestIds.has(String(transfer.id)) && !isPendingTransfer(transfer)).map((transfer) => String(transfer.id));
-    await owner.commitConfirmed(page.transfers, {
+    await owner.commitHistory([...pending, ...page.transfers], {
       position: "prepend",
       nextOffset: Math.max(owner.historyStore.getSnapshot().nextOffset, page.nextOffset),
       boundaryMs,
@@ -58064,12 +58595,11 @@ async function loadRecentTransfers(owner, options = {}, generation = owner.gener
     });
     if (!isCurrentGeneration2(owner, generation))
       return null;
-    const fetchedTransfers = page.hasMore ? mergeRecentSnapshotForWallet(previousTransfers, latestTransfers, owner.walletPK) : mergeTransferPageForWallet([], latestTransfers, owner.walletPK);
-    const committedTransfers = boundedWorkingTransfers(mergeTransferPageForWallet(owner.snapshot.getTransfers(), fetchedTransfers, owner.walletPK, "append"));
     if (!showLoading)
       await yieldToUi();
     if (!isCurrentGeneration2(owner, generation))
       return null;
+    const committedTransfers = boundedWorkingTransfers(mergeTransferPageForWallet(owner.snapshot.getTransfers(), [...pending, ...page.transfers], owner.walletPK, "append"));
     owner.nextOffset = Math.max(owner.nextOffset, page.nextOffset);
     const committedHistory = owner.historyStore.getSnapshot();
     const visibleCount = Math.min(committedTransfers.length, Math.max(owner.snapshot.getTransfers().length, RECENT_TRANSFER_LIMIT));
@@ -58119,8 +58649,8 @@ function getRecentTransfers(owner, options = {}) {
   owner.recentPromise = request;
   return request;
 }
-function createTransferHistorySync({ walletPK, historyStore, initialOffset = 0, snapshot, readPage, commitConfirmed, pending, waitForWork, backgroundSignal = null, isClosed, diag = null } = {}) {
-  if (!walletPK || !historyStore || !snapshot || typeof readPage !== "function" || typeof commitConfirmed !== "function" || !pending || typeof waitForWork !== "function" || typeof isClosed !== "function") {
+function createTransferHistorySync({ walletPK, historyStore, initialOffset = 0, snapshot, readPage, commitHistory, pending, waitForWork, backgroundSignal = null, isClosed, diag = null } = {}) {
+  if (!walletPK || !historyStore || !snapshot || typeof readPage !== "function" || typeof commitHistory !== "function" || !pending || typeof waitForWork !== "function" || typeof isClosed !== "function") {
     throw new Error("transfer history sync requires history, snapshot, pending, and read ports");
   }
   const owner = {
@@ -58128,7 +58658,7 @@ function createTransferHistorySync({ walletPK, historyStore, initialOffset = 0,
     historyStore,
     snapshot,
     readPage,
-    commitConfirmed,
+    commitHistory,
     pending,
     waitForWork,
     backgroundSignal,
@@ -58185,6 +58715,7 @@ var ID_INDEX_PREFIX = "whi";
 var PEER_INDEX_PREFIX = "whp";
 var REPOSITORY_VERSION = 2;
 var SEGMENT_SIZE = 100;
+var WALLET_HISTORY_HEAD_SIZE = SEGMENT_SIZE;
 var SEGMENT_CACHE_LIMIT = 5;
 var ID_BUCKET_COUNT = 4096;
 var PEER_BUCKET_COUNT = 256;
@@ -58222,13 +58753,20 @@ function compareTransfers(left, right) {
   const delta = txCreatedMs(right) - txCreatedMs(left);
   return delta || transferId(right).localeCompare(transferId(left));
 }
+function mergeHistoryTransfer(current, next) {
+  if (!current)
+    return next;
+  if (!isPendingTransfer(current) && isPendingTransfer(next) || txUpdatedMs(next) < txUpdatedMs(current))
+    return current;
+  return { ...current, ...next };
+}
 function normalizeTransfers(transfers, walletPK) {
   const byId = new Map;
   for (const transfer of Array.isArray(transfers) ? transfers : EMPTY_TRANSFERS) {
     const id = transferId(transfer);
     if (!id || !isVisibleTransfer(transfer) || !transferBelongsToWallet(transfer, walletPK))
       continue;
-    byId.set(id, jsonClone(transfer));
+    byId.set(id, mergeHistoryTransfer(byId.get(id), jsonClone(transfer)));
   }
   return [...byId.values()].sort(compareTransfers);
 }
@@ -58253,7 +58791,8 @@ function emptyProjection() {
     days: {},
     hours: {},
     months: {},
-    peers: {}
+    peers: {},
+    pending: {}
   };
 }
 function cleanStats(value) {
@@ -58268,6 +58807,7 @@ function cleanStats(value) {
 }
 function cleanProjection(value) {
   const projection = emptyProjection();
+  projection.pending = { ...value?.pending };
   projection.all = cleanStats(value?.all);
   for (const [key, stats] of Object.entries(value?.days || {}))
     projection.days[key] = cleanStats(stats);
@@ -58304,6 +58844,8 @@ function applyStats(stats, transfer, sign2, { excludeFunding = false } = {}) {
   const amount = Number(transfer?.totalValue) || 0;
   const incoming = isIncomingTransfer(transfer);
   stats.count += sign2;
+  if (incoming && isPendingTransfer(transfer))
+    return;
   stats.vol += sign2 * amount;
   if (incoming) {
     stats.received += sign2 * amount;
@@ -58322,6 +58864,11 @@ function normalizeStats(stats) {
   return stats;
 }
 function applyProjection(projection, transfer, sign2) {
+  const id = transferId(transfer);
+  if (sign2 > 0 && isPendingTransfer(transfer))
+    projection.pending[id] = txCreatedMs(transfer);
+  else
+    delete projection.pending[id];
   const { day, hour, month } = timeKeys(transfer);
   projection.days[day] ||= emptyStats();
   projection.hours[hour] ||= emptyStats();
@@ -58407,11 +58954,12 @@ function normalizeManifest(value, walletPK) {
     projection: cleanProjection(value.projection)
   };
 }
-function repositorySnapshot(manifest, ready, syncing = false) {
+function repositorySnapshot(manifest, ready, syncing = false, head = EMPTY_TRANSFERS) {
   return Object.freeze({
     walletPK: manifest.walletPK,
     ready,
     syncing,
+    head,
     count: manifest.count,
     complete: manifest.complete,
     bitcoinOldestMs: manifest.bitcoinOldestMs,
@@ -58459,8 +59007,14 @@ function buildSegmentCommitPlan({ manifest, incoming, removedIds, mappings, oldS
   const incomingById = new Map(incoming.map((transfer) => [transferId(transfer), transfer]));
   const working = new Map;
   for (const [segmentId, segmentTransfers] of oldSegments) {
-    for (const transfer of segmentTransfers)
-      previousById.set(transferId(transfer), transfer);
+    for (const transfer of segmentTransfers) {
+      const id = transferId(transfer);
+      previousById.set(id, transfer);
+      const next2 = incomingById.get(id);
+      if (!next2)
+        continue;
+      incomingById.set(id, mergeHistoryTransfer(transfer, next2));
+    }
     const next = segmentTransfers.filter((transfer) => !removedIds.has(transferId(transfer))).map((transfer) => incomingById.get(transferId(transfer)) || transfer);
     working.set(segmentId, normalizeTransfers(next, walletPK));
   }
@@ -58676,6 +59230,15 @@ async function openWalletHistoryRepository({ localCache, walletPK } = {}) {
     }
     return rememberSegment(id, transfers);
   };
+  const readHead = async () => {
+    const transfers = [];
+    for (const segment of manifest.segments) {
+      transfers.push(...await readSegment(segment.id));
+      if (transfers.length >= WALLET_HISTORY_HEAD_SIZE)
+        break;
+    }
+    return transfers.length ? Object.freeze(transfers.slice(0, WALLET_HISTORY_HEAD_SIZE)) : EMPTY_TRANSFERS;
+  };
   const readIdMappings = async (ids, generation = manifest.generation) => {
     const grouped = new Map;
     for (const id of ids) {
@@ -58720,7 +59283,7 @@ async function openWalletHistoryRepository({ localCache, walletPK } = {}) {
     if (!wrote)
       throw new Error("wallet history checkpoint write failed");
     manifest = normalizeManifest(nextManifest, requestedWalletPK);
-    snapshot = repositorySnapshot(manifest, true);
+    snapshot = repositorySnapshot(manifest, true, false, await readHead());
     emit(listeners);
   };
   const pruneSegments = async () => {
@@ -58738,6 +59301,13 @@ async function openWalletHistoryRepository({ localCache, walletPK } = {}) {
   };
   const prunePromise = pruneSegments();
   await prunePromise;
+  const initialHead = await readHead().catch(async (error) => {
+    if (!recoveryPromise)
+      throw error;
+    await recoveryPromise;
+    return EMPTY_TRANSFERS;
+  });
+  snapshot = repositorySnapshot(manifest, true, false, initialHead);
   const readCommitSource = async (incoming, removedIds, position) => {
     const ids = [...new Set([...incoming.map(transferId), ...removedIds])];
     const { mappings, known, buckets: idBuckets } = await readIdMappings(ids);
@@ -58809,7 +59379,9 @@ async function openWalletHistoryRepository({ localCache, walletPK } = {}) {
       if (!wrote)
         throw new Error("wallet history checkpoint write failed");
       manifest = normalizeManifest(nextManifest, requestedWalletPK);
-      snapshot = repositorySnapshot(manifest, true);
+      for (const record of plan.newSegmentRecords)
+        rememberSegment(record.descriptor.id, record.transfers);
+      snapshot = repositorySnapshot(manifest, true, false, await readHead());
       emit(listeners);
     } else {
       for (const record of plan.newSegmentRecords) {
@@ -58836,6 +59408,10 @@ async function openWalletHistoryRepository({ localCache, walletPK } = {}) {
     await prunePromise;
     const incoming = normalizeTransfers(transfers, requestedWalletPK);
     const removedIds = new Set((Array.isArray(options.removedIds) ? options.removedIds : []).map(String).filter(Boolean));
+    for (const transfer of transfers) {
+      if (transfer?.id && transferBelongsToWallet(transfer, requestedWalletPK) && !isVisibleTransfer(transfer))
+        removedIds.add(String(transfer.id));
+    }
     const bitcoinTimes = incoming.filter((tx) => !tx.tokenIdentifier).map(txCreatedMs);
     if (bitcoinTimes.length)
       options = { ...options, bitcoinOldestMs: Math.min(manifest.bitcoinOldestMs ?? Infinity, ...bitcoinTimes) };
@@ -58869,13 +59445,13 @@ async function openWalletHistoryRepository({ localCache, walletPK } = {}) {
     commitPage(transfers, options = {}) {
       if (corruptionDetected)
         return Promise.reject(new Error("wallet history cache recovery in progress"));
-      snapshot = repositorySnapshot(manifest, true, true);
+      snapshot = repositorySnapshot(manifest, true, true, snapshot.head);
       emit(listeners);
       const run = () => commit(transfers, options);
       const result = writeTail.then(run, run);
       writeTail = result.catch(() => {}).finally(() => {
         if (!closed) {
-          snapshot = repositorySnapshot(manifest, true, false);
+          snapshot = repositorySnapshot(manifest, true, false, snapshot.head);
           emit(listeners);
         }
       });
@@ -59174,9 +59750,9 @@ function createWalletTransferSession({ wallet, walletPK, claimIncomingTransfers,
     const snapshot = transferStore.getSnapshot();
     return lowerText(snapshot.walletPK) === walletKey && snapshot.ready === true;
   };
-  const commitConfirmedHistoryPage = (pageTransfers, options = {}) => {
-    const confirmed = compactTransfersForWallet(pageTransfers, walletKey).filter((transfer) => !isPendingTransfer(transfer));
-    return historyStore.commitPage(confirmed, options);
+  const commitHistoryPage = (pageTransfers, options = {}) => {
+    const updates = pageTransfers.map((transfer) => compactTransfer(transfer)).filter((transfer) => transfer && transferBelongsToWallet(transfer, walletKey));
+    return historyStore.commitPage(updates, options);
   };
   const forgetPendingLookupIds = (ids = []) => pendingReconciliation.forget(ids);
   const rememberPendingTransferIds = (ids = []) => pendingReconciliation.remember(ids);
@@ -59212,9 +59788,6 @@ function createWalletTransferSession({ wallet, walletPK, claimIncomingTransfers,
     if (closed)
       return current;
     let ownedTransfers = owned ? nextTransfers : filterTransfersForWallet(nextTransfers, walletKey);
-    if (current.length && ownedTransfers.length && ownedTransfers.length < current.length) {
-      ownedTransfers = mergeTransferPageForWallet(ownedTransfers, current, walletKey, "append");
-    }
     ownedTransfers = boundedWorkingTransfers(applyTransferStatusOverlays(ownedTransfers));
     const committed = sameTransfers(current, ownedTransfers) ? current : ownedTransfers;
     transferStore.setHistory({ transfers: committed, walletPK: walletKey });
@@ -59351,7 +59924,7 @@ function createWalletTransferSession({ wallet, walletPK, claimIncomingTransfers,
       return [];
     const nextTransfers = markClaimedTransfersCompleted(current, knownIds);
     if (nextTransfers !== current) {
-      commitConfirmedHistoryPage(nextTransfers.filter((transfer) => knownIds.includes(String(transfer?.id))), { position: "prepend" });
+      commitHistoryPage(nextTransfers.filter((transfer) => knownIds.includes(String(transfer?.id))), { position: "prepend" });
       commitTransferSnapshot(nextTransfers, { publish: true, owned: true });
       setTxReadyValue(true);
     }
@@ -59376,7 +59949,7 @@ function createWalletTransferSession({ wallet, walletPK, claimIncomingTransfers,
     snapshot: {
       getTransfers: currentTransfers,
       replace: (transfers) => commitTransferSnapshot(transfers, { publish: true, owned: true }),
-      commitConfirmed: commitConfirmedHistoryPage,
+      commitHistory: commitHistoryPage,
       setReady: () => setTxReadyValue(true)
     },
     reads: {
@@ -59400,7 +59973,7 @@ function createWalletTransferSession({ wallet, walletPK, claimIncomingTransfers,
       setLoading: setIsTxLoading
     },
     readPage: fetchTransfersPage,
-    commitConfirmed: commitConfirmedHistoryPage,
+    commitHistory: commitHistoryPage,
     pending: {
       query: getPendingTransfersSnapshot,
       isQuerying: () => !!pendingQueryPromiseRef.current,
@@ -59457,7 +60030,10 @@ function createWalletTransferSession({ wallet, walletPK, claimIncomingTransfers,
         const current = currentTransfers();
         const nextTransfers = mergeTransferPageForWallet(current, incomingTransfers, walletKey, "prepend");
         if (nextTransfers !== current) {
-          commitTransferSnapshot(nextTransfers, { publish: true, owned: true });
+          await commitHistoryPage(incomingTransfers, { position: "prepend" });
+          if (closed)
+            return [];
+          commitTransferSnapshot(mergeTransferPageForWallet(currentTransfers(), incomingTransfers, walletKey, "prepend"), { publish: true, owned: true });
           setTxReadyValue(true);
         }
       }
@@ -59499,10 +60075,8 @@ function createWalletTransferSession({ wallet, walletPK, claimIncomingTransfers,
           forgetPendingLookupIds(resolvedUpdateIds);
         }
       }
-      const current = currentTransfers();
-      const nextTransfers = mergeTransferPageForWallet(current, updates, walletKey, "prepend");
-      await commitConfirmedHistoryPage(updates, { position: "prepend" });
-      commitTransferSnapshot(nextTransfers, { publish: true, owned: true });
+      await commitHistoryPage(updates, { position: "prepend" });
+      commitTransferSnapshot(mergeTransferPageForWallet(currentTransfers(), updates, walletKey, "prepend"), { publish: true, owned: true });
       setTxReadyValue(true);
       markDone(diag, "wallet.claimedTxs", startedAt2, { found: true, count: updates.length });
       return updates;
@@ -59527,10 +60101,8 @@ function createWalletTransferSession({ wallet, walletPK, claimIncomingTransfers,
           forgetPendingLookupIds([compact.id]);
         }
       }
-      const current = currentTransfers();
-      const nextTransfers = mergeTransferPageForWallet(current, [compact], walletKey, "prepend");
-      await commitConfirmedHistoryPage([compact], { position: "prepend" });
-      commitTransferSnapshot(nextTransfers, { publish: true, owned: true });
+      await commitHistoryPage([compact], { position: "prepend" });
+      commitTransferSnapshot(mergeTransferPageForWallet(currentTransfers(), [compact], walletKey, "prepend"), { publish: true, owned: true });
       setTxReadyValue(true);
       markDone(diag, "wallet.claimedTx", startedAt, { found: true });
       return compact;
@@ -60337,27 +60909,21 @@ function tokenHistoryBalance(tokens, unitsByToken = {}) {
 }
 // ../../core/wallet/txlist.js
-async function readTxListPage(pending, queryHistory, { offset = 0, limit = 100 } = {}) {
+async function readTxListPage(queryHistory, { offset = 0, limit = 100 } = {}) {
   const start2 = Math.max(0, Math.floor(offset));
   const count = Math.max(1, Math.min(500, Math.floor(limit)));
-  const head = pending.slice(start2, start2 + count);
-  const remaining = count - head.length;
-  const history = remaining ? await queryHistory({ offset: Math.max(0, start2 - pending.length), limit: remaining }) : { transfers: [] };
-  return { offset: start2, transfers: [...head, ...history.transfers] };
-}
-async function findTxListPeriod(pending, history, queryHistory, { sinceMs, untilMs, hourly }) {
-  const pendingIndex = pending.findIndex((tx) => tx.createdMs >= sinceMs && tx.createdMs < untilMs);
-  if (pendingIndex >= 0)
-    return pendingIndex;
+  const history = await queryHistory({ offset: start2, limit: count });
+  return { offset: start2, transfers: history.transfers };
+}
+async function findTxListPeriod(history, queryHistory, { sinceMs, hourly }) {
   const key = (hourly ? dayHourKey : dayKey)(new Date(sinceMs));
   const buckets = history.projection[hourly ? "hours" : "days"];
   const newer = Object.entries(buckets).reduce((count, [period, stats]) => count + (period > key ? stats.count : 0), 0);
   if (buckets[key]?.count)
-    return pending.length + newer;
+    return newer;
   const offset = Math.max(0, newer - 1);
   const { transfers } = await queryHistory({ offset, limit: 2 });
-  const candidates = pending.map((tx, index) => ({ tx, index }));
-  transfers.forEach((tx, index) => candidates.push({ tx, index: pending.length + offset + index }));
+  const candidates = transfers.map((tx, index) => ({ tx, index: offset + index }));
   candidates.sort((a, b) => Math.abs(a.tx.createdMs - sinceMs) - Math.abs(b.tx.createdMs - sinceMs));
   return candidates[0]?.index ?? -1;
 }
@@ -60596,14 +61162,14 @@ function mergeTxSearchResults(loaded, found, limit = TX_SEARCH_DEFAULT_LIMIT) {
   }
   return [...byId.values()].sort(byRecentTx).slice(0, max2);
 }
-function getDailySeries({ days, transactions, aggregatedData, balance, historyComplete, oldestMs, cache }) {
+function getDailySeries({ days, transactions, aggregatedData, balance, historyComplete, oldestMs, cache, nowMs: nowMs2 = Date.now() }) {
   if (!transactions.length || balance == null)
     return [];
   const cacheKey = `daily-${days}`;
-  if (cache.has(cacheKey)) {
-    return cache.get(cacheKey);
-  }
-  const today = new Date;
+  const clock = Math.floor(nowMs2 / 60000);
+  if (cache.get(cacheKey)?.clock === clock)
+    return cache.get(cacheKey).series;
+  const today = new Date(nowMs2);
   today.setHours(0, 0, 0, 0);
   const series = [];
   let runningBalance = Number(balance);
@@ -60614,84 +61180,44 @@ function getDailySeries({ days, transactions, aggregatedData, balance, historyCo
     const d = new Date(today);
     d.setDate(d.getDate() - i2);
     const key = dayKey(d);
-    series.push({ date: key, balance: runningBalance });
+    const end = new Date(d);
+    end.setDate(end.getDate() + 1);
+    series.push({ date: key, timestamp: i2 === 0 ? nowMs2 : end.getTime(), now: i2 === 0, balance: runningBalance });
     const dayData = aggregatedData.dayMap.get(key);
     if (dayData) {
       runningBalance -= dayData.net;
     }
   }
   const result = series.reverse();
-  cache.set(cacheKey, result);
+  cache.set(cacheKey, { clock, series: result });
   return result;
 }
-function getHourlySeriesForData({ hours, prefix = "today", transactions, aggregatedData, balance, historyComplete, oldestMs, cache }) {
+function getHourlySeriesForData({ hours, prefix = "today", transactions, aggregatedData, balance, historyComplete, oldestMs, cache, nowMs: nowMs2 = Date.now() }) {
   if (!transactions.length || balance == null)
     return [];
   const cacheKey = `hourly-${hours}-${prefix}`;
-  if (cache.has(cacheKey)) {
-    return cache.get(cacheKey);
-  }
-  const now = new Date;
-  const series = [];
+  const clock = Math.floor(nowMs2 / 60000);
+  if (cache.get(cacheKey)?.clock === clock)
+    return cache.get(cacheKey).series;
+  const now = new Date(nowMs2);
+  const series = [{ hour: "now", timestamp: nowMs2, now: true, balance: Number(balance) }];
   let runningBalance = Number(balance);
-  const today = dayKey(now);
-  const yesterday = dayKey(new Date(now.getTime() - DAY_MS));
+  const today = new Date(now);
+  today.setHours(0, 0, 0, 0);
   const coveredHours = historyComplete ? hours : coveredUnitsSince(oldestMs, HOUR_MS, now.getTime());
   const actualHours = Math.min(hours, coveredHours);
-  if (prefix === "today") {
-    const currentHour = now.getHours();
-    const maxHour = Math.min(actualHours - 1, currentHour);
-    for (let i2 = 0;i2 <= maxHour; i2++) {
-      const key = `${today}-${hourKey(i2)}`;
-      const hourData = aggregatedData.hourMap.get(key);
-      if (hourData) {
-        runningBalance -= hourData.net;
-      }
-    }
-    for (let i2 = 0;i2 <= maxHour; i2++) {
-      const hour = hourKey(i2);
-      series.push({ hour, balance: runningBalance });
-      const key = `${today}-${hour}`;
-      const hourData = aggregatedData.hourMap.get(key);
-      if (hourData) {
-        runningBalance += hourData.net;
-      }
-    }
-    series.push({ hour: "now", balance: Number(balance) });
-  } else if (prefix === "24h") {
-    const currentHour = now.getHours();
-    const firstOffset = Math.max(0, 24 - actualHours);
-    for (let i2 = 0;i2 <= currentHour; i2++) {
-      const key = `${today}-${hourKey(i2)}`;
-      const hourData = aggregatedData.hourMap.get(key);
-      if (hourData)
-        runningBalance -= hourData.net;
-    }
-    for (let i2 = Math.max(currentHour + 1, firstOffset);i2 < 24; i2++) {
-      const key = `${yesterday}-${hourKey(i2)}`;
-      const hourData = aggregatedData.hourMap.get(key);
-      if (hourData)
-        runningBalance -= hourData.net;
-    }
-    for (let i2 = Math.max(currentHour + 1, firstOffset);i2 < 24; i2++) {
-      const hour = hourKey(i2);
-      series.push({ hour, balance: runningBalance });
-      const key = `${yesterday}-${hour}`;
-      const hourData = aggregatedData.hourMap.get(key);
-      if (hourData)
-        runningBalance += hourData.net;
-    }
-    for (let i2 = firstOffset > currentHour ? firstOffset : 0;i2 <= currentHour; i2++) {
-      const hour = hourKey(i2);
-      series.push({ hour, balance: runningBalance });
-      const key = `${today}-${hour}`;
-      const hourData = aggregatedData.hourMap.get(key);
-      if (hourData)
-        runningBalance += hourData.net;
-    }
-  }
-  cache.set(cacheKey, series);
-  return series;
+  const endHour = new Date(now);
+  endHour.setMinutes(0, 0, 0);
+  for (let offset = 0;offset < actualHours; offset++) {
+    const date = new Date(endHour.getTime() - offset * HOUR_MS);
+    if (prefix === "today" && date < today)
+      break;
+    runningBalance -= aggregatedData.hourMap.get(dayHourKey(date))?.net || 0;
+    series.push({ hour: hourKey(date), timestamp: date.getTime(), balance: runningBalance });
+  }
+  const result = series.reverse();
+  cache.set(cacheKey, { clock, series: result });
+  return result;
 }
 function getTxsInRangeFrom(sortedTransactions, timeRange) {
   if (!sortedTransactions.length)
@@ -60899,11 +61425,8 @@ function createTxData({ transferStore, historyStore, diag = null, deferAggregati
       transfers: result.transfers.map((transfer) => getVisibleWalletTransfer(transfer, sources.walletPK)).filter(Boolean)
     };
   }
-  function pendingList() {
-    return readCurrentAggregatedData(sources.walletPK).sortedTxs.filter((tx) => tx.pending);
-  }
   function getTxListPage(options) {
-    return readTxListPage(pendingList(), queryHistory, options);
+    return readTxListPage(queryHistory, options);
   }
   async function findTxListPeriod2(period) {
     const { sinceMs, untilMs } = period;
@@ -60921,7 +61444,7 @@ function createTxData({ transferStore, historyStore, diag = null, deferAggregati
       return -1;
     if (!covered())
       throw new Error("transaction history is unavailable for this date");
-    return findTxListPeriod(pendingList(), historyStore.getSnapshot(), queryHistory, period);
+    return findTxListPeriod(historyStore.getSnapshot(), queryHistory, period);
   }
   async function getHistoryById(txId, tokenIdentifier) {
     const { walletPK, lookupTxById } = sources;
@@ -60941,31 +61464,17 @@ function createTxData({ transferStore, historyStore, diag = null, deferAggregati
     const peerKey = lowerText(peerPK);
     const limit = Math.max(1, Math.min(500, Math.floor(Number(options.limit) || 100)));
     const offset = Math.max(0, Math.floor(Number(options.offset) || 0));
-    const pendingData = getPeerDataFromTransfers(transferStore.getSnapshot().transfers.filter(isPendingTransfer), sources.walletPK, peerKey);
-    const pending = pendingData.txs;
-    const pendingPage = pending.slice(offset, offset + limit);
-    const historyOffset = Math.max(0, offset - pending.length);
-    const historyLimit = Math.max(0, limit - pendingPage.length);
-    const result = historyLimit ? await queryHistory({ ...options, peerPK: peerKey, offset: historyOffset, limit: historyLimit }) : { transfers: [], cursor: null };
+    const result = await queryHistory({ ...options, peerPK: peerKey, offset, limit });
     const storedStats = historyStore.getSnapshot().projection?.peers?.[peerKey];
-    const confirmedStats = {
+    const stats = {
       sent: Number(storedStats?.sent) || 0,
       received: Number(storedStats?.received) || 0,
       net: Number(storedStats?.net) || 0,
       vol: Number(storedStats?.vol) || 0,
       cnt: Number(storedStats?.count) || 0
     };
-    const pendingStats = pendingData.stats || { sent: 0, received: 0, net: 0, vol: 0, cnt: 0 };
-    const stats = confirmedStats.cnt || pendingStats.cnt ? {
-      sent: confirmedStats.sent + pendingStats.sent,
-      received: confirmedStats.received + pendingStats.received,
-      net: confirmedStats.net + pendingStats.net,
-      vol: confirmedStats.vol + pendingStats.vol,
-      cnt: confirmedStats.cnt + pendingStats.cnt
-    } : null;
-    const txs = [...pendingPage, ...result.transfers];
-    const total = confirmedStats.cnt + pending.length;
-    return { ...result, transfers: txs, txs, stats, total, hasMore: offset + txs.length < total };
+    const txs = result.transfers;
+    return { ...result, txs, stats: stats.cnt ? stats : null, total: stats.cnt, hasMore: offset + txs.length < stats.cnt };
   }
   async function getHistorySummary(timeRange = "all-time") {
     const result = await historyStore.summarize({ sinceMs: getTxRangeStartMs(timeRange) });
@@ -61021,31 +61530,16 @@ function createTxData({ transferStore, historyStore, diag = null, deferAggregati
     }
     return [...combined.values()].sort(byRecentTx).slice(0, limit);
   }
-  function addCashSeries(series, hourly, prefix) {
-    const history = historyStore.getSnapshot();
-    const tokens = sources.tokens;
+  function addCashSeries(series, hourly, history, tokens) {
     const coverage = !tokens.length || history.tokenComplete;
-    const now = new Date;
     const buckets = history.projection[hourly ? "hours" : "days"];
     return series.map((point) => {
-      let timestamp;
-      if (hourly) {
-        timestamp = new Date(now);
-        if (point.hour !== "now") {
-          const hour = Number(point.hour.slice(0, 2));
-          timestamp.setHours(hour, 0, 0, 0);
-          if (prefix === "24h" && hour > now.getHours())
-            timestamp.setDate(timestamp.getDate() - 1);
-        }
-      } else {
-        timestamp = new Date(`${point.date}T00:00:00`);
-        timestamp.setDate(timestamp.getDate() + 1);
-      }
-      const known = coverage || history.tokenOldestMs != null && timestamp.getTime() > history.tokenOldestMs;
+      const timestamp = new Date(point.timestamp);
+      const known = point.now || coverage || history.tokenOldestMs != null && timestamp.getTime() > history.tokenOldestMs;
       const key = (hourly ? dayHourKey : dayKey)(timestamp);
       const deltas = {};
-      if (point.hour !== "now")
-        for (const [bucketKey, stats] of Object.entries(buckets)) {
+      if (!point.now)
+        for (const [bucketKey, stats] of Object.entries(buckets || {})) {
           if (bucketKey < key)
             continue;
           for (const [id, units] of Object.entries(stats.tokens || {}))
@@ -61055,14 +61549,14 @@ function createTxData({ transferStore, historyStore, diag = null, deferAggregati
     });
   }
   function buildSnapshot() {
-    const { balance, walletPK, oldestTxMs, txReady, isTxLoading, ensureTxCoverage, loadMoreTxs } = sources;
+    const { balance, tokens, walletPK, oldestTxMs, txReady, isTxLoading, ensureTxCoverage, loadMoreTxs } = sources;
     const storeSnapshot = transferStore.getSnapshot();
     const historySnapshot = historyStore.getSnapshot();
     observedStoreSnapshot = storeSnapshot;
     observedHistorySnapshot = historySnapshot;
     const transfers = storeSnapshot.transfers;
     const aggregatedData = deferAggregation ? EMPTY_AGG : readCurrentAggregatedData(walletPK);
-    const projectedData = projectionData(historySnapshot);
+    const projectedData = historySnapshot.walletPK === walletPK ? projectionData(historySnapshot) : null;
     const transactions = aggregatedData.enrichedTxs;
     const sortedTransactions = aggregatedData.sortedTxs;
     const readLiveTransfers = () => deferAggregation ? transferStore.getSnapshot().transfers : transfers;
@@ -61132,16 +61626,17 @@ function createTxData({ transferStore, historyStore, diag = null, deferAggregati
         cache: seriesCache.current
       });
     };
-    const getHistorySeries = (days) => addCashSeries(getDailySeries({
+    const getHistorySeries = (days, nowMs2 = Date.now()) => !projectedData ? [] : addCashSeries(getDailySeries({
       days,
       transactions: projectedData.enrichedTxs,
       aggregatedData: projectedData,
       balance,
       historyComplete: historySnapshot.complete,
       oldestMs: historySnapshot.bitcoinOldestMs,
-      cache: historySeriesCache.current
-    }), false);
-    const getHistoryHourlySeries = (hours, prefix = "today") => addCashSeries(getHourlySeriesForData({
+      cache: historySeriesCache.current,
+      nowMs: nowMs2
+    }), false, historySnapshot, tokens);
+    const getHistoryHourlySeries = (hours, prefix = "today", nowMs2 = Date.now()) => !projectedData ? [] : addCashSeries(getHourlySeriesForData({
       hours,
       prefix,
       transactions: projectedData.enrichedTxs,
@@ -61149,8 +61644,9 @@ function createTxData({ transferStore, historyStore, diag = null, deferAggregati
       balance,
       historyComplete: historySnapshot.complete,
       oldestMs: historySnapshot.bitcoinOldestMs,
-      cache: historySeriesCache.current
-    }), true, prefix);
+      cache: historySeriesCache.current,
+      nowMs: nowMs2
+    }), true, historySnapshot, tokens);
     const getTxById = (txId) => getVisibleTransferById(readLiveTransfers(), walletPK, txId, transferByIdRef);
     const getPeerTxs = (peerPK) => peerPK ? readPeerData(peerPK).txs : EMPTY_TXS2;
     const getPeerStats = (peerPK) => peerPK ? readPeerData(peerPK).stats : null;
@@ -61183,7 +61679,7 @@ function createTxData({ transferStore, historyStore, diag = null, deferAggregati
       queryHistory,
       getTxListPage,
       findTxListPeriod: findTxListPeriod2,
-      txListCount: historySnapshot.count + transfers.filter((tx) => isPendingTransfer(tx) && isVisibleTransfer(tx) && transferBelongsToWallet(tx, walletPK)).length,
+      txListCount: historySnapshot.walletPK === walletPK ? historySnapshot.count : 0,
       getTxById,
       searchTxs,
       getPeerTxs,
@@ -61790,8 +62286,7 @@ function openAccount(options = {}) {
     getPeerProfile: getChatPeerProfile,
     refreshPeerProfile: refreshChatPeerProfile,
     resolvePeerProfile: resolveChatPeerProfile,
-    maintenance: messageMaintenance,
-    resolveActiveCall: (chatId) => calls.resolveActiveCall(chatId)
+    maintenance: messageMaintenance
   }, chatSources());
   const calls = createCallSession({
     cloud,
@@ -61818,11 +62313,11 @@ function openAccount(options = {}) {
   function chatSources(sessionOverride = chatSession) {
     const currentUser = state.user || {};
     const session = sessionOverride;
-    const cachedBlacklist = session?.localCache?.read?.()?.blacklist;
     return {
       uid: currentUser.uid || "",
-      blocked: currentUser.blockedReady ? currentUser.blocked : cachedBlacklist || [],
-      blockedReady: currentUser.blockedReady || Array.isArray(cachedBlacklist),
+      blocked: currentUser.blocked,
+      blockedPending: currentUser.blockedPending,
+      blockedReady: currentUser.blockedReady,
       online: state.online,
       chatPK: session?.chatPK || currentUser.chatPK || "",
       chatSigningPK: session?.chatSigningPK || currentUser.chatSigningPK || "",
@@ -61855,13 +62350,12 @@ function openAccount(options = {}) {
   }
   function syncPeers() {
     const currentUser = state.user || {};
-    const cachedBlacklist = state.session?.localCache?.read?.()?.blacklist;
     const chatSnapshot = chat.getSnapshot();
     peers.setSources({
       chatPeers: chatSnapshot.peers,
       chats: chatSnapshot.chats,
-      blocked: currentUser.blockedReady ? currentUser.blocked : cachedBlacklist || [],
-      blockedReady: currentUser.blockedReady || Array.isArray(cachedBlacklist),
+      blocked: currentUser.blocked,
+      blockedReady: currentUser.blockedReady,
       chatPK: state.session?.chatPK || currentUser.chatPK || "",
       chatSigningPK: state.session?.chatSigningPK || currentUser.chatSigningPK || "",
       walletPeers: wallet.getPeers(),
@@ -62146,8 +62640,9 @@ function openAccount(options = {}) {
         hasVault: !!vault,
         fromCache: !!info.fromCache
       });
+      const currentVault = state.vault && vault && equalBytes(state.vault, vault) ? state.vault : vault || null;
       emit2({
-        vault: vault || null,
+        vault: currentVault,
         vaultFromCache: false,
         vaultReady: state.vaultReady || !info.fromCache,
         vaultError: info.fromCache ? state.vaultError : null
@@ -62257,7 +62752,7 @@ function openAccount(options = {}) {
   function syncBootstrap() {
     if (closed || !state.session || state.session.closed || !serverReady())
       return;
-    if (state.user.blockedReady) {
+    if (state.user.blockedReady && !state.user.blockedPending?.length) {
       const cache = state.session.localCache;
       const blocked = state.user.blocked;
       if (JSON.stringify(cache?.read?.()?.blacklist) !== JSON.stringify(blocked)) {
@@ -62397,6 +62892,7 @@ function openAccount(options = {}) {
       });
       if (!isCurrent())
         throw new Error("account changed during unlock");
+      user.restoreBlocked({ uid, blocked: session.localCache?.read?.()?.blacklist });
       chatSession = session;
       chat.setSources(chatSources());
       unlockStage = "launching";
@@ -62591,15 +63087,21 @@ function openAccount(options = {}) {
       if (!observedVault)
         throw new Error("vault not ready");
       const isCurrent = () => !closed && !operationBarrier.blocksOperations && state.uid === uid && state.session === session && state.vault === observedVault && !session.closed && cloud.auth.user?.uid === uid;
+      markDiag(diag, "account.delete.phase", { phase: "verify-vault" });
       const verified = await vaultCrypto.verifyVaultPassword(observedVault, password);
       if (!verified)
         throw new Error("incorrect password");
       if (!isCurrent())
         throw new Error("account changed during deletion");
+      await waitForOnlineDeletion(isCurrent);
+      markDiag(diag, "account.delete.phase", { phase: "retire-chats" });
       const chats = await chat.getSnapshot().deleteAllChats();
       if (!isCurrent())
         throw new Error("account changed during deletion");
+      await waitForOnlineDeletion(isCurrent);
+      markDiag(diag, "account.delete.phase", { phase: "delete-account" });
       await cloud.user.delete();
+      markDiag(diag, "account.delete.phase", { phase: "clear-local-state" });
       try {
         await localCache?.clear?.();
       } catch (error) {
@@ -62623,6 +63125,31 @@ function openAccount(options = {}) {
       finishOperation();
     }
   }
+  function waitForOnlineDeletion(isCurrent) {
+    if (!isCurrent())
+      return Promise.reject(new Error("account changed during deletion"));
+    if (state.online)
+      return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      const finish = (error) => {
+        clearTimeout(timer);
+        listeners.delete(check);
+        if (error)
+          reject(error);
+        else
+          resolve();
+      };
+      const check = () => {
+        if (!isCurrent())
+          finish(new Error("account changed during deletion"));
+        else if (state.online)
+          finish();
+      };
+      const timer = setTimeout(() => finish(new Error("couldnt connect to server")), ACCOUNT_CONNECTION_UNAVAILABLE_MS);
+      listeners.add(check);
+      check();
+    });
+  }
   async function switchNetwork(network) {
     if (state.lockState !== "unlocked") {
       throw new Error("unlock the vault before switching networks");