@glyphteck/veyl 0.32.1 → 0.35.0

package/dist/cli.js

@@ -118,9 +118,10 @@ var init_links = __esm(() => {
 });
 
 // ../../shared/community.js
-var COMMUNITY_RULES_VERSION = "2026-05-11.1", COMMUNITY_SECTIONS;
+var COMMUNITY_RULES_VERSION = "2026-05-11.1", COMMUNITY_SUPPORT_EMAIL, COMMUNITY_SECTIONS;
 var init_community = __esm(() => {
   init_links();
+  COMMUNITY_SUPPORT_EMAIL = links.contact.replace("mailto:", "");
   COMMUNITY_SECTIONS = [
     {
       title: "Use veyl directly and lawfully",
@@ -160,7 +161,7 @@ var init_community = __esm(() => {
     {
       title: "Reporting and support",
       body: [
-        `If someone is abusing veyl, contact us at ${links.contact.replace("mailto:", "")} and include the username, profile details, screenshots, or any evidence you choose to provide from your own device.`,
+        `If someone is abusing veyl, contact us at ${COMMUNITY_SUPPORT_EMAIL} and include the username, profile details, screenshots, or any evidence you choose to provide from your own device.`,
         "Because veyl uses end-to-end encryption, we may rely on reports, account-level signals, and evidence you submit when reviewing abuse."
       ]
     }
@@ -979,7 +980,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "veyl",
-    version: "0.32.1",
+    version: "0.35.0",
     private: true,
     license: "Apache-2.0",
     workspaces: {
@@ -995,16 +996,16 @@ var init_package = __esm(() => {
         "@noble/curves": "^2.2.0",
         "@noble/hashes": "^2.2.0",
         "@scure/bip39": "^2.2.0",
-        "@tailwindcss/postcss": "^4.3.2",
+        "@tailwindcss/postcss": "^4.3.3",
         bech32: "^2.0.0",
         firebase: "^12.16.0",
         "lucide-react": "^1.24.0",
         next: "16.3.0-preview.6",
         "next-themes": "^0.4.6",
-        postcss: "^8.5.19",
-        react: "19.2.7",
-        "react-dom": "19.2.7",
-        tailwindcss: "^4.3.2",
+        postcss: "^8.5.22",
+        react: "19.2.8",
+        "react-dom": "19.2.8",
+        tailwindcss: "^4.3.3",
         "tw-animate-css": "^1.4.0"
       }
     },
@@ -104534,7 +104535,7 @@ var init_seed = __esm(() => {
 });
 
 // ../../shared/config.js
-var MS_PER_SECOND = 1000, MINUTE_MS, HOUR_MS, DAY_MS, KIB_BYTES = 1024, MIB_BYTES, SATS_PER_BITCOIN = 100000000n, USERNAME_MAX_CHARS = 12, PASSWORD_MIN_CHARS = 12, PASSWORD_MAX_CHARS = 64, AUTOLOCK_MIN_MINUTES = 1, AUTOLOCK_MAX_MINUTES = 60, LOCAL_CACHE_WRITE_DELAY_MS = 350, LOCAL_MEDIA_CACHE_MAX_BYTES, LOCAL_MEDIA_CACHE_MAX_ITEMS = 1000, LOCAL_MEDIA_ACCESS_TOUCH_MIN_MS, LOCAL_PROFILE_CACHE_MAX_ITEMS = 500, LOCAL_PROFILE_CACHE_MAX_AGE_MS, LOCAL_CHAT_CACHE_MAX_ITEMS = 1000, LOCAL_CHAT_MESSAGE_CACHE_MAX_VISIBLE = 1000, LOCAL_AVATAR_CACHE_MAX_BYTES, LOCAL_AVATAR_CACHE_MAX_AGE_MS, AVATAR_IMAGE_MAX_BYTES, CHAT_READY_DOWNLOAD_MAX_BYTES, CHAT_MESSAGE_FILE_CACHE_MAX_BYTES, IDLE_CALLBACK_MIN_TIMEOUT_MS = 50, ATTACHMENT_CACHE_IDLE_TIMEOUT_MS = 2500, ATTACHMENT_CACHE_FALLBACK_DELAY_MS = 250, CHAT_UNSAVED_TTL_DAYS = 21, CHAT_UNSAVED_TTL_MS, CHAT_AFTER_SEEN_MS, CHAT_MEDIA_TTL_DAYS, CHAT_MEDIA_TTL_MS, CHAT_UPLOAD_MAX_BYTES, CHAT_AUDIO_TRANSCODE_BITRATE_BPS = 128000, CHAT_VIDEO_TRANSCODE_VIDEO_BITRATE_BPS = 768000, CHAT_VIDEO_TRANSCODE_AUDIO_BITRATE_BPS, CHAT_MESSAGE_BATCH_SIZE = 40, CHAT_MESSAGE_QUERY_MAX_DOCS = 120, CHAT_TTL_CLIENT_DELETE_GRACE_MS, CHAT_TTL_DELETE_CHUNK_SIZE = 40, CHAT_DELETE_SCAN_BATCH_SIZE = 200, CHAT_TTL_WRITE_BATCH_SIZE = 400, CHAT_DELETE_WRITE_BATCH_SIZE = 400, CHAT_BATCH_CLEANUP_IDLE_TIMEOUT_MS = 1500, CHAT_BATCH_CLEANUP_IDLE_DELAY_MS = 250, CHAT_LIST_PAGE_SIZE = 20, CHAT_LIST_LIVE_COUNT, CHAT_INBOX_PING_PAGE_SIZE = 25, CHAT_LIST_CACHE_WRITE_DELAY_MS = 1500, CHAT_LIST_SNAPSHOT_COALESCE_MS = 80, CHAT_LIST_STATUS_CACHE_MS, CHAT_LIST_LISTENER_RETRY_MS = 1000, CHAT_TOP_WARM_COUNT = 0, CHAT_EAGER_WARM_COUNT = 0, CHAT_WARM_DELAY_MS = 3000, CHAT_WARM_BATCH_SIZE, CHAT_MESSAGE_VIEW_CACHE_SIZE = 30, CHAT_MEDIA_WARM_MESSAGES_PER_CHAT, CHAT_MEDIA_WARM_START_DELAY_MS = 600, CHAT_MEDIA_WARM_STEP_DELAY_MS = 120, CHAT_MEDIA_WARM_TYPES, CHAT_MEDIA_WARM_MAX_BYTES = 0, CHAT_READ_WRITE_INTERVAL_MS, CHAT_SEND_QUEUE_RATE_LIMIT_COUNT = 12, CHAT_SEND_QUEUE_RATE_LIMIT_WINDOW_MS, CHAT_MESSAGE_BODY_MAX_BYTES, CHAT_LAST_MESSAGE_BODY_MAX_BYTES, CHAT_SETTINGS_BODY_MAX_BYTES, BOT_WALLET_CLAIM_POLL_MS, BOT_WALLET_IDLE_CLAIM_POLL_MS, CHAT_MAX_TEXT_CHARS = 2048, CHAT_MAX_REACTIONS = 2, CHAT_PAIR_CACHE_LIMIT = 256, SEARCH_DEBOUNCE_MS = 300, SEARCH_USERNAME_LIMIT = 15, SEARCH_ROLE_LIMIT = 15, RECENT_PEER_REFRESH_LIMIT = 50, RECENT_PEER_REFRESH_DELAY_MS = 250, RECENT_PEER_REFRESH_INTERVAL_MS, RECENT_PEER_REFRESH_THROTTLE_MS = 120, BAN_REFRESH_GRACE_MS = 50, REQUEST_MONEY_MAX_SATS, WALLET_TRANSFER_POLL_MS, WALLET_ACTIVE_TRANSFER_REFRESH_MS, WALLET_IDLE_ACTIVE_TRANSFER_REFRESH_MS, WALLET_VISIBLE_TRANSFER_DISCOVERY_WINDOW_MS, WALLET_ACTIVE_TRANSFER_EMPTY_SCAN_LIMIT = 8, WALLET_CACHE_HYDRATE_DELAY_MS = 0, WALLET_BOOT_REFRESH_DELAY_MS = 500, WALLET_BOOT_CACHED_REFRESH_DELAY_MS = 2500, WALLET_REGTEST_DEPOSIT_CLAIM_POLL_MS, WALLET_MAINNET_DEPOSIT_CLAIM_POLL_MS, WALLET_BALANCE_EVENT_COALESCE_MS, WALLET_INCOMING_UPDATE_COALESCE_MS = 250, WALLET_AUTO_CLAIM_MAX_FEE_SATS = 5000, WALLET_CLAIM_PAGE_SIZE = 100, WALLET_PENDING_TRANSFER_CLAIM_BATCH_SIZE = 50, WALLET_PENDING_TRANSFER_STATUS_BATCH_SIZE = 2, WALLET_PENDING_TRANSFER_COLD_REFRESH_BATCH_SIZE = 50, WALLET_PENDING_TRANSFER_COLD_REFRESH_INTERVAL_MS, WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_SMALL_QUEUE = 3, WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_LARGE_QUEUE = 10, WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_SMALL_SIZE = 2, WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_LARGE_SIZE = 3, WALLET_PENDING_TRANSFER_SLOW_CLAIM_MS, WALLET_PENDING_TRANSFER_CLAIM_COOLDOWN_MS, WALLET_SDK_BACKGROUND_QUIET_MS, WALLET_RECENT_TRANSFER_LIMIT = 100, WALLET_TRANSFER_CACHE_LIMIT = 1e4, WALLET_TRANSFER_PAGE_LIMIT = 100, WALLET_TRANSFER_FETCH_THROTTLE_MS = 150, WALLET_PENDING_TRANSFER_CLAIM_RETRY_MS, WALLET_SENT_TRANSFER_REFRESH_DELAY_MS, WALLET_PENDING_TRANSFER_BOOT_GRACE_MS, WALLET_PENDING_TRANSFER_HOT_AGE_MS, WALLET_PENDING_TRANSFER_WARM_AGE_MS, WALLET_PENDING_TRANSFER_WARM_RETRY_MS, WALLET_PENDING_TRANSFER_STALE_RETRY_MS, WALLET_PENDING_TRANSFER_STUCK_RETRY_MS, WALLET_PENDING_TRANSFER_DORMANT_RETRY_MS, WALLET_TRANSFER_CACHE_WRITE_DELAY_MS;
+var MS_PER_SECOND = 1000, MINUTE_MS, HOUR_MS, DAY_MS, KIB_BYTES = 1024, MIB_BYTES, SATS_PER_BITCOIN = 100000000n, USERNAME_MAX_CHARS = 12, PASSWORD_MIN_CHARS = 12, PASSWORD_MAX_CHARS = 64, AUTOLOCK_MIN_MINUTES = 1, AUTOLOCK_MAX_MINUTES = 60, LOCAL_CACHE_WRITE_DELAY_MS = 350, LOCAL_MEDIA_CACHE_MAX_BYTES, LOCAL_MEDIA_CACHE_MAX_ITEMS = 1000, LOCAL_MEDIA_ACCESS_TOUCH_MIN_MS, LOCAL_PROFILE_CACHE_MAX_ITEMS = 500, LOCAL_PROFILE_CACHE_MAX_AGE_MS, LOCAL_CHAT_CACHE_MAX_ITEMS = 1000, LOCAL_CHAT_MESSAGE_CACHE_MAX_VISIBLE = 1000, LOCAL_AVATAR_CACHE_MAX_BYTES, LOCAL_AVATAR_CACHE_MAX_AGE_MS, AVATAR_IMAGE_MAX_BYTES, CHAT_READY_DOWNLOAD_MAX_BYTES, CHAT_MESSAGE_FILE_CACHE_MAX_BYTES, IDLE_CALLBACK_MIN_TIMEOUT_MS = 50, ATTACHMENT_CACHE_IDLE_TIMEOUT_MS = 2500, ATTACHMENT_CACHE_FALLBACK_DELAY_MS = 250, CHAT_UNSAVED_TTL_DAYS = 21, CHAT_UNSAVED_TTL_MS, CHAT_AFTER_SEEN_MS, CHAT_MEDIA_TTL_DAYS, CHAT_MEDIA_TTL_MS, CHAT_UPLOAD_MAX_BYTES, CHAT_AUDIO_TRANSCODE_BITRATE_BPS = 128000, CHAT_VIDEO_TRANSCODE_VIDEO_BITRATE_BPS = 3000000, CHAT_VIDEO_TRANSCODE_AUDIO_BITRATE_BPS, CHAT_MESSAGE_BATCH_SIZE = 40, CHAT_MESSAGE_QUERY_MAX_DOCS = 120, CHAT_TTL_CLIENT_DELETE_GRACE_MS, CHAT_TTL_DELETE_CHUNK_SIZE = 40, CHAT_DELETE_SCAN_BATCH_SIZE = 200, CHAT_TTL_WRITE_BATCH_SIZE = 400, CHAT_DELETE_WRITE_BATCH_SIZE = 400, CHAT_BATCH_CLEANUP_IDLE_TIMEOUT_MS = 1500, CHAT_BATCH_CLEANUP_IDLE_DELAY_MS = 250, CHAT_LIST_PAGE_SIZE = 20, CHAT_LIST_LIVE_COUNT, CHAT_INBOX_PING_PAGE_SIZE = 25, CHAT_LIST_CACHE_WRITE_DELAY_MS = 1500, CHAT_LIST_SNAPSHOT_COALESCE_MS = 80, CHAT_LIST_STATUS_CACHE_MS, CHAT_LIST_LISTENER_RETRY_MS = 1000, CHAT_TOP_WARM_COUNT = 0, CHAT_EAGER_WARM_COUNT = 0, CHAT_WARM_DELAY_MS = 3000, CHAT_WARM_BATCH_SIZE, CHAT_MESSAGE_VIEW_CACHE_SIZE = 30, CHAT_MEDIA_WARM_MESSAGES_PER_CHAT, CHAT_MEDIA_WARM_START_DELAY_MS = 600, CHAT_MEDIA_WARM_STEP_DELAY_MS = 120, CHAT_MEDIA_WARM_TYPES, CHAT_MEDIA_WARM_MAX_BYTES = 0, CHAT_READ_WRITE_INTERVAL_MS, CHAT_SEND_QUEUE_RATE_LIMIT_COUNT = 12, CHAT_SEND_QUEUE_RATE_LIMIT_WINDOW_MS, CHAT_MESSAGE_BODY_MAX_BYTES, CHAT_LAST_MESSAGE_BODY_MAX_BYTES, CHAT_SETTINGS_BODY_MAX_BYTES, BOT_WALLET_CLAIM_POLL_MS, BOT_WALLET_IDLE_CLAIM_POLL_MS, CHAT_MAX_TEXT_CHARS = 2048, CHAT_MAX_REACTIONS = 2, CHAT_PAIR_CACHE_LIMIT = 256, SEARCH_DEBOUNCE_MS = 300, SEARCH_USERNAME_LIMIT = 15, SEARCH_ROLE_LIMIT = 15, RECENT_PEER_REFRESH_LIMIT = 50, RECENT_PEER_REFRESH_DELAY_MS = 250, RECENT_PEER_REFRESH_INTERVAL_MS, RECENT_PEER_REFRESH_THROTTLE_MS = 120, BAN_REFRESH_GRACE_MS = 50, REQUEST_MONEY_MAX_SATS, WALLET_TRANSFER_POLL_MS, WALLET_ACTIVE_TRANSFER_REFRESH_MS, WALLET_IDLE_ACTIVE_TRANSFER_REFRESH_MS, WALLET_VISIBLE_TRANSFER_DISCOVERY_WINDOW_MS, WALLET_ACTIVE_TRANSFER_EMPTY_SCAN_LIMIT = 8, WALLET_CACHE_HYDRATE_DELAY_MS = 0, WALLET_BOOT_REFRESH_DELAY_MS = 500, WALLET_BOOT_CACHED_REFRESH_DELAY_MS = 2500, WALLET_REGTEST_DEPOSIT_CLAIM_POLL_MS, WALLET_MAINNET_DEPOSIT_CLAIM_POLL_MS, WALLET_BALANCE_EVENT_COALESCE_MS, WALLET_INCOMING_UPDATE_COALESCE_MS = 250, WALLET_AUTO_CLAIM_MAX_FEE_SATS = 5000, WALLET_CLAIM_PAGE_SIZE = 100, WALLET_PENDING_TRANSFER_CLAIM_BATCH_SIZE = 50, WALLET_PENDING_TRANSFER_STATUS_BATCH_SIZE = 2, WALLET_PENDING_TRANSFER_COLD_REFRESH_BATCH_SIZE = 50, WALLET_PENDING_TRANSFER_COLD_REFRESH_INTERVAL_MS, WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_SMALL_QUEUE = 3, WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_LARGE_QUEUE = 10, WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_SMALL_SIZE = 2, WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_LARGE_SIZE = 3, WALLET_PENDING_TRANSFER_SLOW_CLAIM_MS, WALLET_PENDING_TRANSFER_CLAIM_COOLDOWN_MS, WALLET_SDK_BACKGROUND_QUIET_MS, WALLET_RECENT_TRANSFER_LIMIT = 100, WALLET_TRANSFER_CACHE_LIMIT = 1e4, WALLET_TRANSFER_PAGE_LIMIT = 100, WALLET_TRANSFER_FETCH_THROTTLE_MS = 150, WALLET_PENDING_TRANSFER_CLAIM_RETRY_MS, WALLET_SENT_TRANSFER_REFRESH_DELAY_MS, WALLET_PENDING_TRANSFER_BOOT_GRACE_MS, WALLET_PENDING_TRANSFER_HOT_AGE_MS, WALLET_PENDING_TRANSFER_WARM_AGE_MS, WALLET_PENDING_TRANSFER_WARM_RETRY_MS, WALLET_PENDING_TRANSFER_STALE_RETRY_MS, WALLET_PENDING_TRANSFER_STUCK_RETRY_MS, WALLET_PENDING_TRANSFER_DORMANT_RETRY_MS, WALLET_TRANSFER_CACHE_WRITE_DELAY_MS;
 var init_config = __esm(() => {
   MINUTE_MS = 60 * MS_PER_SECOND;
   HOUR_MS = 60 * MINUTE_MS;
@@ -105980,20 +105981,17 @@ function expectedSigningKeys(pair, signingKeysByChatKey) {
   }
   return values;
 }
-async function verifyExpectedSignatureBeforeOpen(pair, sig, bytes, options = {}) {
+async function preverifyExpectedSigner(pair, sig, bytes, options = {}) {
   if (!options?.crypto?.preverifyBeforeOpen) {
-    return true;
-  }
-  const signingKeysByChatKey = expectedSigningKeys(pair, options?.signingKeysByChatKey);
-  if (signingKeysByChatKey.length < 2) {
-    return true;
+    return "";
   }
-  for (const signingPublicKey of signingKeysByChatKey) {
+  const signingPublicKeys = expectedSigningKeys(pair, options?.signingKeysByChatKey);
+  for (const signingPublicKey of signingPublicKeys) {
     if (await verifyMsgSignature(signingPublicKey, sig, bytes, options)) {
-      return true;
+      return signingPublicKey;
     }
   }
-  return false;
+  return null;
 }
 async function sealMsg(pair, message, options = {}) {
   const head = getHead(pair, message);
@@ -106014,14 +106012,16 @@ async function openMsg(pair, data, options = {}) {
   const { suite, flags, nonce, sig, ct } = unpackMsgBody(data.body);
   const aad = getMsgAad(pair, head, suite, flags);
   const signatureInput = getSignatureInput(aad, nonce, ct);
-  if (!await verifyExpectedSignatureBeforeOpen(pair, sig, signatureInput, options)) {
+  const preverifiedSigner = await preverifyExpectedSigner(pair, sig, signatureInput, options);
+  if (preverifiedSigner == null) {
     throw new Error("invalid chat action signature");
   }
   const plaintext = await openMsgPlaintext(pair, nonce, ct, aad, options);
   try {
     const action = JSON.parse(decoder.decode(plaintext));
     const normalized = normalizeOpenedAction(pair, head, action, options);
-    if (!await verifyMsgSignature(normalized.signingPublicKey, sig, signatureInput, options)) {
+    const validSignature = preverifiedSigner ? normalized.signingPublicKey === preverifiedSigner : await verifyMsgSignature(normalized.signingPublicKey, sig, signatureInput, options);
+    if (!validSignature) {
       throw new Error("invalid chat action signature");
     }
     return {
@@ -106095,40 +106095,120 @@ var init_protocol = __esm(() => {
 });
 
 // ../../shared/chat/pairs.js
+function accountGeneration(chatPK) {
+  return accountGenerations.get(cleanText(chatPK)) || 0;
+}
 function getChatPairKey(chatPK, peerChatPK, chatId = "") {
   if (!chatPK || !peerChatPK)
     return null;
   return `${cleanText(chatPK)}|${cleanText(peerChatPK)}|${cleanText(chatId)}`;
 }
-function clearChatPairCache() {
-  for (const pair of pairCache.values()) {
-    closeChatPair(pair);
+function closeEntry(entry) {
+  if (!entry || entry.closed || entry.leases > 0) {
+    return;
+  }
+  entry.closed = true;
+  closeChatPair(entry.pair);
+}
+function retireEntry(entry) {
+  if (!entry || entry.retired) {
+    return;
+  }
+  entry.retired = true;
+  closeEntry(entry);
+}
+function releaseEntry(entry) {
+  if (!entry || entry.leases <= 0) {
+    return;
+  }
+  entry.leases -= 1;
+  if (entry.retired) {
+    closeEntry(entry);
   }
-  pairCache.clear();
 }
-async function getCachedPair(chatPK, chatPrivKey, peerChatPK, options = {}) {
+function evictOverflow() {
+  while (pairCache.size > MAX_PAIR_CACHE) {
+    const firstKey = pairCache.keys().next().value;
+    if (!firstKey) {
+      return;
+    }
+    const entry = pairCache.get(firstKey);
+    pairCache.delete(firstKey);
+    retireEntry(entry);
+  }
+}
+function clearChatPairCache(chatPK = "") {
+  const account = cleanText(chatPK);
+  if (!account) {
+    cacheGeneration += 1;
+    accountGenerations.clear();
+    for (const entry of pairCache.values()) {
+      retireEntry(entry);
+    }
+    pairCache.clear();
+    return;
+  }
+  accountGenerations.set(account, accountGeneration(account) + 1);
+  for (const [key, entry] of pairCache) {
+    if (entry.account !== account) {
+      continue;
+    }
+    pairCache.delete(key);
+    retireEntry(entry);
+  }
+}
+async function acquireCachedPair(chatPK, chatPrivKey, peerChatPK, options = {}) {
+  const account = cleanText(chatPK);
   const chatId = cleanText(options?.chatId);
   const key = getChatPairKey(chatPK, peerChatPK, chatId);
+  const generation = cacheGeneration;
+  const accountVersion = accountGeneration(account);
   if (!key) {
-    return openChatPair(chatPK, chatPrivKey, peerChatPK, { chatId });
+    const pair = await openChatPair(chatPK, chatPrivKey, peerChatPK, { chatId });
+    const entry2 = { pair, leases: 1, retired: true, closed: false };
+    return {
+      pair,
+      release: () => releaseEntry(entry2)
+    };
   }
-  const cached = pairCache.get(key);
-  if (cached)
-    return cached;
-  const pair = await openChatPair(chatPK, chatPrivKey, peerChatPK, { chatId });
-  pairCache.set(key, pair);
-  if (pairCache.size > MAX_PAIR_CACHE) {
-    const firstKey = pairCache.keys().next().value;
-    if (firstKey) {
-      closeChatPair(pairCache.get(firstKey));
-      pairCache.delete(firstKey);
+  let entry = pairCache.get(key);
+  if (!entry) {
+    const pair = await openChatPair(chatPK, chatPrivKey, peerChatPK, { chatId });
+    if (generation !== cacheGeneration || accountVersion !== accountGeneration(account)) {
+      const staleEntry = { pair, leases: 1, retired: true, closed: false };
+      return {
+        pair,
+        release: () => releaseEntry(staleEntry)
+      };
     }
+    entry = pairCache.get(key);
+    if (entry) {
+      closeChatPair(pair);
+    } else {
+      entry = { account, pair, leases: 0, retired: false, closed: false };
+      pairCache.set(key, entry);
+      evictOverflow();
+    }
+  } else {
+    pairCache.delete(key);
+    pairCache.set(key, entry);
+  }
+  entry.leases += 1;
+  return {
+    pair: entry.pair,
+    release: () => releaseEntry(entry)
+  };
+}
+async function withCachedPair(chatPK, chatPrivKey, peerChatPK, options, runWithPair) {
+  const { pair, release } = await acquireCachedPair(chatPK, chatPrivKey, peerChatPK, options);
+  try {
+    return await runWithPair(pair);
+  } finally {
+    release();
   }
-  return pair;
 }
 async function resolveLinkId(chatPK, chatPrivKey, peerChatPK) {
-  const pair = await getCachedPair(chatPK, chatPrivKey, peerChatPK);
-  return pair?.linkId || null;
+  return withCachedPair(chatPK, chatPrivKey, peerChatPK, {}, (pair) => pair?.linkId || null);
 }
 async function resolvePeerChat(cloud, chatPK, chatPrivateKey, peerChatPK, options = {}) {
   const existingChatId = cleanText(options?.chatId);
@@ -106159,13 +106239,14 @@ async function resolvePeerChat(cloud, chatPK, chatPrivateKey, peerChatPK, option
     exists: linkChat?.exists === true
   };
 }
-var pairCache, MAX_PAIR_CACHE;
+var pairCache, MAX_PAIR_CACHE, cacheGeneration = 0, accountGenerations;
 var init_pairs = __esm(() => {
   init_config();
   init_chat();
   init_protocol();
   pairCache = new Map;
   MAX_PAIR_CACHE = CHAT_PAIR_CACHE_LIMIT;
+  accountGenerations = new Map;
 });
 
 // ../../shared/utils/diagnostics.js
@@ -106318,14 +106399,16 @@ function lockWallet(wallet) {
     cleanup?.catch?.(() => {});
   } catch {}
 }
-function lockChat(chatPrivateKey) {
+function lockChat(chatPrivateKey, chatPK = "") {
   try {
     if (chatPrivateKey) {
       chatPrivateKey.fill(0);
     }
   } catch {}
   try {
-    clearChatPairCache();
+    if (chatPK) {
+      clearChatPairCache(chatPK);
+    }
   } catch {}
 }
 var init_vault = __esm(() => {
@@ -106345,7 +106428,7 @@ function walletPubkey(value) {
   }
   return key;
 }
-function closeSessionResources({ wallet, chatPrivateKey, localCache, vaultAccess, vaultSigner } = {}) {
+function closeSessionResources({ wallet, chatPK, chatPrivateKey, localCache, vaultAccess, vaultSigner } = {}) {
   try {
     vaultAccess?.close?.();
   } catch {}
@@ -106356,7 +106439,7 @@ function closeSessionResources({ wallet, chatPrivateKey, localCache, vaultAccess
     localCache?.close?.();
   } catch {}
   lockWallet(wallet);
-  lockChat(chatPrivateKey);
+  lockChat(chatPrivateKey, chatPK);
 }
 function createAccountSession(resources = {}) {
   let closed = false;
@@ -106447,6 +106530,32 @@ function notifySeedDecrypted(callback, markDiag2, source) {
     failed(error);
   }
 }
+function startWalletBoot(bootWallet2, walletMnemonic, user, options) {
+  let closed = false;
+  let handedOff = false;
+  let wallet = null;
+  const result = Promise.resolve().then(() => bootWallet2(walletMnemonic, user, options)).then((identity) => {
+    wallet = identity?.wallet || null;
+    if (closed && wallet) {
+      lockWallet(wallet);
+    }
+    return identity;
+  });
+  return {
+    result,
+    handoff() {
+      handedOff = true;
+    },
+    close() {
+      if (closed)
+        return;
+      closed = true;
+      if (wallet && !handedOff) {
+        lockWallet(wallet);
+      }
+    }
+  };
+}
 async function openVaultAccountSession(vault, password, options = {}) {
   const {
     uid,
@@ -106488,6 +106597,7 @@ async function openVaultAccountSession(vault, password, options = {}) {
     throw new Error("unlockSettings missing");
   const { decryptSeed: decryptSeed2, unpackVaultSeedData } = vaultCrypto;
   let wallet = null;
+  let chatPK = "";
   let chatPrivateKey = null;
   let localCache = null;
   let masterSeed = null;
@@ -106498,6 +106608,7 @@ async function openVaultAccountSession(vault, password, options = {}) {
   let vaultSigner = null;
   let vaultAccess = null;
   let vaultAccessResult = null;
+  let walletBoot = null;
   let network;
   try {
     onStage?.("unlocking");
@@ -106566,46 +106677,18 @@ async function openVaultAccountSession(vault, password, options = {}) {
     onStage?.("wallet");
     const walletStartedAt = Date.now();
     mark(diag, "vault.unlock.wallet.start", { source });
-    const walletIdentity = await bootWallet2(walletMnemonic, user, { network, diag });
-    wallet = walletIdentity?.wallet;
-    const walletPK = walletPubkey(walletIdentity?.walletPK);
-    mark(diag, "vault.unlock.wallet.done", { elapsedMs: Date.now() - walletStartedAt, source });
-    requireCurrent(isCurrent);
+    walletBoot = startWalletBoot(bootWallet2, walletMnemonic, user, { network, diag });
     onStage?.("chat");
     const chatStartedAt = Date.now();
     mark(diag, "vault.unlock.chat.start", { source });
     const chatIdentity = await bootChat2(chatSeed, user, { diag });
     chatPrivateKey = chatIdentity?.chatPrivateKey;
-    const chatPK = cleanText(chatIdentity?.chatPK);
+    chatPK = cleanText(chatIdentity?.chatPK);
     if (!chatPrivateKey || !chatPK)
       throw new Error("chat identity missing");
     chatSeed = null;
     mark(diag, "vault.unlock.chat.done", { elapsedMs: Date.now() - chatStartedAt, source });
     requireCurrent(isCurrent);
-    const identityPayload = {};
-    if (walletIdentity?.walletPKNeedsWrite) {
-      identityPayload.walletPK = walletPK;
-      identityPayload.network = network;
-    }
-    if (chatIdentity?.chatPKNeedsWrite) {
-      identityPayload.chatPK = chatPK;
-    }
-    const identityFields = Object.keys(identityPayload);
-    let identityResult = null;
-    if (identityFields.length) {
-      const identitiesStartedAt = Date.now();
-      mark(diag, "vault.unlock.identities.start", { source, fields: identityFields });
-      identityResult = cloud.user.profile.identity.write(identityPayload).then(() => {
-        mark(diag, "vault.unlock.identities.done", {
-          elapsedMs: Date.now() - identitiesStartedAt,
-          source,
-          fields: identityFields
-        });
-        return { error: null };
-      }, (error) => ({ error }));
-    } else {
-      mark(diag, "vault.unlock.identities.skip", { source });
-    }
     const cacheStartedAt = Date.now();
     mark(diag, "vault.unlock.localCache.start", { source });
     localCache = await openLocalCache(cacheKey, { uid, network });
@@ -106613,20 +106696,16 @@ async function openVaultAccountSession(vault, password, options = {}) {
     cleanBytes(cacheKey);
     cacheKey = null;
     requireCurrent(isCurrent);
-    const identityWrite = await identityResult;
-    if (identityWrite?.error)
-      throw identityWrite.error;
-    requireCurrent(isCurrent);
     const signatureResult = await vaultAccessResult;
     if (signatureResult.error)
       throw signatureResult.error;
     vaultAccess = signatureResult.access;
     requireCurrent(isCurrent);
-    return createAccountSession({
+    const session = createAccountSession({
       uid,
       network,
-      wallet,
-      walletPK,
+      wallet: null,
+      walletPK: null,
       chatPK,
       chatPrivateKey,
       localCache,
@@ -106634,12 +106713,56 @@ async function openVaultAccountSession(vault, password, options = {}) {
       vaultAccess,
       vaultPK: vaultSigner.publicKey
     });
+    session.own(walletBoot);
+    const walletReady = walletBoot.result.then(async (walletIdentity) => {
+      if (session.closed)
+        throw new Error("account session closed");
+      const readyWallet = walletIdentity?.wallet;
+      const walletPK = walletPubkey(walletIdentity?.walletPK);
+      if (!readyWallet)
+        throw new Error("wallet missing");
+      mark(diag, "vault.unlock.wallet.done", { elapsedMs: Date.now() - walletStartedAt, source });
+      const identityPayload = {};
+      if (walletIdentity?.walletPKNeedsWrite) {
+        identityPayload.walletPK = walletPK;
+        identityPayload.network = network;
+      }
+      if (chatIdentity?.chatPKNeedsWrite) {
+        identityPayload.chatPK = chatPK;
+      }
+      const identityFields = Object.keys(identityPayload);
+      if (identityFields.length) {
+        const identitiesStartedAt = Date.now();
+        mark(diag, "vault.unlock.identities.start", { source, fields: identityFields });
+        await cloud.user.profile.identity.write(identityPayload);
+        mark(diag, "vault.unlock.identities.done", {
+          elapsedMs: Date.now() - identitiesStartedAt,
+          source,
+          fields: identityFields
+        });
+      } else {
+        mark(diag, "vault.unlock.identities.skip", { source });
+      }
+      if (session.closed)
+        throw new Error("account session closed");
+      walletBoot.handoff();
+      session.wallet = readyWallet;
+      session.walletPK = walletPK;
+      return { wallet: readyWallet, walletPK };
+    }).catch((error) => {
+      walletBoot.close();
+      throw error;
+    });
+    walletReady.catch(() => {});
+    session.walletReady = walletReady;
+    return session;
   } catch (error) {
+    walletBoot?.close();
     if (vaultAccessResult && !vaultAccess) {
       const signatureResult = await vaultAccessResult;
       vaultAccess = signatureResult.access;
     }
-    closeSessionResources({ wallet, chatPrivateKey, localCache, vaultAccess, vaultSigner });
+    closeSessionResources({ wallet, chatPK, chatPrivateKey, localCache, vaultAccess, vaultSigner });
     throw error;
   } finally {
     cleanBytes(masterSeed, walletEntropy, chatSeed, cacheKey, settingsKey);
@@ -106654,6 +106777,7 @@ async function openAccountSessionFromSecrets(walletEntropy, chatSeed, masterSeed
   }
   const walletMnemonic = mnemonicFromWalletEntropy(walletEntropy);
   let wallet = null;
+  let chatPK = "";
   let chatPrivateKey = null;
   let chatPubKey = null;
   let vaultSigner = null;
@@ -106682,10 +106806,11 @@ async function openAccountSessionFromSecrets(walletEntropy, chatSeed, masterSeed
         throw new Error("vault signature uid missing");
       vaultAccess = await cloud.auth.vaultSignature.open(vaultSigner);
     }
+    chatPK = toHex(chatPubKey);
     return createAccountSession({
       wallet,
       walletPK,
-      chatPK: toHex(chatPubKey),
+      chatPK,
       chatPrivateKey,
       localCache,
       network,
@@ -106694,7 +106819,7 @@ async function openAccountSessionFromSecrets(walletEntropy, chatSeed, masterSeed
       vaultPK: vaultSigner.publicKey
     });
   } catch (error) {
-    closeSessionResources({ wallet, chatPrivateKey, localCache, vaultAccess, vaultSigner });
+    closeSessionResources({ wallet, chatPK, chatPrivateKey, localCache, vaultAccess, vaultSigner });
     throw error;
   } finally {
     cleanBytes(chatSeed, chatPubKey);
@@ -107770,7 +107895,7 @@ function getSubtleCrypto() {
 async function importAesKey(key, usages) {
   return getSubtleCrypto().importKey("raw", toBytes32(key, "file key"), { name: "AES-GCM" }, false, usages);
 }
-async function sealFile(_pair, key, bytes, scope) {
+async function sealFile(key, bytes, scope) {
   const fileKey = new Uint8Array(toBytes32(key, "file key"));
   try {
     const cryptoKey = await importAesKey(fileKey, ["encrypt"]);
@@ -107933,20 +108058,22 @@ async function toUploadBytes(data) {
   }
   return toBytes2(data, "upload bytes");
 }
-async function makeChatFileUploadPayload(pair, cid, data, { cacheControl = "private, max-age=0, no-transform" } = {}) {
-  const chatId = cleanMediaChatId(pair?.chatId);
+async function makeChatFileUploadPayload(chatId, cid, data, { cacheControl = "private, max-age=0, no-transform" } = {}) {
+  const nextChatId = cleanMediaChatId(chatId);
   const mediaId = makeChatMediaId();
-  const path = mediaFilePath(chatId, mediaId);
+  const path = mediaFilePath(nextChatId, mediaId);
   const expiresAt = Date.now() + CHAT_MEDIA_TTL_MS2;
   const key = createFileKey();
   try {
     const uploadBytes = await toUploadBytes(data);
     assertChatUploadByteSize(uploadBytes);
+    const body = await sealFile(key, uploadBytes, path);
+    assertChatUploadByteSize(body);
     return {
-      chatId,
+      chatId: nextChatId,
       mediaId,
       path,
-      body: await sealFile(pair, key, uploadBytes, path),
+      body,
       metadata: {
         contentType: "application/octet-stream",
         cacheControl
@@ -107975,10 +108102,12 @@ async function makeSharedFileUploadPayload(data, { contentType = "application/oc
   try {
     const uploadBytes = await toUploadBytes(data);
     assertChatUploadByteSize(uploadBytes);
+    const body = await sealFile(key, uploadBytes, path);
+    assertChatUploadByteSize(body);
     return {
       sharedId,
       path,
-      body: await sealFile(null, key, uploadBytes, path),
+      body,
       metadata: {
         contentType,
         cacheControl
@@ -109904,10 +110033,19 @@ function sortedUniqueValues(items) {
 }
 
 // ../../shared/chat/chats.js
+function sameSigningKeys(left, right) {
+  if (left === right)
+    return true;
+  const leftKeys = Object.keys(left || {});
+  const rightKeys = Object.keys(right || {});
+  if (leftKeys.length !== rightKeys.length)
+    return false;
+  return leftKeys.every((key) => left[key] === right[key]);
+}
 function sameChatShape(a, b) {
   if (!a || !b)
     return a === b;
-  return a.id === b.id && a.protocol === b.protocol && a.linkId === b.linkId && a.ts === b.ts && a.startMs === b.startMs && a.unseen === b.unseen && a.settings?.retention === b.settings?.retention && sameChatPreview(a.preview, b.preview);
+  return a.id === b.id && a.protocol === b.protocol && a.linkId === b.linkId && a.entryId === b.entryId && a.peerChatPK === b.peerChatPK && a.peerUid === b.peerUid && sameSigningKeys(a.signingKeysByChatKey, b.signingKeysByChatKey) && a.ts === b.ts && a.startMs === b.startMs && a.unseen === b.unseen && a.settings?.retention === b.settings?.retention && sameChatPreview(a.preview, b.preview);
 }
 function sameChats(prev, next) {
   if (prev.length !== next.length)
@@ -111470,8 +111608,14 @@ function mediaAad(uid, network, id) {
 function partAad(uid, network, part) {
   return encoder.encode(JSON.stringify(["veyl-local-cache-part", CACHE_PART_ENVELOPE_VERSION, String(uid || ""), String(network || ""), String(part || "")]));
 }
+function encodePayloadData(payload) {
+  return encoder.encode(JSON.stringify({ ...normalizePayload(payload), savedAt: Date.now() }));
+}
+function decodePayloadData(raw) {
+  return JSON.parse(decoder.decode(toBytes2(raw, "cache payload")));
+}
 async function sealPayload(key, payload, uid, network) {
-  const body = encoder.encode(JSON.stringify({ ...normalizePayload(payload), savedAt: Date.now() }));
+  const body = encodePayloadData(payload);
   try {
     const { iv, ct } = await sealAes(key, body, cacheAad(uid, network));
     return JSON.stringify({
@@ -111493,7 +111637,7 @@ async function openPayloadData(key, raw, uid, network) {
   }
   const plain = await openAes(key, fromHexBytes(envelope.iv, "cache iv"), fromHexBytes(envelope.ct, "cache ciphertext"), cacheAad(uid, network));
   try {
-    return JSON.parse(decoder.decode(plain));
+    return decodePayloadData(plain);
   } finally {
     cleanBytes(plain);
   }
@@ -111554,6 +111698,14 @@ function mediaCrypto(uid, network, id, keyBytes) {
     ivBytes: AES_IV_BYTES
   };
 }
+function payloadCrypto(uid, network, keyBytes) {
+  return {
+    key: keyBytes,
+    aad: cacheAad(uid, network),
+    version: LOCAL_DATA_CACHE_VERSION,
+    ivBytes: AES_IV_BYTES
+  };
+}
 var MEDIA_ENVELOPE_VERSION = 1, CACHE_PART_ENVELOPE_VERSION = 1;
 var init_crypto = __esm(() => {
   init_aes2();
@@ -111589,11 +111741,32 @@ async function openVaultCache({ key, storage, uid, network }) {
   let writeTimer = null;
   let writeTask = Promise.resolve();
   const partWriteTasks = new Map;
+  let storedPayload = null;
   try {
-    const rawPayload = await openPayloadData(cacheKey, await storage.read(), uid, network);
-    payload = normalizePayload(rawPayload);
+    storedPayload = await storage.read();
+    if (!storedPayload) {
+      payload = emptyPayload();
+    } else if (typeof storage.openPayload === "function") {
+      const readKey = new Uint8Array(cacheKey);
+      let plain;
+      try {
+        plain = await storage.openPayload(storedPayload, payloadCrypto(uid, network, readKey));
+        payload = normalizePayload(decodePayloadData(plain));
+      } finally {
+        cleanBytes(plain, readKey);
+      }
+    } else {
+      payload = normalizePayload(await openPayloadData(cacheKey, storedPayload, uid, network));
+    }
   } catch {
     payload = emptyPayload();
+    if (storedPayload) {
+      await Promise.all([
+        storage.remove().catch(() => {}),
+        storage.removeAllMedia().catch(() => {}),
+        storage.removeAllParts().catch(() => {})
+      ]);
+    }
   }
   const writeNow = () => {
     if (closed) {
@@ -111611,10 +111784,12 @@ async function openVaultCache({ key, storage, uid, network }) {
         return;
       }
       const writeKey = new Uint8Array(cacheKey);
+      let body;
       try {
-        await storage.write(await sealPayload(writeKey, payload, uid, network));
+        const raw = typeof storage.sealPayload === "function" ? await storage.sealPayload(body = encodePayloadData(payload), payloadCrypto(uid, network, writeKey)) : await sealPayload(writeKey, payload, uid, network);
+        await storage.write(raw);
       } finally {
-        cleanBytes(writeKey);
+        cleanBytes(body, writeKey);
       }
     }).catch(() => {});
     return writeTask;
@@ -112417,9 +112592,9 @@ function setErrorStage(error, stage, extra = {}) {
   Object.assign(error, extra);
   return error;
 }
-async function makeChatFileUpload(pair, cid, data, { cacheControl = "private, max-age=0, no-transform" } = {}) {
+async function makeChatFileUpload(chatId, cid, data, { cacheControl = "private, max-age=0, no-transform" } = {}) {
   try {
-    return await makeChatFileUploadPayload(pair, cid, data, {
+    return await makeChatFileUploadPayload(chatId, cid, data, {
       cacheControl
     });
   } catch (error) {
@@ -112429,8 +112604,8 @@ async function makeChatFileUpload(pair, cid, data, { cacheControl = "private, ma
     });
   }
 }
-async function putChatFile(pair, cid, data, options) {
-  const upload = await makeChatFileUpload(pair, cid, data, options);
+async function putChatFile(chatId, cid, data, options) {
+  const upload = await makeChatFileUpload(chatId, cid, data, options);
   try {
     if (typeof options?.uploadChatMedia !== "function") {
       throw new Error("chat media upload required");
@@ -112465,7 +112640,7 @@ async function putSharedFile(data, options = {}) {
     throw setErrorStage(error, "upload", { path: upload.path });
   }
 }
-async function readChatFile(readChatMedia, _pair, file) {
+async function readChatFile(readChatMedia, file) {
   let body;
   try {
     if (typeof readChatMedia !== "function") {
@@ -112523,8 +112698,8 @@ function buildAttachmentMsg(type, file) {
       return makeAttachment(type, file);
   }
 }
-async function putAttachment(pair, cid, type, data, meta = {}) {
-  const file = await putChatFile(pair, cid, data, meta);
+async function putAttachment(chatId, cid, type, data, meta = {}) {
+  const file = await putChatFile(chatId, cid, data, meta);
   return buildAttachmentMsg(type, {
     ...file,
     ...pickAttachmentMeta(meta)
@@ -112537,26 +112712,26 @@ async function putSharedAttachment(type, data, meta = {}) {
     ...pickAttachmentMeta(meta)
   });
 }
-async function putImg(pair, cid, data, meta = {}) {
-  return putAttachment(pair, cid, "img", data, meta);
+async function putImg(chatId, cid, data, meta = {}) {
+  return putAttachment(chatId, cid, "img", data, meta);
 }
-async function putGif(pair, cid, data, meta = {}) {
-  return putAttachment(pair, cid, "gif", data, meta);
+async function putGif(chatId, cid, data, meta = {}) {
+  return putAttachment(chatId, cid, "gif", data, meta);
 }
-async function putM4a(pair, cid, data, meta = {}) {
-  return putAttachment(pair, cid, "m4a", data, meta);
+async function putM4a(chatId, cid, data, meta = {}) {
+  return putAttachment(chatId, cid, "m4a", data, meta);
 }
-async function putMp4(pair, cid, data, meta = {}) {
-  return putAttachment(pair, cid, "mp4", data, meta);
+async function putMp4(chatId, cid, data, meta = {}) {
+  return putAttachment(chatId, cid, "mp4", data, meta);
 }
-async function putFile(pair, cid, data, meta = {}) {
-  return putAttachment(pair, cid, "file", data, meta);
+async function putFile(chatId, cid, data, meta = {}) {
+  return putAttachment(chatId, cid, "file", data, meta);
 }
-function readMsgAttachment(readChatMedia, pair, msg) {
-  return readChatFile(readChatMedia, pair, msg);
+function readMsgAttachment(readChatMedia, msg) {
+  return readChatFile(readChatMedia, msg);
 }
-function readMsgFile(readChatMedia, pair, msg) {
-  return readMsgAttachment(readChatMedia, pair, msg);
+function readMsgFile(readChatMedia, msg) {
+  return readMsgAttachment(readChatMedia, msg);
 }
 var init_media2 = __esm(() => {
   init_files2();
@@ -112805,14 +112980,6 @@ function ownerEditedPreview(senderPubkey, message) {
     failed: false
   };
 }
-function messageFileChatId(message) {
-  try {
-    const ref = getMediaFileRef(message?.p);
-    return ref?.type === "chat" ? ref.chatId : "";
-  } catch {
-    return "";
-  }
-}
 async function recipientForSend(cloud, receiverChatPK, options, needed) {
   if (!needed) {
     return null;
@@ -112833,50 +113000,51 @@ async function sendMsg(cloud, senderPubkey, senderPrivkey, receiverChatPK, messa
   if (!chatId) {
     throw new Error("chat id required");
   }
-  const pair = await getCachedPair(senderPubkey, senderPrivkey, receiverChatPK, { chatId });
-  if (options?.linkId && cleanText(options.linkId) !== pair.linkId) {
-    throw new Error("link mismatch");
-  }
-  const retention = cleanChatRetention(options?.retention ?? options?.ttlMode);
-  const tsMs = Date.now();
-  const messagePayload = withMessageRetention(message, retention);
-  const actionOp = actionOpForPayload(messagePayload);
-  const { head, body } = await sealMsg(pair, messagePayload, { op: actionOp, ts: tsMs });
-  const ttlMs = actionOp === CHAT_ACTION_OPS.CREATE ? newStorageTtlMs() : null;
-  const messageId = head.cid;
-  const msgData = {
-    head,
-    body,
-    ttlMs
-  };
-  const recipientProfile = await recipientForSend(cloud, receiverChatPK, options, updatePreview || options?.ping === true);
-  const sentMessage = ownerPreview(senderPubkey, messagePayload, messageId, head, tsMs, ttlMs);
-  const preview2 = updatePreview ? sentMessage : null;
-  const ownerEntry = updatePreview ? await ownEntryWrite(cloud, cleanText(options?.senderUid), senderPrivkey, pair, {
-    peerUid: recipientProfile?.uid || cleanText(options?.receiverUid),
-    peerSigningPublicKey: recipientProfile?.signingPublicKey,
-    entry: options?.ownEntry,
-    settings: options?.chatSettings,
-    preview: preview2,
-    ts: tsMs
-  }) : null;
-  const pingKind = updatePreview ? "message" : cleanText(options?.pingKind) || "ping";
-  const ping = recipientProfile?.uid && (updatePreview || options?.ping === true) ? await sealPing(senderPubkey, senderPrivkey, receiverChatPK, {
-    kind: pingKind,
-    chatId,
-    senderUid: cleanText(options?.senderUid),
-    messageId,
-    ts: tsMs
-  }) : null;
-  const write = await cloud.chat.messages.send({
-    chatId,
-    messageId,
-    message: msgData,
-    ownerEntry,
-    inbox: ping ? { recipientUid: recipientProfile?.uid, ping } : null,
-    onCommitted: typeof options?.onCommitted === "function" ? (committed) => options.onCommitted({ ...committed, message: sentMessage, preview: preview2 }) : undefined
+  return withCachedPair(senderPubkey, senderPrivkey, receiverChatPK, { chatId }, async (pair) => {
+    if (options?.linkId && cleanText(options.linkId) !== pair.linkId) {
+      throw new Error("link mismatch");
+    }
+    const retention = cleanChatRetention(options?.retention ?? options?.ttlMode);
+    const tsMs = Date.now();
+    const messagePayload = withMessageRetention(message, retention);
+    const actionOp = actionOpForPayload(messagePayload);
+    const { head, body } = await sealMsg(pair, messagePayload, { op: actionOp, ts: tsMs });
+    const ttlMs = actionOp === CHAT_ACTION_OPS.CREATE ? newStorageTtlMs() : null;
+    const messageId = head.cid;
+    const msgData = {
+      head,
+      body,
+      ttlMs
+    };
+    const recipientProfile = await recipientForSend(cloud, receiverChatPK, options, updatePreview || options?.ping === true);
+    const sentMessage = ownerPreview(senderPubkey, messagePayload, messageId, head, tsMs, ttlMs);
+    const preview2 = updatePreview ? sentMessage : null;
+    const ownerEntry = updatePreview ? await ownEntryWrite(cloud, cleanText(options?.senderUid), senderPrivkey, pair, {
+      peerUid: recipientProfile?.uid || cleanText(options?.receiverUid),
+      peerSigningPublicKey: recipientProfile?.signingPublicKey,
+      entry: options?.ownEntry,
+      settings: options?.chatSettings,
+      preview: preview2,
+      ts: tsMs
+    }) : null;
+    const pingKind = updatePreview ? "message" : cleanText(options?.pingKind) || "ping";
+    const ping = recipientProfile?.uid && (updatePreview || options?.ping === true) ? await sealPing(senderPubkey, senderPrivkey, receiverChatPK, {
+      kind: pingKind,
+      chatId,
+      senderUid: cleanText(options?.senderUid),
+      messageId,
+      ts: tsMs
+    }) : null;
+    const write = await cloud.chat.messages.send({
+      chatId,
+      messageId,
+      message: msgData,
+      ownerEntry,
+      inbox: ping ? { recipientUid: recipientProfile?.uid, ping } : null,
+      onCommitted: typeof options?.onCommitted === "function" ? (committed) => options.onCommitted({ ...committed, message: sentMessage, preview: preview2 }) : undefined
+    });
+    return { chatId, msgId: messageId, cid: head.cid, message: sentMessage, preview: preview2, ...write?.skipped ? { skipped: true } : {} };
   });
-  return { chatId, msgId: messageId, cid: head.cid, message: sentMessage, preview: preview2, ...write?.skipped ? { skipped: true } : {} };
 }
 async function sendReadReceipt(cloud, senderPubkey, senderPrivkey, receiverChatPK, target, options = {}) {
   const receipt = {
@@ -112986,27 +113154,28 @@ async function setChatRetention(cloud, chatId, senderPubkey, senderPrivkey, peer
     throw new Error("vault locked");
   }
   const nextRetention = cleanChatRetention(retention);
-  const pair = await getCachedPair(senderPubkey, senderPrivkey, peerChatPK, { chatId });
-  if (chatId && pair.chatId !== chatId) {
-    throw new Error("chat mismatch");
-  }
-  const systemMessage = {
-    ...makeRetentionSystemMsg(nextRetention),
-    cid: cleanText(options?.cid) || makeCid(),
-    s: senderPubkey
-  };
-  await sendMsg(cloud, senderPubkey, senderPrivkey, peerChatPK, systemMessage, {
-    chatId,
-    linkId: pair.linkId,
-    updatePreview: true,
-    retention: nextRetention,
-    chatExists: true,
-    senderUid: options?.senderUid,
-    ownEntry: options?.ownEntry,
-    chatSettings: { retention: nextRetention },
-    onCommitted: options?.onCommitted
+  return withCachedPair(senderPubkey, senderPrivkey, peerChatPK, { chatId }, async (pair) => {
+    if (chatId && pair.chatId !== chatId) {
+      throw new Error("chat mismatch");
+    }
+    const systemMessage = {
+      ...makeRetentionSystemMsg(nextRetention),
+      cid: cleanText(options?.cid) || makeCid(),
+      s: senderPubkey
+    };
+    await sendMsg(cloud, senderPubkey, senderPrivkey, peerChatPK, systemMessage, {
+      chatId,
+      linkId: pair.linkId,
+      updatePreview: true,
+      retention: nextRetention,
+      chatExists: true,
+      senderUid: options?.senderUid,
+      ownEntry: options?.ownEntry,
+      chatSettings: { retention: nextRetention },
+      onCommitted: options?.onCommitted
+    });
+    return nextRetention;
   });
-  return nextRetention;
 }
 async function uploadAttachmentMsg(_cloud, senderPubkey, senderPrivkey, receiverChatPK, attachment = {}) {
   if (!senderPrivkey || !senderPubkey) {
@@ -113020,95 +113189,96 @@ async function uploadAttachmentMsg(_cloud, senderPubkey, senderPrivkey, receiver
   if (!chatId) {
     throw new Error("chat id required");
   }
-  const pair = await getCachedPair(senderPubkey, senderPrivkey, receiverChatPK, { chatId });
   const type = cleanText(attachment?.type) || "file";
   const data = attachment?.data;
   const meta = attachment?.meta || {};
   switch (type) {
     case "img":
-      return putImg(pair, nextCid, data, meta);
+      return putImg(chatId, nextCid, data, meta);
     case "gif":
-      return putGif(pair, nextCid, data, meta);
+      return putGif(chatId, nextCid, data, meta);
     case "m4a":
-      return putM4a(pair, nextCid, data, meta);
+      return putM4a(chatId, nextCid, data, meta);
     case "mp4":
-      return putMp4(pair, nextCid, data, meta);
+      return putMp4(chatId, nextCid, data, meta);
     case "file":
-      return putFile(pair, nextCid, data, meta);
+      return putFile(chatId, nextCid, data, meta);
     default:
-      return putAttachment(pair, nextCid, type, data, meta);
+      return putAttachment(chatId, nextCid, type, data, meta);
   }
 }
 async function updateMsg(cloud, chatId, msgId, senderPubkey, senderPrivkey, receiverChatPK, newMessage, options = {}) {
   if (!senderPubkey || !senderPrivkey)
     throw new Error("vault locked");
-  const pair = await getCachedPair(senderPubkey, senderPrivkey, receiverChatPK, { chatId });
-  if (pair.chatId !== chatId) {
-    throw new Error("chat mismatch");
-  }
-  const target = cleanText(newMessage?.cid) || cleanText(msgId);
-  if (!target) {
-    throw new Error("message target required");
-  }
-  const op = newMessage?.t === "req" && cleanText(newMessage?.tx) ? CHAT_ACTION_OPS.PAY_CONFIRM : CHAT_ACTION_OPS.EDIT;
-  const tsMs = Date.now();
-  const action = {
-    ...newMessage || {},
-    cid: makeCid(),
-    s: senderPubkey
-  };
-  const { head, body } = await sealMsg(pair, action, { op, target, ts: tsMs });
-  const messageId = head.cid;
-  const updatePreview = options?.updatePreview === true;
-  const preview2 = updatePreview ? ownerEditedPreview(senderPubkey, newMessage) : null;
-  const ownerEntry = updatePreview ? await ownEntryWrite(cloud, cleanText(options?.senderUid), senderPrivkey, pair, {
-    peerUid: cleanText(options?.receiverUid),
-    peerSigningPublicKey: cleanText(options?.peerSigningPublicKey),
-    entry: options?.ownEntry,
-    preview: preview2,
-    ts: preview2?.ts ?? tsMs
-  }) : null;
-  await cloud.chat.messages.send({
-    chatId,
-    messageId,
-    message: {
-      head,
-      body,
-      ttlMs: null
-    },
-    ownerEntry,
-    inbox: null
+  return withCachedPair(senderPubkey, senderPrivkey, receiverChatPK, { chatId }, async (pair) => {
+    if (pair.chatId !== chatId) {
+      throw new Error("chat mismatch");
+    }
+    const target = cleanText(newMessage?.cid) || cleanText(msgId);
+    if (!target) {
+      throw new Error("message target required");
+    }
+    const op = newMessage?.t === "req" && cleanText(newMessage?.tx) ? CHAT_ACTION_OPS.PAY_CONFIRM : CHAT_ACTION_OPS.EDIT;
+    const tsMs = Date.now();
+    const action = {
+      ...newMessage || {},
+      cid: makeCid(),
+      s: senderPubkey
+    };
+    const { head, body } = await sealMsg(pair, action, { op, target, ts: tsMs });
+    const messageId = head.cid;
+    const updatePreview = options?.updatePreview === true;
+    const preview2 = updatePreview ? ownerEditedPreview(senderPubkey, newMessage) : null;
+    const ownerEntry = updatePreview ? await ownEntryWrite(cloud, cleanText(options?.senderUid), senderPrivkey, pair, {
+      peerUid: cleanText(options?.receiverUid),
+      peerSigningPublicKey: cleanText(options?.peerSigningPublicKey),
+      entry: options?.ownEntry,
+      preview: preview2,
+      ts: preview2?.ts ?? tsMs
+    }) : null;
+    await cloud.chat.messages.send({
+      chatId,
+      messageId,
+      message: {
+        head,
+        body,
+        ttlMs: null
+      },
+      ownerEntry,
+      inbox: null
+    });
+    return {
+      chatId,
+      msgId: messageId,
+      cid: head.cid,
+      preview: preview2
+    };
   });
-  return {
-    chatId,
-    msgId: messageId,
-    cid: head.cid,
-    preview: preview2
-  };
 }
 async function deleteMsg(cloud, chatId, messageOrId, senderPubkey, senderPrivkey, peerChatPK, options = {}) {
   if (!cloud || !chatId || !messageOrId || !senderPubkey || !senderPrivkey || !peerChatPK) {
     return false;
   }
-  const pair = await getCachedPair(senderPubkey, senderPrivkey, peerChatPK, { chatId });
-  if (pair.chatId !== chatId) {
-    return false;
-  }
-  const item = messageDeleteItems([messageOrId])[0];
-  const target = cleanText(options?.docId) || cleanText(item?.id);
-  if (!target || target.startsWith("local:")) {
-    return false;
-  }
-  const deleteTarget = cleanText(options?.target) || cleanText(getMessageKey(messageOrId)) || target;
-  await sendDeleteAction(cloud, senderPubkey, senderPrivkey, peerChatPK, deleteTarget, {
-    chatId,
-    linkId: options?.linkId,
-    senderUid: options?.senderUid
-  });
-  await cloud.chat.messages.delete(chatId, target, {
-    mediaPaths: item?.mediaPath ? [item.mediaPath] : []
+  return withCachedPair(senderPubkey, senderPrivkey, peerChatPK, { chatId }, async (pair) => {
+    if (pair.chatId !== chatId) {
+      return false;
+    }
+    const item = messageDeleteItems([messageOrId])[0];
+    const target = cleanText(options?.docId) || cleanText(item?.id);
+    if (!target || target.startsWith("local:")) {
+      return false;
+    }
+    const deleteTarget = cleanText(options?.target) || cleanText(getMessageKey(messageOrId)) || target;
+    await sendDeleteAction(cloud, senderPubkey, senderPrivkey, peerChatPK, deleteTarget, {
+      chatId,
+      linkId: options?.linkId,
+      senderUid: options?.senderUid
+    });
+    await cloud.chat.messages.delete(chatId, target, {
+      mediaPaths: item?.mediaPath ? [item.mediaPath] : []
+    });
+    return true;
   });
-  return true;
 }
 async function deleteMsgs(cloud, chatId, messages, senderPubkey, senderPrivkey, peerChatPK) {
   if (!cloud || !chatId || !senderPubkey || !senderPrivkey || !peerChatPK) {
@@ -113118,31 +113288,31 @@ async function deleteMsgs(cloud, chatId, messages, senderPubkey, senderPrivkey,
   if (!items.length) {
     return 0;
   }
-  const pair = await getCachedPair(senderPubkey, senderPrivkey, peerChatPK, { chatId });
-  if (pair.chatId !== chatId) {
-    return 0;
-  }
-  let deleted = 0;
-  for (let index = 0;index < items.length; index += DELETE_WRITE_BATCH_SIZE) {
-    const chunk = items.slice(index, index + DELETE_WRITE_BATCH_SIZE);
-    const targets = chunk.map((item) => cleanText(item.id)).filter((target) => target && !target.startsWith("local:"));
-    const mediaPaths = chunk.map((item) => cleanText(item.mediaPath)).filter(Boolean);
-    deleted += await cloud.chat.messages.deleteMany(chatId, targets, { mediaPaths });
-  }
-  return deleted;
+  return withCachedPair(senderPubkey, senderPrivkey, peerChatPK, { chatId }, async (pair) => {
+    if (pair.chatId !== chatId) {
+      return 0;
+    }
+    let deleted = 0;
+    for (let index = 0;index < items.length; index += DELETE_WRITE_BATCH_SIZE) {
+      const chunk = items.slice(index, index + DELETE_WRITE_BATCH_SIZE);
+      const targets = chunk.map((item) => cleanText(item.id)).filter((target) => target && !target.startsWith("local:"));
+      const mediaPaths = chunk.map((item) => cleanText(item.mediaPath)).filter(Boolean);
+      deleted += await cloud.chat.messages.deleteMany(chatId, targets, { mediaPaths });
+    }
+    return deleted;
+  });
 }
-async function readMsgMedia(readChatMedia, userChatPK, userPrivKey, peerChatPK, msg) {
-  return readMsgAttachment2(readChatMedia, userChatPK, userPrivKey, peerChatPK, msg);
+async function readMsgMedia(readChatMedia, msg) {
+  return readMsgAttachment2(readChatMedia, msg);
 }
-async function readMsgAttachment2(readChatMedia, userChatPK, userPrivKey, peerChatPK, msg) {
+async function readMsgAttachment2(readChatMedia, msg) {
   if (typeof readChatMedia !== "function") {
     throw new Error("chat media read required");
   }
-  if (!userChatPK || !userPrivKey || !peerChatPK || !msg) {
+  if (!msg) {
     return null;
   }
-  const pair = await getCachedPair(userChatPK, userPrivKey, peerChatPK, { chatId: msg?.chatId || messageFileChatId(msg) });
-  return readMsgFile(readChatMedia, pair, msg);
+  return readMsgFile(readChatMedia, msg);
 }
 var DELETE_WRITE_BATCH_SIZE;
 var init_write = __esm(() => {
@@ -113385,14 +113555,14 @@ function hasInvalidStoredMediaRef(message) {
     return true;
   }
 }
-function readMessageMedia(cloud, media, chatPK, chatPrivateKey, peerChatPK, message) {
+function readMessageMedia(cloud, media, message) {
   const readChatMedia = cloud?.chat?.media?.read;
   if (typeof media?.readMessageFile === "function") {
-    return media.readMessageFile(readChatMedia, chatPK, chatPrivateKey, peerChatPK, message);
+    return media.readMessageFile(readChatMedia, message);
   }
-  return readMsgMedia(readChatMedia, chatPK, chatPrivateKey, peerChatPK, message);
+  return readMsgMedia(readChatMedia, message);
 }
-function createChatSave({ cloud, media = {}, chatBanned, chatPK, chatPrivateKey, localCache }) {
+function createChatSave({ cloud, media = {}, chatBanned, localCache }) {
   const makeMessagePermanent = async (chatId, message) => {
     if (chatBanned) {
       throw makeChatUnavailableError();
@@ -113410,7 +113580,7 @@ function createChatSave({ cloud, media = {}, chatBanned, chatPK, chatPrivateKey,
     const updated = await makeMsgTemporary(cloud, chatId, list, ttl);
     return { updated, ttl };
   };
-  const readMessageFile = async (peerChatPK, message) => {
+  const readMessageFile = async (_peerChatPK, message) => {
     if (chatBanned) {
       throw makeChatUnavailableError();
     }
@@ -113432,7 +113602,7 @@ function createChatSave({ cloud, media = {}, chatBanned, chatPK, chatPrivateKey,
       throw makeFileGoneError();
     }
     try {
-      const bytes = await readMessageMedia(cloud, media, chatPK, chatPrivateKey, peerChatPK, message);
+      const bytes = await readMessageMedia(cloud, media, message);
       saveMedia(localCache, message, bytes, message);
       return bytes;
     } catch (error) {
@@ -114078,8 +114248,11 @@ function withSharedMediaUpload(cloud, media, meta = {}) {
   };
 }
 function uploadMessageAttachment(cloud, media, senderPubkey, senderPrivkey, receiverChatPK, attachment = {}) {
+  if (!senderPubkey || !senderPrivkey) {
+    throw new Error("vault locked");
+  }
   if (typeof media?.uploadAttachment === "function") {
-    return media.uploadAttachment(senderPubkey, senderPrivkey, receiverChatPK, attachment);
+    return media.uploadAttachment(attachment);
   }
   return uploadAttachmentMsg(cloud, senderPubkey, senderPrivkey, receiverChatPK, withMediaUpload(cloud, media, attachment));
 }
@@ -114377,17 +114550,21 @@ ${cid}` : "";
       const requiredPreview = previewRequired || sendOptions.chatExists !== true;
       let local = await showLocalMessage(peerChatPK, message, sendOptions);
       let committed = false;
+      let sent = false;
+      const markSent = () => {
+        if (sent)
+          return;
+        sent = true;
+        sentChatIdsRef.current.add(local.chatId);
+        markLocalStatus(local.chatId, local.cid, LOCAL_SENT);
+      };
       const markCommitted = () => {
         if (committed)
           return;
         committed = true;
-        sentChatIdsRef.current.add(local.chatId);
+        markSent();
         markDone(diag, "chat.send.commit", startedAt, { type: local?.t || "txt", previewRequired: !!requiredPreview });
       };
-      const markSent = () => {
-        sentChatIdsRef.current.add(local.chatId);
-        markLocalStatus(local.chatId, local.cid, LOCAL_SENT);
-      };
       return await new Promise((resolve2, reject) => {
         const job = {
           previewKey: local.chatId,
@@ -114605,7 +114782,8 @@ ${cid}` : "";
           linkId: local.linkId,
           version: local.version,
           sendOptions,
-          nextAttachment: prepared.nextAttachment
+          nextAttachment: prepared.nextAttachment,
+          committed: false
         };
       }));
       return await new Promise((resolve2, reject) => {
@@ -114614,7 +114792,9 @@ ${cid}` : "";
           reject,
           onError: () => {
             for (const item of locals) {
-              markLocalStatus(item.chatId, item.cid, LOCAL_FAILED);
+              if (!item.committed) {
+                markLocalStatus(item.chatId, item.cid, LOCAL_FAILED);
+              }
             }
           },
           run: async () => {
@@ -114629,6 +114809,7 @@ ${cid}` : "";
                 results.push({ peerChatPK: item.peerChatPK, ok: false, error: uploadError });
                 continue;
               }
+              let sentMessage;
               try {
                 let uploaded = uploads.get(uploadKey);
                 if (!uploaded) {
@@ -114641,17 +114822,32 @@ ${cid}` : "";
                   cid: item.cid,
                   s: chatPK
                 };
-                const sentMessage = withMessageRetention(sent, item.sendOptions.retention);
+                sentMessage = withMessageRetention(sent, item.sendOptions.retention);
                 rememberCachedLocalMedia(item.chatId, item.cid, sentMessage);
-                await sendMsg(cloud, chatPK, chatPrivateKey, item.peerChatPK, sentMessage, { ...item.sendOptions, chatId: item.chatId, linkId: item.linkId, senderUid: uid });
-                markLocalStatus(item.chatId, item.cid, LOCAL_SENT);
+                await sendMsg(cloud, chatPK, chatPrivateKey, item.peerChatPK, sentMessage, {
+                  ...item.sendOptions,
+                  chatId: item.chatId,
+                  linkId: item.linkId,
+                  senderUid: uid,
+                  onCommitted: () => {
+                    if (item.committed)
+                      return;
+                    item.committed = true;
+                    sentChatIdsRef.current.add(item.chatId);
+                    markLocalStatus(item.chatId, item.cid, LOCAL_SENT);
+                  }
+                });
                 results.push({ peerChatPK: item.peerChatPK, ok: true, message: sentMessage });
               } catch (error) {
                 if (!uploads.has(uploadKey)) {
                   uploadErrors.set(uploadKey, error);
                 }
-                markLocalStatus(item.chatId, item.cid, LOCAL_FAILED);
-                results.push({ peerChatPK: item.peerChatPK, ok: false, error });
+                if (item.committed) {
+                  results.push({ peerChatPK: item.peerChatPK, ok: true, message: sentMessage });
+                } else {
+                  markLocalStatus(item.chatId, item.cid, LOCAL_FAILED);
+                  results.push({ peerChatPK: item.peerChatPK, ok: false, error });
+                }
               }
             }
             return results;
@@ -115458,7 +115654,6 @@ async function decryptRecordEntries(records, userChatPK, userPrivKey, peerChatPK
     return [];
   }
   const signingKeysVersion = signingKeysFingerprint(options?.signingKeysByChatKey);
-  const pair = await getCachedPair(userChatPK, userPrivKey, peerChatPK, { chatId: options?.chatId });
   const entryOptions = { ...options, signingKeysVersion };
   const shouldYield = positiveInt(options?.yieldEvery, 0) > 0;
   const entries = new Array(source.length).fill(null);
@@ -115475,38 +115670,40 @@ async function decryptRecordEntries(records, userChatPK, userPrivKey, peerChatPK
     }
     pending.push({ record, index });
   };
-  const openPending = async (pending) => {
-    if (!pending.length) {
-      return;
-    }
-    const opened = await decryptRecordBatchWithPair(pending.map((item) => item.record), pair, cache, entryOptions);
-    for (let index = 0;index < opened.length; index += 1) {
-      const entry = opened[index];
-      if (entry) {
-        entries[pending[index].index] = entry;
+  return withCachedPair(userChatPK, userPrivKey, peerChatPK, { chatId: options?.chatId }, async (pair) => {
+    const openPending = async (pending) => {
+      if (!pending.length) {
+        return;
+      }
+      const opened = await decryptRecordBatchWithPair(pending.map((item) => item.record), pair, cache, entryOptions);
+      for (let index = 0;index < opened.length; index += 1) {
+        const entry = opened[index];
+        if (entry) {
+          entries[pending[index].index] = entry;
+        }
+      }
+    };
+    if (!options?.signal && !shouldYield) {
+      const pending = [];
+      for (let index = 0;index < source.length; index += 1) {
+        collectRecord(source[index], index, pending);
       }
+      await openPending(pending);
+      return entries.filter(Boolean);
     }
-  };
-  if (!options?.signal && !shouldYield) {
-    const pending = [];
-    for (let index = 0;index < source.length; index += 1) {
-      collectRecord(source[index], index, pending);
+    const chunkSize = positiveInt(options?.yieldEvery, source.length || 1);
+    for (let index = 0;index < source.length; index += chunkSize) {
+      throwIfAborted(options?.signal);
+      const chunk = source.slice(index, index + chunkSize);
+      const pending = [];
+      for (let offset = 0;offset < chunk.length; offset += 1) {
+        collectRecord(chunk[offset], index + offset, pending);
+      }
+      await openPending(pending);
+      await maybeYield(index + chunk.length, options);
     }
-    await openPending(pending);
     return entries.filter(Boolean);
-  }
-  const chunkSize = positiveInt(options?.yieldEvery, source.length || 1);
-  for (let index = 0;index < source.length; index += chunkSize) {
-    throwIfAborted(options?.signal);
-    const chunk = source.slice(index, index + chunkSize);
-    const pending = [];
-    for (let offset = 0;offset < chunk.length; offset += 1) {
-      collectRecord(chunk[offset], index + offset, pending);
-    }
-    await openPending(pending);
-    await maybeYield(index + chunk.length, options);
-  }
-  return entries.filter(Boolean);
+  });
 }
 function messageQueryLimit(pageSize) {
   return positiveInt(pageSize, MSG_BATCH_SIZE);
@@ -115852,9 +116049,10 @@ async function decryptMsg(msgData, userChatPK, userPrivKey, peerChatPK, options
     return null;
   }
   try {
-    const pair = await getCachedPair(userChatPK, userPrivKey, peerChatPK, { chatId: options?.chatId });
-    const message = await openMsg(pair, msgData, { signingKeysByChatKey: options?.signingKeysByChatKey, crypto: options?.crypto });
-    return normalizeDecryptedMsg(msgData, message);
+    return await withCachedPair(userChatPK, userPrivKey, peerChatPK, { chatId: options?.chatId }, async (pair) => {
+      const message = await openMsg(pair, msgData, { signingKeysByChatKey: options?.signingKeysByChatKey, crypto: options?.crypto });
+      return normalizeDecryptedMsg(msgData, message);
+    });
   } catch {
     return null;
   }
@@ -116924,12 +117122,12 @@ function warmKeyStore(ref) {
   }
   return ref.current;
 }
-function readMessageMedia2(cloud, media, chatPK, chatPrivateKey, peerChatPK, message) {
+function readMessageMedia2(cloud, media, message) {
   const readChatMedia = cloud?.chat?.media?.read;
   if (typeof media?.readMessageFile === "function") {
-    return media.readMessageFile(readChatMedia, chatPK, chatPrivateKey, peerChatPK, message);
+    return media.readMessageFile(readChatMedia, message);
   }
-  return readMsgMedia(readChatMedia, chatPK, chatPrivateKey, peerChatPK, message);
+  return readMsgMedia(readChatMedia, message);
 }
 function isDenied3(error) {
   return error?.code === "permission-denied";
@@ -117136,12 +117334,12 @@ function createChatMessageBatches({ cloud, media = {}, chatPK, chatPrivateKey, c
       return;
     }
     const tasks = buildMediaTasks();
-    const readFile4 = async (peerChatPK, message) => {
+    const readFile4 = async (_peerChatPK, message) => {
       const cached = await readCachedMedia(localCache, message);
       if (cached?.byteLength) {
         return cached;
       }
-      const bytes = await readMessageMedia2(cloud, media, chatPK, chatPrivateKey, peerChatPK, message);
+      const bytes = await readMessageMedia2(cloud, media, message);
       if (bytes?.byteLength) {
         saveMedia(localCache, message, bytes, message);
       }
@@ -117888,6 +118086,16 @@ function pingSigningKeys(ping, existing) {
     [ping.payload.senderChatPK]: ping.payload.signingPublicKey
   };
 }
+function chatSettingsFromPreview(settings, preview2) {
+  const current = normalizeChatSettings(settings);
+  if (!isSystemMsg(preview2)) {
+    return current;
+  }
+  return {
+    ...current,
+    retention: cleanChatRetention(preview2.retention)
+  };
+}
 function chatFromPing(ping, entryId, existing, preview2, userChatPK, ms, options = {}) {
   const ts = timestampMs(ms, null) ?? timestampMs(existing?.ts, null) ?? timestampMs(preview2?.ts, null) ?? 0;
   if (!ts) {
@@ -117904,7 +118112,7 @@ function chatFromPing(ping, entryId, existing, preview2, userChatPK, ms, options
     peerChatPK: ping.payload.senderChatPK,
     peerUid: existing?.peerUid || cleanText(ping.payload.senderUid) || null,
     signingKeysByChatKey: pingSigningKeys(ping, existing),
-    settings: existing?.settings,
+    settings: chatSettingsFromPreview(existing?.settings, preview2),
     saved: existing?.saved || null,
     readMs,
     startMs,
@@ -117963,7 +118171,7 @@ async function savePing(cloud, uid, userChatPK, userPrivKey, ping, options = {})
     peerUid: peerUid2 || existing?.peerUid,
     peerSigningPublicKey: ping.payload.signingPublicKey || existing?.signingKeysByChatKey?.[ping.payload.senderChatPK],
     signingKeysByChatKey,
-    settings: existing?.settings,
+    settings: chatSettingsFromPreview(existing?.settings, preview2),
     preview: preview2 || existing?.preview,
     readMs: existing?.readMs,
     startMs: existing ? existing.startMs : timestampMs(options.startPreview?.ts ?? preview2?.ts, null, { positive: true })
@@ -118152,6 +118360,7 @@ var init_inbox = __esm(() => {
   init_ping();
   init_query();
   init_chats();
+  init_ttl();
   init_time();
   init_protocol();
 });
@@ -118647,6 +118856,7 @@ function createChatList({
   let chats = [];
   let peers = [];
   let isChatDataReady = false;
+  let isChatListLive = false;
   let chatSourceReady = false;
   let lastChat = null;
   let serverChatIds = [];
@@ -118683,6 +118893,7 @@ function createChatList({
       chats,
       peers,
       isChatDataReady,
+      isChatListLive,
       hasChats: chats.length > 0,
       previewNow,
       lastChat,
@@ -118716,6 +118927,13 @@ function createChatList({
     isChatDataReady = value;
     publish();
   };
+  const setIsChatListLive = (next) => {
+    const value = nextValue(isChatListLive, next);
+    if (Object.is(isChatListLive, value))
+      return;
+    isChatListLive = value;
+    publish();
+  };
   const setLastChat = (next) => {
     const value = nextValue(lastChat, next);
     if (Object.is(lastChat, value))
@@ -118925,6 +119143,7 @@ function createChatList({
   const resetChatList = (ready = false) => {
     chatSourceReady = ready;
     syncChatDataReady();
+    setIsChatListLive(false);
     setChats((prev) => prev.length ? [] : prev);
     setPeers((prev) => prev.length ? [] : prev);
     setLastChat((prev) => prev ? null : prev);
@@ -119014,6 +119233,7 @@ function createChatList({
       resetAllChatState();
       return;
     }
+    setIsChatListLive(false);
     let cancelled = false;
     const hydrateKey = localCache?.id ? `${localCache.id}:${chatPK}` : "";
     if (hydrateKey && lastHydratedCacheKeyRef.current !== hydrateKey) {
@@ -119113,6 +119333,7 @@ function createChatList({
         writeCache: true,
         serverEndReached: cachedHistoryEndRef.current
       });
+      setIsChatListLive(true);
       listenUpdateSeqRef.current += 1;
       markDiag(diag, "chat.provider.listen.update", {
         seq: listenUpdateSeqRef.current,
@@ -119155,6 +119376,7 @@ function createChatList({
       markChatSourceReady();
       fillVisibleChatPage();
     }, (error) => {
+      setIsChatListLive(false);
       markError(diag, "chat.provider.listen", listenStartedAt, error);
       if (shouldResetChatListAfterListenError(error)) {
         resetAllChatState();
@@ -122844,11 +123066,6 @@ function createWalletPrivacy({ wallet, ghostWallet, diag }) {
       const startedAt = Date.now();
       const desired = desiredPrivacy;
       markDiag(diag, "wallet.privacy.start", { ghostWallet: desired });
-      const current = typeof wallet.getWalletSettings === "function" ? await wallet.getWalletSettings() : null;
-      if (closed || requestRevision !== revision || current?.privateEnabled === true === desired) {
-        markDone(diag, "wallet.privacy", startedAt, { changed: false, cancelled: closed || requestRevision !== revision });
-        return;
-      }
       await wallet.setPrivacyEnabled(desired);
       markDone(diag, "wallet.privacy", startedAt, { changed: true });
     }).catch((error) => {
@@ -123698,7 +123915,7 @@ function adaptiveClaimBatchSize(maxBatchSize, queueDepth) {
   }
   return 1;
 }
-function createWalletTransferSession({ wallet, walletPK, localCache, claimIncomingTransfers, pendingClaimBatchSize = null, eagerOutgoingStatusRefresh = false, transferStore, appState = null, deferBackgroundWork = null, backgroundSignal = null, diag }) {
+function createWalletTransferSession({ wallet, walletPK, localCache, claimIncomingTransfers, pendingClaimBatchSize = null, eagerOutgoingStatusRefresh = false, eagerCacheHistory = true, transferStore, appState = null, deferBackgroundWork = null, backgroundSignal = null, diag }) {
   if (!transferStore || typeof transferStore.subscribe !== "function" || typeof transferStore.getSnapshot !== "function" || typeof transferStore.getCacheState !== "function" || typeof transferStore.setHistory !== "function") {
     throw new Error("createWalletTransferSession requires transferStore");
   }
@@ -123712,6 +123929,7 @@ function createWalletTransferSession({ wallet, walletPK, localCache, claimIncomi
   const initialTransfers = canUseInitialStore ? transferStore.getTransfers() : [];
   const initialHistoryTransfers = canUseInitialStore ? transferStore.getHistoryTransfers() : [];
   const initialTxReady = canUseInitialStore && (initialStoreSnapshot.ready || initialTransfers.length > 0 || initialHistoryTransfers.length > 0);
+  const initialCacheReady = initialTxReady && (eagerCacheHistory === false || initialStoreSnapshot.serverEndReached === true && initialHistoryTransfers.length >= initialStoreSnapshot.historyCount);
   const listeners = new Set;
   let isTxLoading = false;
   let publishedSnapshot = null;
@@ -125428,6 +125646,9 @@ function createWalletTransferSession({ wallet, walletPK, localCache, claimIncomi
     if (!wallet || !localCache || !walletPKRef.current) {
       return;
     }
+    if (initialCacheReady) {
+      return;
+    }
     const hydrateKey = `${localCache.id || "cache"}:${walletPKRef.current}`;
     if (cacheHydrateKeyRef.current === hydrateKey) {
       return;
@@ -125452,7 +125673,7 @@ function createWalletTransferSession({ wallet, walletPK, localCache, claimIncomi
         return;
       }
       const hydratedHead = applyCachedTransferState(cachedHead, { label: "wallet.provider.cache.hydrate", publish: true, startedAt: hydrateStartedAt });
-      if (cancelled)
+      if (cancelled || !eagerCacheHistory)
         return;
       await loadFullTransferCache({ label: "wallet.provider.cache.fullHydrate", publish: !hydratedHead });
     }).catch((error) => {
@@ -125861,6 +126082,7 @@ function createWalletSession({
   pendingClaimBatchSize = null,
   activeTransferRefreshMs = null,
   eagerOutgoingStatusRefresh = false,
+  eagerCacheHistory = true,
   sentTransferRefreshDelayMs = null,
   deferBackgroundWork = null,
   appState = null,
@@ -125889,6 +126111,7 @@ function createWalletSession({
     claimIncomingTransfers,
     pendingClaimBatchSize,
     eagerOutgoingStatusRefresh,
+    eagerCacheHistory,
     transferStore,
     appState,
     deferBackgroundWork,
@@ -125999,7 +126222,7 @@ function createWalletSession({
       balanceReady: balanceState.balanceReady,
       isBalanceLoading: balanceState.isBalanceLoading,
       isWalletDataReady: true,
-      isWalletDataLoaded: balanceState.balanceReady && currentTransferState.txReady,
+      isWalletDataLoaded: balanceState.balanceReady || currentTransferState.txReady,
       refresh: claims.refresh,
       requestTransferDiscoveryHotWindow: polling.requestTransferDiscoveryHotWindow,
       claimDeposits: claims.claimDeposits,
@@ -169941,7 +170164,12 @@ function createFirebaseCloud({ db, auth: auth2, getAuth: getAuth2, functions: fu
       "Content-Type": upload?.metadata?.contentType || "application/octet-stream"
     };
     if (typeof uploadSignedStorageBytes === "function") {
-      await uploadSignedStorageBytes(url, upload?.body, { ...signed, method, headers, metadata: upload?.metadata || {}, path: upload?.path || "" });
+      await uploadSignedStorageBytes(url, upload?.body, { ...signed, method, headers, metadata: upload?.metadata || {}, path: upload?.path || "" }).catch((error) => {
+        if (error?.status === 412 && (headers["X-Goog-If-Generation-Match"] === "0" || headers["x-goog-if-generation-match"] === "0")) {
+          return true;
+        }
+        throw error;
+      });
       return true;
     }
     const payload = typeof Blob !== "undefined" && upload?.body instanceof Blob ? upload.body : toBytes2(upload?.body, "upload bytes");
@@ -169950,6 +170178,9 @@ function createFirebaseCloud({ db, auth: auth2, getAuth: getAuth2, functions: fu
       headers,
       body: payload
     });
+    if (response.status === 412 && (headers["X-Goog-If-Generation-Match"] === "0" || headers["x-goog-if-generation-match"] === "0")) {
+      return true;
+    }
     if (!response.ok) {
       const error = new Error(`signed upload failed (${response.status || 0})`);
       error.status = response.status || 0;
@@ -170464,20 +170695,12 @@ function createFirebaseCloud({ db, auth: auth2, getAuth: getAuth2, functions: fu
     const snapshot = await getDocs(roleQuery);
     return peerRecordsFromSnapshot(snapshot);
   }
-  async function uploadChatMedia(upload) {
+  async function uploadMedia(upload) {
     const path = upload?.path;
     if (!path)
       throw new Error("media path required");
-    getChatMediaFileRef(path);
-    await uploadStorageFile(path, upload?.body, upload?.metadata || {});
-    return true;
-  }
-  async function uploadSharedMedia(upload) {
-    const path = upload?.path;
-    if (!path)
-      throw new Error("shared media path required");
-    const signed = await callFunction("reserveSharedMediaUpload", {
-      sharedId: upload?.sharedId,
+    getMediaFileRef(path);
+    const signed = await callFunction("reserveMediaUpload", {
       path,
       size: uploadByteSize(upload?.body),
       contentType: upload?.metadata?.contentType || "application/octet-stream"
@@ -170485,6 +170708,14 @@ function createFirebaseCloud({ db, auth: auth2, getAuth: getAuth2, functions: fu
     await uploadSignedStorageFile(upload, signed?.upload);
     return true;
   }
+  async function uploadChatMedia(upload) {
+    getChatMediaFileRef(upload?.path);
+    return uploadMedia(upload);
+  }
+  async function uploadSharedMedia(upload) {
+    getSharedMediaFileRef(upload?.path);
+    return uploadMedia(upload);
+  }
   async function readChatMedia(path) {
     if (!path)
       throw new Error("media path required");
@@ -175688,6 +175919,7 @@ class VeylHeadlessClient {
           this.userOwner.setNetwork(network);
         }
       });
+      await opened.walletReady;
       this.userSnapshot = this.userOwner.getSnapshot();
     } catch (error) {
       if (opened)