@glyphteck/veyl 0.32.1 → 1.0.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."
       ]
     }
@@ -446,6 +447,34 @@ var init_legal = __esm(() => {
   };
 });
 
+// ../../shared/actioncopy.js
+var ACCOUNT_DELETE_PREPARE = "you should export or empty your wallet first.", ACCOUNT_DELETE_CONDITION = "if you delete your account,", ACCOUNT_DELETE_CONSEQUENCE = "you will permanently lose access to your funds and chats.", PASSKEY_DELETE_PENDING = "deleting a pending link disables it.", PASSKEY_DELETE_VERIFIED = "deleting a verified passkey will log out any session currently using it.", PASSKEY_DELETE_LIMITS = "you can’t delete the passkey used by this session or the account’s last passkey.", ACCOUNT_DELETE_COPY, BLOCK_USER_BODY = "they will no longer be able to message you, and this chat will be permanently deleted.", UNBLOCK_USER_BODY = "they will be able to message you again.", CHAT_DELETE_BODY = "this chat will be permanently deleted.", PASSKEY_DELETE_COPY, WALLET_EXPORT_COPY, WITHDRAWAL_COPY, LOGOUT_ALL_DEVICES_BODY = "This will sign your account out on every connected device. If you suspect someone else has access, logging out may not be enough: they may already have copied your wallet recovery phrase or other sensitive information. Move your funds to a safe wallet only you control as soon as possible, then remove sensitive information from this account. Information already copied to another device cannot be erased remotely.";
+var init_actioncopy = __esm(() => {
+  ACCOUNT_DELETE_COPY = Object.freeze({
+    prepare: ACCOUNT_DELETE_PREPARE,
+    condition: ACCOUNT_DELETE_CONDITION,
+    consequence: ACCOUNT_DELETE_CONSEQUENCE,
+    body: `${ACCOUNT_DELETE_PREPARE} ${ACCOUNT_DELETE_CONDITION} ${ACCOUNT_DELETE_CONSEQUENCE}`
+  });
+  PASSKEY_DELETE_COPY = Object.freeze({
+    pendingBody: PASSKEY_DELETE_PENDING,
+    body: PASSKEY_DELETE_VERIFIED,
+    description: `${PASSKEY_DELETE_PENDING} ${PASSKEY_DELETE_VERIFIED}`,
+    infoBody: `${PASSKEY_DELETE_PENDING} ${PASSKEY_DELETE_LIMITS} ${PASSKEY_DELETE_VERIFIED}`
+  });
+  WALLET_EXPORT_COPY = Object.freeze({
+    networkLead: "this is not a bitcoin wallet.",
+    networkBody: "you cannot use it like a normal bitcoin wallet. you can only use it with the spark network: with a new account on this platform, on a different platform that uses spark wallets, or directly through the spark sdk.",
+    withdrawBody: "if you do not want to use this account anymore, withdraw your funds back to a bitcoin wallet instead.",
+    secretBody: "the mnemonic gives full control of this Spark wallet. reveal it only somewhere private."
+  });
+  WITHDRAWAL_COPY = Object.freeze({
+    feeBody: "you can withdraw your funds back to any bitcoin address. bitcoin transactions are not free. validators need to get paid.",
+    reviewBody: "veyl gets a live Spark withdrawal quote after you press withdraw. review the destination address, the amount leaving your wallet, the quoted fee, and the amount that reaches the address before confirming.",
+    irreversibleBody: "once confirmed, bitcoin withdrawals are irreversible."
+  });
+});
+
 // src/commands.js
 import { Buffer as Buffer2 } from "node:buffer";
 import { chmod, readFile, writeFile } from "node:fs/promises";
@@ -613,6 +642,7 @@ function cliHelpLines() {
 }
 var stringProp, numberProp, booleanProp, objectProp, stringArrayProp, MIME_BY_EXTENSION, TYPE_BY_MIME, optionsOnly = (_args, context) => ({ ...context.commandOptions }), firstArg = (key) => (args, context) => ({ ...context.commandOptions, [key]: args[0] }), peerInput, peerMessageInput = (args, context) => ({ ...context.commandOptions, peer: args[0], message: args.slice(1).join(" ") }), peerMessageIdInput = (args, context) => ({ ...context.commandOptions, peer: args[0], messageId: args[1] }), peerCidInput = (args, context) => ({ ...context.commandOptions, peer: args[0], cid: args[1] }), peerMessageActionInput = (args, context) => ({ ...context.commandOptions, peer: args[0], messageId: args[1], message: args.slice(2).join(" ") }), peerEmojiInput = (args, context) => ({ ...context.commandOptions, peer: args[0], messageId: args[1], emoji: args.slice(2).join(" ") }), peerSatsInput = (args, context) => ({ ...context.commandOptions, peer: args[0], sats: args[1] }), invoiceInput, requestInput, idInput, withdrawalInput = (args, context) => ({ ...context.commandOptions, address: args[0], sats: args[1] }), inviteLinkInput = (args, context) => ({ ...context.commandOptions, kind: args[0], sats: args[1] }), HEADLESS_COMMANDS, commandByName, cliPaths, MCP_TOOLS, groups, COMMANDS;
 var init_commands = __esm(() => {
+  init_actioncopy();
   stringProp = Object.freeze({ type: "string" });
   numberProp = Object.freeze({ type: "number" });
   booleanProp = Object.freeze({ type: "boolean" });
@@ -689,12 +719,12 @@ var init_commands = __esm(() => {
       invokeCli: async (client, input, context) => client.account.acceptTerms({ ...input, termsVersion: await context.acceptTerms(input.termsVersion) })
     }),
     command({ name: "account_logout", group: "account", apiName: "logout", description: "Lock and sign out this runtime.", usage: "account logout", cliInput: optionsOnly, access: "write", invoke: (client) => client.account.logout() }),
-    command({ name: "account_logout_all", group: "account", apiName: "logoutAll", description: "Revoke all product auth sessions.", usage: "account logout-all", cliInput: optionsOnly, access: "destructive", invoke: (client) => client.account.logoutAll() }),
-    command({ name: "account_delete", group: "account", apiName: "delete", description: "Delete the account, chats, and local profile.", properties: { confirm: booleanProp }, required: ["confirm"], usage: "account delete", cliInput: optionsOnly, access: "destructive", invoke: (client, input) => client.account.delete(input) }),
+    command({ name: "account_logout_all", group: "account", apiName: "logoutAll", description: LOGOUT_ALL_DEVICES_BODY, usage: "account logout-all", cliInput: optionsOnly, access: "destructive", invoke: (client) => client.account.logoutAll() }),
+    command({ name: "account_delete", group: "account", apiName: "delete", description: ACCOUNT_DELETE_COPY.body, properties: { confirm: booleanProp }, required: ["confirm"], usage: "account delete", cliInput: optionsOnly, access: "destructive", invoke: (client, input) => client.account.delete(input) }),
     command({ name: "vault_create", group: "vault", apiName: "create", description: "Create and upload a locally encrypted vault.", properties: { secret: stringProp, saveSecret: booleanProp }, usage: "vault create", cliInput: vaultInput, access: "write", secret: true, invoke: (client, input) => client.vault.create(input) }),
     command({ name: "vault_unlock", group: "vault", apiName: "unlock", description: "Unlock the local vault.", properties: { secret: stringProp }, usage: "vault unlock", cliInput: vaultInput, access: "write", secret: true, invoke: (client, input) => client.vault.unlock(input) }),
     command({ name: "vault_lock", group: "vault", apiName: "lock", description: "Lock wallet and chat state.", usage: "vault lock", cliInput: optionsOnly, access: "write", invoke: (client) => client.vault.lock() }),
-    command({ name: "vault_export", group: "vault", apiName: "export", description: "Export the Spark wallet mnemonic.", properties: { secret: stringProp }, usage: "vault export", cliInput: vaultInput, mcp: false, secret: true, invoke: (client, input) => client.vault.export(input) }),
+    command({ name: "vault_export", group: "vault", apiName: "export", description: WALLET_EXPORT_COPY.secretBody, properties: { secret: stringProp }, usage: "vault export", cliInput: vaultInput, mcp: false, secret: true, invoke: (client, input) => client.vault.export(input) }),
     command({ name: "profile_show", group: "profile", apiName: "show", description: "Show the public account profile.", usage: "profile show", cliInput: optionsOnly, invoke: (client) => client.profile.show() }),
     command({
       name: "profile_avatar_set",
@@ -720,8 +750,8 @@ var init_commands = __esm(() => {
     command({ name: "peers_search", group: "peers", apiName: "search", description: "Search public Veyl profiles.", properties: { query: stringProp, count: numberProp }, required: ["query"], usage: "peers search <query>", cliInput: (args, context) => ({ ...context.commandOptions, query: args.join(" ") }), invoke: (client, input) => client.peers.search(input.query, input) }),
     command({ name: "peers_list", group: "peers", apiName: "list", description: "List recent peers.", properties: { count: numberProp, recent: booleanProp }, usage: "peers list", cliInput: optionsOnly, invoke: (client, input) => client.peers.list(input) }),
     command({ name: "peers_blocked", group: "peers", apiName: "blocked", description: "List blocked peers.", usage: "peers blocked", cliInput: optionsOnly, invoke: (client) => client.peers.blocked() }),
-    command({ name: "peers_block", group: "peers", apiName: "block", description: "Block a peer and hide their local chat.", properties: { peer: stringProp }, required: ["peer"], usage: "peers block @name", cliInput: peerInput, access: "destructive", invoke: (client, input) => client.peers.block(input.peer) }),
-    command({ name: "peers_unblock", group: "peers", apiName: "unblock", description: "Unblock a peer.", properties: { peer: stringProp }, required: ["peer"], usage: "peers unblock @name", cliInput: peerInput, access: "write", invoke: (client, input) => client.peers.unblock(input.peer) }),
+    command({ name: "peers_block", group: "peers", apiName: "block", description: BLOCK_USER_BODY, properties: { peer: stringProp }, required: ["peer"], usage: "peers block @name", cliInput: peerInput, access: "destructive", invoke: (client, input) => client.peers.block(input.peer) }),
+    command({ name: "peers_unblock", group: "peers", apiName: "unblock", description: UNBLOCK_USER_BODY, properties: { peer: stringProp }, required: ["peer"], usage: "peers unblock @name", cliInput: peerInput, access: "write", invoke: (client, input) => client.peers.unblock(input.peer) }),
     command({ name: "chat_list", group: "chat", apiName: "list", description: "List chats.", properties: { count: numberProp }, usage: "chat list", cliInput: optionsOnly, invoke: (client, input) => client.chat.list(input) }),
     command({ name: "chat_messages", group: "chat", apiName: "messages", clientMethods: ["read"], description: "Read messages and mark the latest peer message as read.", properties: { peer: stringProp, count: numberProp }, required: ["peer"], usage: "chat messages @name", cliInput: peerInput, access: "write", invoke: (client, input) => client.chat.read(input.peer, input) }),
     command({ name: "chat_mark_read", group: "chat", apiName: "markRead", description: "Mark the latest peer message as read.", properties: { peer: stringProp }, required: ["peer"], usage: "chat mark-read @name", cliInput: peerInput, access: "write", invoke: (client, input) => client.chat.markRead(input.peer, input) }),
@@ -734,7 +764,7 @@ var init_commands = __esm(() => {
     command({ name: "chat_unsave", group: "chat", apiName: "unsave", description: "Return one message to temporary retention.", properties: { peer: stringProp, messageId: stringProp }, required: ["peer", "messageId"], usage: "chat unsave @name message-id", cliInput: peerMessageIdInput, access: "write", invoke: (client, { peer, messageId, ...options }) => client.chat.unsave(peer, messageId, options) }),
     command({ name: "chat_edit", group: "chat", apiName: "edit", clientMethods: ["update"], description: "Edit a text message you sent.", properties: { peer: stringProp, messageId: stringProp, message: stringProp }, required: ["peer", "messageId", "message"], usage: "chat edit @name message-id message", cliInput: peerMessageActionInput, access: "write", invoke: (client, { peer, messageId, message, ...options }) => client.chat.update(peer, messageId, message, options) }),
     command({ name: "chat_delete_message", group: "chat", apiName: "deleteMessage", clientMethods: ["delete"], description: "Delete one message immediately.", properties: { peer: stringProp, messageId: stringProp }, required: ["peer", "messageId"], usage: "chat delete-message @name message-id", cliInput: peerMessageIdInput, access: "destructive", invoke: (client, { peer, messageId, ...options }) => client.chat.delete(peer, messageId, options) }),
-    command({ name: "chat_delete", group: "chat", apiName: "deleteChat", description: "Delete one chat.", properties: { peer: stringProp, cleanup: booleanProp }, required: ["peer"], usage: "chat delete @name", cliInput: peerInput, access: "destructive", invoke: (client, input) => client.chat.deleteChat(input.peer, input) }),
+    command({ name: "chat_delete", group: "chat", apiName: "deleteChat", description: CHAT_DELETE_BODY, properties: { peer: stringProp, cleanup: booleanProp }, required: ["peer"], usage: "chat delete @name", cliInput: peerInput, access: "destructive", invoke: (client, input) => client.chat.deleteChat(input.peer, input) }),
     command({ name: "chat_retention", group: "chat", apiName: "retention", description: "Set chat retention to seen or 24h.", properties: { peer: stringProp, retention: stringProp }, required: ["peer", "retention"], usage: "chat retention @name seen|24h", cliInput: (args, context) => ({ ...context.commandOptions, peer: args[0], retention: args[1] }), access: "write", invoke: (client, input) => client.chat.retention(input.peer, input.retention, input) }),
     command({
       name: "chat_send_file",
@@ -819,12 +849,12 @@ var init_commands = __esm(() => {
     command({ name: "lightning_send", group: "lightning", apiName: "send", description: "Read a Lightning send request.", properties: { id: stringProp }, required: ["id"], usage: "lightning send id", cliInput: idInput, money: true, invoke: (client, input) => client.lightning.send(input.id, input) }),
     command({ name: "withdrawal_quote", group: "withdrawal", apiName: "quote", description: "Quote an on-chain withdrawal.", properties: { address: stringProp, sats: numberProp }, required: ["address", "sats"], usage: "withdrawal quote address sats", cliInput: withdrawalInput, access: "write", money: true, invoke: (client, input) => client.withdrawal.quote(input.address, input.sats, input) }),
     command({ name: "withdrawal_prepare", group: "withdrawal", apiName: "prepare", description: "Prepare an on-chain withdrawal review.", properties: { address: stringProp, sats: numberProp, speed: stringProp, deductFeeFromWithdrawalAmount: booleanProp }, required: ["address", "sats"], usage: "withdrawal prepare address sats", cliInput: withdrawalInput, access: "write", money: true, invoke: (client, input) => client.withdrawal.prepare(input.address, input.sats, input) }),
-    command({ name: "withdrawal_confirm", group: "withdrawal", apiName: "confirm", description: "Confirm an on-chain withdrawal.", properties: { address: stringProp, sats: numberProp, speed: stringProp, feeQuoteId: stringProp, feeAmountSats: numberProp, deductFeeFromWithdrawalAmount: booleanProp }, required: ["address", "sats"], usage: "withdrawal confirm address sats", cliInput: withdrawalInput, access: "destructive", money: true, invoke: (client, input) => client.withdrawal.confirm(input.address, input.sats, input) }),
+    command({ name: "withdrawal_confirm", group: "withdrawal", apiName: "confirm", description: WITHDRAWAL_COPY.irreversibleBody, properties: { address: stringProp, sats: numberProp, speed: stringProp, feeQuoteId: stringProp, feeAmountSats: numberProp, deductFeeFromWithdrawalAmount: booleanProp }, required: ["address", "sats"], usage: "withdrawal confirm address sats", cliInput: withdrawalInput, access: "destructive", money: true, invoke: (client, input) => client.withdrawal.confirm(input.address, input.sats, input) }),
     command({ name: "invite_link", group: "invite", apiName: "link", description: "Create a join, chat, send, or request invite link.", properties: { kind: stringProp, sats: numberProp }, usage: "invite link [join|chat|send|request] [sats]", cliInput: inviteLinkInput, invoke: (client, input) => client.invite.link(input) }),
     command({ name: "invite_read", group: "invite", apiName: "read", description: "Parse a Veyl invite URL.", properties: { value: stringProp }, required: ["value"], usage: "invite read url", cliInput: firstArg("value"), invoke: (client, input) => client.invite.read(input.value) }),
     command({ name: "passkeys_list", group: "passkeys", apiName: "list", description: "List passkeys and pending links.", usage: "passkeys list", cliInput: optionsOnly, invoke: (client, input) => client.passkeys.list(input) }),
     command({ name: "passkeys_link", group: "passkeys", apiName: "link", clientMethods: ["createLink"], description: "Create a one-time passkey link.", properties: { webUrl: stringProp }, usage: "passkeys link", cliInput: optionsOnly, mcp: false, access: "write", secret: true, invoke: (client, input) => client.passkeys.createLink(input) }),
-    command({ name: "passkeys_delete", group: "passkeys", apiName: "delete", description: "Delete a pending link or verified passkey.", properties: { id: stringProp, webUrl: stringProp }, required: ["id"], usage: "passkeys delete id", cliInput: (args, context) => ({ ...context.commandOptions, id: args[0], webUrl: context.options.webUrl, onUrl: context.onPasskeyUrl }), access: "destructive", invoke: (client, input) => client.passkeys.delete(input.id, input) }),
+    command({ name: "passkeys_delete", group: "passkeys", apiName: "delete", description: PASSKEY_DELETE_COPY.description, properties: { id: stringProp, webUrl: stringProp }, required: ["id"], usage: "passkeys delete id", cliInput: (args, context) => ({ ...context.commandOptions, id: args[0], webUrl: context.options.webUrl, onUrl: context.onPasskeyUrl }), access: "destructive", invoke: (client, input) => client.passkeys.delete(input.id, input) }),
     command({ name: "support_feedback", group: "support", apiName: "feedback", description: "Send product feedback.", properties: { message: stringProp, type: stringProp, context: stringProp }, required: ["message"], usage: "support feedback message", cliInput: (args, context) => ({ ...context.commandOptions, message: args.join(" ") }), access: "write", invoke: (client, input) => client.support.feedback(input.message, input) }),
     command({ name: "support_bug", group: "support", apiName: "bug", description: "Submit a bug report.", properties: { message: stringProp }, required: ["message"], usage: "support bug message", cliInput: (args, context) => ({ ...context.commandOptions, message: args.join(" ") }), access: "write", invoke: (client, input) => client.support.bug(input.message, input) }),
     command({ name: "support_report", group: "support", apiName: "report", description: "Report a peer or one harmful message.", properties: { peer: stringProp, messageId: stringProp, note: stringProp, includeAttachment: booleanProp }, required: ["peer"], usage: "support report @name [message-id]", cliInput: (args, context) => ({ ...context.commandOptions, peer: args[0], messageId: args[1] }), access: "write", invoke: (client, input) => client.support.report(input.peer, input) }),
@@ -979,7 +1009,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "veyl",
-    version: "0.32.1",
+    version: "1.0.0",
     private: true,
     license: "Apache-2.0",
     workspaces: {
@@ -995,16 +1025,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 +104564,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;
@@ -104545,7 +104575,7 @@ var init_config = __esm(() => {
   LOCAL_PROFILE_CACHE_MAX_AGE_MS = 30 * DAY_MS;
   LOCAL_AVATAR_CACHE_MAX_BYTES = 128 * MIB_BYTES;
   LOCAL_AVATAR_CACHE_MAX_AGE_MS = 30 * DAY_MS;
-  AVATAR_IMAGE_MAX_BYTES = 8 * MIB_BYTES;
+  AVATAR_IMAGE_MAX_BYTES = 256 * KIB_BYTES;
   CHAT_READY_DOWNLOAD_MAX_BYTES = 8 * MIB_BYTES;
   CHAT_MESSAGE_FILE_CACHE_MAX_BYTES = 64 * MIB_BYTES;
   CHAT_UNSAVED_TTL_MS = CHAT_UNSAVED_TTL_DAYS * DAY_MS;
@@ -105980,20 +106010,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 +106041,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 +106124,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);
+  }
+}
+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);
   }
-  pairCache.clear();
 }
-async function getCachedPair(chatPK, chatPrivKey, peerChatPK, options = {}) {
+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 +106268,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 +106428,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 +106457,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 +106468,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 +106559,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 +106626,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 +106637,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 +106706,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 +106725,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 +106742,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 +106806,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 +106835,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 +106848,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);
@@ -106866,18 +107020,13 @@ var init_values = __esm(() => {
 
 // ../../shared/avatar.js
 function readAvatarVersion(value) {
-  if (value == null || value === "" || typeof value !== "number" && typeof value !== "string") {
-    return null;
-  }
-  const version = Number(value);
-  return Number.isSafeInteger(version) && version >= 0 ? version : null;
+  const version = typeof value === "string" ? value.trim().toLowerCase() : "";
+  return AVATAR_VERSION_RE.test(version) ? version : null;
 }
-function avatarUrlWithVersion(url, version) {
-  if (!url)
-    return null;
-  return version == null ? url : `${url}${url.includes("?") ? "&" : "?"}v=${encodeURIComponent(String(version))}`;
-}
-var init_avatar = () => {};
+var AVATAR_VERSION_RE;
+var init_avatar = __esm(() => {
+  AVATAR_VERSION_RE = /^[0-9a-f]{64}$/;
+});
 
 // ../../shared/moderation.js
 function banUntilMs(ban) {
@@ -107155,11 +107304,16 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
     markDiag(diag, "user.avatar.fetch.start", { force: !!force, persist: !!persist, hasVersion: avatarVersion != null });
     try {
       const promise = (async () => {
-        const nextAvatar = await cloud.peer.avatar.url(uid, { version: avatarVersion });
-        if (persist && avatarVersion != null) {
-          cloud.peer.avatar.read(uid).then((bytes) => writeCachedAvatar(uid, { version: avatarVersion, bytes })).catch(() => {});
+        if (persist && avatarVersion != null && avatarCache && typeof cloud.peer.avatar.read === "function") {
+          try {
+            const bytes = await cloud.peer.avatar.read(uid, { version: avatarVersion });
+            const cachedAvatar = await writeCachedAvatar(uid, { version: avatarVersion, bytes });
+            if (cachedAvatar) {
+              return cachedAvatar;
+            }
+          } catch {}
         }
-        return nextAvatar;
+        return cloud.peer.avatar.url(uid, { version: avatarVersion });
       })().then((nextAvatar) => {
         markDone(diag, "user.avatar.fetch", startedAt, { found: !!nextAvatar, hasVersion: avatarVersion != null });
         if (!nextAvatar || avatarFetch.uid !== uid || avatarFetch.key !== key) {
@@ -107499,10 +107653,12 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
   }
   function refetchAvatar(options = {}) {
     const requestedVersion = readAvatarVersion(options?.version);
-    const optimistic = options?.optimistic === true;
-    const nextVersion = requestedVersion ?? (optimistic && state.avatarVersion != null ? state.avatarVersion + 1 : state.avatarVersion);
-    const persist = options?.persist ?? !(optimistic && requestedVersion == null);
-    return fetchAvatar(state.uid, { force: true, persist, version: nextVersion });
+    const nextVersion = requestedVersion ?? state.avatarVersion;
+    return fetchAvatar(state.uid, {
+      force: options?.force === true || state.avatarVersion !== nextVersion || !state.avatar,
+      persist: options?.persist !== false,
+      version: nextVersion
+    });
   }
   function setNetwork(nextNetwork) {
     if (activeNetwork === nextNetwork)
@@ -107770,7 +107926,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 +108089,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 +108133,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 +110064,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.signerShared === b.signerShared && 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)
@@ -110266,8 +110435,10 @@ function emptyPayload() {
     chatsById: {},
     profilesByUid: {},
     mediaByKey: {},
+    walletBalance: null,
     resumeRoute: null,
-    lastCameraFacing: null
+    lastCameraFacing: null,
+    cloaked: false
   };
 }
 function isObject3(value) {
@@ -110328,8 +110499,26 @@ function normalizePayload(value) {
     chatsById: isObject3(input.chatsById) ? input.chatsById : {},
     profilesByUid: isObject3(input.profilesByUid) ? input.profilesByUid : {},
     mediaByKey: isObject3(input.mediaByKey) ? input.mediaByKey : {},
+    walletBalance: cleanWalletBalance(input.walletBalance),
     resumeRoute: cleanResumeRoute(input.resumeRoute),
-    lastCameraFacing: cleanCameraFacing(input.lastCameraFacing)
+    lastCameraFacing: cleanCameraFacing(input.lastCameraFacing),
+    cloaked: input.cloaked === true
+  };
+}
+function cleanWalletBalance(value) {
+  if (!isObject3(value))
+    return null;
+  const walletPK = cleanText(value.walletPK).toLowerCase();
+  const network = cleanText(value.network).toLowerCase();
+  const balance = Number(value.balance);
+  if (!walletPK || !network || !Number.isSafeInteger(balance) || balance < 0) {
+    return null;
+  }
+  return {
+    walletPK,
+    network,
+    balance,
+    savedAt: Number.isFinite(value.savedAt) ? value.savedAt : 0
   };
 }
 function cleanResumeRoute(route) {
@@ -110775,8 +110964,8 @@ function stateFromPayload(payload, { chatId, selfChatPublicKey, peerChatPublicKe
   if (!cleanOlder.length && !cleanLive.length) {
     return { rejectReason: "empty-message-cache" };
   }
-  const historyStartReached = payload.historyStartReached === true && payload.truncated !== true;
-  const payloadHasOlder = historyStartReached ? false : payload.hasOlder === true || payload.truncated === true;
+  const historyStartReached = payload.historyStartReached === true;
+  const payloadHasOlder = payload.hasOlder === true || payload.truncated === true;
   const partialOlderThan = partial ? markerFromMessage(cleanOlder[0]) : null;
   return {
     historyMessages: cleanOlder,
@@ -110921,7 +111110,7 @@ function writeCachedMessageState(cache, { stateVersion = null, chatId, selfChatP
       signingKeysVersion: cleanText(signingKeysVersion),
       savedAt: Date.now(),
       hasOlder: nextHasOlder === true || compacted.truncated,
-      historyStartReached: nextHistoryStartReached === true && compacted.truncated !== true,
+      historyStartReached: nextHistoryStartReached === true,
       olderThan: serializeMarker(storedOlderThan),
       olderLoaded: nextOlderLoaded === true || compacted.historyMessages.length > 0,
       latestServerPage: batchFromLive(compacted.latestMessages, expiredKeys, deletedKeys, nextServerBatch),
@@ -111180,6 +111369,36 @@ var init_chats2 = __esm(() => {
   "use client";
 });
 
+// ../../shared/cache/localdata/balance.js
+function normalizedBalance(value) {
+  const balance = Number(value);
+  return Number.isSafeInteger(balance) && balance >= 0 ? balance : null;
+}
+function writeCachedWalletBalance(cache, { walletPK = null, network = null, balance = null } = {}) {
+  const nextWalletPK = lowerText(walletPK);
+  const nextNetwork = lowerText(network);
+  const nextBalance = normalizedBalance(balance);
+  if (!cache || !nextWalletPK || !nextNetwork || nextBalance == null) {
+    return Promise.resolve(false);
+  }
+  const current = cache.read?.()?.walletBalance;
+  if (sameText(current?.walletPK, nextWalletPK) && sameText(current?.network, nextNetwork) && normalizedBalance(current?.balance) === nextBalance) {
+    return Promise.resolve(false);
+  }
+  return cache.patch((draft) => {
+    draft.walletBalance = {
+      walletPK: nextWalletPK,
+      network: nextNetwork,
+      balance: nextBalance,
+      savedAt: Date.now()
+    };
+    return draft;
+  }).then(() => true);
+}
+var init_balance = __esm(() => {
+  "use client";
+});
+
 // ../../shared/cache/localdata/profiles.js
 function isUsableProfile(profile, now = Date.now()) {
   if (!profile?.uid || !profile.walletPK && !profile.chatPK) {
@@ -111420,24 +111639,26 @@ async function readCachedTransferHeadState(cache, { walletPK = null } = {}) {
   const stored = cache ? await cache.readPart(TX_HEAD_PART).catch(() => null) : null;
   return stateFromPayload2(stored, { walletPK, source: "head" });
 }
-function writeCachedTransferState(cache, { transfers, walletPK = null, serverEndReached = false, nextOffset = null, oldestTxMs = null } = {}) {
-  if (!cache || !Array.isArray(transfers)) {
-    return Promise.resolve(false);
+function cachedTransferPayloads({ transfers, walletPK = null, serverEndReached = false, historyCount = null, nextOffset = null, oldestTxMs = null } = {}) {
+  if (!Array.isArray(transfers)) {
+    return null;
   }
   const nextWalletPK = lowerText(walletPK);
   if (!nextWalletPK) {
-    return Promise.resolve(false);
+    return null;
   }
   const visible = [...transfers].filter((tx) => tx?.id && isVisibleTransfer(tx) && transferBelongsToWallet(tx, nextWalletPK)).sort((a, b) => txCreatedMs(b) - txCreatedMs(a));
   const sorted2 = visible.slice(0, Math.max(1, WALLET_TRANSFER_CACHE_LIMIT)).map(jsonClean);
   const capped = sorted2.length < visible.length;
+  const knownHistoryCount = Math.max(sorted2.length, Math.floor(Number(historyCount) || 0));
+  const complete = serverEndReached === true && !capped && sorted2.length >= knownHistoryCount;
   const fullPayload = {
     version: CACHE_VERSION,
     walletPK: nextWalletPK,
-    serverEndReached: serverEndReached === true && !capped,
-    historyCount: sorted2.length,
+    serverEndReached: complete,
+    historyCount: knownHistoryCount,
     nextOffset: Number.isFinite(nextOffset) ? nextOffset : sorted2.length,
-    oldestTxMs: serverEndReached === true && !capped && Number.isFinite(oldestTxMs) ? oldestTxMs : null,
+    oldestTxMs: complete && Number.isFinite(oldestTxMs) ? oldestTxMs : null,
     savedAt: Date.now(),
     transfers: sorted2
   };
@@ -111446,7 +111667,24 @@ function writeCachedTransferState(cache, { transfers, walletPK = null, serverEnd
     ...fullPayload,
     transfers: headTransfers
   };
-  return Promise.all([cache.writePart(TX_HEAD_PART, headPayload), cache.writePart(TX_PART, fullPayload)]).then((results) => results.some(Boolean));
+  return { fullPayload, headPayload };
+}
+function writeCachedTransferHeadState(cache, state = {}) {
+  if (!cache) {
+    return Promise.resolve(false);
+  }
+  const payloads = cachedTransferPayloads(state);
+  return payloads ? cache.writePart(TX_HEAD_PART, payloads.headPayload) : Promise.resolve(false);
+}
+function writeCachedTransferState(cache, state = {}) {
+  if (!cache) {
+    return Promise.resolve(false);
+  }
+  const payloads = cachedTransferPayloads(state);
+  if (!payloads) {
+    return Promise.resolve(false);
+  }
+  return Promise.all([cache.writePart(TX_HEAD_PART, payloads.headPayload), cache.writePart(TX_PART, payloads.fullPayload)]).then((results) => results.some(Boolean));
 }
 var TX_PART = "wallet-transfers", TX_HEAD_PART = "wallet-transfers-head", CACHE_VERSION = 2, CACHE_HEAD_LIMIT;
 var init_transfers = __esm(() => {
@@ -111470,8 +111708,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 +111737,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 +111798,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 +111841,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 +111884,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;
@@ -111885,6 +112160,7 @@ var init_vault2 = __esm(() => {
 // ../../shared/cache/localdata.js
 var init_localdata = __esm(() => {
   init_chats2();
+  init_balance();
   init_media();
   init_messages2();
   init_profiles();
@@ -111962,7 +112238,8 @@ function makeOwnChatEntry(pair, fields = {}) {
     preview: fields.preview || null,
     saved: fields.saved || null,
     readMs: Number.isFinite(fields.readMs) ? fields.readMs : null,
-    startMs: Number.isFinite(fields.startMs) ? fields.startMs : null
+    startMs: Number.isFinite(fields.startMs) ? fields.startMs : null,
+    signerShared: fields.signerShared === true
   };
 }
 var CHAT_ENTRY_VERSION = 1;
@@ -112417,9 +112694,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 +112706,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 +112742,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 +112800,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 +112814,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();
@@ -112727,7 +113004,25 @@ async function setChatRead(cloud, uid, chatPrivKey, chatId, readMs, options = {}
     body: await sealOwnChatEntry(chatPrivKey, entryId, {
       ...entry,
       readMs: Math.max(currentReadMs, nextReadMs),
-      ...hasPreviewPatch ? { preview: preview2 || null } : {}
+      ...hasPreviewPatch ? { preview: preview2 || null } : {},
+      ...options.signerShared === true ? { signerShared: true } : {}
+    })
+  });
+  return true;
+}
+async function setChatSignerShared(cloud, uid, chatPrivKey, chatId) {
+  if (!cloud || !uid || !chatPrivKey || !chatId) {
+    return false;
+  }
+  const entryId = ownChatEntryId(chatPrivKey, chatId);
+  const entry = await readOwnEntry(cloud, uid, chatPrivKey, entryId);
+  if (!entry?.chatId || entry.signerShared === true) {
+    return entry?.signerShared === true;
+  }
+  await cloud.user.chats.write(uid, entryId, {
+    body: await sealOwnChatEntry(chatPrivKey, entryId, {
+      ...entry,
+      signerShared: true
     })
   });
   return true;
@@ -112770,7 +113065,8 @@ async function ownEntryWrite(cloud, uid, chatPrivKey, pair, fields = {}) {
     preview: fields.preview || existing?.preview,
     saved: existing?.saved || null,
     readMs: existing?.readMs,
-    startMs: existing?.startMs
+    startMs: existing?.startMs,
+    signerShared: fields.signerShared === true || existing?.signerShared === true
   });
   const tsMs = timestampMs(fields.ts, null);
   return {
@@ -112805,14 +113101,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 +113121,63 @@ 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, notify: options?.notify !== false } : null,
+      onCommitted: typeof options?.onCommitted === "function" ? (committed) => options.onCommitted({ ...committed, message: sentMessage, preview: preview2 }) : undefined
+    });
+    const delivered = options?.ping === true ? !!ping && write?.delivered !== false : write?.delivered !== false;
+    if (ping && delivered && ownerEntry && options?.ownEntry?.signerShared !== true) {
+      await setChatSignerShared(cloud, cleanText(options?.senderUid), senderPrivkey, chatId).catch(() => false);
+    }
+    return {
+      chatId,
+      msgId: messageId,
+      cid: head.cid,
+      message: sentMessage,
+      preview: preview2,
+      delivered,
+      ...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 = {
@@ -112884,7 +113185,13 @@ async function sendReadReceipt(cloud, senderPubkey, senderPrivkey, receiverChatP
     cid: makeCid(),
     s: senderPubkey
   };
-  return sendMsg(cloud, senderPubkey, senderPrivkey, receiverChatPK, receipt, { ...options, updatePreview: false, ping: false });
+  return sendMsg(cloud, senderPubkey, senderPrivkey, receiverChatPK, receipt, {
+    ...options,
+    updatePreview: false,
+    ping: options?.ping === true,
+    pingKind: "read",
+    notify: false
+  });
 }
 async function sendReaction(cloud, senderPubkey, senderPrivkey, receiverChatPK, target, emoji, options = {}) {
   const reaction = {
@@ -112986,27 +113293,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 +113328,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 +113427,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 +113694,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 +113719,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 +113741,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) {
@@ -113499,7 +113808,7 @@ function messageExpiryGroups(messages, selfChatPublicKey, seenAt) {
     { messages: day, expiresAt: seenAt + AFTER_SEEN_MS }
   ].filter((group) => group.messages.length);
 }
-function createChatSeen({ cloud, uid, chatBanned, chatPK, chatPrivateKey, localCache, pendingReadRef, readCacheRef, readWriteInterval, getChatRetention, setChats, diag }) {
+function createChatSeen({ cloud, uid, chatBanned, chatPK, chatPrivateKey, localCache, pendingReadRef, readCacheRef, readWriteInterval, getChatRetention, sendOptionsForPeer, setChats, diag }) {
   const scheduleRead = (chatId, message, previewMs, sendReceipt, expiryMessages = []) => {
     scheduleReadWrite({
       pendingRead: pendingReadRef.current,
@@ -113510,24 +113819,37 @@ function createChatSeen({ cloud, uid, chatBanned, chatPK, chatPrivateKey, localC
       expiryMessages: sendReceipt ? expiryMessages : [],
       interval: readWriteInterval,
       write: async (pending) => {
+        let receiptError = null;
+        let receiptResult = null;
+        let introduceSigner = false;
+        if (pending.receipt) {
+          const sendOptions = sendOptionsForPeer(pending.receipt.peerChatPK);
+          introduceSigner = sendOptions?.signerShared !== true;
+          try {
+            receiptResult = await sendReadReceipt(cloud, chatPK, chatPrivateKey, pending.receipt.peerChatPK, pending.receipt.target, {
+              chatId,
+              retention: getChatRetention(chatId),
+              senderUid: uid,
+              receiverUid: sendOptions?.receiverUid,
+              ping: introduceSigner
+            });
+          } catch (error) {
+            receiptError = error;
+          }
+        }
         const writes = [
           setChatRead(cloud, uid, chatPrivateKey, chatId, pending.previewMs, {
-            preview: (currentPreview) => withChatPreviewOpened(currentPreview, pending.message, pending.previewMs, chatPK) || currentPreview
+            preview: (currentPreview) => withChatPreviewOpened(currentPreview, pending.message, pending.previewMs, chatPK) || currentPreview,
+            signerShared: introduceSigner && receiptResult?.delivered === true
           })
         ];
         if (pending.receipt) {
-          writes.push(sendReadReceipt(cloud, chatPK, chatPrivateKey, pending.receipt.peerChatPK, pending.receipt.target, {
-            chatId,
-            retention: getChatRetention(chatId),
-            senderUid: uid
-          }));
           for (const group of messageExpiryGroups(pending.expiryMessages, chatPK, pending.expirySeenAt)) {
             writes.push(setMessageExpiry(cloud, chatId, group.messages, group.expiresAt));
           }
         }
         const results = await Promise.allSettled(writes);
         const ownerError = results[0]?.status === "rejected" ? results[0].reason : null;
-        const receiptError = pending.receipt && results[1]?.status === "rejected" ? results[1].reason : null;
         if (ownerError) {
           markError(diag, "chat.read.state.write", Date.now(), ownerError);
         }
@@ -113535,7 +113857,7 @@ function createChatSeen({ cloud, uid, chatBanned, chatPK, chatPrivateKey, localC
           readCacheRef.current.delete(chatId);
           markError(diag, "chat.read.receipt.write", Date.now(), receiptError);
         }
-        for (const result of results.slice(pending.receipt ? 2 : 1)) {
+        for (const result of results.slice(1)) {
           if (result?.status === "rejected") {
             markError(diag, "chat.message.expiry.write", Date.now(), result.reason);
           }
@@ -114078,8 +114400,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 +114702,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 +114934,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 +114944,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 +114961,7 @@ ${cid}` : "";
                 results.push({ peerChatPK: item.peerChatPK, ok: false, error: uploadError });
                 continue;
               }
+              let sentMessage;
               try {
                 let uploaded = uploads.get(uploadKey);
                 if (!uploaded) {
@@ -114641,17 +114974,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 +115806,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 +115822,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);
@@ -115559,7 +115908,11 @@ function readableEntryWindow(entries, pageSize, chatPK, peerChatPK, options = {}
   const limitCount = positiveInt(pageSize, MSG_BATCH_SIZE);
   const projectedEntries = readableProjectedEntries(source, chatPK, peerChatPK, options);
   if (!projectedEntries.length) {
-    return { count: 0, entries: [], start: 0 };
+    return {
+      count: 0,
+      entries: source.filter((entry) => isProjectionSupportMsg(entry?.message)),
+      start: 0
+    };
   }
   const indexes = projectedEntries.map((entry) => entry.index);
   const projectedByIndex = new Map(projectedEntries.map((entry) => [entry.index, entry.message]));
@@ -115852,9 +116205,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 +117278,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 +117490,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 +118242,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,10 +118268,11 @@ 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,
+    signerShared: existing?.signerShared === true,
     preview: visiblePreview,
     ts,
     unseen: visiblePreview ? isChatUnseenForUser({ preview: visiblePreview, readMs }, userChatPK) : false
@@ -117963,10 +118328,11 @@ 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 })
+    startMs: existing ? existing.startMs : timestampMs(options.startPreview?.ts ?? preview2?.ts, null, { positive: true }),
+    signerShared: existing?.signerShared === true
   });
   const body = await sealOwnChatEntry(userPrivKey, entryId, entry);
   const record = { body };
@@ -117976,14 +118342,16 @@ async function savePing(cloud, uid, userChatPK, userPrivKey, ping, options = {})
   await cloud.user.chats.write(uid, entryId, record);
   return true;
 }
-function chatWithReadPreview(existing, preview2, userChatPK) {
-  if (!existing?.id || !preview2) {
+function chatWithReadPreview(existing, preview2, userChatPK, fields = {}) {
+  if (!existing?.id) {
     return null;
   }
   return {
     ...existing,
-    preview: preview2,
-    unseen: isChatUnseenForUser({ preview: preview2, readMs: existing.readMs }, userChatPK)
+    signingKeysByChatKey: fields.signingKeysByChatKey || existing.signingKeysByChatKey,
+    peerUid: fields.peerUid || existing.peerUid,
+    preview: preview2 || existing.preview,
+    unseen: preview2 ? isChatUnseenForUser({ preview: preview2, readMs: existing.readMs }, userChatPK) : existing.unseen
   };
 }
 function patchReadPingPreview(existing, receiptPreview, userChatPK) {
@@ -118064,6 +118432,8 @@ async function processInbox(cloud, uid, userChatPK, userPrivKey, options = {}) {
       let current = chatsById.get(group.chatId) || null;
       let wrote = false;
       let handled = false;
+      const identityPing = group.message?.ping || group.read?.ping || group.delete?.ping;
+      const peerUid2 = await resolvePingUid(cloud, identityPing?.payload);
       if (group.message) {
         const item = group.message;
         const entryId = ownChatEntryId(userPrivKey, item.chatId);
@@ -118084,7 +118454,8 @@ async function processInbox(cloud, uid, userChatPK, userPrivKey, options = {}) {
           signingKeysByChatKey,
           preview: preview2,
           startPreview,
-          tsMs: item.ms
+          tsMs: item.ms,
+          peerUid: peerUid2
         });
       }
       if (group.read) {
@@ -118094,22 +118465,24 @@ async function processInbox(cloud, uid, userChatPK, userPrivKey, options = {}) {
         const signingKeysByChatKey = pingSigningKeys(item.ping, existing);
         const receiptPreview = await readPingMsg(cloud, userChatPK, userPrivKey, item.ping, signingKeysByChatKey);
         const openedPreview = patchReadPingPreview(existing, receiptPreview, userChatPK);
-        const chat = chatWithReadPreview(current, openedPreview, userChatPK);
+        const chat = chatWithReadPreview(current || existing, openedPreview, userChatPK, {
+          signingKeysByChatKey,
+          peerUid: peerUid2
+        });
         handled = true;
-        if (openedPreview) {
-          if (chat) {
-            current = chat;
-            chatsById.set(chat.id, chat);
-            options.onPingChat?.(chat);
-          }
-          const writeExisting = chat || existing;
-          wrote = await savePing(cloud, uid, userChatPK, userPrivKey, item.ping, {
-            existing: writeExisting,
-            signingKeysByChatKey,
-            preview: openedPreview,
-            writeTs: false
-          }) || wrote;
+        if (chat) {
+          current = chat;
+          chatsById.set(chat.id, chat);
+          options.onPingChat?.(chat);
         }
+        const writeExisting = chat || existing;
+        wrote = await savePing(cloud, uid, userChatPK, userPrivKey, item.ping, {
+          existing: writeExisting,
+          signingKeysByChatKey,
+          preview: openedPreview || existing?.preview || null,
+          writeTs: false,
+          peerUid: peerUid2
+        }) || wrote;
       }
       if (group.delete) {
         const item = group.delete;
@@ -118130,7 +118503,8 @@ async function processInbox(cloud, uid, userChatPK, userPrivKey, options = {}) {
           wrote = await savePing(cloud, uid, userChatPK, userPrivKey, item.ping, {
             existing: writeExisting,
             signingKeysByChatKey,
-            preview: deletedPreview
+            preview: deletedPreview,
+            peerUid: peerUid2
           }) || wrote;
         }
       }
@@ -118152,6 +118526,7 @@ var init_inbox = __esm(() => {
   init_ping();
   init_query();
   init_chats();
+  init_ttl();
   init_time();
   init_protocol();
 });
@@ -118535,6 +118910,7 @@ async function decryptChatEntry(entryRecord, userChatPK, userPrivKey) {
     saved: entry.saved || null,
     readMs,
     startMs,
+    signerShared: entry.signerShared === true,
     preview: visiblePreview,
     ts,
     unseen: visiblePreview ? isChatUnseenForUser({ preview: visiblePreview, readMs }, userChatPK) : false
@@ -118647,6 +119023,7 @@ function createChatList({
   let chats = [];
   let peers = [];
   let isChatDataReady = false;
+  let isChatListLive = false;
   let chatSourceReady = false;
   let lastChat = null;
   let serverChatIds = [];
@@ -118683,6 +119060,7 @@ function createChatList({
       chats,
       peers,
       isChatDataReady,
+      isChatListLive,
       hasChats: chats.length > 0,
       previewNow,
       lastChat,
@@ -118716,6 +119094,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 +119310,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 +119400,7 @@ function createChatList({
       resetAllChatState();
       return;
     }
+    setIsChatListLive(false);
     let cancelled = false;
     const hydrateKey = localCache?.id ? `${localCache.id}:${chatPK}` : "";
     if (hydrateKey && lastHydratedCacheKeyRef.current !== hydrateKey) {
@@ -119113,6 +119500,7 @@ function createChatList({
         writeCache: true,
         serverEndReached: cachedHistoryEndRef.current
       });
+      setIsChatListLive(true);
       listenUpdateSeqRef.current += 1;
       markDiag(diag, "chat.provider.listen.update", {
         seq: listenUpdateSeqRef.current,
@@ -119155,6 +119543,7 @@ function createChatList({
       markChatSourceReady();
       fillVisibleChatPage();
     }, (error) => {
+      setIsChatListLive(false);
       markError(diag, "chat.provider.listen", listenStartedAt, error);
       if (shouldResetChatListAfterListenError(error)) {
         resetAllChatState();
@@ -119308,6 +119697,7 @@ function createChatList({
       chatExists: !!peerChat?.id || hasServerChatForPeer(peerChatPK),
       receiverUid: peerChat?.peerUid || "",
       peerSigningPublicKey: peerChat?.signingKeysByChatKey?.[peerChatPK] || "",
+      signerShared: peerChat?.signerShared === true,
       ownEntry: peerChat?.entryId ? peerChat : null
     };
   };
@@ -120005,6 +120395,7 @@ function createChatSession({
       readCacheRef,
       readWriteInterval,
       getChatRetention,
+      sendOptionsForPeer,
       setChats,
       diag
     });
@@ -121149,7 +121540,7 @@ function createPeersApi({ cloud, network, avatarCache = null }) {
     }
     if (avatarVersion != null && typeof cloud.peer.avatar.read === "function") {
       try {
-        const bytes = await cloud.peer.avatar.read(uid);
+        const bytes = await cloud.peer.avatar.read(uid, { version: avatarVersion });
         const cachedSource = await writeCachedAvatar(uid, avatarVersion, bytes);
         if (cachedSource) {
           return cachedSource;
@@ -121686,6 +122077,10 @@ function getSatsBalance(result) {
   }
   return satsBalance;
 }
+function displayBalanceValue(value) {
+  const balance = Number(value);
+  return Number.isSafeInteger(balance) && balance >= 0 ? balance : null;
+}
 function samePlainObject(a, b) {
   if (a === b) {
     return true;
@@ -121714,9 +122109,10 @@ function sameTokenBalances(a, b) {
   }
   return true;
 }
-function createWalletBalance({ wallet, diag, onChange = null }) {
+function createWalletBalance({ wallet, diag, initialDisplayBalance = null, onBalance = null, onChange = null }) {
   let snapshot = {
     balance: null,
+    displayBalance: displayBalanceValue(initialDisplayBalance),
     satsBalance: null,
     tokenBalances: new Map,
     balanceReady: false,
@@ -121726,10 +122122,28 @@ function createWalletBalance({ wallet, diag, onChange = null }) {
     snapshot = { ...snapshot, ...changes };
     onChange?.();
   };
+  const publishDisplayBalance = (changes, value, trusted = false) => {
+    const displayBalance = displayBalanceValue(value);
+    if (displayBalance == null || !trusted && !snapshot.balanceReady) {
+      return null;
+    }
+    if (!Object.is(snapshot.displayBalance, displayBalance)) {
+      changes.displayBalance = displayBalance;
+    }
+    return displayBalance;
+  };
   const setBalance = (nextBalance) => {
     const value = typeof nextBalance === "function" ? nextBalance(snapshot.balance) : nextBalance;
+    const changes = {};
     if (!Object.is(snapshot.balance, value)) {
-      publish({ balance: value });
+      changes.balance = value;
+    }
+    const displayBalance = publishDisplayBalance(changes, value);
+    if (Object.keys(changes).length) {
+      publish(changes);
+    }
+    if (displayBalance != null) {
+      onBalance?.(displayBalance);
     }
   };
   const setTokenBalances = (nextTokenBalances) => {
@@ -121738,12 +122152,13 @@ function createWalletBalance({ wallet, diag, onChange = null }) {
       publish({ tokenBalances: new Map(source) });
     }
   };
-  const setBalanceResult = (result) => {
+  const setBalanceResult = (result, { ready = false } = {}) => {
     const changes = {};
     const nextBalance = getBalanceValue(result);
     if (nextBalance != null && !Object.is(snapshot.balance, nextBalance)) {
       changes.balance = nextBalance;
     }
+    const nextDisplayBalance = publishDisplayBalance(changes, nextBalance, true);
     const nextSatsBalance = getSatsBalance(result);
     if (nextSatsBalance && !samePlainObject(snapshot.satsBalance, nextSatsBalance)) {
       changes.satsBalance = nextSatsBalance;
@@ -121752,9 +122167,15 @@ function createWalletBalance({ wallet, diag, onChange = null }) {
     if (nextTokenBalances && !sameTokenBalances(snapshot.tokenBalances, nextTokenBalances)) {
       changes.tokenBalances = new Map(nextTokenBalances);
     }
+    if (ready && !snapshot.balanceReady) {
+      changes.balanceReady = true;
+    }
     if (Object.keys(changes).length) {
       publish(changes);
     }
+    if (nextDisplayBalance != null) {
+      onBalance?.(nextDisplayBalance);
+    }
   };
   const setSatsBalanceResult = (nextSatsBalance) => {
     if (!nextSatsBalance || typeof nextSatsBalance !== "object") {
@@ -121767,9 +122188,13 @@ function createWalletBalance({ wallet, diag, onChange = null }) {
     if (nextSatsBalance.available != null && !Object.is(snapshot.balance, nextSatsBalance.available)) {
       changes.balance = nextSatsBalance.available;
     }
+    const nextDisplayBalance = publishDisplayBalance(changes, nextSatsBalance.available);
     if (Object.keys(changes).length) {
       publish(changes);
     }
+    if (nextDisplayBalance != null) {
+      onBalance?.(nextDisplayBalance);
+    }
   };
   const getBalance = async () => {
     if (!wallet) {
@@ -121783,7 +122208,7 @@ function createWalletBalance({ wallet, diag, onChange = null }) {
     }
     try {
       const result = await wallet.getBalance();
-      setBalanceResult(result);
+      setBalanceResult(result, { ready: true });
       markDone(diag, "wallet.balance", startedAt, { hasBalance: getBalanceValue(result) != null, hasSatsBalance: !!getSatsBalance(result), hasTokenBalances: !!getTokenBalances(result) });
     } catch (error) {
       markError(diag, "wallet.balance", startedAt, error);
@@ -121803,6 +122228,7 @@ function createWalletBalance({ wallet, diag, onChange = null }) {
   const reset = () => {
     snapshot = {
       balance: null,
+      displayBalance: null,
       satsBalance: null,
       tokenBalances: new Map,
       balanceReady: false,
@@ -121819,7 +122245,7 @@ function createWalletBalance({ wallet, diag, onChange = null }) {
     setSatsBalanceResult
   };
 }
-var init_balance = () => {};
+var init_balance2 = () => {};
 
 // ../../shared/wallet/deposits.js
 async function getClaimableDepositUtxos(wallet, options = {}) {
@@ -122844,11 +123270,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) => {
@@ -123602,8 +124023,8 @@ function pendingTransfers(transfers = []) {
 function pendingTransferIds(transfers = []) {
   return pendingTransfers(transfers).map((tx) => String(tx.id));
 }
-function pendingIncomingWalletTransfers(transfers = []) {
-  return pendingTransfers(transfers).filter((tx) => isIncomingTransfer(tx) && isWalletTransfer(tx));
+function pendingIncomingTransfers(transfers = []) {
+  return pendingTransfers(transfers).filter(isIncomingTransfer);
 }
 function uniqueIds(ids = []) {
   return [...new Set((Array.isArray(ids) ? ids : [ids]).map((id) => String(id || "")).filter(Boolean))];
@@ -123698,7 +124119,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, refreshBalance = 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 +124133,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;
@@ -123762,7 +124184,7 @@ function createWalletTransferSession({ wallet, walletPK, localCache, claimIncomi
   const cacheHydrateKeyRef = { current: "" };
   const cacheHydratePromiseRef = { current: null };
   const fullCacheHydratePromiseRef = { current: null };
-  const cacheWriteRef = { current: { timer: null, cache: null, state: null } };
+  const cacheWriteRef = { current: { timer: null, cache: null, state: null, fullHistory: false } };
   const cacheDirtyRef = { current: false };
   const lastFetchAtRef = { current: 0 };
   const claimBatchSize = Math.max(1, Number(pendingClaimBatchSize) || PENDING_TRANSFER_CLAIM_BATCH_SIZE);
@@ -124090,9 +124512,9 @@ function createWalletTransferSession({ wallet, walletPK, localCache, claimIncomi
       return false;
     }
     const cachedTransfers = filterTransfersForWallet(cached.transfers, walletPKRef.current);
-    const cachedPendingIncoming = pendingIncomingWalletTransfers(cachedTransfers);
-    const cachedPending = pendingTransfers(cachedTransfers);
-    const cachedPublishTransfers = cachedTransfers;
+    const cachedPublishTransfers = !publish && historyTransfersRef.current.length ? mergeTransferPageForWallet(historyTransfersRef.current, cachedTransfers, walletPKRef.current, "append") : cachedTransfers;
+    const cachedPendingIncoming = pendingIncomingTransfers(cachedPublishTransfers);
+    const cachedPending = pendingTransfers(cachedPublishTransfers);
     rememberPendingTransferIds(cachedPending.map((tx) => tx.id));
     markDiag(diag, label, {
       elapsedMs: Date.now() - startedAt,
@@ -124231,9 +124653,11 @@ function createWalletTransferSession({ wallet, walletPK, localCache, claimIncomi
     pending.timer = null;
     const cache = pending.cache;
     const state = pending.state;
+    const fullHistory = pending.fullHistory;
     pending.state = null;
     if (cache && state) {
-      writeCachedTransferState(cache, state);
+      const write = fullHistory ? writeCachedTransferState : writeCachedTransferHeadState;
+      write(cache, state);
     }
   };
   const queueWalletFetch = (read) => {
@@ -124338,7 +124762,7 @@ function createWalletTransferSession({ wallet, walletPK, localCache, claimIncomi
     return pendingQueryPromiseRef.current;
   };
   const pendingIncomingClaimCandidates = (sourceTransfers = []) => {
-    return pendingIncomingWalletTransfers(sourceTransfers).filter((tx) => {
+    return pendingIncomingTransfers(sourceTransfers).filter((tx) => {
       const id = String(tx?.id || "");
       return id && !claimedTransferIdsRef.current.has(id);
     });
@@ -124554,6 +124978,9 @@ function createWalletTransferSession({ wallet, walletPK, localCache, claimIncomi
         batchClaimedIds.push(...staged);
         flushClaimed();
         const uniqueBatchClaimedIds = uniqueIds(batchClaimedIds);
+        if (uniqueBatchClaimedIds.length && typeof refreshBalance === "function") {
+          await refreshBalance();
+        }
         const unclaimedIds = candidateIds.filter((id) => !uniqueBatchClaimedIds.includes(id) && !claimedTransferIdsRef.current.has(id));
         if (unclaimedIds.length) {
           const elapsedMs = Date.now() - startedAt;
@@ -125076,7 +125503,7 @@ function createWalletTransferSession({ wallet, walletPK, localCache, claimIncomi
     try {
       await yieldToUi();
       const pendingTransfers2 = await getPendingTransfersSnapshot();
-      const incomingTransfers = pendingIncomingWalletTransfers(pendingTransfers2);
+      const incomingTransfers = pendingIncomingTransfers(pendingTransfers2);
       const claimCandidates = pendingIncomingClaimCandidates(incomingTransfers);
       if (!incomingTransfers.length) {
         markDone(diag, "wallet.pendingTxs.active", startedAt, { pending: 0, claimed: 0, reason });
@@ -125421,13 +125848,16 @@ function createWalletTransferSession({ wallet, walletPK, localCache, claimIncomi
     if (cacheWriteRef.current.timer) {
       clearTimeout(cacheWriteRef.current.timer);
     }
-    cacheWriteRef.current = { timer: null, cache: null, state: null };
+    cacheWriteRef.current = { timer: null, cache: null, state: null, fullHistory: false };
     cacheDirtyRef.current = false;
   };
   const startCacheHydration = () => {
     if (!wallet || !localCache || !walletPKRef.current) {
       return;
     }
+    if (initialCacheReady) {
+      return;
+    }
     const hydrateKey = `${localCache.id || "cache"}:${walletPKRef.current}`;
     if (cacheHydrateKeyRef.current === hydrateKey) {
       return;
@@ -125452,7 +125882,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) => {
@@ -125476,12 +125906,10 @@ function createWalletTransferSession({ wallet, walletPK, localCache, claimIncomi
     if (!cacheDirtyRef.current && !cacheWriteRef.current.timer) {
       return;
     }
-    if (historyTransfersRef.current.length < knownHistoryCountRef.current) {
-      return;
-    }
     cacheDirtyRef.current = false;
     cacheWriteRef.current.cache = localCache;
     cacheWriteRef.current.state = transferStore.getCacheState();
+    cacheWriteRef.current.fullHistory = historyTransfersRef.current.length >= knownHistoryCountRef.current;
     if (cacheWriteRef.current.timer) {
       clearTimeout(cacheWriteRef.current.timer);
     }
@@ -125510,7 +125938,7 @@ function createWalletTransferSession({ wallet, walletPK, localCache, claimIncomi
       serverHistoryComplete: serverHistoryCompleteRef.current,
       hasMoreTxs: !historyComplete,
       hasPendingTxs,
-      hasPendingIncomingTxs: pendingIncomingWalletTransfers(transfersRef.current).length > 0,
+      hasPendingIncomingTxs: pendingIncomingTransfers(transfersRef.current).length > 0,
       beginSdkActivity,
       getRecentTxs,
       claimPendingIncomingTransfers: claimPendingIncomingTransfers2,
@@ -125861,10 +126289,12 @@ function createWalletSession({
   pendingClaimBatchSize = null,
   activeTransferRefreshMs = null,
   eagerOutgoingStatusRefresh = false,
+  eagerCacheHistory = true,
   sentTransferRefreshDelayMs = null,
   deferBackgroundWork = null,
   appState = null,
   transferStore,
+  cachedBalance = null,
   ghostWallet = true,
   diag = null
 }) {
@@ -125882,6 +126312,7 @@ function createWalletSession({
   const txSubscriptions = createFieldSubscriptions(() => publishedSnapshot?.txValue);
   let polling = null;
   let readyDiag = null;
+  let refreshWalletBalance = null;
   const transferSession = createWalletTransferSession({
     wallet,
     walletPK,
@@ -125889,10 +126320,12 @@ function createWalletSession({
     claimIncomingTransfers,
     pendingClaimBatchSize,
     eagerOutgoingStatusRefresh,
+    eagerCacheHistory,
     transferStore,
     appState,
     deferBackgroundWork,
     backgroundSignal: backgroundAbort.signal,
+    refreshBalance: () => refreshWalletBalance?.(),
     diag
   });
   const getTransferState = () => transferSession.getSnapshot();
@@ -125912,7 +126345,16 @@ function createWalletSession({
       listener();
     }
   };
-  const balance = createWalletBalance({ wallet, diag, onChange: publish });
+  const balance = createWalletBalance({
+    wallet,
+    diag,
+    initialDisplayBalance: cachedBalance,
+    onBalance: (value) => {
+      writeCachedWalletBalance(localCache, { walletPK, network, balance: value }).catch(() => {});
+    },
+    onChange: publish
+  });
+  refreshWalletBalance = balance.getBalance;
   const funding = createFundingAddress({ wallet, network, diag, onChange: publish });
   const updateWalletData = createWalletData({
     wallet,
@@ -125993,13 +126435,14 @@ function createWalletSession({
       wallet,
       network,
       balance: balanceState.balance,
+      displayBalance: balanceState.displayBalance,
       satsBalance: balanceState.satsBalance,
       tokenBalances: balanceState.tokenBalances,
       fundingAddress: funding.getSnapshot(),
       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,
@@ -126091,7 +126534,7 @@ function createWalletSession({
   };
 }
 var init_session4 = __esm(() => {
-  init_balance();
+  init_balance2();
   init_claims();
   init_funding();
   init_lightning();
@@ -126100,6 +126543,7 @@ var init_session4 = __esm(() => {
   init_send2();
   init_transfers2();
   init_withdraw();
+  init_localdata();
 });
 
 // ../../shared/wallet/transferstore.js
@@ -126308,6 +126752,7 @@ function createTransferStore() {
         transfers: state.historyTransfers,
         walletPK: state.walletPK,
         serverEndReached: state.serverEndReached,
+        historyCount: state.historyCount,
         nextOffset: state.nextOffset,
         oldestTxMs: state.serverEndReached ? state.oldestVerifiedTxMs : null
       };
@@ -169791,9 +170236,13 @@ function peerRecordFromDoc(snap) {
 function peerRecordsFromSnapshot(snapshot) {
   return snapshot.docs.map(peerRecordFromDoc).filter(Boolean);
 }
-function avatarPath(uid) {
+function avatarPath(uid, version8) {
   requireUid(uid);
-  return `${uid}/avatar.webp`;
+  const avatarVersion = readAvatarVersion(version8);
+  if (!avatarVersion) {
+    throw new Error("avatar version required");
+  }
+  return `${uid}/avatars/${avatarVersion}.webp`;
 }
 function reportEvidencePath(reporter, targetUid, evidenceId) {
   if (!reporter || !targetUid || !evidenceId) {
@@ -169859,6 +170308,7 @@ function createFirebaseCloud({ db, auth: auth2, getAuth: getAuth2, functions: fu
   }
   let activeVaultSigner = null;
   const localSessionTerminations = new Set;
+  const pendingAvatars = new Map;
   function pageTs(value) {
     if (value instanceof Timestamp2) {
       return value;
@@ -169941,7 +170391,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 +170405,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;
@@ -170119,6 +170577,7 @@ function createFirebaseCloud({ db, auth: auth2, getAuth: getAuth2, functions: fu
     }, onError);
   }
   async function logout() {
+    pendingAvatars.clear();
     await signOut(requireAuth());
     return true;
   }
@@ -170252,25 +170711,45 @@ function createFirebaseCloud({ db, auth: auth2, getAuth: getAuth2, functions: fu
     await callFunction("acceptAgreement");
     return true;
   }
-  async function writeProfileAvatar(uid, avatar) {
+  async function setProfileAvatar(uid, data) {
     requireUid(uid);
-    await updateDoc(doc(db, "profiles", uid), { avatar });
-    return true;
-  }
-  async function uploadProfileAvatar(uid, data, { contentType = "image/webp" } = {}) {
-    const targetStorage = requireStorage2();
-    const path = avatarPath(uid);
-    const result = typeof uploadStorageBytes === "function" ? await uploadStorageBytes(targetStorage, path, data, { contentType }) : await uploadBytes(ref(targetStorage, path), typeof Blob !== "undefined" && data instanceof Blob ? data : toBytes2(data, "upload bytes"), { contentType });
-    const url = await getDownloadURL(ref(targetStorage, path));
-    return {
-      url,
-      generation: result?.metadata?.generation ?? result?.generation ?? null
-    };
-  }
-  async function deleteProfileAvatar(uid) {
-    const targetStorage = requireStorage2();
-    await deleteObject(ref(targetStorage, avatarPath(uid)));
-    return true;
+    if (requireAuth().currentUser?.uid !== uid) {
+      throw new Error("avatar account mismatch");
+    }
+    if (data == null) {
+      pendingAvatars.delete(uid);
+      const result = await callFunction("setAvatar", { body: null });
+      if (result?.avatar != null) {
+        throw new Error("avatar clear returned invalid state");
+      }
+      return { version: null };
+    }
+    const bytes = new Uint8Array(encryptedBytes(data, "avatar bytes"));
+    const pending = { bytes, version: null, promise: null };
+    const entries = pendingAvatars.get(uid) || [];
+    pendingAvatars.set(uid, [...entries, pending]);
+    pending.promise = callFunction("setAvatar", {
+      body: cloudBytesBase64(bytes, "avatar bytes")
+    }).then((result) => {
+      const version8 = readAvatarVersion(result?.avatar);
+      if (!version8) {
+        throw new Error("avatar publish returned invalid version");
+      }
+      pending.version = version8;
+      return version8;
+    });
+    try {
+      return { version: await pending.promise };
+    } catch (error) {
+      const active = pendingAvatars.get(uid) || [];
+      const remaining = active.filter((entry) => entry !== pending);
+      if (remaining.length) {
+        pendingAvatars.set(uid, remaining);
+      } else {
+        pendingAvatars.delete(uid);
+      }
+      throw error;
+    }
   }
   async function writeProfileIdentity(identity) {
     if (!identity || typeof identity !== "object" || Array.isArray(identity)) {
@@ -170407,13 +170886,28 @@ function createFirebaseCloud({ db, auth: auth2, getAuth: getAuth2, functions: fu
       onUpdate?.(snap.exists() ? snap.data()?.active === true : false, { exists: snap.exists() });
     }, onError);
   }
-  async function readPeerAvatar(uid) {
-    return readStorageFile(avatarPath(uid));
+  async function readPeerAvatar(uid, { version: version8 = null } = {}) {
+    const avatarVersion = readAvatarVersion(version8);
+    const entries = pendingAvatars.get(uid) || [];
+    if (entries.length) {
+      await Promise.allSettled(entries.map((entry) => entry.promise));
+      const pending = entries.find((entry) => entry.version === avatarVersion);
+      if (pending) {
+        const active = pendingAvatars.get(uid) || [];
+        const remaining = active.filter((entry) => entry !== pending);
+        if (remaining.length) {
+          pendingAvatars.set(uid, remaining);
+        } else {
+          pendingAvatars.delete(uid);
+        }
+        return new Uint8Array(pending.bytes);
+      }
+    }
+    return readStorageFile(avatarPath(uid, avatarVersion));
   }
   async function peerAvatarUrl(uid, { version: version8 = null } = {}) {
     const targetStorage = requireStorage2();
-    const url = await getDownloadURL(ref(targetStorage, avatarPath(uid)));
-    return avatarUrlWithVersion(url, version8);
+    return getDownloadURL(ref(targetStorage, avatarPath(uid, version8)));
   }
   function profileQueryField(field2, { network } = {}) {
     if (field2 === "walletPK") {
@@ -170464,20 +170958,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 +170971,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");
@@ -170872,12 +171366,13 @@ function createFirebaseCloud({ db, auth: auth2, getAuth: getAuth2, functions: fu
       }
     };
   }
-  async function pushInbox(recipientUid, ping) {
+  async function pushInbox(recipientUid, ping, options2 = {}) {
     requireUid(recipientUid);
     if (!ping)
       throw new Error("inbox ping required");
     await callFunction("push", {
       recipientUid,
+      notify: options2?.notify !== false,
       ping: {
         v: ping.v,
         epk: ping.epk,
@@ -170916,7 +171411,9 @@ function createFirebaseCloud({ db, auth: auth2, getAuth: getAuth2, functions: fu
     payload.onCommitted?.({ chatId, messageId });
     let delivered = true;
     if (payload.inbox?.recipientUid && payload.inbox?.ping) {
-      delivered = await pushInbox(payload.inbox.recipientUid, payload.inbox.ping).then(() => true, () => false);
+      delivered = await pushInbox(payload.inbox.recipientUid, payload.inbox.ping, {
+        notify: payload.inbox.notify !== false
+      }).then(() => true, () => false);
     }
     return { chatId, messageId, delivered };
   }
@@ -171169,18 +171666,19 @@ function createFirebaseCloud({ db, auth: auth2, getAuth: getAuth2, functions: fu
   }
   async function banAdminUser(uid, feature = "chat") {
     requireUid(uid);
-    await setDoc(doc(db, "moderation", uid), { banned: { [feature]: { until: null } } }, { merge: true });
     if (feature === "avatar") {
-      await deleteProfileAvatar(uid).catch((error) => {
-        if (error?.code !== "storage/object-not-found") {
-          throw error;
-        }
-      });
+      await callFunction("setAvatarModeration", { uid, banned: true });
+      return true;
     }
+    await setDoc(doc(db, "moderation", uid), { banned: { [feature]: { until: null } } }, { merge: true });
     return true;
   }
   async function unbanAdminUser(uid, feature = "chat") {
     requireUid(uid);
+    if (feature === "avatar") {
+      await callFunction("setAvatarModeration", { uid, banned: false });
+      return true;
+    }
     await setDoc(doc(db, "moderation", uid), { banned: { [feature]: deleteField() } }, { merge: true });
     return true;
   }
@@ -171218,9 +171716,7 @@ function createFirebaseCloud({ db, auth: auth2, getAuth: getAuth2, functions: fu
           write: writeProfileIdentity
         },
         avatar: {
-          write: writeProfileAvatar,
-          upload: uploadProfileAvatar,
-          delete: deleteProfileAvatar
+          set: setProfileAvatar
         }
       },
       private: {
@@ -173810,13 +174306,6 @@ function cleanMessage(value, limit2, label = "message") {
     throw new Error(`${label} must be ${limit2} characters or fewer`);
   return message;
 }
-function readAvatarGeneration(value) {
-  const version8 = Number(value);
-  if (!Number.isSafeInteger(version8) || version8 <= 0) {
-    throw new Error("avatar upload did not return a valid generation");
-  }
-  return version8;
-}
 function passkeyRows(linksList, passkeys, currentPasskeyId) {
   return [...linksList, ...passkeys].sort((left, right) => (right.createdAt || 0) - (left.createdAt || 0)).map((row) => ({
     ...row,
@@ -173904,23 +174393,17 @@ function createRuntimeProductActions({
       const user = await getUser();
       if (!data)
         throw new Error("avatar data required");
-      const result = await cloud.user.profile.avatar.upload(user.uid, data, {
-        contentType: options2.contentType || "image/webp"
-      });
-      const avatarVersion = readAvatarGeneration(result?.generation);
-      await cloud.user.profile.avatar.write(user.uid, avatarVersion);
-      await user.refetchAvatar?.({ version: avatarVersion, optimistic: true });
-      return { avatar: result?.url || null, avatarVersion };
+      if (options2.contentType && options2.contentType !== "image/webp") {
+        throw new Error("avatar content type must be image/webp");
+      }
+      const result = await cloud.user.profile.avatar.set(user.uid, data);
+      await user.refetchAvatar?.({ version: result.version });
+      const updated = await getUser();
+      return { avatar: updated.avatar || null, avatarVersion: result.version };
     },
     async deleteAvatar() {
       const user = await getUser();
-      try {
-        await cloud.user.profile.avatar.delete(user.uid);
-      } catch (error) {
-        if (error?.code !== "storage/object-not-found")
-          throw error;
-      }
-      await cloud.user.profile.avatar.write(user.uid, null);
+      await cloud.user.profile.avatar.set(user.uid, null);
       user.clearAvatar?.();
       return { deleted: true };
     }
@@ -175688,6 +176171,7 @@ class VeylHeadlessClient {
           this.userOwner.setNetwork(network);
         }
       });
+      await opened.walletReady;
       this.userSnapshot = this.userOwner.getSnapshot();
     } catch (error) {
       if (opened)