@glyphteck/veyl 0.2.0 → 0.3.1

package/dist/index.js

@@ -38993,12 +38993,6 @@ function mnemonicFromWalletEntropy(entropy) {
   }
   return entropyToMnemonic(entropyBytesValue, wordlist);
 }
-function deriveLegacyWalletEntropy(seed) {
-  const entropy = deriveSeed(seed, "wallet-mnemonic");
-  const out = new Uint8Array(entropy.subarray(0, WALLET_MNEMONIC_ENTROPY_BYTES));
-  cleanBytes(entropy);
-  return out;
-}
 function getKeyPair(seed) {
   const priv = new Uint8Array(seed);
   priv[0] &= 248;
@@ -39085,15 +39079,6 @@ async function openAccountSessionFromSecrets(walletEntropy, chatSeed, { SparkWal
     cleanBytes(chatSeed, chatPubKey);
   }
 }
-async function openLegacyAccountSession(masterSeed, options = {}) {
-  const walletEntropy = deriveLegacyWalletEntropy(masterSeed);
-  const chatSeed = deriveSeed(masterSeed, "chat");
-  try {
-    return await openAccountSessionFromSecrets(walletEntropy, chatSeed, options);
-  } finally {
-    cleanBytes(walletEntropy, chatSeed);
-  }
-}
 async function openRegistryAccountSession(masterSeed, registryEnvelope, options = {}) {
   const registry = await openSecretRegistry(masterSeed, registryEnvelope);
   const walletEntropy = getDefaultWalletEntropy(registry);
@@ -39108,7 +39093,7 @@ async function openRegistryAccountSession(masterSeed, registryEnvelope, options
 import { Buffer as Buffer4 } from "buffer";
 import process5 from "process";
 
-// ../../node_modules/.bun/@buildonspark+spark-sdk@0.8.8+04a16a716d9f5b94/node_modules/@buildonspark/spark-sdk/dist/chunk-BCcL9Bmk.js
+// ../../node_modules/.bun/@buildonspark+spark-sdk@0.8.8+bee703889d31789e/node_modules/@buildonspark/spark-sdk/dist/chunk-BCcL9Bmk.js
 var __toBinaryNode = (base642) => new Uint8Array(Buffer.from(base642, "base64"));
 
 // ../../node_modules/.bun/@bufbuild+protobuf@2.12.0/node_modules/@bufbuild/protobuf/dist/esm/wire/varint.js
@@ -39724,7 +39709,7 @@ function assertFloat32(arg) {
     throw new Error("invalid float32: " + arg);
 }
 
-// ../../node_modules/.bun/@buildonspark+spark-sdk@0.8.8+04a16a716d9f5b94/node_modules/@buildonspark/spark-sdk/dist/empty-CbimPmjm.js
+// ../../node_modules/.bun/@buildonspark+spark-sdk@0.8.8+bee703889d31789e/node_modules/@buildonspark/spark-sdk/dist/empty-CbimPmjm.js
 function createBaseTimestamp() {
   return {
     seconds: 0,
@@ -39967,7 +39952,7 @@ var Empty = {
   }
 };
 
-// ../../node_modules/.bun/@buildonspark+spark-sdk@0.8.8+04a16a716d9f5b94/node_modules/@buildonspark/spark-sdk/dist/proto/spark.js
+// ../../node_modules/.bun/@buildonspark+spark-sdk@0.8.8+bee703889d31789e/node_modules/@buildonspark/spark-sdk/dist/proto/spark.js
 var Network = /* @__PURE__ */ function(Network2) {
   Network2[Network2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
   Network2[Network2["MAINNET"] = 1] = "MAINNET";
@@ -57118,7 +57103,7 @@ var DefaultRequester = class extends Requester {
   }
 };
 
-// ../../node_modules/.bun/@buildonspark+spark-sdk@0.8.8+04a16a716d9f5b94/node_modules/@buildonspark/spark-sdk/dist/sdk-types-DJDUa17y.js
+// ../../node_modules/.bun/@buildonspark+spark-sdk@0.8.8+bee703889d31789e/node_modules/@buildonspark/spark-sdk/dist/sdk-types-DJDUa17y.js
 var BitcoinNetwork = /* @__PURE__ */ function(BitcoinNetwork2) {
   BitcoinNetwork2["FUTURE_VALUE"] = "FUTURE_VALUE";
   BitcoinNetwork2["MAINNET"] = "MAINNET";
@@ -57979,7 +57964,7 @@ function mapTransferToWalletTransfer(proto, identityPublicKey, userRequest) {
   };
 }
 
-// ../../node_modules/.bun/@buildonspark+spark-sdk@0.8.8+04a16a716d9f5b94/node_modules/@buildonspark/spark-sdk/dist/multisig-BPUmc7A3.js
+// ../../node_modules/.bun/@buildonspark+spark-sdk@0.8.8+bee703889d31789e/node_modules/@buildonspark/spark-sdk/dist/multisig-BPUmc7A3.js
 function createBaseMultisigConfig() {
   return {
     version: 0,
@@ -58204,7 +58189,7 @@ function isSet3(value) {
   return value !== null && value !== undefined;
 }
 
-// ../../node_modules/.bun/@buildonspark+spark-sdk@0.8.8+04a16a716d9f5b94/node_modules/@buildonspark/spark-sdk/dist/proto/spark_token.js
+// ../../node_modules/.bun/@buildonspark+spark-sdk@0.8.8+bee703889d31789e/node_modules/@buildonspark/spark-sdk/dist/proto/spark_token.js
 var TokenOutputStatus = /* @__PURE__ */ function(TokenOutputStatus2) {
   TokenOutputStatus2[TokenOutputStatus2["TOKEN_OUTPUT_STATUS_UNSPECIFIED"] = 0] = "TOKEN_OUTPUT_STATUS_UNSPECIFIED";
   TokenOutputStatus2[TokenOutputStatus2["TOKEN_OUTPUT_STATUS_AVAILABLE"] = 1] = "TOKEN_OUTPUT_STATUS_AVAILABLE";
@@ -67597,7 +67582,7 @@ class Transaction {
 // ../../node_modules/.bun/@scure+btc-signer@1.8.1/node_modules/@scure/btc-signer/esm/index.js
 /*! scure-btc-signer - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 
-// ../../node_modules/.bun/@buildonspark+spark-sdk@0.8.8+04a16a716d9f5b94/node_modules/@buildonspark/spark-sdk/dist/spark-wallet-DEFcyFjN.js
+// ../../node_modules/.bun/@buildonspark+spark-sdk@0.8.8+bee703889d31789e/node_modules/@buildonspark/spark-sdk/dist/spark-wallet-DEFcyFjN.js
 var import_nice_grpc_common = __toESM(require_lib(), 1);
 
 // ../../node_modules/.bun/@scure+bip32@1.7.0/node_modules/@scure/bip32/lib/esm/index.js
@@ -70215,7 +70200,7 @@ class Mutex {
 // ../../node_modules/.bun/eventemitter3@5.0.4/node_modules/eventemitter3/index.mjs
 var import__ = __toESM(require_eventemitter3(), 1);
 
-// ../../node_modules/.bun/@buildonspark+spark-sdk@0.8.8+04a16a716d9f5b94/node_modules/@buildonspark/spark-sdk/dist/spark-wallet-DEFcyFjN.js
+// ../../node_modules/.bun/@buildonspark+spark-sdk@0.8.8+bee703889d31789e/node_modules/@buildonspark/spark-sdk/dist/spark-wallet-DEFcyFjN.js
 var import_light_bolt11_decoder = __toESM(require_bolt11(), 1);
 var SparkFrostBase = class {
   generateAdaptorFromSignature(signature) {
@@ -89329,7 +89314,7 @@ function isTokenTransactionStreamEvent(event) {
   return Boolean(event?.$case === "tokenTransaction" && event.tokenTransaction.tokenTransactionHash);
 }
 
-// ../../node_modules/.bun/@buildonspark+spark-sdk@0.8.8+04a16a716d9f5b94/node_modules/@buildonspark/spark-sdk/dist/buffer-C7zVfCZb.js
+// ../../node_modules/.bun/@buildonspark+spark-sdk@0.8.8+bee703889d31789e/node_modules/@buildonspark/spark-sdk/dist/buffer-C7zVfCZb.js
 import { Buffer as Buffer2 } from "buffer";
 if (typeof globalThis.Buffer === "undefined")
   globalThis.Buffer = Buffer2;
@@ -89340,7 +89325,7 @@ if (typeof window !== "undefined") {
     window.globalThis = window;
 }
 
-// ../../node_modules/.bun/@buildonspark+spark-sdk@0.8.8+04a16a716d9f5b94/node_modules/@buildonspark/spark-sdk/dist/index.browser.js
+// ../../node_modules/.bun/@buildonspark+spark-sdk@0.8.8+bee703889d31789e/node_modules/@buildonspark/spark-sdk/dist/index.browser.js
 var import_nice_grpc_common2 = __toESM(require_lib(), 1);
 var import_nice_grpc_client_middleware_retry = __toESM(require_lib4(), 1);
 var import_nice_grpc_web = __toESM(require_lib5(), 1);
@@ -92127,7 +92112,7 @@ var CHAT_READY_DOWNLOAD_MAX_BYTES = 8 * MIB_BYTES;
 var CHAT_MESSAGE_FILE_CACHE_MAX_BYTES = 64 * MIB_BYTES;
 var CHAT_UNSAVED_TTL_DAYS = 21;
 var CHAT_UNSAVED_TTL_MS = CHAT_UNSAVED_TTL_DAYS * DAY_MS;
-var CHAT_SEEN_TTL_MS = DAY_MS;
+var CHAT_AFTER_SEEN_MS = DAY_MS;
 var CHAT_MEDIA_TTL_DAYS = CHAT_UNSAVED_TTL_DAYS;
 var CHAT_MEDIA_TTL_MS = CHAT_MEDIA_TTL_DAYS * DAY_MS;
 var CHAT_UPLOAD_MAX_BYTES = 64 * MIB_BYTES;
@@ -92135,10 +92120,12 @@ var CHAT_AUDIO_TRANSCODE_BITRATE_BPS = 128000;
 var CHAT_VIDEO_TRANSCODE_VIDEO_BITRATE_BPS = 768000;
 var CHAT_VIDEO_TRANSCODE_AUDIO_BITRATE_BPS = CHAT_AUDIO_TRANSCODE_BITRATE_BPS;
 var CHAT_MESSAGE_BATCH_SIZE = 40;
+var CHAT_TTL_WRITE_BATCH_SIZE = 400;
 var CHAT_LIST_PAGE_SIZE = 20;
 var CHAT_INBOX_PING_PAGE_SIZE = 25;
 var CHAT_LIST_STATUS_CACHE_MS = 30 * MS_PER_SECOND;
 var CHAT_MEDIA_WARM_TYPES = Object.freeze(["img", "gif", "mp4"]);
+var CHAT_READ_WRITE_INTERVAL_MS = 5 * MS_PER_SECOND;
 var CHAT_SEND_QUEUE_RATE_LIMIT_WINDOW_MS = 10 * MS_PER_SECOND;
 var CHAT_MESSAGE_BODY_MAX_BYTES = 64 * KIB_BYTES;
 var CHAT_LAST_MESSAGE_BODY_MAX_BYTES = 64 * KIB_BYTES;
@@ -92168,6 +92155,7 @@ var WALLET_PENDING_TRANSFER_WARM_AGE_MS = 10 * MINUTE_MS;
 var WALLET_PENDING_TRANSFER_WARM_RETRY_MS = 15 * MS_PER_SECOND;
 var WALLET_PENDING_TRANSFER_STALE_RETRY_MS = 2 * MINUTE_MS;
 var WALLET_PENDING_TRANSFER_STUCK_RETRY_MS = 10 * MINUTE_MS;
+var WALLET_TRANSFER_CACHE_WRITE_DELAY_MS = 3 * MS_PER_SECOND;
 
 // ../../shared/chat/filepayload.js
 "use client";
@@ -92295,8 +92283,8 @@ var CHAT_RETENTION_LABELS = Object.freeze({
   [CHAT_RETENTION_SEEN]: "delete after seen",
   [CHAT_RETENTION_24H]: "keep for 24h"
 });
-var DEFAULT_MESSAGE_TTL_MS = CHAT_UNSAVED_TTL_MS;
-var SEEN_MESSAGE_TTL_MS = CHAT_SEEN_TTL_MS;
+var MESSAGE_STORAGE_TTL_MS = CHAT_UNSAVED_TTL_MS;
+var AFTER_SEEN_MS = CHAT_AFTER_SEEN_MS;
 function hasChatRetention(value) {
   const retention = cleanText(value);
   return CHAT_RETENTION_VALUES.includes(retention);
@@ -92332,16 +92320,14 @@ function isTtlExpired(value, now = Date.now()) {
   const ms = ttlMillis(value);
   return ms != null && ms <= now;
 }
-function newMessageTtlMs(retention = DEFAULT_CHAT_RETENTION, now = Date.now()) {
-  switch (cleanChatRetention(retention)) {
-    case CHAT_RETENTION_SEEN:
-    case CHAT_RETENTION_24H:
-    default:
-      return now + DEFAULT_MESSAGE_TTL_MS;
-  }
+function newMessageStorageTtlMs(now = Date.now()) {
+  return now + MESSAGE_STORAGE_TTL_MS;
 }
-function seenMessageTtlMs(now = Date.now()) {
-  return now + SEEN_MESSAGE_TTL_MS;
+function messageExpiryMs(retention, seenAt) {
+  if (!Number.isFinite(seenAt)) {
+    return null;
+  }
+  return cleanChatRetention(retention) === CHAT_RETENTION_24H ? seenAt + AFTER_SEEN_MS : seenAt;
 }
 
 // ../../shared/links.js
@@ -92567,7 +92553,6 @@ function targetMessageMs(target, byKey) {
 }
 
 // ../../shared/chat/messages/control.js
-var retainedMessageCache = new WeakMap;
 function cleanReactionEmoji(value) {
   const emoji = cleanText(value);
   return emoji || DEFAULT_REACTION_EMOJI;
@@ -92590,13 +92575,6 @@ function isPeerMsg(msg, chatPK) {
 function isServerConfirmedMsg(msg) {
   return !!msg?.id && !String(msg.id).startsWith("local:") && !msg.pending && !msg.failed;
 }
-function messageOrderMs(message) {
-  const ms = getMessageOrderMs(message);
-  return Number.isFinite(ms) ? ms : null;
-}
-function hasAnyMsgKey(msg, keys) {
-  return messageHasKey(msg, keys);
-}
 function makeReadReceipt(target) {
   const upto = cleanTarget(target);
   if (!upto) {
@@ -92698,236 +92676,6 @@ function canStoreMsg(msg) {
   }
   return canShowMsg(msg) || isControlMsg(msg) || isActionMutationMsg(msg);
 }
-function needsRetentionProjection(messages) {
-  for (const msg of messages || []) {
-    if (isSystemMsg(msg) || isReadReceiptMsg(msg) || isHiddenCheckpointMsg(msg)) {
-      return true;
-    }
-  }
-  return false;
-}
-function receiptCoverageTarget(receipt, byKey) {
-  const targetKey = cleanText(receipt?.upto);
-  if (!targetKey) {
-    return null;
-  }
-  const target = byKey.get(targetKey);
-  const targetMs = messageOrderMs(target) ?? messageOrderMs({ cid: targetKey }) ?? messageOrderMs(receipt);
-  const receiptMs = messageOrderMs(receipt);
-  if (targetMs == null || receiptMs == null) {
-    return null;
-  }
-  return {
-    target,
-    targetMs,
-    receiptMs
-  };
-}
-function makeReceiptCoverage(messages, byKey, chatPK, peerChatPK) {
-  const peerMessageReceipts = [];
-  const ownMessageReceipts = [];
-  for (const msg of messages || []) {
-    if (!isServerConfirmedMsg(msg) || !isReadReceiptMsg(msg)) {
-      continue;
-    }
-    const coverage = receiptCoverageTarget(msg, byKey);
-    if (!coverage) {
-      continue;
-    }
-    const receiptFromPeer = isPeerMsg(msg, chatPK);
-    if (receiptFromPeer) {
-      if (peerChatPK && msg?.s !== peerChatPK) {
-        continue;
-      }
-      if (coverage.target && isPeerMsg(coverage.target, chatPK)) {
-        continue;
-      }
-      ownMessageReceipts.push(coverage);
-    } else {
-      if (coverage.target && !isPeerMsg(coverage.target, chatPK)) {
-        continue;
-      }
-      peerMessageReceipts.push(coverage);
-    }
-  }
-  peerMessageReceipts.sort((a, b) => b.targetMs - a.targetMs);
-  ownMessageReceipts.sort((a, b) => b.targetMs - a.targetMs);
-  return {
-    peer: { receipts: peerMessageReceipts, index: 0, seenAt: null },
-    own: { receipts: ownMessageReceipts, index: 0, seenAt: null }
-  };
-}
-function receiptCoverageSeenAt(state, messageMs) {
-  if (!state || messageMs == null) {
-    return null;
-  }
-  while (state.index < state.receipts.length && state.receipts[state.index].targetMs >= messageMs) {
-    const receiptMs = state.receipts[state.index].receiptMs;
-    state.seenAt = state.seenAt == null ? receiptMs : Math.min(state.seenAt, receiptMs);
-    state.index += 1;
-  }
-  return state.seenAt;
-}
-function hasRetentionControls(messages) {
-  for (const msg of messages || []) {
-    if (isServerConfirmedMsg(msg) && (isReadReceiptMsg(msg) || isHiddenCheckpointMsg(msg))) {
-      return true;
-    }
-  }
-  return false;
-}
-function hiddenCheckpointCoverageTarget(checkpoint, byKey) {
-  const targetKey = cleanText(checkpoint?.upto);
-  if (!targetKey) {
-    return null;
-  }
-  const target = byKey.get(targetKey);
-  const targetMs = targetMessageMs(targetKey, byKey);
-  const targetFrom = cleanText(target?.s) || cleanText(target?.from) || cleanText(checkpoint?.targetFrom);
-  if (targetMs == null || !targetFrom) {
-    return null;
-  }
-  return { targetMs, targetFrom };
-}
-function makeHiddenCheckpointCoverage(messages, byKey, chatPK, peerChatPK) {
-  const own = cleanText(chatPK);
-  const peer = cleanText(peerChatPK);
-  const coverage = { peerTargetMs: null, ownTargetMs: null };
-  if (!own) {
-    return coverage;
-  }
-  for (const msg of messages || []) {
-    if (!isServerConfirmedMsg(msg) || !isHiddenCheckpointMsg(msg)) {
-      continue;
-    }
-    const checkpointFrom = cleanText(msg?.s);
-    if (checkpointFrom !== own && (!peer || checkpointFrom !== peer)) {
-      continue;
-    }
-    const target = hiddenCheckpointCoverageTarget(msg, byKey);
-    if (!target) {
-      continue;
-    }
-    const targetFrom = target.targetFrom;
-    if (targetFrom === own) {
-      coverage.ownTargetMs = coverage.ownTargetMs == null ? target.targetMs : Math.max(coverage.ownTargetMs, target.targetMs);
-    } else if (!peer || targetFrom === peer) {
-      coverage.peerTargetMs = coverage.peerTargetMs == null ? target.targetMs : Math.max(coverage.peerTargetMs, target.targetMs);
-    }
-  }
-  return coverage;
-}
-function canRetentionControlsHideMessages(messages, now) {
-  let hasSeenRetention = false;
-  let hasExpiredSeenWindow = false;
-  let hasCheckpoint = false;
-  for (const msg of messages || []) {
-    if (isServerConfirmedMsg(msg) && isReadReceiptMsg(msg)) {
-      const ms = messageOrderMs(msg);
-      if (ms != null && seenMessageTtlMs(ms) <= now) {
-        hasExpiredSeenWindow = true;
-      }
-      continue;
-    }
-    if (isServerConfirmedMsg(msg) && isHiddenCheckpointMsg(msg)) {
-      hasCheckpoint = true;
-      continue;
-    }
-    if (getMessageRetention(msg) === CHAT_RETENTION_SEEN) {
-      hasSeenRetention = true;
-    }
-    if (hasSeenRetention && (hasExpiredSeenWindow || hasCheckpoint)) {
-      return true;
-    }
-  }
-  return hasSeenRetention || hasExpiredSeenWindow || hasCheckpoint;
-}
-function collectSeenHiddenMessages(messages, chatPK, peerChatPK, options = {}) {
-  if (!Array.isArray(messages) || !messages.length || !chatPK) {
-    return { hidden: [], nextMs: null };
-  }
-  if (!hasRetentionControls(messages)) {
-    return { hidden: [], nextMs: null };
-  }
-  const keepKeys = options?.keepKeys instanceof Set ? options.keepKeys : new Set(Array.isArray(options?.keepKeys) ? options.keepKeys.filter(Boolean) : []);
-  const now = Number.isFinite(options?.now) ? options.now : Date.now();
-  if (options?.next !== true && !canRetentionControlsHideMessages(messages, now)) {
-    return { hidden: [], nextMs: null };
-  }
-  const byKey = indexMessagesByKey(messages, { keep: "last" });
-  const coverage = makeReceiptCoverage(messages, byKey, chatPK, peerChatPK);
-  const checkpointCoverage = makeHiddenCheckpointCoverage(messages, byKey, chatPK, peerChatPK);
-  if (!coverage.peer.receipts.length && !coverage.own.receipts.length && checkpointCoverage.peerTargetMs == null && checkpointCoverage.ownTargetMs == null) {
-    return { hidden: [], nextMs: null };
-  }
-  const hidden = [];
-  let nextMs = null;
-  const candidates = [];
-  for (const msg of messages) {
-    if (!hasAnyMsgKey(msg, keepKeys) && isServerConfirmedMsg(msg) && !isControlMsg(msg) && !isSystemMsg(msg) && canShowMsg(msg) && msg.ttl != null) {
-      const ms = messageOrderMs(msg);
-      if (ms != null) {
-        candidates.push({ msg, ms, fromPeer: isPeerMsg(msg, chatPK) });
-      }
-    }
-  }
-  candidates.sort((a, b) => b.ms - a.ms);
-  for (const candidate of candidates) {
-    const retention = getMessageRetention(candidate.msg);
-    const checkpointTargetMs = candidate.fromPeer ? checkpointCoverage.peerTargetMs : checkpointCoverage.ownTargetMs;
-    if (options?.hideSeen !== false && retention === CHAT_RETENTION_SEEN && checkpointTargetMs != null && candidate.ms <= checkpointTargetMs) {
-      hidden.push(candidate.msg);
-      continue;
-    }
-    const seenAt = receiptCoverageSeenAt(candidate.fromPeer ? coverage.peer : coverage.own, candidate.ms);
-    if (seenAt == null) {
-      continue;
-    }
-    if (retention === CHAT_RETENTION_SEEN) {
-      if (options?.hideSeen !== false) {
-        hidden.push(candidate.msg);
-      }
-      continue;
-    }
-    const hideAt = seenMessageTtlMs(seenAt);
-    if (hideAt <= now) {
-      hidden.push(candidate.msg);
-    } else if (nextMs == null || hideAt < nextMs) {
-      nextMs = hideAt;
-    }
-  }
-  return { hidden, nextMs };
-}
-function filterSeenMessages(messages, chatPK, peerChatPK, options = {}) {
-  const state = collectProjectedSeenHiddenState(messages, chatPK, peerChatPK, options);
-  const projectedMessages = state.messages;
-  const hidden = state.hidden;
-  if (!hidden.length) {
-    return projectedMessages;
-  }
-  const hiddenKeys = collectMessageKeys(hidden);
-  return projectedMessages.filter((msg) => !hasAnyMsgKey(msg, hiddenKeys));
-}
-function getDisplayMessages(messages, chatPK, peerChatPK, options = {}) {
-  return filterSeenMessages(messages, chatPK, peerChatPK, options);
-}
-function collectProjectedSeenHiddenState(messages, chatPK, peerChatPK, options = {}) {
-  const actionMessages = applyMessageActions(messages);
-  if (!needsRetentionProjection(actionMessages)) {
-    return {
-      messages: actionMessages || [],
-      hidden: [],
-      nextMs: null
-    };
-  }
-  const projectedMessages = applyMessageRetentionTimeline(actionMessages, options.fallback);
-  const state = collectSeenHiddenMessages(projectedMessages, chatPK, peerChatPK, options);
-  return {
-    messages: projectedMessages,
-    hidden: state.hidden,
-    nextMs: state.nextMs
-  };
-}
 function actionTarget(msg) {
   return cleanText(msg?.actionTarget) || cleanText(msg?.target) || cleanText(msg?.id);
 }
@@ -92943,7 +92691,7 @@ function actionPatch(msg) {
     actionId,
     actionOp,
     actionTarget: actionTarget2,
-    actor,
+    signingPublicKey,
     target,
     ...payload
   } = msg || {};
@@ -93031,53 +92779,241 @@ function applyMessageActions(messages) {
   }
   return out.filter(Boolean);
 }
+
+// ../../shared/chat/messages/expiry.js
+var retainedMessageCache = new WeakMap;
+function messageOrderMs(message) {
+  const ms = getMessageOrderMs(message);
+  return Number.isFinite(ms) ? ms : null;
+}
+function hasExpiryControls(messages) {
+  return (messages || []).some((message) => isServerConfirmedMsg(message) && (isReadReceiptMsg(message) || isHiddenCheckpointMsg(message)));
+}
+function needsRetentionTimeline(messages) {
+  return (messages || []).some(isSystemMsg);
+}
+function withCachedRetention(message, retention) {
+  const nextRetention = cleanChatRetention(retention);
+  if (message.retention === nextRetention) {
+    return message;
+  }
+  let byRetention = retainedMessageCache.get(message);
+  if (!byRetention) {
+    byRetention = new Map;
+    retainedMessageCache.set(message, byRetention);
+  }
+  const cached = byRetention.get(nextRetention);
+  if (cached) {
+    return cached;
+  }
+  const next = { ...message, retention: nextRetention };
+  byRetention.set(nextRetention, next);
+  return next;
+}
 function applyMessageRetentionTimeline(messages, fallback = DEFAULT_CHAT_RETENTION) {
   if (!Array.isArray(messages) || !messages.length) {
     return messages || [];
   }
   let retention = cleanChatRetention(fallback);
-  let timelineActive = false;
   let changed = false;
-  const next = messages.map((msg) => {
-    if (!msg || typeof msg !== "object" || Array.isArray(msg)) {
-      return msg;
-    }
-    if (isSystemMsg(msg)) {
-      retention = cleanChatRetention(msg.retention);
-      timelineActive = true;
-      return msg;
+  const next = messages.map((message) => {
+    if (!message || typeof message !== "object" || Array.isArray(message)) {
+      return message;
     }
-    if (isControlMsg(msg) || !canShowMsg(msg)) {
-      return msg;
+    if (isSystemMsg(message)) {
+      retention = cleanChatRetention(message.retention);
+      return message;
     }
-    if (hasChatRetention(msg.retention)) {
-      return msg;
+    if (isControlMsg(message) || !canShowMsg(message) || hasChatRetention(message.retention)) {
+      return message;
     }
-    const next2 = withCachedMessageRetention(msg, retention);
-    if (next2 !== msg) {
+    const retained = withCachedRetention(message, retention);
+    if (retained !== message) {
       changed = true;
     }
-    return next2;
+    return retained;
   });
   return changed ? next : messages;
 }
-function withCachedMessageRetention(msg, retention) {
-  const nextRetention = cleanChatRetention(retention);
-  if (msg.retention === nextRetention) {
-    return msg;
+function receiptTarget(receipt, byKey) {
+  const targetKey = cleanText(receipt?.upto);
+  if (!targetKey) {
+    return null;
   }
-  let byRetention = retainedMessageCache.get(msg);
-  if (!byRetention) {
-    byRetention = new Map;
-    retainedMessageCache.set(msg, byRetention);
+  const target = byKey.get(targetKey);
+  const targetMs = messageOrderMs(target) ?? messageOrderMs({ cid: targetKey }) ?? messageOrderMs(receipt);
+  const seenAt = messageOrderMs(receipt);
+  const receiptKey = getMessageKey(receipt);
+  return targetMs == null || seenAt == null || !receiptKey ? null : { receiptKey, target, targetMs, seenAt };
+}
+function makeReceiptCoverage(messages, byKey, selfChatPublicKey, peerChatPublicKey) {
+  const peerMessages = [];
+  const ownMessages = [];
+  for (const message of messages || []) {
+    if (!isServerConfirmedMsg(message) || !isReadReceiptMsg(message)) {
+      continue;
+    }
+    const receipt = receiptTarget(message, byKey);
+    if (!receipt) {
+      continue;
+    }
+    if (isPeerMsg(message, selfChatPublicKey)) {
+      if (peerChatPublicKey && message.s !== peerChatPublicKey || receipt.target && isPeerMsg(receipt.target, selfChatPublicKey)) {
+        continue;
+      }
+      ownMessages.push(receipt);
+    } else {
+      if (receipt.target && !isPeerMsg(receipt.target, selfChatPublicKey)) {
+        continue;
+      }
+      peerMessages.push(receipt);
+    }
   }
-  const cached = byRetention.get(nextRetention);
-  if (cached) {
-    return cached;
+  peerMessages.sort((left, right) => right.targetMs - left.targetMs || left.seenAt - right.seenAt);
+  ownMessages.sort((left, right) => right.targetMs - left.targetMs || left.seenAt - right.seenAt);
+  return {
+    peer: { items: peerMessages, index: 0, current: null },
+    own: { items: ownMessages, index: 0, current: null }
+  };
+}
+function coveringReceipt(state, messageMs) {
+  while (state && state.index < state.items.length && state.items[state.index].targetMs >= messageMs) {
+    const next = state.items[state.index];
+    if (!state.current || next.seenAt < state.current.seenAt) {
+      state.current = next;
+    }
+    state.index += 1;
   }
-  const next = { ...msg, retention: nextRetention };
-  byRetention.set(nextRetention, next);
-  return next;
+  return state?.current ?? null;
+}
+function checkpointTarget(checkpoint, byKey) {
+  const targetKey = cleanText(checkpoint?.upto);
+  if (!targetKey) {
+    return null;
+  }
+  const target = byKey.get(targetKey);
+  const targetMs = targetMessageMs(targetKey, byKey);
+  const targetFrom = cleanText(target?.s) || cleanText(target?.from) || cleanText(checkpoint?.targetFrom);
+  const hiddenAt = messageOrderMs(checkpoint);
+  return targetMs == null || !targetFrom || hiddenAt == null ? null : { targetMs, targetFrom, hiddenAt };
+}
+function makeCheckpointCoverage(messages, byKey, selfChatPublicKey, peerChatPublicKey) {
+  const peerMessages = [];
+  const ownMessages = [];
+  const self2 = cleanText(selfChatPublicKey);
+  const peer = cleanText(peerChatPublicKey);
+  for (const message of messages || []) {
+    if (!isServerConfirmedMsg(message) || !isHiddenCheckpointMsg(message)) {
+      continue;
+    }
+    const checkpointFrom = cleanText(message.s);
+    if (checkpointFrom !== self2 && (!peer || checkpointFrom !== peer)) {
+      continue;
+    }
+    const checkpoint = checkpointTarget(message, byKey);
+    if (!checkpoint) {
+      continue;
+    }
+    if (checkpoint.targetFrom === self2) {
+      ownMessages.push(checkpoint);
+    } else if (!peer || checkpoint.targetFrom === peer) {
+      peerMessages.push(checkpoint);
+    }
+  }
+  peerMessages.sort((left, right) => right.targetMs - left.targetMs || left.hiddenAt - right.hiddenAt);
+  ownMessages.sort((left, right) => right.targetMs - left.targetMs || left.hiddenAt - right.hiddenAt);
+  return {
+    peer: { items: peerMessages, index: 0, current: null },
+    own: { items: ownMessages, index: 0, current: null }
+  };
+}
+function coveringCheckpoint(state, messageMs) {
+  while (state && state.index < state.items.length && state.items[state.index].targetMs >= messageMs) {
+    const next = state.items[state.index];
+    if (!state.current || next.targetMs > state.current.targetMs || next.targetMs === state.current.targetMs && next.hiddenAt < state.current.hiddenAt) {
+      state.current = next;
+    }
+    state.index += 1;
+  }
+  return state?.current ?? null;
+}
+function heldKeys(value) {
+  if (value instanceof Set) {
+    return value;
+  }
+  return new Set(Array.isArray(value) ? value.filter(Boolean) : []);
+}
+function analyzeMessageExpiry(messages, selfChatPublicKey, peerChatPublicKey, options = {}) {
+  const actionMessages = applyMessageActions(messages);
+  const projectedMessages = needsRetentionTimeline(actionMessages) ? applyMessageRetentionTimeline(actionMessages, options.fallback) : actionMessages || [];
+  if (!projectedMessages.length || !selfChatPublicKey || !hasExpiryControls(projectedMessages)) {
+    return {
+      messages: projectedMessages,
+      visible: projectedMessages,
+      expired: [],
+      heldExpired: [],
+      nextExpiryAt: null,
+      requiredReceiptKeys: new Set
+    };
+  }
+  const byKey = indexMessagesByKey(projectedMessages, { keep: "last" });
+  const receipts = makeReceiptCoverage(projectedMessages, byKey, selfChatPublicKey, peerChatPublicKey);
+  const checkpoints = makeCheckpointCoverage(projectedMessages, byKey, selfChatPublicKey, peerChatPublicKey);
+  const keepKeys = heldKeys(options.keepKeys);
+  const now = Number.isFinite(options.now) ? options.now : Date.now();
+  const candidates = [];
+  for (const message of projectedMessages) {
+    if (!isServerConfirmedMsg(message) || isControlMsg(message) || isSystemMsg(message) || !canShowMsg(message) || message.ttl == null) {
+      continue;
+    }
+    const orderMs = messageOrderMs(message);
+    if (orderMs != null) {
+      candidates.push({ message, orderMs, fromPeer: isPeerMsg(message, selfChatPublicKey) });
+    }
+  }
+  candidates.sort((left, right) => right.orderMs - left.orderMs);
+  const expired = [];
+  const heldExpired = [];
+  const requiredReceiptKeys = new Set;
+  let nextExpiryAt = null;
+  for (const candidate of candidates) {
+    const direction = candidate.fromPeer ? "peer" : "own";
+    const receipt = coveringReceipt(receipts[direction], candidate.orderMs);
+    const checkpoint = coveringCheckpoint(checkpoints[direction], candidate.orderMs);
+    const retention = getMessageRetention(candidate.message);
+    const seenAt = retention === CHAT_RETENTION_SEEN ? receipt?.seenAt ?? checkpoint?.hiddenAt ?? null : receipt?.seenAt ?? null;
+    if (retention !== CHAT_RETENTION_SEEN && receipt) {
+      requiredReceiptKeys.add(receipt.receiptKey);
+    }
+    const expiresAt = messageExpiryMs(retention, seenAt);
+    if (expiresAt == null) {
+      continue;
+    }
+    if (expiresAt > now) {
+      nextExpiryAt = nextExpiryAt == null ? expiresAt : Math.min(nextExpiryAt, expiresAt);
+      continue;
+    }
+    if (messageHasKey(candidate.message, keepKeys)) {
+      heldExpired.push(candidate.message);
+    } else {
+      expired.push(candidate.message);
+    }
+  }
+  if (!expired.length) {
+    return { messages: projectedMessages, visible: projectedMessages, expired, heldExpired, nextExpiryAt, requiredReceiptKeys };
+  }
+  const expiredKeys = collectMessageKeys(expired);
+  return {
+    messages: projectedMessages,
+    visible: projectedMessages.filter((message) => !messageHasKey(message, expiredKeys)),
+    expired,
+    heldExpired,
+    nextExpiryAt,
+    requiredReceiptKeys
+  };
+}
+function getDisplayMessages(messages, selfChatPublicKey, peerChatPublicKey, options = {}) {
+  return analyzeMessageExpiry(messages, selfChatPublicKey, peerChatPublicKey, options).visible;
 }
 
 // ../../shared/chat/messages/compose.js
@@ -93428,21 +93364,21 @@ function markError(diag, label, startedAt, error, data = {}) {
 
 // ../../shared/crypto/sign.js
 "use client";
-var CHAT_ACTOR_SIGN_SCOPE = "chat-actor-sign-v2";
+var CHAT_SIGNING_SCOPE = "chat-actor-sign-v2";
 function orderKeys(a, b) {
   if (!a || !b) {
     throw new Error("chat keys required");
   }
   return a <= b ? [a, b] : [b, a];
 }
-function deriveChatActorSecret(chatPrivKey, chatId, chatPK, peerChatPK) {
+function deriveChatSigningSecret(chatPrivKey, chatId, chatPK, peerChatPK) {
   if (!chatPrivKey || !chatId || !chatPK || !peerChatPK) {
-    throw new Error("chat actor key material required");
+    throw new Error("chat signing key material required");
   }
-  return deriveKey2(toBytes(chatPrivKey, "chat private key"), CHAT_ACTOR_SIGN_SCOPE, [chatId, ...orderKeys(chatPK, peerChatPK)]);
+  return deriveKey2(toBytes(chatPrivKey, "chat private key"), CHAT_SIGNING_SCOPE, [chatId, ...orderKeys(chatPK, peerChatPK)]);
 }
-function getChatActorKey(chatPrivKey, chatId, chatPK, peerChatPK) {
-  const secret = deriveChatActorSecret(chatPrivKey, chatId, chatPK, peerChatPK);
+function getChatSigningKey(chatPrivKey, chatId, chatPK, peerChatPK) {
+  const secret = deriveChatSigningSecret(chatPrivKey, chatId, chatPK, peerChatPK);
   try {
     return {
       secret,
@@ -93453,15 +93389,15 @@ function getChatActorKey(chatPrivKey, chatId, chatPK, peerChatPK) {
     throw error;
   }
 }
-function signChatBytes(actorKey, bytes) {
-  if (!actorKey?.secret || !actorKey?.publicKey) {
-    throw new Error("chat actor key required");
+function signChatBytes(signingKey, bytes) {
+  if (!signingKey?.secret || !signingKey?.publicKey) {
+    throw new Error("chat signing key required");
   }
-  return toHex(ed25519.sign(toBytes(bytes, "signing bytes"), actorKey.secret));
+  return toHex(ed25519.sign(toBytes(bytes, "signing bytes"), signingKey.secret));
 }
 function verifyChatBytes(publicKey, sig, bytes) {
   try {
-    return ed25519.verify(fromHexBytes(sig, "chat signature"), toBytes(bytes, "signed bytes"), fromHex(publicKey, "chat actor public key"));
+    return ed25519.verify(fromHexBytes(sig, "chat signature"), toBytes(bytes, "signed bytes"), fromHex(publicKey, "chat signing public key"));
   } catch {
     return false;
   }
@@ -93503,12 +93439,12 @@ async function openPair(chatPK, chatPrivKey, peerChatPK, options = {}) {
   const linkRoot = deriveKey2(secret, "chat-link-root-v1", orderedKeys);
   const root = chatId ? deriveKey2(secret, "chat-root-v2", [chatId, ...orderedKeys]) : null;
   const bodyKey = root ? deriveKey2(root, "chat-msg-body-key-v2") : null;
-  const actor = chatId ? getChatActorKey(privKeyBytes, chatId, chatPK, peerChatPK) : null;
+  const signingKey = chatId ? getChatSigningKey(privKeyBytes, chatId, chatPK, peerChatPK) : null;
   cleanBytes(sharedSecret);
-  return { linkId, chatId, chatPK, peerChatPK, linkRoot, root, bodyKey, actor };
+  return { linkId, chatId, chatPK, peerChatPK, linkRoot, root, bodyKey, signingKey };
 }
 function closePair(pair) {
-  cleanBytes(pair?.linkRoot, pair?.root, pair?.bodyKey, pair?.actor?.secret);
+  cleanBytes(pair?.linkRoot, pair?.root, pair?.bodyKey, pair?.signingKey?.secret);
 }
 function getPairAad(pair, scope, ...parts) {
   if (!pair?.chatId) {
@@ -93579,7 +93515,7 @@ function normalizePlainPayload(payload) {
   return payload;
 }
 function makeMsgAction(pair, head, message, options = {}) {
-  if (!pair?.chatId || !pair?.actor?.publicKey) {
+  if (!pair?.chatId || !pair?.signingKey?.publicKey) {
     throw new Error("chat action pair required");
   }
   const payload = getPayload(message);
@@ -93590,7 +93526,7 @@ function makeMsgAction(pair, head, message, options = {}) {
     id: cleanText(options?.id) || head.cid,
     ...target ? { target } : {},
     s: pair.chatPK,
-    actor: pair.actor.publicKey,
+    actor: pair.signingKey.publicKey,
     ts: Number.isFinite(options?.ts) ? options.ts : Date.now(),
     p: payload
   };
@@ -93643,12 +93579,12 @@ function unpackMsgBody(body) {
     ct: bytes.subarray(MSG_BODY_HEADER_BYTES)
   };
 }
-function expectedActorForSender(pair, sender, actors) {
+function expectedSigningKeyForSender(pair, sender, signingKeysByChatKey) {
   if (sender === pair?.chatPK) {
-    return cleanText(pair?.actor?.publicKey);
+    return cleanText(pair?.signingKey?.publicKey);
   }
-  if (sender === pair?.peerChatPK && actors && typeof actors === "object" && !Array.isArray(actors)) {
-    return cleanText(actors[sender]);
+  if (sender === pair?.peerChatPK && signingKeysByChatKey && typeof signingKeysByChatKey === "object" && !Array.isArray(signingKeysByChatKey)) {
+    return cleanText(signingKeysByChatKey[sender]);
   }
   return "";
 }
@@ -93665,17 +93601,17 @@ function normalizeOpenedAction(pair, head, action, options = {}) {
   if (sender !== pair.chatPK && sender !== pair.peerChatPK) {
     throw new Error("chat action sender mismatch");
   }
-  const actor = cleanText(action.actor);
-  const expectedActor = expectedActorForSender(pair, sender, options?.actors);
-  if (!expectedActor || actor !== expectedActor) {
-    throw new Error("chat action actor mismatch");
+  const signingPublicKey = cleanText(action.actor);
+  const expectedSigningPublicKey = expectedSigningKeyForSender(pair, sender, options?.signingKeysByChatKey);
+  if (!expectedSigningPublicKey || signingPublicKey !== expectedSigningPublicKey) {
+    throw new Error("chat action signer mismatch");
   }
   return {
     op,
     id,
     target: cleanText(action.target),
     sender,
-    actor,
+    signingPublicKey,
     ts: cleanActionTimestamp(action.ts),
     payload: normalizePlainPayload(action.p)
   };
@@ -93688,7 +93624,7 @@ async function sealMsgBody(pair, head, action) {
   const body = encoder.encode(JSON.stringify(action));
   try {
     const { nonce, ct } = await sealBox(pair.bodyKey, body, aad);
-    const sig = signChatBytes(pair.actor, getSignatureInput(aad, nonce, ct));
+    const sig = signChatBytes(pair.signingKey, getSignatureInput(aad, nonce, ct));
     return packMsgBody({ nonce, sig, ct });
   } finally {
     cleanBytes(body);
@@ -93704,31 +93640,31 @@ async function openMsgPlaintext(pair, nonce, ct, aad, options = {}) {
   }
   return openBox(pair.bodyKey, nonce, ct, aad);
 }
-async function verifyMsgSignature(actor, sig, bytes, options = {}) {
+async function verifyMsgSignature(signingPublicKey, sig, bytes, options = {}) {
   const crypto3 = options?.crypto;
   if (typeof crypto3?.isAvailable === "function" && !crypto3.isAvailable()) {
-    return verifyChatBytes(actor, toHex(sig), bytes);
+    return verifyChatBytes(signingPublicKey, toHex(sig), bytes);
   }
   if (typeof crypto3?.verifyChatBytes === "function") {
-    return crypto3.verifyChatBytes(actor, sig, bytes);
+    return crypto3.verifyChatBytes(signingPublicKey, sig, bytes);
   }
-  return verifyChatBytes(actor, toHex(sig), bytes);
+  return verifyChatBytes(signingPublicKey, toHex(sig), bytes);
 }
-function expectedSignatureActors(pair, actors) {
+function expectedSigningKeys(pair, signingKeysByChatKey) {
   const values = [];
   const seen = new Set;
   const add3 = (value) => {
-    const actor = cleanText(value);
-    if (!actor || seen.has(actor)) {
+    const signingPublicKey = cleanText(value);
+    if (!signingPublicKey || seen.has(signingPublicKey)) {
       return;
     }
-    seen.add(actor);
-    values.push(actor);
+    seen.add(signingPublicKey);
+    values.push(signingPublicKey);
   };
-  add3(pair?.actor?.publicKey);
-  if (actors && typeof actors === "object" && !Array.isArray(actors)) {
-    add3(actors[pair?.chatPK]);
-    add3(actors[pair?.peerChatPK]);
+  add3(pair?.signingKey?.publicKey);
+  if (signingKeysByChatKey && typeof signingKeysByChatKey === "object" && !Array.isArray(signingKeysByChatKey)) {
+    add3(signingKeysByChatKey[pair?.chatPK]);
+    add3(signingKeysByChatKey[pair?.peerChatPK]);
   }
   return values;
 }
@@ -93736,12 +93672,12 @@ async function verifyExpectedSignatureBeforeOpen(pair, sig, bytes, options = {})
   if (!options?.crypto?.preverifyBeforeOpen) {
     return true;
   }
-  const actors = expectedSignatureActors(pair, options?.actors);
-  if (actors.length < 2) {
+  const signingKeysByChatKey = expectedSigningKeys(pair, options?.signingKeysByChatKey);
+  if (signingKeysByChatKey.length < 2) {
     return true;
   }
-  for (const actor of actors) {
-    if (await verifyMsgSignature(actor, sig, bytes, options)) {
+  for (const signingPublicKey of signingKeysByChatKey) {
+    if (await verifyMsgSignature(signingPublicKey, sig, bytes, options)) {
       return true;
     }
   }
@@ -93773,7 +93709,7 @@ async function openMsg(pair, data, options = {}) {
   try {
     const action = JSON.parse(decoder.decode(plaintext));
     const normalized = normalizeOpenedAction(pair, head, action, options);
-    if (!await verifyMsgSignature(normalized.actor, sig, signatureInput, options)) {
+    if (!await verifyMsgSignature(normalized.signingPublicKey, sig, signatureInput, options)) {
       throw new Error("invalid chat action signature");
     }
     return {
@@ -93783,7 +93719,7 @@ async function openMsg(pair, data, options = {}) {
       actionId: normalized.id,
       actionOp: normalized.op,
       actionTarget: normalized.target,
-      actor: normalized.actor,
+      signingPublicKey: normalized.signingPublicKey,
       from: normalized.sender,
       s: normalized.sender
     };
@@ -93894,9 +93830,11 @@ function entryAad(entryId) {
 async function sealOwnChatEntry(chatPrivKey, entryId, entry) {
   const key = entryKey(chatPrivKey, entryId);
   try {
+    const { signingKeysByChatKey, ...entryFields } = entry || {};
     const body = {
       v: CHAT_ENTRY_VERSION,
-      ...entry,
+      ...entryFields,
+      actors: signingKeysByChatKey || {},
       settings: normalizeChatSettings(entry?.settings)
     };
     const { nonce, ct } = await sealJson(key, body, entryAad(entryId));
@@ -93913,8 +93851,10 @@ async function openOwnChatEntry(chatPrivKey, entryId, body) {
     if (entry?.v !== CHAT_ENTRY_VERSION || !entry?.linkId || !entry?.chatId || !entry?.peerChatPK) {
       throw new Error("invalid chat entry");
     }
+    const { actors, ...entryFields } = entry;
     return {
-      ...entry,
+      ...entryFields,
+      signingKeysByChatKey: actors || {},
       settings: normalizeChatSettings(entry.settings)
     };
   } finally {
@@ -93928,10 +93868,10 @@ function makeOwnChatEntry(pair, fields = {}) {
     chatId: pair.chatId,
     peerChatPK: pair.peerChatPK,
     peerUid: cleanText(fields.peerUid),
-    actors: {
-      ...fields.actors || {},
-      [pair.chatPK]: pair.actor.publicKey,
-      ...fields.peerActorPK ? { [pair.peerChatPK]: fields.peerActorPK } : {}
+    signingKeysByChatKey: {
+      ...fields.signingKeysByChatKey || {},
+      [pair.chatPK]: pair.signingKey.publicKey,
+      ...fields.peerSigningPublicKey ? { [pair.peerChatPK]: fields.peerSigningPublicKey } : {}
     },
     settings: normalizeChatSettings(fields.settings),
     preview: fields.preview || null,
@@ -93967,7 +93907,7 @@ async function sealPing(senderChatPK, senderPrivKey, recipientChatPK, fields = {
   let key = null;
   try {
     pair = await openChatPair(senderChatPK, senderPrivKey, recipientChatPK, { chatId: fields.chatId });
-    if (!pair?.chatId || !pair?.actor?.publicKey || !pair?.linkRoot) {
+    if (!pair?.chatId || !pair?.signingKey?.publicKey || !pair?.linkRoot) {
       throw new Error("chat ping pair required");
     }
     eph = getKeyPair(randomBytes3(32));
@@ -93983,7 +93923,7 @@ async function sealPing(senderChatPK, senderPrivKey, recipientChatPK, fields = {
       chatId: pair.chatId,
       senderChatPK,
       senderUid: cleanText(fields.senderUid),
-      actorPK: pair.actor.publicKey,
+      actorPK: pair.signingKey.publicKey,
       messageId: cleanText(fields.messageId),
       ts: Number.isFinite(fields.ts) ? fields.ts : Date.now()
     };
@@ -94013,26 +93953,27 @@ async function openPing(chatPK, chatPrivKey, ping) {
   const key = deriveKey2(shared.subarray(0, 32), "chat-inbox-ping-v1", [epk, chatPK]);
   try {
     const { nonce, ct } = unpackBodyData(ping.body);
-    const payload = await openJson(key, nonce, ct, canonicalBytes({ v: CHAT_PING_VERSION, epk }, "chat ping aad"));
-    const senderChatPK = cleanText(payload?.senderChatPK);
-    if (!senderChatPK || payload?.v !== CHAT_PING_VERSION || payload?.protocol !== CHAT_PROTOCOL_VERSION) {
+    const wirePayload = await openJson(key, nonce, ct, canonicalBytes({ v: CHAT_PING_VERSION, epk }, "chat ping aad"));
+    const senderChatPK = cleanText(wirePayload?.senderChatPK);
+    if (!senderChatPK || wirePayload?.v !== CHAT_PING_VERSION || wirePayload?.protocol !== CHAT_PROTOCOL_VERSION) {
       throw new Error("invalid chat ping payload");
     }
     linkPair = await openChatPair(chatPK, chatPrivKey, senderChatPK);
-    if (payload.linkId !== linkPair.linkId || payload.proof !== pingProof(linkPair.linkRoot, payload)) {
+    if (wirePayload.linkId !== linkPair.linkId || wirePayload.proof !== pingProof(linkPair.linkRoot, wirePayload)) {
       throw new Error("invalid chat ping proof");
     }
-    const pair = await openChatPair(chatPK, chatPrivKey, senderChatPK, { chatId: payload.chatId });
-    if (!pair?.chatId || !pair?.actor?.publicKey) {
+    const pair = await openChatPair(chatPK, chatPrivKey, senderChatPK, { chatId: wirePayload.chatId });
+    if (!pair?.chatId || !pair?.signingKey?.publicKey) {
       closeChatPair(pair);
       throw new Error("invalid chat ping chat");
     }
+    const { actorPK, ...payloadFields } = wirePayload;
     return {
       pair,
       payload: {
-        ...payload,
+        ...payloadFields,
         senderChatPK,
-        actorPK: cleanText(payload.actorPK)
+        signingPublicKey: cleanText(actorPK)
       }
     };
   } finally {
@@ -94049,27 +93990,24 @@ function makeTtlMs(value) {
   const ms = timestampMs(value, null, { positive: true });
   return ms == null ? null : ms;
 }
-function getMessageTtlMs(retention) {
-  return makeTtlMs(newMessageTtlMs(retention));
+function newStorageTtlMs() {
+  return makeTtlMs(newMessageStorageTtlMs());
 }
 async function profileByChatPK(cloud, chatPK) {
   if (!cloud || !chatPK) {
     return null;
   }
-  const peer = await cloud.search.peer.byChatPK(chatPK).catch(() => null);
+  const peer = await cloud.search.peer.byChatPK(chatPK);
   if (!peer) {
     return null;
   }
-  return {
-    uid: cleanText(peer.uid),
-    actorPK: cleanText(peer.actorPK)
-  };
+  return { uid: cleanText(peer.uid) };
 }
 async function readOwnEntry(cloud, uid, chatPrivKey, entryId) {
   if (!cloud || !uid || !chatPrivKey || !entryId) {
     return null;
   }
-  const record = await cloud.user.chats.read(uid, entryId).catch(() => null);
+  const record = await cloud.user.chats.read(uid, entryId);
   if (!record) {
     return null;
   }
@@ -94103,16 +94041,16 @@ async function ownEntryWrite(cloud, uid, chatPrivKey, pair, fields = {}) {
   }
   const entryId = ownChatEntryId(chatPrivKey, pair.chatId);
   const existing = fields.entry || await readOwnEntry(cloud, uid, chatPrivKey, entryId);
-  const peerActorPK = cleanText(fields.peerActorPK) || cleanText(existing?.actors?.[pair.peerChatPK]);
-  const actors = {
-    ...existing?.actors || {},
-    [pair.chatPK]: pair.actor.publicKey,
-    ...peerActorPK ? { [pair.peerChatPK]: peerActorPK } : {}
+  const peerSigningPublicKey = cleanText(fields.peerSigningPublicKey) || cleanText(existing?.signingKeysByChatKey?.[pair.peerChatPK]);
+  const signingKeysByChatKey = {
+    ...existing?.signingKeysByChatKey || {},
+    [pair.chatPK]: pair.signingKey.publicKey,
+    ...peerSigningPublicKey ? { [pair.peerChatPK]: peerSigningPublicKey } : {}
   };
   const entry = makeOwnChatEntry(pair, {
     peerUid: fields.peerUid || existing?.peerUid,
-    peerActorPK,
-    actors,
+    peerSigningPublicKey,
+    signingKeysByChatKey,
     settings: fields.settings || existing?.settings,
     preview: fields.preview || existing?.preview,
     saved: existing?.saved || null,
@@ -94156,9 +94094,9 @@ async function recipientForSend(cloud, receiverChatPK, options, needed) {
     return null;
   }
   const uid = cleanText(options?.receiverUid);
-  const actorPK = cleanText(options?.peerActorPK);
+  const signingPublicKey = cleanText(options?.peerSigningPublicKey);
   if (uid) {
-    return { uid, actorPK };
+    return { uid, signingPublicKey };
   }
   return profileByChatPK(cloud, receiverChatPK);
 }
@@ -94180,7 +94118,7 @@ async function sendMsg(cloud, senderPubkey, senderPrivkey, receiverChatPK, messa
   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 ? getMessageTtlMs(retention) : null;
+  const ttlMs = actionOp === CHAT_ACTION_OPS.CREATE ? newStorageTtlMs() : null;
   const messageId = cleanText(options?.messageId) || await cloud.chat.messages.id(chatId);
   const msgData = {
     head,
@@ -94192,7 +94130,7 @@ async function sendMsg(cloud, senderPubkey, senderPrivkey, receiverChatPK, messa
   const preview = updatePreview ? sentMessage : null;
   const ownerEntry = updatePreview ? await ownEntryWrite(cloud, cleanText(options?.senderUid), senderPrivkey, pair, {
     peerUid: recipientProfile?.uid || cleanText(options?.receiverUid),
-    peerActorPK: recipientProfile?.actorPK,
+    peerSigningPublicKey: recipientProfile?.signingPublicKey,
     entry: options?.ownEntry,
     settings: options?.chatSettings,
     preview,
@@ -94213,7 +94151,7 @@ async function sendMsg(cloud, senderPubkey, senderPrivkey, receiverChatPK, messa
     message: msgData,
     ownerEntry,
     inbox: ping ? { recipientUid: recipientProfile?.uid, ping } : null,
-    onCommitted: options?.onCommitted
+    onCommitted: typeof options?.onCommitted === "function" ? (committed) => options.onCommitted({ ...committed, message: sentMessage, preview }) : undefined
   });
   return { chatId, msgId: messageId, cid: head.cid, message: sentMessage, preview, ...write?.skipped ? { skipped: true } : {} };
 }
@@ -94276,7 +94214,7 @@ function messagePermanentUpdateItems(messages) {
 function messageTemporaryUpdateItems(messages) {
   return messageMutationItems(messages, { include: (message) => message?.ttl == null });
 }
-async function makeMsgTemporary(cloud, chatId, messages, ttlMs = newMessageTtlMs()) {
+async function makeMsgTemporary(cloud, chatId, messages, ttlMs = newMessageStorageTtlMs()) {
   const nextTtlMs = makeTtlMs(ttlMs);
   const items = messageTemporaryUpdateItems(messages);
   if (!cloud || !chatId || !nextTtlMs || !items.length) {
@@ -94285,7 +94223,7 @@ async function makeMsgTemporary(cloud, chatId, messages, ttlMs = newMessageTtlMs
   if (typeof cloud.chat?.messages?.ttl !== "function") {
     throw new Error("message ttl unavailable");
   }
-  const result = await cloud.chat.messages.ttl(chatId, items, { permanent: false, ttlMs: nextTtlMs });
+  const result = await cloud.chat.messages.ttl(chatId, items, { permanent: false, ttlMs: nextTtlMs, releaseMediaHold: true });
   return Number.isFinite(result?.updated) ? result.updated : items.length;
 }
 async function makeMsgPermanent(cloud, chatId, messages) {
@@ -94310,7 +94248,7 @@ async function setChatRetention(cloud, chatId, senderPubkey, senderPrivkey, peer
   }
   const systemMessage = {
     ...makeRetentionSystemMsg(nextRetention),
-    cid: makeCid(),
+    cid: cleanText(options?.cid) || makeCid(),
     s: senderPubkey
   };
   await sendMsg(cloud, senderPubkey, senderPrivkey, peerChatPK, systemMessage, {
@@ -94321,7 +94259,8 @@ async function setChatRetention(cloud, chatId, senderPubkey, senderPrivkey, peer
     chatExists: true,
     senderUid: options?.senderUid,
     ownEntry: options?.ownEntry,
-    chatSettings: { retention: nextRetention }
+    chatSettings: { retention: nextRetention },
+    onCommitted: options?.onCommitted
   });
   return nextRetention;
 }
@@ -94349,7 +94288,7 @@ async function updateMsg(cloud, chatId, msgId, senderPubkey, senderPrivkey, rece
   const preview = updatePreview ? ownerEditedPreview(senderPubkey, newMessage) : null;
   const ownerEntry = updatePreview ? await ownEntryWrite(cloud, cleanText(options?.senderUid), senderPrivkey, pair, {
     peerUid: cleanText(options?.receiverUid),
-    peerActorPK: cleanText(options?.peerActorPK),
+    peerSigningPublicKey: cleanText(options?.peerSigningPublicKey),
     entry: options?.ownEntry,
     preview,
     ts: preview?.ts ?? tsMs
@@ -94491,7 +94430,7 @@ async function decryptMsg(msgData, userChatPK, userPrivKey, peerChatPK, options
   }
   try {
     const pair = await getCachedPair(userChatPK, userPrivKey, peerChatPK, { chatId: options?.chatId });
-    const message = await openMsg(pair, msgData, { actors: options?.actors, crypto: options?.crypto });
+    const message = await openMsg(pair, msgData, { signingKeysByChatKey: options?.signingKeysByChatKey, crypto: options?.crypto });
     return normalizeDecryptedMsg(msgData, message);
   } catch {
     return null;
@@ -94513,7 +94452,7 @@ function normalizeChatPreview(msgData, message) {
   return canRenderChatPreview(normalized) ? normalized : null;
 }
 async function readExistingEntry(cloud, uid, userPrivKey, entryId) {
-  const entry = await cloud.user.chats.read(uid, entryId).catch(() => null);
+  const entry = await cloud.user.chats.read(uid, entryId);
   if (!entry) {
     return null;
   }
@@ -94539,11 +94478,11 @@ function isReadPing(ping) {
 function isDeletePing(ping) {
   return pingKind(ping) === CHAT_PING_KIND_DELETE;
 }
-function pingActors(ping, existing) {
+function pingSigningKeys(ping, existing) {
   return {
-    ...existing?.actors || {},
-    [ping.pair.chatPK]: ping.pair.actor.publicKey,
-    [ping.payload.senderChatPK]: ping.payload.actorPK
+    ...existing?.signingKeysByChatKey || {},
+    [ping.pair.chatPK]: ping.pair.signingKey.publicKey,
+    [ping.payload.senderChatPK]: ping.payload.signingPublicKey
   };
 }
 function chatFromPing(ping, entryId, existing, preview, userChatPK, ms) {
@@ -94560,7 +94499,7 @@ function chatFromPing(ping, entryId, existing, preview, userChatPK, ms) {
     entryId,
     peerChatPK: ping.payload.senderChatPK,
     peerUid: existing?.peerUid || cleanText(ping.payload.senderUid) || null,
-    actors: pingActors(ping, existing),
+    signingKeysByChatKey: pingSigningKeys(ping, existing),
     settings: existing?.settings,
     saved: existing?.saved || null,
     readMs,
@@ -94576,27 +94515,27 @@ async function resolvePingUid(cloud, payload) {
     return null;
   }
   if (claimedUid) {
-    const peer2 = await cloud.peer.read(claimedUid).catch(() => null);
+    const peer2 = await cloud.peer.read(claimedUid);
     if (cleanText(peer2?.chatPK) !== senderChatPK) {
       throw new Error("ping sender uid mismatch");
     }
     return claimedUid;
   }
-  const peer = await cloud.search.peer.byChatPK(senderChatPK).catch(() => null);
+  const peer = await cloud.search.peer.byChatPK(senderChatPK);
   return peer?.uid || null;
 }
-async function readPingMsg(cloud, userChatPK, userPrivKey, ping, actors, options = {}) {
+async function readPingMsg(cloud, userChatPK, userPrivKey, ping, signingKeysByChatKey, options = {}) {
   const chatId = ping?.pair?.chatId;
   const messageId = cleanText(ping?.payload?.messageId);
   const peerChatPK = cleanText(ping?.payload?.senderChatPK);
   if (!cloud || !chatId || !messageId || !userChatPK || !userPrivKey || !peerChatPK) {
     return null;
   }
-  const data = await cloud.chat.messages.read(chatId, messageId).catch(() => null);
+  const data = await cloud.chat.messages.read(chatId, messageId);
   if (!data) {
     return null;
   }
-  const message = await decryptMsg(data, userChatPK, userPrivKey, peerChatPK, { actors, chatId }).catch(() => null);
+  const message = await decryptMsg(data, userChatPK, userPrivKey, peerChatPK, { signingKeysByChatKey, chatId }).catch(() => null);
   const normalized = message ? { ...message, id: data.id, ts: data.ts ?? message.ts, ttl: data.ttl ?? message.ttl } : null;
   if (options.raw === true) {
     return normalized;
@@ -94606,19 +94545,19 @@ async function readPingMsg(cloud, userChatPK, userPrivKey, ping, actors, options
 }
 async function savePing(cloud, uid, userChatPK, userPrivKey, ping, options = {}) {
   const chatId = ping?.pair?.chatId;
-  if (!chatId || !cleanText(ping?.payload?.actorPK) || !cleanText(ping?.payload?.senderChatPK)) {
+  if (!chatId || !cleanText(ping?.payload?.signingPublicKey) || !cleanText(ping?.payload?.senderChatPK)) {
     return false;
   }
   const entryId = ownChatEntryId(userPrivKey, chatId);
   const existing = options.existing || await readExistingEntry(cloud, uid, userPrivKey, entryId);
   const peerUid = options.peerUid || await resolvePingUid(cloud, ping.payload);
-  const actors = options.actors || pingActors(ping, existing);
+  const signingKeysByChatKey = options.signingKeysByChatKey || pingSigningKeys(ping, existing);
   const hasPreview = Object.prototype.hasOwnProperty.call(options, "preview");
-  const preview = hasPreview ? options.preview : await readPingMsg(cloud, userChatPK, userPrivKey, ping, actors);
+  const preview = hasPreview ? options.preview : await readPingMsg(cloud, userChatPK, userPrivKey, ping, signingKeysByChatKey);
   const entry = makeOwnChatEntry(ping.pair, {
     peerUid: peerUid || existing?.peerUid,
-    peerActorPK: ping.payload.actorPK || existing?.actors?.[ping.payload.senderChatPK],
-    actors,
+    peerSigningPublicKey: ping.payload.signingPublicKey || existing?.signingKeysByChatKey?.[ping.payload.senderChatPK],
+    signingKeysByChatKey,
     settings: existing?.settings,
     preview: preview || existing?.preview,
     readMs: existing?.readMs
@@ -94661,7 +94600,7 @@ async function processInbox(cloud, uid, userChatPK, userPrivKey, options = {}) {
   if (!cloud || !uid || !userChatPK || !userPrivKey) {
     return false;
   }
-  const inboxItems = await cloud.inbox.list(uid).catch(() => null);
+  const inboxItems = await cloud.inbox.list(uid);
   if (!inboxItems?.length) {
     return false;
   }
@@ -94716,9 +94655,9 @@ async function processInbox(cloud, uid, userChatPK, userPrivKey, options = {}) {
       if (group.message) {
         const item = group.message;
         const entryId = ownChatEntryId(userPrivKey, item.chatId);
-        const actors = pingActors(item.ping, current);
+        const signingKeysByChatKey = pingSigningKeys(item.ping, current);
         const existingMs = timestampMs(current?.preview?.ts, 0) ?? 0;
-        const preview = existingMs >= item.ms ? current?.preview || null : await readPingMsg(cloud, userChatPK, userPrivKey, item.ping, actors);
+        const preview = existingMs >= item.ms ? current?.preview || null : await readPingMsg(cloud, userChatPK, userPrivKey, item.ping, signingKeysByChatKey);
         const chat = chatFromPing(item.ping, entryId, current, preview, userChatPK, item.ms);
         if (chat) {
           current = chat;
@@ -94728,7 +94667,7 @@ async function processInbox(cloud, uid, userChatPK, userPrivKey, options = {}) {
         }
         wrote = await savePing(cloud, uid, userChatPK, userPrivKey, item.ping, {
           existing: current,
-          actors,
+          signingKeysByChatKey,
           preview
         });
       }
@@ -94736,8 +94675,8 @@ async function processInbox(cloud, uid, userChatPK, userPrivKey, options = {}) {
         const item = group.read;
         const entryId = ownChatEntryId(userPrivKey, item.chatId);
         const existing = current || await readExistingEntry(cloud, uid, userPrivKey, entryId);
-        const actors = pingActors(item.ping, existing);
-        const receiptPreview = await readPingMsg(cloud, userChatPK, userPrivKey, item.ping, actors);
+        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);
         handled = true;
@@ -94750,7 +94689,7 @@ async function processInbox(cloud, uid, userChatPK, userPrivKey, options = {}) {
           const writeExisting = chat || existing;
           wrote = await savePing(cloud, uid, userChatPK, userPrivKey, item.ping, {
             existing: writeExisting,
-            actors,
+            signingKeysByChatKey,
             preview: openedPreview,
             writeTs: false
           }) || wrote;
@@ -94760,8 +94699,8 @@ async function processInbox(cloud, uid, userChatPK, userPrivKey, options = {}) {
         const item = group.delete;
         const entryId = ownChatEntryId(userPrivKey, item.chatId);
         const existing = current || await readExistingEntry(cloud, uid, userPrivKey, entryId);
-        const actors = pingActors(item.ping, existing);
-        const deletePreview = await readPingMsg(cloud, userChatPK, userPrivKey, item.ping, actors, { raw: true });
+        const signingKeysByChatKey = pingSigningKeys(item.ping, existing);
+        const deletePreview = await readPingMsg(cloud, userChatPK, userPrivKey, item.ping, signingKeysByChatKey, { raw: true });
         const deletedPreview = patchDeletePingPreview(existing, deletePreview);
         const chat = deletedPreview ? chatFromPing(item.ping, entryId, current || existing, deletedPreview, userChatPK, item.ms) : null;
         handled = true;
@@ -94774,7 +94713,7 @@ async function processInbox(cloud, uid, userChatPK, userPrivKey, options = {}) {
           const writeExisting = chat || existing;
           wrote = await savePing(cloud, uid, userChatPK, userPrivKey, item.ping, {
             existing: writeExisting,
-            actors,
+            signingKeysByChatKey,
             preview: deletedPreview
           }) || wrote;
         }
@@ -94943,7 +94882,7 @@ async function getChat(cloud, uid, chatId, userChatPK, userPrivKey) {
     return null;
   }
   const entryId = ownChatEntryId(userPrivKey, chatId);
-  const entry = await cloud.user.chats.read(uid, entryId).catch(() => null);
+  const entry = await cloud.user.chats.read(uid, entryId);
   if (!entry) {
     return null;
   }
@@ -94978,7 +94917,7 @@ async function decryptChatEntry(entryRecord, userChatPK, userPrivKey) {
     entryId: entryRecord.id,
     peerChatPK: entry.peerChatPK,
     peerUid: entry.peerUid || null,
-    actors: entry.actors || {},
+    signingKeysByChatKey: entry.signingKeysByChatKey || {},
     settings: entry.settings,
     saved: entry.saved || null,
     readMs,
@@ -95236,7 +95175,7 @@ function createChatActions({ readCloud, readSession, inbox, peers }) {
       chatId: chat.id,
       senderUid: active.uid,
       receiverUid: chat.peerUid,
-      peerActorPK: chat.actors?.[chat.peerChatPK],
+      peerSigningPublicKey: chat.signingKeysByChatKey?.[chat.peerChatPK],
       ownEntry: chat.entryId ? chat : null,
       chatSettings: normalizeChatSettings(chat.settings)
     };
@@ -95257,10 +95196,7 @@ function createChatActions({ readCloud, readSession, inbox, peers }) {
       ...chat,
       peerChatPK,
       peerUid: profile.uid || chat.peerUid || null,
-      actors: {
-        ...chat.actors || {},
-        ...peerChatPK && profile.actorPK ? { [peerChatPK]: profile.actorPK } : {}
-      }
+      signingKeysByChatKey: chat.signingKeysByChatKey || {}
     };
   }
   async function list(options = {}) {
@@ -95284,11 +95220,11 @@ function createChatActions({ readCloud, readSession, inbox, peers }) {
       if (chat) {
         return withPeerProfile(chat, profile2);
       }
-      const link = await resolvePeerChat(readCloud(), active.chatPK, active.chatPrivKey, profile2.chatPK, options).catch(() => null);
+      const link = await resolvePeerChat(readCloud(), active.chatPK, active.chatPrivKey, profile2.chatPK, options);
       if (!link?.chatId) {
         return null;
       }
-      const linkedChat = await getChat(readCloud(), active.uid, link.chatId, active.chatPK, active.chatPrivKey).catch(() => null);
+      const linkedChat = await getChat(readCloud(), active.uid, link.chatId, active.chatPK, active.chatPrivKey);
       return withPeerProfile(linkedChat, profile2);
     };
     if (CHAT_PK_RE.test(value)) {
@@ -95296,12 +95232,12 @@ function createChatActions({ readCloud, readSession, inbox, peers }) {
       if (chat) {
         return chat;
       }
-      const profile2 = await peers.resolve(value).catch(() => null);
+      const profile2 = await peers.resolve(value);
       const resolvedChat = await chatByProfile(profile2);
       if (resolvedChat) {
         return resolvedChat;
       }
-      return getChat(readCloud(), active.uid, value, active.chatPK, active.chatPrivKey).catch(() => null);
+      return getChat(readCloud(), active.uid, value, active.chatPK, active.chatPrivKey);
     }
     const profile = await peers.resolve(peer);
     return chatByProfile(profile);
@@ -95311,7 +95247,7 @@ function createChatActions({ readCloud, readSession, inbox, peers }) {
     const decrypted = [];
     for (const record of page.records || []) {
       const message = await decryptMsg(record, active.chatPK, active.chatPrivKey, chat.peerChatPK, {
-        actors: chat.actors,
+        signingKeysByChatKey: chat.signingKeysByChatKey,
         chatId: chat.id
       });
       if (message) {
@@ -95340,7 +95276,7 @@ function createChatActions({ readCloud, readSession, inbox, peers }) {
             senderUid: active.uid,
             receiverUid: chat.peerUid,
             linkId: chat.linkId,
-            peerActorPK: chat.actors?.[chat.peerChatPK],
+            peerSigningPublicKey: chat.signingKeysByChatKey?.[chat.peerChatPK],
             ping: true
           }).catch(() => {});
         }
@@ -95369,9 +95305,9 @@ function createChatActions({ readCloud, readSession, inbox, peers }) {
     if (message) {
       return { active, chat, message, target: getMessageKey(message) || target };
     }
-    const record = await readCloud().chat.messages.read(chat.id, target).catch(() => null);
+    const record = await readCloud().chat.messages.read(chat.id, target);
     const direct = record ? await decryptMsg(record, active.chatPK, active.chatPrivKey, chat.peerChatPK, {
-      actors: chat.actors,
+      signingKeysByChatKey: chat.signingKeysByChatKey,
       chatId: chat.id
     }) : null;
     if (!direct) {
@@ -95420,8 +95356,7 @@ function createChatActions({ readCloud, readSession, inbox, peers }) {
       linkVersion: link.version,
       protocol: link.protocol,
       senderUid: active.uid,
-      receiverUid: profile.uid,
-      peerActorPK: profile.actorPK
+      receiverUid: profile.uid
     });
     return {
       chat: {
@@ -96792,7 +96727,7 @@ function createMoneyActions({ readCloud, readSession, resolvePeer, sendPayload }
     }
     const record = await readCloud().chat.messages.read(chat.id, messageId);
     const message = await decryptMsg(record, active.chatPK, active.chatPrivKey, chat.peerChatPK, {
-      actors: chat.actors,
+      signingKeysByChatKey: chat.signingKeysByChatKey,
       chatId: chat.id
     });
     if (!message || message.t !== "req") {
@@ -96815,7 +96750,7 @@ function createMoneyActions({ readCloud, readSession, resolvePeer, sendPayload }
       senderUid: active.uid,
       receiverUid: chat.peerUid,
       linkId: chat.linkId,
-      peerActorPK: chat.actors?.[chat.peerChatPK]
+      peerSigningPublicKey: chat.signingKeysByChatKey?.[chat.peerChatPK]
     });
     return {
       ...paid,
@@ -98115,7 +98050,7 @@ replaceTraps((oldTraps) => ({
   has: (target, prop) => !!getMethod2(target, prop) || oldTraps.has(target, prop)
 }));
 
-// ../../node_modules/.bun/@firebase+app@0.15.0/node_modules/@firebase/app/dist/esm/index.esm.js
+// ../../node_modules/.bun/@firebase+app@0.15.1/node_modules/@firebase/app/dist/esm/index.esm.js
 class PlatformLoggerServiceImpl {
   constructor(container) {
     this.container = container;
@@ -98137,7 +98072,7 @@ function isVersionServiceProvider(provider) {
   return component?.type === "VERSION";
 }
 var name$q = "@firebase/app";
-var version$1 = "0.15.0";
+var version$1 = "0.15.1";
 var logger2 = new Logger2("@firebase/app");
 var name$p = "@firebase/app-compat";
 var name$o = "@firebase/analytics-compat";
@@ -98165,7 +98100,7 @@ var name$3 = "@firebase/firestore";
 var name$2 = "@firebase/ai";
 var name$1 = "@firebase/firestore-compat";
 var name2 = "firebase";
-var version2 = "12.15.0";
+var version2 = "12.16.0";
 var DEFAULT_ENTRY_NAME2 = "[DEFAULT]";
 var PLATFORM_LOG_STRING = {
   [name$q]: "fire-core",
@@ -98615,12 +98550,12 @@ function registerCoreComponents(variant) {
 }
 registerCoreComponents("");
 
-// ../../node_modules/.bun/firebase@12.15.0+419ecb626e0dfd90/node_modules/firebase/app/dist/index.mjs
+// ../../node_modules/.bun/firebase@12.16.0+419ecb626e0dfd90/node_modules/firebase/app/dist/index.mjs
 var name3 = "firebase";
-var version3 = "12.15.0";
+var version3 = "12.16.0";
 registerVersion(name3, version3, "app");
 
-// ../../node_modules/.bun/@firebase+auth@1.13.3+92862aca8e915725/node_modules/@firebase/auth/dist/node-esm/totp-65577477.js
+// ../../node_modules/.bun/@firebase+auth@1.13.3+8807f692d12224be/node_modules/@firebase/auth/dist/node-esm/totp-65577477.js
 function _prodErrorMap() {
   return {
     ["dependent-sdk-initialized-before-auth"]: "Another Firebase SDK was initialized and is trying to use Auth before Auth is " + "initialized. Please be sure to call `initializeAuth` or `getAuth` before " + "starting any other Firebase SDK."
@@ -101913,7 +101848,7 @@ var Md5;
   Integer = bloom_blob_es2018.Integer = t;
 }).apply(typeof commonjsGlobal !== "undefined" ? commonjsGlobal : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {});
 
-// ../../node_modules/.bun/@firebase+firestore@4.16.0+5bd1f26d8863c124/node_modules/@firebase/firestore/dist/common-cc96d03b.node.mjs
+// ../../node_modules/.bun/@firebase+firestore@4.16.0+80db1b7a714a6e79/node_modules/@firebase/firestore/dist/common-cc96d03b.node.mjs
 var grpc = __toESM(require_src3(), 1);
 var protoLoader = __toESM(require_src2(), 1);
 import { TextEncoder as TextEncoder2, inspect as inspect2, TextDecoder as TextDecoder2 } from "util";
@@ -106116,7 +106051,7 @@ class RE2JS {
   }
 }
 
-// ../../node_modules/.bun/@firebase+firestore@4.16.0+5bd1f26d8863c124/node_modules/@firebase/firestore/dist/common-cc96d03b.node.mjs
+// ../../node_modules/.bun/@firebase+firestore@4.16.0+80db1b7a714a6e79/node_modules/@firebase/firestore/dist/common-cc96d03b.node.mjs
 class User {
   constructor(uid) {
     this.uid = uid;
@@ -110822,6 +110757,31 @@ function toMutationDocument(serializer, key, fields) {
     fields: fields.value.mapValue.fields
   };
 }
+function fromFound(serializer, doc) {
+  hardAssert(!!doc.found, 43571);
+  assertPresent(doc.found.name);
+  assertPresent(doc.found.updateTime);
+  const key = fromName(serializer, doc.found.name);
+  const version6 = fromVersion(doc.found.updateTime);
+  const createTime = doc.found.createTime ? fromVersion(doc.found.createTime) : SnapshotVersion.min();
+  const data = new ObjectValue({ mapValue: { fields: doc.found.fields } });
+  return MutableDocument.newFoundDocument(key, version6, createTime, data);
+}
+function fromMissing(serializer, result) {
+  hardAssert(!!result.missing, 3894);
+  hardAssert(!!result.readTime, 22933);
+  const key = fromName(serializer, result.missing);
+  const version6 = fromVersion(result.readTime);
+  return MutableDocument.newNoDocument(key, version6);
+}
+function fromBatchGetDocumentsResponse(serializer, result) {
+  if ("found" in result) {
+    return fromFound(serializer, result);
+  } else if ("missing" in result) {
+    return fromMissing(serializer, result);
+  }
+  return fail(7234, { result });
+}
 function fromWatchChange(serializer, change) {
   let watchChange;
   if ("targetChange" in change) {
@@ -116699,6 +116659,34 @@ class DatastoreImpl extends Datastore {
 function newDatastore(authCredentials, appCheckCredentials, connection, serializer) {
   return new DatastoreImpl(authCredentials, appCheckCredentials, connection, serializer);
 }
+async function invokeCommitRpc(datastore, mutations) {
+  const datastoreImpl = debugCast(datastore);
+  const request = {
+    writes: mutations.map((m) => toMutation(datastoreImpl.serializer, m))
+  };
+  await datastoreImpl.invokeRPC("Commit", datastoreImpl.serializer.databaseId, ResourcePath.emptyPath(), request);
+}
+async function invokeBatchGetDocumentsRpc(datastore, keys) {
+  const datastoreImpl = debugCast(datastore);
+  const request = {
+    documents: keys.map((k) => toName(datastoreImpl.serializer, k))
+  };
+  const response = await datastoreImpl.invokeStreamingRPC("BatchGetDocuments", datastoreImpl.serializer.databaseId, ResourcePath.emptyPath(), request, keys.length);
+  const docs = new Map;
+  response.forEach((proto) => {
+    const doc = fromBatchGetDocumentsResponse(datastoreImpl.serializer, proto);
+    docs.set(doc.key.toString(), doc);
+  });
+  const result = [];
+  keys.forEach((key) => {
+    const doc = docs.get(key.toString());
+    hardAssert(!!doc, 55234, {
+      key
+    });
+    result.push(doc);
+  });
+  return result;
+}
 function newPersistentWriteStream(datastore, queue, listener) {
   const datastoreImpl = debugCast(datastore);
   datastoreImpl.verifyInitialized();
@@ -125371,6 +125359,172 @@ class AsyncObserver {
     }, 0);
   }
 }
+class Transaction2 {
+  constructor(datastore) {
+    this.datastore = datastore;
+    this.readVersions = new Map;
+    this.mutations = [];
+    this.committed = false;
+    this.lastTransactionError = null;
+    this.writtenDocs = new Set;
+  }
+  async lookup(keys) {
+    this.ensureCommitNotCalled();
+    if (this.mutations.length > 0) {
+      this.lastTransactionError = new FirestoreError(Code.INVALID_ARGUMENT, "Firestore transactions require all reads to be executed before all writes.");
+      throw this.lastTransactionError;
+    }
+    const docs = await invokeBatchGetDocumentsRpc(this.datastore, keys);
+    docs.forEach((doc2) => this.recordVersion(doc2));
+    return docs;
+  }
+  set(key, data) {
+    this.write(data.toMutation(key, this.precondition(key)));
+    this.writtenDocs.add(key.toString());
+  }
+  update(key, data) {
+    try {
+      this.write(data.toMutation(key, this.preconditionForUpdate(key)));
+    } catch (e) {
+      this.lastTransactionError = e;
+    }
+    this.writtenDocs.add(key.toString());
+  }
+  delete(key) {
+    this.write(new DeleteMutation(key, this.precondition(key)));
+    this.writtenDocs.add(key.toString());
+  }
+  async commit() {
+    this.ensureCommitNotCalled();
+    if (this.lastTransactionError) {
+      throw this.lastTransactionError;
+    }
+    const unwritten = this.readVersions;
+    this.mutations.forEach((mutation) => {
+      unwritten.delete(mutation.key.toString());
+    });
+    unwritten.forEach((_, path) => {
+      const key = DocumentKey.fromPath(path);
+      this.mutations.push(new VerifyMutation(key, this.precondition(key)));
+    });
+    await invokeCommitRpc(this.datastore, this.mutations);
+    this.committed = true;
+  }
+  recordVersion(doc2) {
+    let docVersion;
+    if (doc2.isFoundDocument()) {
+      docVersion = doc2.version;
+    } else if (doc2.isNoDocument()) {
+      docVersion = SnapshotVersion.min();
+    } else {
+      throw fail(50498, {
+        documentName: doc2.constructor.name
+      });
+    }
+    const existingVersion = this.readVersions.get(doc2.key.toString());
+    if (existingVersion) {
+      if (!docVersion.isEqual(existingVersion)) {
+        throw new FirestoreError(Code.ABORTED, "Document version changed between two reads.");
+      }
+    } else {
+      this.readVersions.set(doc2.key.toString(), docVersion);
+    }
+  }
+  precondition(key) {
+    const version6 = this.readVersions.get(key.toString());
+    if (!this.writtenDocs.has(key.toString()) && version6) {
+      if (version6.isEqual(SnapshotVersion.min())) {
+        return Precondition.exists(false);
+      } else {
+        return Precondition.updateTime(version6);
+      }
+    } else {
+      return Precondition.none();
+    }
+  }
+  preconditionForUpdate(key) {
+    const version6 = this.readVersions.get(key.toString());
+    if (!this.writtenDocs.has(key.toString()) && version6) {
+      if (version6.isEqual(SnapshotVersion.min())) {
+        throw new FirestoreError(Code.INVALID_ARGUMENT, "Can't update a document that doesn't exist.");
+      }
+      return Precondition.updateTime(version6);
+    } else {
+      return Precondition.exists(true);
+    }
+  }
+  write(mutation) {
+    this.ensureCommitNotCalled();
+    this.mutations.push(mutation);
+  }
+  ensureCommitNotCalled() {}
+}
+
+class TransactionRunner {
+  constructor(asyncQueue, datastore, options2, updateFunction, deferred) {
+    this.asyncQueue = asyncQueue;
+    this.datastore = datastore;
+    this.options = options2;
+    this.updateFunction = updateFunction;
+    this.deferred = deferred;
+    this.attemptsRemaining = options2.maxAttempts;
+    this.backoff = new ExponentialBackoff(this.asyncQueue, "transaction_retry");
+  }
+  run() {
+    this.attemptsRemaining -= 1;
+    this.runWithBackOff();
+  }
+  runWithBackOff() {
+    this.backoff.backoffAndRun(async () => {
+      const transaction = new Transaction2(this.datastore);
+      const userPromise = this.tryRunUpdateFunction(transaction);
+      if (userPromise) {
+        userPromise.then((result) => {
+          this.asyncQueue.enqueueAndForget(() => {
+            return transaction.commit().then(() => {
+              this.deferred.resolve(result);
+            }).catch((commitError) => {
+              this.handleTransactionError(commitError);
+            });
+          });
+        }).catch((userPromiseError) => {
+          this.handleTransactionError(userPromiseError);
+        });
+      }
+    });
+  }
+  tryRunUpdateFunction(transaction) {
+    try {
+      const userPromise = this.updateFunction(transaction);
+      if (isNullOrUndefined(userPromise) || !userPromise.catch || !userPromise.then) {
+        this.deferred.reject(Error("Transaction callback must return a Promise"));
+        return null;
+      }
+      return userPromise;
+    } catch (error) {
+      this.deferred.reject(error);
+      return null;
+    }
+  }
+  handleTransactionError(error) {
+    if (this.attemptsRemaining > 0 && this.isRetryableTransactionError(error)) {
+      this.attemptsRemaining -= 1;
+      this.asyncQueue.enqueueAndForget(() => {
+        this.runWithBackOff();
+        return Promise.resolve();
+      });
+    } else {
+      this.deferred.reject(error);
+    }
+  }
+  isRetryableTransactionError(error) {
+    if (error?.name === "FirebaseError") {
+      const code = error.code;
+      return code === "aborted" || code === "failed-precondition" || code === "already-exists" || !isPermanentError(code);
+    }
+    return false;
+  }
+}
 var LOG_TAG$1 = "FirestoreClient";
 var MAX_CONCURRENT_LIMBO_RESOLUTIONS = 100;
 var DOM_EXCEPTION_INVALID_STATE = 11;
@@ -125505,6 +125659,9 @@ async function ensureOnlineComponents(client2) {
 function getSyncEngine(client2) {
   return ensureOnlineComponents(client2).then((c) => c.syncEngine);
 }
+function getDatastore(client2) {
+  return ensureOnlineComponents(client2).then((c) => c.datastore);
+}
 async function getEventManager(client2) {
   const onlineComponentProvider = await ensureOnlineComponents(client2);
   const eventManager = onlineComponentProvider.eventManager;
@@ -125553,6 +125710,14 @@ function firestoreClientWrite(client2, mutations) {
   });
   return deferred.promise;
 }
+function firestoreClientTransaction(client2, updateFunction, options2) {
+  const deferred = new Deferred2;
+  client2.asyncQueue.enqueueAndForget(async () => {
+    const datastore = await getDatastore(client2);
+    new TransactionRunner(client2.asyncQueue, datastore, options2, updateFunction, deferred).run();
+  });
+  return deferred.promise;
+}
 function readDocumentViaSnapshotListener(eventManager, asyncQueue, key, options2, result) {
   const wrappedObserver = new AsyncObserver({
     next: (snap) => {
@@ -125907,7 +126072,7 @@ class ExpUserDataWriter extends AbstractUserDataWriter {
     return new DocumentReference(this.firestore, null, key);
   }
 }
-// ../../node_modules/.bun/@firebase+firestore@4.16.0+5bd1f26d8863c124/node_modules/@firebase/firestore/dist/index.node.mjs
+// ../../node_modules/.bun/@firebase+firestore@4.16.0+80db1b7a714a6e79/node_modules/@firebase/firestore/dist/index.node.mjs
 var import_grpc_js = __toESM(require_src3(), 1);
 var import_proto_loader = __toESM(require_src2(), 1);
 var name$12 = "@firebase/firestore";
@@ -126305,6 +126470,20 @@ function applyFirestoreDataConverter(converter, value, options2) {
   }
   return convertedValue;
 }
+
+class LiteUserDataWriter extends AbstractUserDataWriter {
+  constructor(firestore) {
+    super();
+    this.firestore = firestore;
+  }
+  convertBytes(bytes) {
+    return new Bytes(bytes);
+  }
+  convertReference(name5) {
+    const key = this.convertDocumentKey(name5, this.firestore._databaseId);
+    return new DocumentReference(this.firestore, null, key);
+  }
+}
 var encoder2 = newTextEncoder();
 function lengthPrefixedString(o) {
   const str = JSON.stringify(o);
@@ -126719,6 +126898,15 @@ function resultChangeType(type) {
       return fail(61501, { type });
   }
 }
+var DEFAULT_TRANSACTION_OPTIONS = {
+  maxAttempts: 5
+};
+function validateTransactionOptions(options2) {
+  if (options2.maxAttempts < 1) {
+    throw new FirestoreError(Code.INVALID_ARGUMENT, "Max attempts must be at least 1");
+  }
+}
+
 class WriteBatch {
   constructor(_firestore, _commitHandler) {
     this._firestore = _firestore;
@@ -126776,6 +126964,79 @@ function validateReference(documentRef, firestore) {
     return documentRef;
   }
 }
+
+class Transaction$1 {
+  constructor(_firestore, _transaction) {
+    this._firestore = _firestore;
+    this._transaction = _transaction;
+    this._dataReader = newUserDataReader(_firestore);
+  }
+  get(documentRef) {
+    const ref = validateReference(documentRef, this._firestore);
+    const userDataWriter = new LiteUserDataWriter(this._firestore);
+    return this._transaction.lookup([ref._key]).then((docs) => {
+      if (!docs || docs.length !== 1) {
+        return fail(24041);
+      }
+      const doc3 = docs[0];
+      if (doc3.isFoundDocument()) {
+        return new DocumentSnapshot$1(this._firestore, userDataWriter, doc3.key, doc3, ref.converter);
+      } else if (doc3.isNoDocument()) {
+        return new DocumentSnapshot$1(this._firestore, userDataWriter, ref._key, null, ref.converter);
+      } else {
+        throw fail(18433, {
+          doc: doc3
+        });
+      }
+    });
+  }
+  set(documentRef, value, options2) {
+    const ref = validateReference(documentRef, this._firestore);
+    const convertedValue = applyFirestoreDataConverter(ref.converter, value, options2);
+    const parsed = parseSetData(this._dataReader, "Transaction.set", ref._key, convertedValue, ref.converter !== null, options2);
+    this._transaction.set(ref._key, parsed);
+    return this;
+  }
+  update(documentRef, fieldOrUpdateData, value, ...moreFieldsAndValues) {
+    const ref = validateReference(documentRef, this._firestore);
+    fieldOrUpdateData = getModularInstance(fieldOrUpdateData);
+    let parsed;
+    if (typeof fieldOrUpdateData === "string" || fieldOrUpdateData instanceof FieldPath) {
+      parsed = parseUpdateVarargs(this._dataReader, "Transaction.update", ref._key, fieldOrUpdateData, value, moreFieldsAndValues);
+    } else {
+      parsed = parseUpdateData(this._dataReader, "Transaction.update", ref._key, fieldOrUpdateData);
+    }
+    this._transaction.update(ref._key, parsed);
+    return this;
+  }
+  delete(documentRef) {
+    const ref = validateReference(documentRef, this._firestore);
+    this._transaction.delete(ref._key);
+    return this;
+  }
+}
+
+class Transaction3 extends Transaction$1 {
+  constructor(_firestore, _transaction) {
+    super(_firestore, _transaction);
+    this._firestore = _firestore;
+  }
+  get(documentRef) {
+    const ref = validateReference(documentRef, this._firestore);
+    const userDataWriter = new ExpUserDataWriter(this._firestore);
+    return super.get(documentRef).then((liteDocumentSnapshot) => new DocumentSnapshot(this._firestore, userDataWriter, ref._key, liteDocumentSnapshot._document, new SnapshotMetadata(false, false), ref.converter));
+  }
+}
+function runTransaction(firestore, updateFunction, options2) {
+  firestore = cast(firestore, Firestore);
+  const optionsWithDefaults = {
+    ...DEFAULT_TRANSACTION_OPTIONS,
+    ...options2
+  };
+  validateTransactionOptions(optionsWithDefaults);
+  const client2 = ensureFirestoreConfigured(firestore);
+  return firestoreClientTransaction(client2, (internalTransaction) => updateFunction(new Transaction3(firestore, internalTransaction)), optionsWithDefaults);
+}
 function isPartialObserver(obj) {
   return implementsAnyMethods2(obj, ["next", "error", "complete"]);
 }
@@ -126920,7 +127181,7 @@ function writeBatch(firestore) {
 }
 var persistentCacheIndexManagerByFirestore = new WeakMap;
 registerFirestore("node");
-// ../../node_modules/.bun/@firebase+functions@0.13.5+5bd1f26d8863c124/node_modules/@firebase/functions/dist/esm/index.esm.js
+// ../../node_modules/.bun/@firebase+functions@0.13.5+80db1b7a714a6e79/node_modules/@firebase/functions/dist/esm/index.esm.js
 var LONG_TYPE = "type.googleapis.com/google.protobuf.Int64Value";
 var UNSIGNED_LONG_TYPE = "type.googleapis.com/google.protobuf.UInt64Value";
 function mapValues(o, f) {
@@ -127485,7 +127746,7 @@ function httpsCallable(functionsInstance, name6, options2) {
   return httpsCallable$1(getModularInstance(functionsInstance), name6, options2);
 }
 registerFunctions();
-// ../../node_modules/.bun/@firebase+storage@0.14.3+5bd1f26d8863c124/node_modules/@firebase/storage/dist/node-esm/index.node.esm.js
+// ../../node_modules/.bun/@firebase+storage@0.14.3+80db1b7a714a6e79/node_modules/@firebase/storage/dist/node-esm/index.node.esm.js
 var DEFAULT_HOST2 = "firebasestorage.googleapis.com";
 var CONFIG_STORAGE_BUCKET_KEY = "storageBucket";
 var DEFAULT_MAX_OPERATION_RETRY_TIME = 2 * 60 * 1000;
@@ -128962,7 +129223,7 @@ function registerStorage() {
   registerVersion(name6, version8);
 }
 registerStorage();
-// ../../node_modules/.bun/@firebase+auth@1.13.3+77f33dfe73ba26c8/node_modules/@firebase/auth/dist/node-esm/totp-65577477.js
+// ../../node_modules/.bun/@firebase+auth@1.13.3+5d31dd782a334479/node_modules/@firebase/auth/dist/node-esm/totp-65577477.js
 function _prodErrorMap2() {
   return {
     ["dependent-sdk-initialized-before-auth"]: "Another Firebase SDK was initialized and is trying to use Auth before Auth is " + "initialized. Please be sure to call `initializeAuth` or `getAuth` before " + "starting any other Firebase SDK."
@@ -132562,10 +132823,10 @@ function createFirebaseCloud({ db, auth: auth3, getAuth: getAuth3, functions: fu
     }
     const unlinked = targets.filter((target) => !target.linkId);
     const unlinkedStatuses = await Promise.all(unlinked.map(async (target) => {
-      const chatSnap = await getDocFromServer(doc(db, "chats", target.chatId)).catch(() => null);
+      const chatSnap = await getDocFromServer(doc(db, "chats", target.chatId));
       return {
         chatId: target.chatId,
-        active: chatSnap?.data?.()?.deleted !== true
+        active: !chatSnap.exists() || chatSnap.data()?.deleted !== true
       };
     }));
     for (const status of unlinkedStatuses) {
@@ -132589,6 +132850,10 @@ function createFirebaseCloud({ db, auth: auth3, getAuth: getAuth3, functions: fu
     await callFunction("submitReport", payload);
     return true;
   }
+  async function submitBug(payload) {
+    const result = await callFunction("submitBug", payload);
+    return result || true;
+  }
   async function submitFeedback(payload) {
     const result = await callFunction("submitFeedback", payload);
     return result || true;
@@ -132791,7 +133056,7 @@ function createFirebaseCloud({ db, auth: auth3, getAuth: getAuth3, functions: fu
     return chatMessagesPage(snap, count, { reverse: messagesQuery.reverse });
   }
   async function readChatMessage(chatId, messageId) {
-    const snap = await getDocFromServer(chatMessageDoc(chatId, messageId)).catch(() => null);
+    const snap = await getDocFromServer(chatMessageDoc(chatId, messageId));
     return messageRecordFromDoc(snap);
   }
   function cleanMessageWrite(message) {
@@ -132887,11 +133152,31 @@ function createFirebaseCloud({ db, auth: auth3, getAuth: getAuth3, functions: fu
       throw new Error("message ttl required");
     }
     const ttl = options2?.permanent === true ? null : Timestamp2.fromMillis(ttlMs);
-    const updateItems = async (nextTtl = ttl, targetItems = items) => {
+    const updateItems = async (nextTtl = ttl, targetItems = items, { shortenOnly = false } = {}) => {
       const updated2 = [];
-      for (const item of targetItems) {
-        await updateDoc(chatMessageDoc(chatId, item.id), { ttl: nextTtl });
-        updated2.push(item);
+      for (let index = 0;index < targetItems.length; index += CHAT_TTL_WRITE_BATCH_SIZE) {
+        const chunk = targetItems.slice(index, index + CHAT_TTL_WRITE_BATCH_SIZE);
+        if (shortenOnly) {
+          const chunkUpdated = await runTransaction(db, async (transaction) => {
+            const refs = chunk.map((item) => chatMessageDoc(chatId, item.id));
+            const snapshots = await Promise.all(refs.map((messageRef) => transaction.get(messageRef)));
+            const eligible = [];
+            snapshots.forEach((snapshot, snapshotIndex) => {
+              const currentTtlMs = timestampMs(snapshot?.data?.()?.ttl, null);
+              if (snapshot?.exists?.() && currentTtlMs != null && currentTtlMs > ttlMs) {
+                transaction.update(refs[snapshotIndex], { ttl: nextTtl });
+                eligible.push(chunk[snapshotIndex]);
+              }
+            });
+            return eligible;
+          });
+          updated2.push(...chunkUpdated);
+          continue;
+        }
+        const batch = writeBatch(db);
+        chunk.forEach((item) => batch.update(chatMessageDoc(chatId, item.id), { ttl: nextTtl }));
+        await batch.commit();
+        updated2.push(...chunk);
       }
       return updated2;
     };
@@ -132909,6 +133194,10 @@ function createFirebaseCloud({ db, auth: auth3, getAuth: getAuth3, functions: fu
         throw error;
       }
     }
+    if (options2?.releaseMediaHold !== true) {
+      const updated2 = await updateItems(ttl, items, { shortenOnly: options2?.shortenOnly === true });
+      return { updated: updated2.length };
+    }
     let updated = [];
     try {
       updated = await updateItems();
@@ -132948,7 +133237,7 @@ function createFirebaseCloud({ db, auth: auth3, getAuth: getAuth3, functions: fu
     requireUid(uid);
     if (!entryId)
       throw new Error("chat entry id required");
-    const snap = await getDocFromServer(doc(db, "users", uid, "chats", entryId)).catch(() => null);
+    const snap = await getDocFromServer(doc(db, "users", uid, "chats", entryId));
     return userChatRecordFromDoc(snap);
   }
   async function writeUserChat(uid, entryId, { body, tsMs, touchTs = false } = {}) {
@@ -133045,6 +133334,12 @@ function createFirebaseCloud({ db, auth: auth3, getAuth: getAuth3, functions: fu
       onUpdate?.(recordsFromSnapshot(snap));
     }, onError);
   }
+  function watchAdminBugs(onUpdate, onError, options2 = {}) {
+    const count = Math.min(positiveInt(options2?.count, 100), 250);
+    return onSnapshot(query(collection(db, "bugs"), orderBy("createdAt", "desc"), limit(count)), (snap) => {
+      onUpdate?.(recordsFromSnapshot(snap));
+    }, onError);
+  }
   function watchAdminBots(onUpdate, onError) {
     return onSnapshot(collection(db, "bots"), (snap) => {
       onUpdate?.(recordsFromSnapshot(snap));
@@ -133218,6 +133513,9 @@ function createFirebaseCloud({ db, auth: auth3, getAuth: getAuth3, functions: fu
       push: pushInbox
     },
     admin: {
+      bugs: {
+        watch: watchAdminBugs
+      },
       reports: {
         watchOffenders: watchAdminReportOffenders,
         watchUser: watchAdminUserReports,
@@ -133248,6 +133546,9 @@ function createFirebaseCloud({ db, auth: auth3, getAuth: getAuth3, functions: fu
         upload: uploadReportEvidence
       }
     },
+    bugs: {
+      submit: submitBug
+    },
     feedback: {
       submit: submitFeedback
     },
@@ -134806,57 +135107,203 @@ class ProfileStore {
 // src/mcp.js
 import { createInterface } from "readline";
 import process4 from "process";
-function tool(name8, description, properties = {}, required = []) {
-  return {
+// package.json
+var package_default = {
+  name: "@glyphteck/veyl",
+  version: "0.3.1",
+  license: "Apache-2.0",
+  type: "module",
+  description: "Programmable Bun client for Veyl accounts, vaults, chat, and wallet payments.",
+  exports: {
+    ".": "./dist/index.js"
+  },
+  bin: {
+    veyl: "dist/cli.js"
+  },
+  files: [
+    "dist",
+    "docs",
+    "README.md",
+    "package.json"
+  ],
+  engines: {
+    bun: ">=1.3.0"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    build: "bun build src/index.js src/cli.js --target=bun --outdir dist",
+    prepack: "bun run build",
+    start: "bun src/cli.js",
+    lint: "eslint src --quiet"
+  }
+};
+
+// src/commands.js
+var stringProp = Object.freeze({ type: "string" });
+var numberProp = Object.freeze({ type: "number" });
+var booleanProp = Object.freeze({ type: "boolean" });
+var objectProp = Object.freeze({ type: "object" });
+function command({ name: name8, group, apiNames, description, properties = {}, required = [], paths = [], shortUsage = "", structuredUsage = "", cliInput, invoke, invokeCli, mcp = true }) {
+  return Object.freeze({
     name: name8,
+    group,
+    apiNames: Object.freeze(apiNames || []),
     description,
-    inputSchema: {
-      type: "object",
-      properties,
-      ...required.length ? { required } : {}
-    }
-  };
-}
-var stringProp = { type: "string" };
-var numberProp = { type: "number" };
-var booleanProp = { type: "boolean" };
-var objectProp = { type: "object" };
-var TOOLS = [
-  tool("account_create", "Create a Veyl account headlessly.", { username: stringProp, network: stringProp }, ["username"]),
-  tool("account_login", "Log in with the local machine credential.", { username: stringProp }),
-  tool("account_me", "Show the current local account."),
-  tool("vault_create", "Create and upload the local encrypted vault.", { secret: stringProp, saveSecret: booleanProp }),
-  tool("vault_unlock", "Unlock the local encrypted vault.", { secret: stringProp }),
-  tool("vault_lock", "Lock the wallet and chat session."),
-  tool("chat_list", "List chats.", { count: numberProp }),
-  tool("chat_read", "Read display messages from a chat.", { peer: stringProp, count: numberProp }, ["peer"]),
-  tool("chat_send", "Send a text message.", { peer: stringProp, message: stringProp }, ["peer", "message"]),
-  tool("chat_reply", "Reply to one displayed message. Pass either a peer plus messageId or a message event from veyl listen.", { peer: stringProp, messageId: stringProp, event: objectProp, message: stringProp }, ["message"]),
-  tool("chat_react", "React to one displayed message.", { peer: stringProp, messageId: stringProp, emoji: stringProp }, ["peer", "messageId", "emoji"]),
-  tool("chat_react_to", "React to a displayed message or a message event from veyl listen.", { peer: stringProp, messageId: stringProp, event: objectProp, emoji: stringProp }, ["emoji"]),
-  tool("chat_unreact", "Remove your reaction from one displayed message.", { peer: stringProp, messageId: stringProp }, ["peer", "messageId"]),
-  tool("chat_save", "Keep one displayed message permanently.", { peer: stringProp, messageId: stringProp }, ["peer", "messageId"]),
-  tool("chat_unsave", "Return one displayed message to normal temporary retention.", { peer: stringProp, messageId: stringProp }, ["peer", "messageId"]),
-  tool("chat_delete_message", "Delete one displayed message.", { peer: stringProp, messageId: stringProp }, ["peer", "messageId"]),
-  tool("chat_delete", "Delete one chat.", { peer: stringProp, cleanup: booleanProp }, ["peer"]),
-  tool("chat_retention", "Set chat retention to seen or 24h.", { peer: stringProp, retention: stringProp }, ["peer", "retention"]),
-  tool("money_receive", "Get the static funding address.", {}),
-  tool("money_claim", "Claim static deposits and pending incoming transfers.", { count: numberProp }),
-  tool("money_balance", "Read wallet balance.", {}),
-  tool("money_send", "Send sats to a peer.", { peer: stringProp, sats: numberProp }, ["peer", "sats"]),
-  tool("money_request", "Request sats from a peer.", { peer: stringProp, sats: numberProp }, ["peer", "sats"]),
-  tool("money_pay", "Pay a chat payment request.", { requestId: stringProp }, ["requestId"]),
-  tool("money_invoice", "Create a Lightning invoice.", { sats: numberProp, memo: stringProp, expirySeconds: numberProp, includeSparkAddress: booleanProp, includeSparkInvoice: booleanProp }),
-  tool("money_pay_invoice", "Pay a Lightning or Spark invoice.", { invoice: stringProp, type: stringProp, amountSats: numberProp, maxFeeSats: numberProp, preferSpark: booleanProp }, ["invoice"]),
-  tool("lightning_quote", "Quote Lightning send fees.", { invoice: stringProp, amountSats: numberProp }, ["invoice"]),
-  tool("lightning_pay", "Pay a Lightning invoice.", { invoice: stringProp, amountSats: numberProp, amountSatsToSend: numberProp, maxFeeSats: numberProp, preferSpark: booleanProp }, ["invoice"]),
-  tool("lightning_receive", "Read a Lightning receive request.", { id: stringProp }, ["id"]),
-  tool("lightning_send", "Read a Lightning send request.", { id: stringProp }, ["id"]),
-  tool("withdraw_quote", "Quote an on-chain withdrawal.", { address: stringProp, sats: numberProp }, ["address", "sats"]),
-  tool("withdraw_prepare", "Prepare an on-chain withdrawal review.", { address: stringProp, sats: numberProp, speed: stringProp, deductFeeFromWithdrawalAmount: booleanProp }, ["address", "sats"]),
-  tool("withdraw_send", "Send an on-chain withdrawal.", { address: stringProp, sats: numberProp, speed: stringProp, deductFeeFromWithdrawalAmount: booleanProp }, ["address", "sats"]),
-  tool("transactions_list", "List wallet transactions.", { count: numberProp, offset: numberProp })
-];
+    properties: Object.freeze(properties),
+    required: Object.freeze(required),
+    paths: Object.freeze(paths.map((path) => Object.freeze(path))),
+    shortUsage,
+    structuredUsage,
+    cliInput,
+    invoke,
+    invokeCli,
+    mcp
+  });
+}
+var optionsOnly = (_args, context) => ({ ...context.commandOptions });
+var peerInput = (args, context) => ({ ...context.commandOptions, peer: args[0] });
+var peerMessageInput = (args, context) => ({ ...context.commandOptions, peer: args[0], message: args.slice(1).join(" ") });
+var peerMessageIdInput = (args, context) => ({ ...context.commandOptions, peer: args[0], messageId: args[1] });
+var peerMessageActionInput = (args, context) => ({ ...context.commandOptions, peer: args[0], messageId: args[1], message: args.slice(2).join(" ") });
+var peerEmojiInput = (args, context) => ({ ...context.commandOptions, peer: args[0], messageId: args[1], emoji: args.slice(2).join(" ") });
+var peerSatsInput = (args, context) => ({ ...context.commandOptions, peer: args[0], sats: args[1] });
+var invoiceInput = (args, context) => ({ ...context.commandOptions, invoice: args[0] });
+var requestInput = (args, context) => ({ ...context.commandOptions, requestId: args[0] });
+var idInput = (args, context) => ({ ...context.commandOptions, id: args[0] });
+var withdrawalInput = (args, context) => ({ ...context.commandOptions, address: args[0], sats: args[1] });
+function accountInput(args, context) {
+  return {
+    username: args[0],
+    network: context.options.network,
+    webUrl: context.options.webUrl,
+    saveCredential: context.options.saveCredential,
+    onPasskeyUrl: context.onPasskeyUrl
+  };
+}
+function vaultInput(_args, context) {
+  return {
+    secret: context.options.secret,
+    saveSecret: context.options.saveSecret
+  };
+}
+function invoiceCreateInput(args, context) {
+  return {
+    ...context.commandOptions,
+    sats: args[0] || 0,
+    memo: context.commandOptions.memo || args.slice(1).join(" ") || undefined
+  };
+}
+var HEADLESS_COMMANDS = Object.freeze([
+  command({
+    name: "account_create",
+    group: "account",
+    apiNames: ["create"],
+    description: "Create a Veyl account headlessly.",
+    properties: { username: stringProp, network: stringProp },
+    required: ["username"],
+    paths: [["create"], ["account", "create"]],
+    shortUsage: "create [--passkey] @name",
+    structuredUsage: "account create [--passkey] @name",
+    cliInput: accountInput,
+    invoke: (client2, input) => client2.account.create(input),
+    invokeCli: (client2, input, context) => context.options.passkey ? client2.account.createPasskey(input) : client2.account.create({ username: input.username, network: input.network, saveCredential: input.saveCredential })
+  }),
+  command({
+    name: "account_login",
+    group: "account",
+    apiNames: ["login"],
+    description: "Log in with the local machine credential.",
+    properties: { username: stringProp },
+    paths: [["login"], ["account", "login"]],
+    shortUsage: "login [--passkey] [@name]",
+    structuredUsage: "account login [--passkey] [@name]",
+    cliInput: accountInput,
+    invoke: (client2, input) => client2.account.login(input),
+    invokeCli: (client2, input, context) => context.options.passkey ? client2.account.loginPasskey(input) : client2.account.login({ username: input.username })
+  }),
+  command({ name: "account_me", group: "account", apiNames: ["me"], description: "Show the current local account.", paths: [["me"], ["account", "me"]], shortUsage: "me", structuredUsage: "account me", cliInput: optionsOnly, invoke: (client2) => client2.account.me() }),
+  command({ name: "vault_create", group: "vault", apiNames: ["create"], description: "Create and upload the local encrypted vault.", properties: { secret: stringProp, saveSecret: booleanProp }, paths: [["vault", "create"]], structuredUsage: "vault create", cliInput: vaultInput, invoke: (client2, input) => client2.vault.create(input) }),
+  command({ name: "vault_unlock", group: "vault", apiNames: ["unlock"], description: "Unlock the local vault.", properties: { secret: stringProp }, paths: [["unlock"], ["vault", "unlock"]], shortUsage: "unlock", structuredUsage: "vault unlock [--secret value]", cliInput: vaultInput, invoke: (client2, input) => client2.vault.unlock(input) }),
+  command({ name: "vault_lock", group: "vault", apiNames: ["lock"], description: "Lock the wallet and chat session.", paths: [["lock"], ["vault", "lock"]], shortUsage: "lock", structuredUsage: "vault lock", cliInput: optionsOnly, invoke: (client2) => client2.vault.lock() }),
+  command({ name: "chat_list", group: "chat", apiNames: ["list"], description: "List chats.", properties: { count: numberProp }, paths: [["chats"], ["chat", "list"]], shortUsage: "chats", structuredUsage: "chat list", cliInput: optionsOnly, invoke: (client2, input) => client2.chat.list(input) }),
+  command({ name: "chat_read", group: "chat", apiNames: ["read"], description: "Read display messages from a chat.", properties: { peer: stringProp, count: numberProp }, required: ["peer"], paths: [["read"], ["chat", "read"]], shortUsage: "read @name", structuredUsage: "chat read @name", cliInput: peerInput, invoke: (client2, input) => client2.chat.read(input.peer, input) }),
+  command({ name: "chat_send", group: "chat", apiNames: ["send"], description: "Send a text message.", properties: { peer: stringProp, message: stringProp }, required: ["peer", "message"], paths: [["say"], ["msg"], ["chat", "send"]], shortUsage: 'say @name "message"', structuredUsage: 'chat send @name "message"', cliInput: peerMessageInput, invoke: (client2, input) => client2.chat.send(input.peer, input.message, input) }),
+  command({ name: "chat_reply", group: "chat", apiNames: ["reply"], description: "Reply to one displayed message or listen event.", properties: { peer: stringProp, messageId: stringProp, event: objectProp, message: stringProp }, required: ["message"], paths: [["reply"], ["chat", "reply"]], shortUsage: 'reply @name <message-id> "message"', structuredUsage: 'chat reply @name <message-id> "message"', cliInput: peerMessageActionInput, invoke: (client2, input) => client2.chat.reply(input.event || { peer: input.peer, messageId: input.messageId }, input.message, input) }),
+  command({ name: "chat_react", group: "chat", apiNames: ["react"], description: "React to one displayed message.", properties: { peer: stringProp, messageId: stringProp, emoji: stringProp }, required: ["peer", "messageId", "emoji"], paths: [["react"], ["chat", "react"]], shortUsage: "react @name <message-id> <emoji>", structuredUsage: "chat react @name <message-id> <emoji>", cliInput: peerEmojiInput, invoke: (client2, input) => client2.chat.react(input.peer, input.messageId, input.emoji, input) }),
+  command({ name: "chat_react_to", group: "chat", apiNames: ["react-to"], description: "React to a displayed message or listen event.", properties: { peer: stringProp, messageId: stringProp, event: objectProp, emoji: stringProp }, required: ["emoji"], paths: [["chat", "react-to"]], structuredUsage: "chat react-to @name <message-id> <emoji>", cliInput: peerEmojiInput, invoke: (client2, input) => client2.chat.reactTo(input.event || { peer: input.peer, messageId: input.messageId }, input.emoji, input) }),
+  command({ name: "chat_unreact", group: "chat", apiNames: ["unreact"], description: "Remove your reaction from one displayed message.", properties: { peer: stringProp, messageId: stringProp }, required: ["peer", "messageId"], paths: [["unreact"], ["chat", "unreact"]], shortUsage: "unreact @name <message-id>", structuredUsage: "chat unreact @name <message-id>", cliInput: peerMessageIdInput, invoke: (client2, input) => client2.chat.unreact(input.peer, input.messageId, input) }),
+  command({ name: "chat_save", group: "chat", apiNames: ["save"], description: "Keep one displayed message permanently.", properties: { peer: stringProp, messageId: stringProp }, required: ["peer", "messageId"], paths: [["save"], ["chat", "save"]], shortUsage: "save @name <message-id>", structuredUsage: "chat save @name <message-id>", cliInput: peerMessageIdInput, invoke: (client2, input) => client2.chat.save(input.peer, input.messageId, input) }),
+  command({ name: "chat_unsave", group: "chat", apiNames: ["unsave"], description: "Return one displayed message to temporary retention.", properties: { peer: stringProp, messageId: stringProp }, required: ["peer", "messageId"], paths: [["unsave"], ["chat", "unsave"]], shortUsage: "unsave @name <message-id>", structuredUsage: "chat unsave @name <message-id>", cliInput: peerMessageIdInput, invoke: (client2, input) => client2.chat.unsave(input.peer, input.messageId, input) }),
+  command({ name: "chat_delete_message", group: "chat", apiNames: ["delete"], description: "Delete one displayed message.", properties: { peer: stringProp, messageId: stringProp }, required: ["peer", "messageId"], paths: [["delete-message"], ["chat", "delete"]], shortUsage: "delete-message @name <message-id>", structuredUsage: "chat delete @name <message-id>", cliInput: peerMessageIdInput, invoke: (client2, input) => client2.chat.delete(input.peer, input.messageId, input) }),
+  command({ name: "chat_delete", group: "chat", apiNames: ["delete-chat"], description: "Delete one chat.", properties: { peer: stringProp, cleanup: booleanProp }, required: ["peer"], paths: [["delete-chat"], ["chat", "delete-chat"]], shortUsage: "delete-chat @name", structuredUsage: "chat delete-chat @name", cliInput: peerInput, invoke: (client2, input) => client2.chat.deleteChat(input.peer, input) }),
+  command({ name: "chat_retention", group: "chat", apiNames: ["retention"], description: "Set chat retention to seen or 24h.", properties: { peer: stringProp, retention: stringProp }, required: ["peer", "retention"], paths: [["retention"], ["chat", "retention"]], shortUsage: "retention @name seen|24h", structuredUsage: "chat retention @name seen|24h", cliInput: (args, context) => ({ ...context.commandOptions, peer: args[0], retention: args[1] }), invoke: (client2, input) => client2.chat.retention(input.peer, input.retention, input) }),
+  command({ name: "money_receive", group: "money", apiNames: ["address", "receive"], description: "Get the static funding address.", paths: [["receive"], ["address"], ["money", "receive"], ["money", "address"]], shortUsage: "receive", structuredUsage: "money receive", cliInput: optionsOnly, invoke: (client2, input) => client2.money.receive(input) }),
+  command({ name: "money_claim", group: "money", apiNames: ["claim"], description: "Claim static deposits and pending incoming transfers.", properties: { count: numberProp }, paths: [["claim"], ["money", "claim"]], shortUsage: "claim", structuredUsage: "money claim", cliInput: optionsOnly, invoke: (client2, input) => client2.money.claim(input) }),
+  command({ name: "money_balance", group: "money", apiNames: ["balance"], description: "Read wallet balance.", paths: [["balance"], ["money", "balance"]], shortUsage: "balance", structuredUsage: "money balance", cliInput: optionsOnly, invoke: (client2, input) => client2.money.balance(input) }),
+  command({ name: "money_send", group: "money", apiNames: ["send"], description: "Send sats to a peer.", properties: { peer: stringProp, sats: numberProp }, required: ["peer", "sats"], paths: [["send"], ["money", "send"]], shortUsage: "send @name 1000", structuredUsage: "money send @name 1000", cliInput: peerSatsInput, invoke: (client2, input) => client2.money.send(input.peer, input.sats, input) }),
+  command({ name: "money_request", group: "money", apiNames: ["request"], description: "Request sats from a peer.", properties: { peer: stringProp, sats: numberProp }, required: ["peer", "sats"], paths: [["request"], ["money", "request"]], shortUsage: "request @name 1000", structuredUsage: "money request @name 1000", cliInput: peerSatsInput, invoke: (client2, input) => client2.money.request(input.peer, input.sats, input) }),
+  command({ name: "money_pay", group: "money", apiNames: ["pay"], description: "Pay a chat payment request.", properties: { requestId: stringProp }, required: ["requestId"], paths: [["pay"], ["money", "pay"]], shortUsage: "pay <request-id>", structuredUsage: "money pay <request-id>", cliInput: requestInput, invoke: (client2, input) => client2.money.pay(input.requestId, input) }),
+  command({ name: "money_invoice", group: "money", apiNames: ["invoice"], description: "Create a Lightning invoice.", properties: { sats: numberProp, memo: stringProp, expirySeconds: numberProp, includeSparkAddress: booleanProp, includeSparkInvoice: booleanProp }, paths: [["invoice"], ["money", "invoice"]], shortUsage: 'invoice 100 ["memo"]', structuredUsage: 'money invoice 100 ["memo"]', cliInput: invoiceCreateInput, invoke: (client2, input) => client2.money.invoice(input.sats || 0, input) }),
+  command({ name: "money_pay_invoice", group: "money", apiNames: ["pay-invoice"], description: "Pay a Lightning or Spark invoice.", properties: { invoice: stringProp, type: stringProp, amountSats: numberProp, maxFeeSats: numberProp, preferSpark: booleanProp }, required: ["invoice"], paths: [["pay-invoice"], ["payinvoice"], ["money", "pay-invoice"]], shortUsage: "pay-invoice <invoice>", structuredUsage: "money pay-invoice <invoice>", cliInput: invoiceInput, invoke: (client2, input) => client2.money.payInvoice(input.invoice, input) }),
+  command({ name: "lightning_quote", group: "money", apiNames: ["lightning-quote"], description: "Quote Lightning send fees.", properties: { invoice: stringProp, amountSats: numberProp }, required: ["invoice"], paths: [["money", "lightning-quote"]], structuredUsage: "money lightning-quote <invoice>", cliInput: invoiceInput, invoke: (client2, input) => client2.money.lightningQuote(input.invoice, input) }),
+  command({ name: "lightning_pay", group: "money", apiNames: ["lightning-pay"], description: "Pay a Lightning invoice.", properties: { invoice: stringProp, amountSats: numberProp, amountSatsToSend: numberProp, maxFeeSats: numberProp, preferSpark: booleanProp }, required: ["invoice"], paths: [["money", "lightning-pay"]], structuredUsage: "money lightning-pay <invoice>", cliInput: invoiceInput, invoke: (client2, input) => client2.money.lightningPay(input.invoice, input) }),
+  command({ name: "lightning_receive", group: "money", apiNames: ["lightning-receive"], description: "Read a Lightning receive request.", properties: { id: stringProp }, required: ["id"], paths: [["money", "lightning-receive"]], structuredUsage: "money lightning-receive <id>", cliInput: idInput, invoke: (client2, input) => client2.money.lightningReceive(input.id, input) }),
+  command({ name: "lightning_send", group: "money", apiNames: ["lightning-send"], description: "Read a Lightning send request.", properties: { id: stringProp }, required: ["id"], paths: [["money", "lightning-send"]], structuredUsage: "money lightning-send <id>", cliInput: idInput, invoke: (client2, input) => client2.money.lightningSend(input.id, input) }),
+  command({ name: "withdraw_quote", group: "money", apiNames: ["withdraw-quote"], description: "Quote an on-chain withdrawal.", properties: { address: stringProp, sats: numberProp }, required: ["address", "sats"], paths: [["withdraw-quote"], ["money", "withdraw-quote"]], shortUsage: "withdraw-quote <address> 1000", structuredUsage: "money withdraw-quote <address> 1000", cliInput: withdrawalInput, invoke: (client2, input) => client2.money.withdrawQuote(input.address, input.sats, input) }),
+  command({ name: "withdraw_prepare", group: "money", apiNames: ["withdraw-prepare"], description: "Prepare an on-chain withdrawal review.", properties: { address: stringProp, sats: numberProp, speed: stringProp, deductFeeFromWithdrawalAmount: booleanProp }, required: ["address", "sats"], paths: [["withdraw-prepare"], ["money", "withdraw-prepare"]], shortUsage: "withdraw-prepare <address> 1000", structuredUsage: "money withdraw-prepare <address> 1000", cliInput: withdrawalInput, invoke: (client2, input) => client2.money.withdrawPrepare(input.address, input.sats, input) }),
+  command({ name: "withdraw_send", group: "money", apiNames: ["withdraw"], description: "Send an on-chain withdrawal.", properties: { address: stringProp, sats: numberProp, speed: stringProp, deductFeeFromWithdrawalAmount: booleanProp }, required: ["address", "sats"], paths: [["withdraw"], ["money", "withdraw"]], shortUsage: "withdraw <address> 1000", structuredUsage: "money withdraw <address> 1000", cliInput: withdrawalInput, invoke: (client2, input) => client2.money.withdraw(input.address, input.sats, input) }),
+  command({ name: "transactions_list", group: "transactions", apiNames: ["list"], description: "List wallet transactions.", properties: { count: numberProp, offset: numberProp }, paths: [["transactions"], ["txs"], ["money", "transactions"]], shortUsage: "transactions", structuredUsage: "money transactions", cliInput: optionsOnly, invoke: (client2, input) => client2.money.transactions(input) }),
+  command({ name: "listen_start", group: "listen", apiNames: ["start"], description: "Listen for account events.", paths: [["listen"]], shortUsage: "listen", cliInput: optionsOnly, mcp: false, invokeCli: (client2, _input, context) => context.listen(client2) }),
+  command({ name: "mcp_serve", group: "mcp", apiNames: ["serve"], description: "Serve MCP over stdio.", paths: [["mcp", "serve"]], structuredUsage: "mcp serve", cliInput: optionsOnly, mcp: false, invoke: (client2) => client2.mcp.serve() })
+]);
+var commandByName = new Map(HEADLESS_COMMANDS.map((item) => [item.name, item]));
+var cliPaths = HEADLESS_COMMANDS.flatMap((item) => item.paths.map((path) => ({ command: item, path }))).sort((a, b) => b.path.length - a.path.length);
+var MCP_TOOLS = Object.freeze(HEADLESS_COMMANDS.filter((item) => item.mcp).map((item) => Object.freeze({
+  name: item.name,
+  description: item.description,
+  inputSchema: Object.freeze({
+    type: "object",
+    properties: item.properties,
+    ...item.required.length ? { required: item.required } : {}
+  })
+})));
+var groups = ["account", "vault", "chat", "money", "mcp", "transactions", "listen"];
+var COMMANDS = Object.freeze(Object.fromEntries(groups.map((group) => [group, Object.freeze(HEADLESS_COMMANDS.filter((item) => item.group === group).flatMap((item) => item.apiNames))])));
+function invokeCommand(client2, name8, input = {}) {
+  const selected = commandByName.get(name8);
+  if (!selected?.invoke || !selected.mcp) {
+    throw new Error(`unknown tool ${name8}`);
+  }
+  return selected.invoke(client2, input);
+}
+function resolveCliCommand(tokens = []) {
+  for (const entry of cliPaths) {
+    if (entry.path.every((part, index) => tokens[index] === part)) {
+      return { command: entry.command, args: tokens.slice(entry.path.length) };
+    }
+  }
+  return null;
+}
+function invokeCliCommand(client2, resolved, context) {
+  const selected = resolved?.command;
+  if (!selected) {
+    throw new Error("command required");
+  }
+  const input = selected.cliInput?.(resolved.args, context) || {};
+  const invoke = selected.invokeCli || selected.invoke;
+  if (!invoke) {
+    throw new Error(`CLI command unavailable: ${selected.name}`);
+  }
+  return invoke(client2, input, context);
+}
+function cliHelpLines(kind) {
+  const field2 = kind === "structured" ? "structuredUsage" : "shortUsage";
+  return HEADLESS_COMMANDS.map((item) => item[field2]).filter(Boolean);
+}
+
+// src/mcp.js
 function result(value) {
   return {
     content: [
@@ -134867,77 +135314,6 @@ function result(value) {
     ]
   };
 }
-async function callTool(client2, name8, args = {}) {
-  if (name8 === "account_create")
-    return client2.account.create(args);
-  if (name8 === "account_login")
-    return client2.account.login(args);
-  if (name8 === "account_me")
-    return client2.account.me();
-  if (name8 === "vault_create")
-    return client2.vault.create(args);
-  if (name8 === "vault_unlock")
-    return client2.vault.unlock(args);
-  if (name8 === "vault_lock")
-    return client2.vault.lock();
-  if (name8 === "chat_list")
-    return client2.chat.list(args);
-  if (name8 === "chat_read")
-    return client2.chat.read(args.peer, args);
-  if (name8 === "chat_send")
-    return client2.chat.send(args.peer, args.message, args);
-  if (name8 === "chat_reply")
-    return client2.chat.reply(args.event || { peer: args.peer, messageId: args.messageId }, args.message, args);
-  if (name8 === "chat_react")
-    return client2.chat.react(args.peer, args.messageId, args.emoji, args);
-  if (name8 === "chat_react_to")
-    return client2.chat.reactTo(args.event || { peer: args.peer, messageId: args.messageId }, args.emoji, args);
-  if (name8 === "chat_unreact")
-    return client2.chat.unreact(args.peer, args.messageId, args);
-  if (name8 === "chat_save")
-    return client2.chat.save(args.peer, args.messageId, args);
-  if (name8 === "chat_unsave")
-    return client2.chat.unsave(args.peer, args.messageId, args);
-  if (name8 === "chat_delete_message")
-    return client2.chat.delete(args.peer, args.messageId, args);
-  if (name8 === "chat_delete")
-    return client2.chat.deleteChat(args.peer, args);
-  if (name8 === "chat_retention")
-    return client2.chat.retention(args.peer, args.retention, args);
-  if (name8 === "money_receive")
-    return client2.money.receive(args);
-  if (name8 === "money_claim")
-    return client2.money.claim(args);
-  if (name8 === "money_balance")
-    return client2.money.balance(args);
-  if (name8 === "money_send")
-    return client2.money.send(args.peer, args.sats, args);
-  if (name8 === "money_request")
-    return client2.money.request(args.peer, args.sats, args);
-  if (name8 === "money_pay")
-    return client2.money.pay(args.requestId, args);
-  if (name8 === "money_invoice")
-    return client2.money.invoice(args.sats || 0, args);
-  if (name8 === "money_pay_invoice")
-    return client2.money.payInvoice(args.invoice, args);
-  if (name8 === "lightning_quote")
-    return client2.money.lightningQuote(args.invoice, args);
-  if (name8 === "lightning_pay")
-    return client2.money.lightningPay(args.invoice, args);
-  if (name8 === "lightning_receive")
-    return client2.money.lightningReceive(args.id, args);
-  if (name8 === "lightning_send")
-    return client2.money.lightningSend(args.id, args);
-  if (name8 === "withdraw_quote")
-    return client2.money.withdrawQuote(args.address, args.sats, args);
-  if (name8 === "withdraw_prepare")
-    return client2.money.withdrawPrepare(args.address, args.sats, args);
-  if (name8 === "withdraw_send")
-    return client2.money.withdraw(args.address, args.sats, args);
-  if (name8 === "transactions_list")
-    return client2.money.transactions(args);
-  throw new Error(`unknown tool ${name8}`);
-}
 function write(message) {
   process4.stdout.write(`${JSON.stringify(message)}
 `);
@@ -134968,13 +135344,13 @@ async function serveMcp(client2) {
           result: {
             protocolVersion: "2024-11-05",
             capabilities: { tools: {} },
-            serverInfo: { name: "veyl", version: "0.1.0" }
+            serverInfo: { name: "veyl", version: package_default.version }
           }
         });
       } else if (message.method === "tools/list") {
-        write({ jsonrpc: "2.0", id: message.id, result: { tools: TOOLS } });
+        write({ jsonrpc: "2.0", id: message.id, result: { tools: MCP_TOOLS } });
       } else if (message.method === "tools/call") {
-        const toolResult = await callTool(client2, message.params?.name, message.params?.arguments || {});
+        const toolResult = await invokeCommand(client2, message.params?.name, message.params?.arguments || {});
         write({ jsonrpc: "2.0", id: message.id, result: result(toolResult) });
       } else if (message.id != null) {
         write({ jsonrpc: "2.0", id: message.id, result: {} });
@@ -134987,15 +135363,6 @@ async function serveMcp(client2) {
 
 // src/client.js
 var API_VERSION = 1;
-var COMMANDS = Object.freeze({
-  account: Object.freeze(["create", "login", "me"]),
-  vault: Object.freeze(["create", "unlock", "lock"]),
-  chat: Object.freeze(["list", "read", "send", "reply", "react", "react-to", "unreact", "save", "unsave", "delete", "delete-chat", "retention"]),
-  money: Object.freeze(["address", "balance", "claim", "invoice", "lightning-quote", "lightning-pay", "lightning-receive", "lightning-send", "pay-invoice", "receive", "request", "send", "pay", "withdraw", "withdraw-prepare", "withdraw-quote"]),
-  mcp: Object.freeze(["serve"]),
-  transactions: Object.freeze(["list"]),
-  listen: Object.freeze(["start"])
-});
 
 class ClientNotReadyError extends Error {
   constructor(feature) {
@@ -135565,7 +135932,6 @@ export {
   signInHeadless,
   runPasskeyBrowserFlow,
   openRegistryAccountSession,
-  openLegacyAccountSession,
   openAccountSessionFromSecrets,
   open,
   headlessFunctionBaseUrl,