@glyphteck/veyl 0.1.1 → 0.2.0

package/dist/cli.js

@@ -92156,6 +92156,9 @@ var WALLET_IDLE_ACTIVE_TRANSFER_REFRESH_MS = 5 * MS_PER_SECOND;
 var WALLET_VISIBLE_TRANSFER_DISCOVERY_WINDOW_MS = 12 * MS_PER_SECOND;
 var WALLET_REGTEST_DEPOSIT_CLAIM_POLL_MS = 20 * MS_PER_SECOND;
 var WALLET_BALANCE_EVENT_COALESCE_MS = 2 * MS_PER_SECOND;
+var WALLET_AUTO_CLAIM_MAX_FEE_SATS = 5000;
+var WALLET_CLAIM_PAGE_SIZE = 100;
+var WALLET_PENDING_TRANSFER_CLAIM_BATCH_SIZE = 50;
 var WALLET_PENDING_TRANSFER_COLD_REFRESH_INTERVAL_MS = 15 * MS_PER_SECOND;
 var WALLET_PENDING_TRANSFER_SLOW_CLAIM_MS = 4 * MS_PER_SECOND;
 var WALLET_PENDING_TRANSFER_CLAIM_COOLDOWN_MS = 15 * MS_PER_SECOND;
@@ -92214,6 +92217,7 @@ var HIDDEN_CHECKPOINT_MSG_TYPE = "hid";
 var DELETE_MSG_TYPE = "del";
 var SYSTEM_MSG_TYPE = "sys";
 var SYSTEM_RETENTION_KIND = "retention";
+var DEFAULT_REACTION_EMOJI = "\u2764\uFE0F";
 var HOLD_VISIBLE_KEY = "__holdVisible";
 
 // ../../shared/chat/messages/actions.js
@@ -92460,6 +92464,17 @@ function hasStoredFileRef(msg) {
     return false;
   }
 }
+function hasChatMediaFileRef(msg) {
+  if (!hasText(msg?.p) || !hasText(msg?.k) || hasLocalFileRef(msg)) {
+    return false;
+  }
+  try {
+    getChatMediaFileRef(msg.p);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function hasFileRef(msg) {
   return hasLocalFileRef(msg) || hasStoredFileRef(msg);
 }
@@ -92496,6 +92511,12 @@ function getMessageOrderMs(message) {
 }
 
 // ../../shared/chat/messagekeys.js
+function keySet(value) {
+  if (value instanceof Set) {
+    return value;
+  }
+  return new Set(Array.isArray(value) ? value.filter(Boolean) : []);
+}
 function messageKeys(message) {
   if (typeof message === "string") {
     const key = cleanText(message);
@@ -92548,10 +92569,20 @@ 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;
+}
 function cleanTarget(value) {
   const target = typeof value === "object" && value ? getMessageKey(value) : value;
   return cleanText(target);
 }
+function cleanTargetFrom(target, fallback) {
+  if (typeof target === "object" && target) {
+    return cleanText(target.from) || cleanText(target.s) || cleanText(fallback);
+  }
+  return cleanText(fallback);
+}
 function isPeerMsg(msg, chatPK) {
   const sender = cleanText(msg?.s);
   const user = cleanText(chatPK);
@@ -92577,6 +92608,20 @@ function makeReadReceipt(target) {
 function isReadReceiptMsg(msg) {
   return msg?.t === READ_RECEIPT_MSG_TYPE && hasText(msg.upto);
 }
+function makeReaction(target, emoji = DEFAULT_REACTION_EMOJI, options = {}) {
+  const nextTarget = cleanTarget(target);
+  if (!nextTarget) {
+    throw new Error("reaction target required");
+  }
+  const nextEmoji = emoji == null ? "" : cleanReactionEmoji(emoji);
+  const targetFrom = cleanTargetFrom(target, options?.targetFrom);
+  return {
+    t: REACTION_MSG_TYPE,
+    target: nextTarget,
+    ...targetFrom ? { targetFrom } : {},
+    ...nextEmoji ? { emoji: nextEmoji } : {}
+  };
+}
 function isReactionMsg(msg) {
   return msg?.t === REACTION_MSG_TYPE && hasText(msg.target) && (msg.emoji == null || hasText(msg.emoji));
 }
@@ -92586,9 +92631,23 @@ function isHiddenCheckpointMsg(msg) {
 function deleteActionTarget(msg) {
   return cleanText(msg?.actionTarget) || cleanText(msg?.target) || cleanText(msg?.id);
 }
+function makeDeleteMsg(target) {
+  const nextTarget = cleanTarget(target);
+  if (!nextTarget) {
+    throw new Error("delete target required");
+  }
+  return { t: DELETE_MSG_TYPE, target: nextTarget };
+}
 function isDeleteMsg(msg) {
   return (msg?.t === DELETE_MSG_TYPE || cleanText(msg?.actionOp) === CHAT_ACTION_OPS.DELETE) && hasText(deleteActionTarget(msg));
 }
+function makeRetentionSystemMsg(retention) {
+  return {
+    t: SYSTEM_MSG_TYPE,
+    sys: SYSTEM_RETENTION_KIND,
+    retention: cleanChatRetention(retention)
+  };
+}
 function isSystemMsg(msg) {
   return msg?.t === SYSTEM_MSG_TYPE && msg?.sys === SYSTEM_RETENTION_KIND && !!getSystemMsgText(msg);
 }
@@ -93023,6 +93082,16 @@ function withCachedMessageRetention(msg, retention) {
 }
 
 // ../../shared/chat/messages/compose.js
+function setReply(msg, replyId) {
+  const nextReplyId = String(replyId ?? "").trim();
+  if (!nextReplyId) {
+    return { ...msg || {} };
+  }
+  return {
+    ...msg || {},
+    r: nextReplyId
+  };
+}
 function makeReq(amount) {
   const a = String(amount ?? "").trim();
   if (!a) {
@@ -93096,6 +93165,12 @@ function canRenderReactionPreview(preview) {
 function canRenderChatPreview(preview) {
   return !!preview && (canRenderPreviewContent(preview) || hasChatPreviewActivity(preview) || isReadReceiptMsg(preview) || canRenderReactionPreview(preview));
 }
+function getChatPreviewSourceKey(preview) {
+  return cleanText(preview?.sourceKey) || cleanText(getMessageKey(preview));
+}
+function getChatPreviewSourceTs(preview) {
+  return timestampMs(preview?.sourceTs, null, { positive: true }) ?? timestampMs(preview?.ts, null, { positive: true }) ?? getMessageOrderMs(preview);
+}
 function getChatPreviewActivityAt(preview) {
   return timestampMs(preview?.activity?.at, null, { positive: true });
 }
@@ -93106,6 +93181,93 @@ function chatPreviewActivityKind(preview) {
 function hasChatPreviewActivity(preview) {
   return !!chatPreviewActivityKind(preview) && getChatPreviewActivityAt(preview) != null;
 }
+function chatPreviewActivityOnly(preview) {
+  if (!hasChatPreviewActivity(preview)) {
+    return null;
+  }
+  const kind = chatPreviewActivityKind(preview);
+  const sourceKey = getChatPreviewSourceKey(preview);
+  const sourceTs = getChatPreviewSourceTs(preview);
+  const sender = cleanText(preview?.from || preview?.s);
+  const activityAt = getChatPreviewActivityAt(preview);
+  const activityBy = cleanText(preview?.activity?.by);
+  return {
+    ...sender ? { s: sender, from: sender } : {},
+    ...sourceKey ? { sourceKey } : {},
+    ...Number.isFinite(sourceTs) ? { sourceTs, ts: sourceTs } : {},
+    activity: {
+      kind,
+      at: activityAt,
+      ...activityBy ? { by: activityBy } : {}
+    }
+  };
+}
+function isChatPreviewActivityOnly(preview) {
+  return hasChatPreviewActivity(preview) && !canRenderPreviewContent(preview) && !isReadReceiptMsg(preview) && !isReactionMsg(preview);
+}
+function withChatPreviewActivity(preview, activity = {}) {
+  if (!preview || typeof preview !== "object" || Array.isArray(preview)) {
+    return null;
+  }
+  const kind = cleanText(activity.kind);
+  const at = timestampMs(activity.at, null, { positive: true });
+  if (!CHAT_PREVIEW_ACTIVITY_KINDS.has(kind) || at == null) {
+    return preview;
+  }
+  const by = cleanText(activity.by);
+  const sourceKey = cleanText(activity.sourceKey) || getChatPreviewSourceKey(preview);
+  const sourceTs = timestampMs(activity.sourceTs, null, { positive: true }) ?? getChatPreviewSourceTs(preview);
+  const contentUntil = timestampMs(activity.contentUntil, null, { positive: true });
+  const { activity: _oldActivity, contentUntil: _oldContentUntil, sourceKey: _oldSourceKey, sourceTs: _oldSourceTs, ...rest } = preview;
+  return {
+    ...rest,
+    ...sourceKey ? { sourceKey } : {},
+    ...Number.isFinite(sourceTs) ? { sourceTs } : {},
+    ...contentUntil != null ? { contentUntil } : {},
+    activity: {
+      kind,
+      at,
+      ...by ? { by } : {}
+    }
+  };
+}
+function withChatPreviewOpened(preview, target, openedAt, by) {
+  if (!preview || !target) {
+    return null;
+  }
+  const keys = collectMessageKeys(target);
+  if (!chatPreviewHasKey(preview, keys)) {
+    return null;
+  }
+  const at = timestampMs(openedAt, null, { positive: true });
+  if (at == null) {
+    return null;
+  }
+  return chatPreviewActivityOnly(withChatPreviewActivity(preview, {
+    kind: CHAT_PREVIEW_ACTIVITY_OPENED,
+    at,
+    by,
+    sourceKey: getChatPreviewSourceKey(preview),
+    sourceTs: getChatPreviewSourceTs(preview)
+  }));
+}
+function withChatPreviewDeleted(preview, target, deletedAt, by) {
+  if (!preview || !target || isChatPreviewActivityOnly(preview)) {
+    return null;
+  }
+  const keys = collectMessageKeys(target);
+  if (!chatPreviewHasKey(preview, keys)) {
+    return null;
+  }
+  const at = timestampMs(deletedAt, Date.now(), { positive: true });
+  return chatPreviewActivityOnly(withChatPreviewActivity(preview, {
+    kind: CHAT_PREVIEW_ACTIVITY_DELETED,
+    at,
+    by,
+    sourceKey: getChatPreviewSourceKey(preview),
+    sourceTs: getChatPreviewSourceTs(preview)
+  }));
+}
 function chatPreviewWantsAttention(preview, chatPK) {
   if (!preview || fromSelf(preview, chatPK)) {
     return false;
@@ -93119,6 +93281,32 @@ function chatPreviewWantsAttention(preview, chatPK) {
   }
   return canRenderPreviewContent(preview);
 }
+function previewActionTargetsKey(message, key) {
+  const targetKey = cleanText(key);
+  if (!targetKey || !isReadReceiptMsg(message) && !isReactionMsg(message)) {
+    return false;
+  }
+  return [message?.target, message?.upto, message?.actionTarget].map(cleanText).some((target) => target === targetKey);
+}
+function chatPreviewHasKey(preview, keys) {
+  const nextKeys = keySet(keys);
+  if (!preview || !nextKeys.size) {
+    return false;
+  }
+  if (messageHasKey(preview, nextKeys)) {
+    return true;
+  }
+  const sourceKey = getChatPreviewSourceKey(preview);
+  if (sourceKey && nextKeys.has(sourceKey)) {
+    return true;
+  }
+  for (const key of nextKeys) {
+    if (previewActionTargetsKey(preview, key)) {
+      return true;
+    }
+  }
+  return false;
+}
 
 // ../../shared/chat/attachments.js
 "use client";
@@ -93226,6 +93414,19 @@ function canonicalChatVersions(chats) {
   return sortChats([...byVersion.values(), ...unkeyed]);
 }
 
+// ../../shared/utils/diagnostics.js
+function markDiag(diag, label, data) {
+  try {
+    diag?.(label, data);
+  } catch {}
+}
+function markDone(diag, label, startedAt, data = {}) {
+  markDiag(diag, `${label}.done`, { ...data, elapsedMs: Date.now() - startedAt });
+}
+function markError(diag, label, startedAt, error, data = {}) {
+  markDiag(diag, `${label}.error`, { ...data, elapsedMs: Date.now() - startedAt, code: error?.code || "", message: error?.message || String(error) });
+}
+
 // ../../shared/crypto/sign.js
 "use client";
 var CHAT_ACTOR_SIGN_SCOPE = "chat-actor-sign-v2";
@@ -93598,7 +93799,7 @@ var MAX_PAIR_CACHE = CHAT_PAIR_CACHE_LIMIT;
 function getChatPairKey(chatPK, peerChatPK, chatId = "") {
   if (!chatPK || !peerChatPK)
     return null;
-  return `${orderChatKeys(chatPK, peerChatPK).join("|")}|${cleanText(chatId)}`;
+  return `${cleanText(chatPK)}|${cleanText(peerChatPK)}|${cleanText(chatId)}`;
 }
 async function getCachedPair(chatPK, chatPrivKey, peerChatPK, options = {}) {
   const chatId = cleanText(options?.chatId);
@@ -93802,6 +94003,44 @@ async function sealPing(senderChatPK, senderPrivKey, recipientChatPK, fields = {
     cleanBytes(eph?.priv, shared, key);
   }
 }
+async function openPing(chatPK, chatPrivKey, ping) {
+  if (ping?.v !== CHAT_PING_VERSION || !ping?.epk || !ping?.body) {
+    throw new Error("invalid chat ping");
+  }
+  let linkPair = null;
+  const priv = toBytes32(chatPrivKey, "chat private key");
+  const epk = cleanText(ping.epk);
+  const shared = x25519.getSharedSecret(priv, fromHex(epk, "chat ping public key"));
+  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) {
+      throw new Error("invalid chat ping payload");
+    }
+    linkPair = await openChatPair(chatPK, chatPrivKey, senderChatPK);
+    if (payload.linkId !== linkPair.linkId || payload.proof !== pingProof(linkPair.linkRoot, payload)) {
+      throw new Error("invalid chat ping proof");
+    }
+    const pair = await openChatPair(chatPK, chatPrivKey, senderChatPK, { chatId: payload.chatId });
+    if (!pair?.chatId || !pair?.actor?.publicKey) {
+      closeChatPair(pair);
+      throw new Error("invalid chat ping chat");
+    }
+    return {
+      pair,
+      payload: {
+        ...payload,
+        senderChatPK,
+        actorPK: cleanText(payload.actorPK)
+      }
+    };
+  } finally {
+    closeChatPair(linkPair);
+    cleanBytes(shared, key);
+  }
+}
 
 // ../../shared/chat/messages/write.js
 function makeTtlMs(value) {
@@ -93987,6 +94226,106 @@ async function sendReadReceipt(cloud, senderPubkey, senderPrivkey, receiverChatP
   };
   return sendMsg(cloud, senderPubkey, senderPrivkey, receiverChatPK, receipt, { ...options, updatePreview: false, ping: options?.ping !== false, pingKind: "read" });
 }
+async function sendReaction(cloud, senderPubkey, senderPrivkey, receiverChatPK, target, emoji, options = {}) {
+  const reaction = {
+    ...makeReaction(target, emoji),
+    cid: makeCid(),
+    s: senderPubkey
+  };
+  const addedReaction = cleanText(reaction.emoji);
+  return sendMsg(cloud, senderPubkey, senderPrivkey, receiverChatPK, reaction, addedReaction ? { ...options, updatePreview: true } : { ...options, updatePreview: false, ping: false });
+}
+async function sendDeleteAction(cloud, senderPubkey, senderPrivkey, receiverChatPK, target, options = {}) {
+  const deleteTarget = cleanText(target);
+  if (!deleteTarget) {
+    throw new Error("delete target required");
+  }
+  const deletion = {
+    ...makeDeleteMsg(deleteTarget),
+    cid: makeCid(),
+    s: senderPubkey
+  };
+  return sendMsg(cloud, senderPubkey, senderPrivkey, receiverChatPK, deletion, { ...options, updatePreview: false, ping: options?.ping !== false, pingKind: "delete" });
+}
+function messageMutationItems(messages, { allowString = false, include = () => true } = {}) {
+  const seen = new Set;
+  const list = Array.isArray(messages) ? messages : [messages];
+  const items = [];
+  for (const message of list || []) {
+    const stringMessage = typeof message === "string";
+    const id = stringMessage ? allowString ? cleanText(message) : "" : cleanText(message?.id);
+    if (!id || id.startsWith("local:") || seen.has(id) || message?.pending || message?.failed || !include(message)) {
+      continue;
+    }
+    seen.add(id);
+    const mediaRef = !stringMessage && hasChatMediaFileRef(message) ? getChatMediaFileRef(message.p) : null;
+    items.push({
+      id,
+      cid: cleanText(message?.cid),
+      mediaKey: mediaRef?.mediaId || "",
+      mediaPath: mediaRef ? cleanText(message.p) : ""
+    });
+  }
+  return items;
+}
+function messageDeleteItems(messages) {
+  return messageMutationItems(messages, { allowString: true });
+}
+function messagePermanentUpdateItems(messages) {
+  return messageMutationItems(messages, { include: (message) => message?.ttl != null });
+}
+function messageTemporaryUpdateItems(messages) {
+  return messageMutationItems(messages, { include: (message) => message?.ttl == null });
+}
+async function makeMsgTemporary(cloud, chatId, messages, ttlMs = newMessageTtlMs()) {
+  const nextTtlMs = makeTtlMs(ttlMs);
+  const items = messageTemporaryUpdateItems(messages);
+  if (!cloud || !chatId || !nextTtlMs || !items.length) {
+    return 0;
+  }
+  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 });
+  return Number.isFinite(result?.updated) ? result.updated : items.length;
+}
+async function makeMsgPermanent(cloud, chatId, messages) {
+  const items = messagePermanentUpdateItems(messages);
+  if (!cloud || !chatId || !items.length) {
+    return 0;
+  }
+  if (typeof cloud.chat?.messages?.ttl !== "function") {
+    throw new Error("message ttl unavailable");
+  }
+  const result = await cloud.chat.messages.ttl(chatId, items, { permanent: true });
+  return Number.isFinite(result?.updated) ? result.updated : items.length;
+}
+async function setChatRetention(cloud, chatId, senderPubkey, senderPrivkey, peerChatPK, retention, options = {}) {
+  if (!senderPubkey || !senderPrivkey || !peerChatPK) {
+    throw new Error("vault locked");
+  }
+  const nextRetention = cleanChatRetention(retention);
+  const pair = await getCachedPair(senderPubkey, senderPrivkey, peerChatPK, { chatId });
+  if (chatId && pair.chatId !== chatId) {
+    throw new Error("chat mismatch");
+  }
+  const systemMessage = {
+    ...makeRetentionSystemMsg(nextRetention),
+    cid: makeCid(),
+    s: senderPubkey
+  };
+  await sendMsg(cloud, senderPubkey, senderPrivkey, peerChatPK, systemMessage, {
+    chatId,
+    linkId: pair.linkId,
+    updatePreview: true,
+    retention: nextRetention,
+    chatExists: true,
+    senderUid: options?.senderUid,
+    ownEntry: options?.ownEntry,
+    chatSettings: { retention: nextRetention }
+  });
+  return nextRetention;
+}
 async function updateMsg(cloud, chatId, msgId, senderPubkey, senderPrivkey, receiverChatPK, newMessage, options = {}) {
   if (!senderPubkey || !senderPrivkey)
     throw new Error("vault locked");
@@ -94034,6 +94373,31 @@ async function updateMsg(cloud, chatId, msgId, senderPubkey, senderPrivkey, rece
     preview
   };
 }
+async function deleteMsg(cloud, chatId, messageOrId, senderPubkey, senderPrivkey, peerChatPK, options = {}) {
+  if (!cloud || !chatId || !messageOrId || !senderPubkey || !senderPrivkey || !peerChatPK) {
+    return false;
+  }
+  const pair = await getCachedPair(senderPubkey, senderPrivkey, peerChatPK, { chatId });
+  if (pair.chatId !== chatId) {
+    return false;
+  }
+  const item = messageDeleteItems([messageOrId])[0];
+  const target = cleanText(options?.docId) || cleanText(item?.id);
+  if (!target || target.startsWith("local:")) {
+    return false;
+  }
+  const deleteTarget = cleanText(options?.target) || cleanText(getMessageKey(messageOrId)) || target;
+  await sendDeleteAction(cloud, senderPubkey, senderPrivkey, peerChatPK, deleteTarget, {
+    chatId,
+    linkId: options?.linkId,
+    messageId: cleanText(options?.deleteActionId),
+    senderUid: options?.senderUid
+  });
+  await cloud.chat.messages.delete(chatId, target, {
+    mediaPaths: item?.mediaPath ? [item.mediaPath] : []
+  });
+  return true;
+}
 
 // ../../shared/chat/actions/send.js
 "use client";
@@ -94113,6 +94477,7 @@ function normalizeDecryptedMsg(msgData, message) {
   }
   const normalized = {
     ...message,
+    id: message.id || msgData?.id || null,
     ts: msgData?.ts ?? null,
     ttl: msgData?.ttl ?? null
   };
@@ -94134,6 +94499,299 @@ async function decryptMsg(msgData, userChatPK, userPrivKey, peerChatPK, options
   }
 }
 
+// ../../shared/chat/inbox.js
+var CHAT_PING_KIND_READ = "read";
+var CHAT_PING_KIND_DELETE = "delete";
+function normalizeChatPreview(msgData, message) {
+  if (!message || typeof message !== "object") {
+    return null;
+  }
+  const normalized = {
+    ...message,
+    ts: msgData?.ts ?? null,
+    ttl: msgData?.ttl ?? null
+  };
+  return canRenderChatPreview(normalized) ? normalized : null;
+}
+async function readExistingEntry(cloud, uid, userPrivKey, entryId) {
+  const entry = await cloud.user.chats.read(uid, entryId).catch(() => null);
+  if (!entry) {
+    return null;
+  }
+  return openOwnChatEntry(userPrivKey, entryId, entry.body).catch(() => null);
+}
+function pingTsMs(ping, preview, fallbackMs) {
+  const ms = timestampMs(ping?.payload?.ts, null) ?? timestampMs(preview?.ts, null) ?? fallbackMs;
+  return Number.isFinite(ms) ? ms : Date.now();
+}
+function pingSortMs(pingDoc, ping) {
+  const payloadMs = Number(ping?.payload?.ts);
+  if (Number.isFinite(payloadMs)) {
+    return payloadMs;
+  }
+  return timestampMs(pingDoc?.ts, 0) ?? 0;
+}
+function pingKind(ping) {
+  return cleanText(ping?.payload?.kind);
+}
+function isReadPing(ping) {
+  return pingKind(ping) === CHAT_PING_KIND_READ;
+}
+function isDeletePing(ping) {
+  return pingKind(ping) === CHAT_PING_KIND_DELETE;
+}
+function pingActors(ping, existing) {
+  return {
+    ...existing?.actors || {},
+    [ping.pair.chatPK]: ping.pair.actor.publicKey,
+    [ping.payload.senderChatPK]: ping.payload.actorPK
+  };
+}
+function chatFromPing(ping, entryId, existing, preview, userChatPK, ms) {
+  const ts = timestampMs(ms, null) ?? timestampMs(existing?.ts, null) ?? timestampMs(preview?.ts, null) ?? 0;
+  if (!ts) {
+    return null;
+  }
+  const visiblePreview = preview || existing?.preview || null;
+  const readMs = timestampMs(existing?.readMs, null);
+  return {
+    protocol: CHAT_PROTOCOL_VERSION,
+    id: ping.pair.chatId,
+    linkId: ping.pair.linkId,
+    entryId,
+    peerChatPK: ping.payload.senderChatPK,
+    peerUid: existing?.peerUid || cleanText(ping.payload.senderUid) || null,
+    actors: pingActors(ping, existing),
+    settings: existing?.settings,
+    saved: existing?.saved || null,
+    readMs,
+    preview: visiblePreview,
+    ts,
+    unseen: visiblePreview ? isChatUnseenForUser({ preview: visiblePreview, readMs }, userChatPK) : false
+  };
+}
+async function resolvePingUid(cloud, payload) {
+  const senderChatPK = cleanText(payload?.senderChatPK);
+  const claimedUid = cleanText(payload?.senderUid);
+  if (!cloud || !senderChatPK) {
+    return null;
+  }
+  if (claimedUid) {
+    const peer2 = await cloud.peer.read(claimedUid).catch(() => null);
+    if (cleanText(peer2?.chatPK) !== senderChatPK) {
+      throw new Error("ping sender uid mismatch");
+    }
+    return claimedUid;
+  }
+  const peer = await cloud.search.peer.byChatPK(senderChatPK).catch(() => null);
+  return peer?.uid || null;
+}
+async function readPingMsg(cloud, userChatPK, userPrivKey, ping, actors, 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);
+  if (!data) {
+    return null;
+  }
+  const message = await decryptMsg(data, userChatPK, userPrivKey, peerChatPK, { actors, 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;
+  }
+  const preview = normalizeChatPreview(data, normalized);
+  return preview && canRenderChatPreview(preview) ? preview : null;
+}
+async function savePing(cloud, uid, userChatPK, userPrivKey, ping, options = {}) {
+  const chatId = ping?.pair?.chatId;
+  if (!chatId || !cleanText(ping?.payload?.actorPK) || !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 hasPreview = Object.prototype.hasOwnProperty.call(options, "preview");
+  const preview = hasPreview ? options.preview : await readPingMsg(cloud, userChatPK, userPrivKey, ping, actors);
+  const entry = makeOwnChatEntry(ping.pair, {
+    peerUid: peerUid || existing?.peerUid,
+    peerActorPK: ping.payload.actorPK || existing?.actors?.[ping.payload.senderChatPK],
+    actors,
+    settings: existing?.settings,
+    preview: preview || existing?.preview,
+    readMs: existing?.readMs
+  });
+  const body = await sealOwnChatEntry(userPrivKey, entryId, entry);
+  const record = { body };
+  if (options.writeTs !== false) {
+    record.tsMs = timestampMs(options.tsMs, null) ?? pingTsMs(ping, preview, Date.now());
+  }
+  await cloud.user.chats.write(uid, entryId, record);
+  return true;
+}
+function chatWithReadPreview(existing, preview, userChatPK) {
+  if (!existing?.id || !preview) {
+    return null;
+  }
+  return {
+    ...existing,
+    preview,
+    unseen: isChatUnseenForUser({ preview, readMs: existing.readMs }, userChatPK)
+  };
+}
+function patchReadPingPreview(existing, receiptPreview, userChatPK) {
+  if (!existing?.preview || !isReadReceiptMsg(receiptPreview)) {
+    return null;
+  }
+  return withChatPreviewOpened(existing.preview, receiptPreview, receiptPreview?.ts, receiptPreview?.from || receiptPreview?.s, userChatPK);
+}
+function deletePingTarget(preview) {
+  return cleanText(preview?.actionTarget) || cleanText(preview?.target) || cleanText(preview?.id);
+}
+function patchDeletePingPreview(existing, deletePreview) {
+  if (!existing?.preview || !isDeleteMsg(deletePreview)) {
+    return null;
+  }
+  const target = deletePingTarget(deletePreview);
+  return withChatPreviewDeleted(existing.preview, target, deletePreview?.ts, deletePreview?.from || deletePreview?.s);
+}
+async function processInbox(cloud, uid, userChatPK, userPrivKey, options = {}) {
+  if (!cloud || !uid || !userChatPK || !userPrivKey) {
+    return false;
+  }
+  const inboxItems = await cloud.inbox.list(uid).catch(() => null);
+  if (!inboxItems?.length) {
+    return false;
+  }
+  const chatsById = new Map((options.currentChats || []).map((chat) => [chat.id, chat]));
+  const opened = [];
+  const invalidDocs = [];
+  for (const pingDoc of inboxItems) {
+    try {
+      const ping = await openPing(userChatPK, userPrivKey, pingDoc);
+      const chatId = ping?.pair?.chatId;
+      if (!chatId) {
+        invalidDocs.push(pingDoc);
+        continue;
+      }
+      opened.push({ pingDoc, ping, chatId, ms: pingSortMs(pingDoc, ping) });
+    } catch {
+      invalidDocs.push(pingDoc);
+    }
+  }
+  await Promise.all(invalidDocs.map((pingDoc) => cloud.inbox.delete(uid, pingDoc.id).catch(() => {})));
+  const pingsByChat = new Map;
+  for (const item of opened.sort((a, b) => a.ms - b.ms)) {
+    let group = pingsByChat.get(item.chatId);
+    if (!group) {
+      group = {
+        chatId: item.chatId,
+        docs: [],
+        message: null,
+        read: null,
+        delete: null
+      };
+      pingsByChat.set(item.chatId, group);
+    }
+    group.docs.push(item.pingDoc);
+    if (isReadPing(item.ping)) {
+      if (!group.read || item.ms > group.read.ms) {
+        group.read = item;
+      }
+    } else if (isDeletePing(item.ping)) {
+      if (!group.delete || item.ms > group.delete.ms) {
+        group.delete = item;
+      }
+    } else if (!group.message || item.ms > group.message.ms) {
+      group.message = item;
+    }
+  }
+  const writes = await Promise.all([...pingsByChat.values()].map(async (group) => {
+    try {
+      let current = chatsById.get(group.chatId) || null;
+      let wrote = false;
+      let handled = false;
+      if (group.message) {
+        const item = group.message;
+        const entryId = ownChatEntryId(userPrivKey, item.chatId);
+        const actors = pingActors(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 chat = chatFromPing(item.ping, entryId, current, preview, userChatPK, item.ms);
+        if (chat) {
+          current = chat;
+          chatsById.set(chat.id, chat);
+          options.onPingChat?.(chat);
+          await new Promise((resolve) => setTimeout(resolve, 0));
+        }
+        wrote = await savePing(cloud, uid, userChatPK, userPrivKey, item.ping, {
+          existing: current,
+          actors,
+          preview
+        });
+      }
+      if (group.read) {
+        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 openedPreview = patchReadPingPreview(existing, receiptPreview, userChatPK);
+        const chat = chatWithReadPreview(current, openedPreview, userChatPK);
+        handled = true;
+        if (openedPreview) {
+          if (chat) {
+            current = chat;
+            chatsById.set(chat.id, chat);
+            options.onPingChat?.(chat);
+          }
+          const writeExisting = chat || existing;
+          wrote = await savePing(cloud, uid, userChatPK, userPrivKey, item.ping, {
+            existing: writeExisting,
+            actors,
+            preview: openedPreview,
+            writeTs: false
+          }) || wrote;
+        }
+      }
+      if (group.delete) {
+        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 deletedPreview = patchDeletePingPreview(existing, deletePreview);
+        const chat = deletedPreview ? chatFromPing(item.ping, entryId, current || existing, deletedPreview, userChatPK, item.ms) : null;
+        handled = true;
+        if (deletedPreview) {
+          if (chat) {
+            current = chat;
+            chatsById.set(chat.id, chat);
+            options.onPingChat?.(chat);
+          }
+          const writeExisting = chat || existing;
+          wrote = await savePing(cloud, uid, userChatPK, userPrivKey, item.ping, {
+            existing: writeExisting,
+            actors,
+            preview: deletedPreview
+          }) || wrote;
+        }
+      }
+      if (wrote || handled) {
+        await Promise.all(group.docs.map((pingDoc) => cloud.inbox.delete(uid, pingDoc.id).catch(() => {})));
+      }
+      return wrote || handled;
+    } catch (error) {
+      options.onPingError?.(error, group);
+      return false;
+    }
+  }));
+  return writes.some(Boolean);
+}
+
 // ../../shared/chat/list.js
 var CHAT_LIST_DECRYPT_YIELD_EVERY = 2;
 function chatDocDataEqual(a, b) {
@@ -94160,7 +94818,7 @@ function pruneChatStatusCache(statusCache, chats, now = Date.now()) {
     }
   }
 }
-function normalizeChatPreview(msgData, message) {
+function normalizeChatPreview2(msgData, message) {
   if (!message || typeof message !== "object") {
     return null;
   }
@@ -94307,7 +94965,7 @@ async function decryptChatEntry(entryRecord, userChatPK, userPrivKey) {
   if (entry.protocol !== CHAT_PROTOCOL_VERSION) {
     return null;
   }
-  const preview = normalizeChatPreview({ ts: data?.ts ?? null, ttl: entry?.preview?.ttl ?? null }, entry?.preview);
+  const preview = normalizeChatPreview2({ ts: data?.ts ?? null, ttl: entry?.preview?.ttl ?? null }, entry?.preview);
   const visiblePreview = preview && canRenderChatPreview(preview) ? preview : null;
   const ts = timestampMs(data?.ts, null) ?? 0;
   const readMs = timestampMs(entry.readMs, null);
@@ -94352,76 +95010,6 @@ async function readEntryResult(entryRecord, userChatPK, userPrivKey, cache) {
   }
 }
 
-// ../../shared/wallet/keys.js
-"use client";
-var VALID_WALLET_NETWORKS = new Set(["MAINNET", "REGTEST", "TESTNET", "SIGNET", "LOCAL"]);
-function normalizeWalletNetwork(network) {
-  const next = String(network ?? "").trim().toUpperCase();
-  if (!VALID_WALLET_NETWORKS.has(next)) {
-    throw new Error("invalid wallet network");
-  }
-  return next;
-}
-function walletPKField(network) {
-  return `walletPKs.${normalizeWalletNetwork(network)}`;
-}
-function resolveWalletPK(data, network) {
-  const key = normalizeWalletNetwork(network);
-  const walletPKs = data?.walletPKs;
-  const walletPK = walletPKs && typeof walletPKs === "object" && typeof walletPKs[key] === "string" ? walletPKs[key].trim() : "";
-  if (walletPK) {
-    return normalizeWalletPK(walletPK);
-  }
-  return null;
-}
-function normalizeWalletPK(walletPK) {
-  return typeof walletPK === "string" ? lowerText(walletPK) : walletPK;
-}
-
-// ../../shared/wallet/spark.js
-var import_bech32 = __toESM(require_dist(), 1);
-var SPARK_ADDRESS_PREFIX = Object.freeze({
-  MAINNET: "spark",
-  TESTNET: "sparkt",
-  REGTEST: "sparkrt",
-  SIGNET: "sparks",
-  LOCAL: "sparkl"
-});
-function getSparkAddressPrefix(network) {
-  const prefix2 = SPARK_ADDRESS_PREFIX[String(network ?? "").toUpperCase()];
-  if (!prefix2) {
-    throw new Error("invalid wallet network");
-  }
-  return prefix2;
-}
-function hexToBytes5(hex3) {
-  const value = String(hex3 ?? "").trim();
-  if (value.length % 2 !== 0) {
-    throw new Error("invalid hex");
-  }
-  const bytes = new Uint8Array(value.length / 2);
-  for (let i = 0;i < bytes.length; i++) {
-    const start = i * 2;
-    const byte = Number.parseInt(value.slice(start, start + 2), 16);
-    if (Number.isNaN(byte)) {
-      throw new Error("invalid hex");
-    }
-    bytes[i] = byte;
-  }
-  return bytes;
-}
-function walletPKtoSparkAddress(walletPK, network) {
-  const key = hexToBytes5(walletPK);
-  if (key.length !== 33) {
-    throw new Error("need 33-byte compressed pubkey");
-  }
-  const payload = new Uint8Array(2 + key.length);
-  payload[0] = 10;
-  payload[1] = 33;
-  payload.set(key, 2);
-  return import_bech32.bech32m.encode(getSparkAddressPrefix(network), import_bech32.bech32m.toWords(payload), 1500);
-}
-
 // ../../shared/wallet/tx.js
 var TRANSFER_STATUS_COMPLETED = "TRANSFER_STATUS_COMPLETED";
 var TRANSFER_TYPE_BITCOIN_DEPOSIT = "BITCOIN_DEPOSIT";
@@ -94490,11 +95078,17 @@ function isVisibleTransferStatus(tx) {
 function isVisibleTransfer(tx) {
   return isVisibleTransferStatus(tx) && (isWalletTransfer(tx) || isFundingTransfer(tx) || isWithdrawalTransfer(tx));
 }
+function isClaimablePendingTransfer(tx, types = null) {
+  if (Array.isArray(types) && types.length && !types.includes(tx?.type)) {
+    return false;
+  }
+  return CLAIMABLE_TRANSFER_STATUSES.has(tx?.status) || CLAIMABLE_TRANSFER_STATUS_CODES.has(tx?.status);
+}
 function transferBelongsToWallet(tx, walletPK) {
   return !!walletPK && (sameText(tx?.senderIdentityPublicKey, walletPK) || sameText(tx?.receiverIdentityPublicKey, walletPK));
 }
 
-// ../../shared/account/actions.js
+// ../../shared/account/actions/values.js
 var CHAT_PK_RE = /^[0-9a-f]{64}$/i;
 var WALLET_PK_RE = /^0[2-3][0-9a-f]{64}$/i;
 function cleanPeer(value) {
@@ -94551,9 +95145,6 @@ function timestampValue(value) {
   const parsed = Date.parse(value);
   return Number.isFinite(parsed) ? parsed : null;
 }
-function messageDirection(message, chatPK) {
-  return isPeerMsg(message, chatPK) ? "peer" : "self";
-}
 function requestRef(chatId, messageId) {
   return `${chatId}:${messageId}`;
 }
@@ -94570,6 +95161,23 @@ function parseRequestRef(value) {
   }
   return { chatId, messageId };
 }
+function requireCloud(value) {
+  if (!value) {
+    throw new Error("cloud required");
+  }
+  return value;
+}
+function requireSession(session) {
+  if (!session?.uid || !session?.network || !session?.wallet || !session?.chatPK || !session?.chatPrivKey) {
+    throw new Error("account session unlocked required");
+  }
+  return session;
+}
+
+// ../../shared/account/actions/summary.js
+function messageDirection(message, chatPK) {
+  return isPeerMsg(message, chatPK) ? "peer" : "self";
+}
 function simplifyAccountMessage(message, chat, chatPK, options = {}) {
   const type = message?.t || "unknown";
   const item = {
@@ -94583,11 +95191,13 @@ function simplifyAccountMessage(message, chat, chatPK, options = {}) {
   };
   if (type === "txt") {
     item.text = message.c || "";
+    item.replyId = message.r || null;
   } else if (type === "req") {
     item.amountSats = Number(message.a || 0);
     item.paid = !!message.tx;
     item.txId = message.tx || null;
     item.requestId = message.id ? requestRef(chat?.id, message.id) : null;
+    item.replyId = message.r || null;
   } else {
     item.payload = { ...message };
   }
@@ -94618,31 +95228,1672 @@ function simplifyAccountTransfer(tx) {
     receiverIdentityPublicKey: tx?.receiverIdentityPublicKey || null
   };
 }
-function requireCloud(value) {
-  if (!value) {
-    throw new Error("cloud required");
+
+// ../../shared/account/actions/chat.js
+function createChatActions({ readCloud, readSession, inbox, peers }) {
+  function writeOptions(active, chat, options = {}) {
+    return {
+      ...options,
+      chatId: chat.id,
+      senderUid: active.uid,
+      receiverUid: chat.peerUid,
+      peerActorPK: chat.actors?.[chat.peerChatPK],
+      ownEntry: chat.entryId ? chat : null,
+      chatSettings: normalizeChatSettings(chat.settings)
+    };
+  }
+  function requireRetention(value) {
+    const retention2 = cleanText(value);
+    if (!hasChatRetention(retention2)) {
+      throw new Error(`retention must be ${CHAT_RETENTION_VALUES.join(" or ")}`);
+    }
+    return cleanChatRetention(retention2);
+  }
+  function withPeerProfile(chat, profile) {
+    if (!chat || !profile) {
+      return chat || null;
+    }
+    const peerChatPK = profile.chatPK || chat.peerChatPK;
+    return {
+      ...chat,
+      peerChatPK,
+      peerUid: profile.uid || chat.peerUid || null,
+      actors: {
+        ...chat.actors || {},
+        ...peerChatPK && profile.actorPK ? { [peerChatPK]: profile.actorPK } : {}
+      }
+    };
+  }
+  async function list(options = {}) {
+    const active = await readSession();
+    const count = cleanLimit(options.count || options.limit, 30);
+    const current = await inbox.load(active, count);
+    const { chats } = await inbox.sync(active, current);
+    const peerMap = await peers.mapForChats(chats);
+    return chats.map((chat) => simplifyAccountChat(chat, peerMap.get(chat.peerChatPK)));
+  }
+  async function chatForPeer(peer, options = {}) {
+    const active = await readSession();
+    const current = await inbox.load(active, cleanLimit(options.count, 50));
+    const { chats } = await inbox.sync(active, current);
+    const value = String(peer ?? "").trim().toLowerCase();
+    const chatByProfile = async (profile2) => {
+      if (!profile2?.chatPK) {
+        return null;
+      }
+      const chat = chats.find((chat2) => chat2.peerChatPK === profile2.chatPK);
+      if (chat) {
+        return withPeerProfile(chat, profile2);
+      }
+      const link = await resolvePeerChat(readCloud(), active.chatPK, active.chatPrivKey, profile2.chatPK, options).catch(() => null);
+      if (!link?.chatId) {
+        return null;
+      }
+      const linkedChat = await getChat(readCloud(), active.uid, link.chatId, active.chatPK, active.chatPrivKey).catch(() => null);
+      return withPeerProfile(linkedChat, profile2);
+    };
+    if (CHAT_PK_RE.test(value)) {
+      const chat = chats.find((item) => item.id === value || item.peerChatPK === value);
+      if (chat) {
+        return chat;
+      }
+      const profile2 = await peers.resolve(value).catch(() => null);
+      const resolvedChat = await chatByProfile(profile2);
+      if (resolvedChat) {
+        return resolvedChat;
+      }
+      return getChat(readCloud(), active.uid, value, active.chatPK, active.chatPrivKey).catch(() => null);
+    }
+    const profile = await peers.resolve(peer);
+    return chatByProfile(profile);
+  }
+  async function readDisplayMessages(active, chat, options = {}) {
+    const page = await readCloud().chat.messages.list(chat.id, { count: cleanLimit(options.count || options.limit, 30) });
+    const decrypted = [];
+    for (const record of page.records || []) {
+      const message = await decryptMsg(record, active.chatPK, active.chatPrivKey, chat.peerChatPK, {
+        actors: chat.actors,
+        chatId: chat.id
+      });
+      if (message) {
+        decrypted.push(message);
+      }
+    }
+    const display = getDisplayMessages(decrypted, active.chatPK, chat.peerChatPK).filter(canShowMsg);
+    return { page, decrypted, display };
+  }
+  async function read(peer, options = {}) {
+    const active = await readSession();
+    const chat = await chatForPeer(peer, options);
+    if (!chat) {
+      return { chat: null, messages: [] };
+    }
+    const { page, display } = await readDisplayMessages(active, chat, options);
+    const messages = display.map((message) => simplifyAccountMessage(message, chat, active.chatPK, options));
+    if (options.markRead !== false) {
+      const lastPeer = [...display].reverse().find((message) => isPeerMsg(message, active.chatPK));
+      if (lastPeer?.id) {
+        await setChatRead(readCloud(), active.uid, active.chatPrivKey, chat.id, lastPeer.ts).catch(() => {});
+        const target = getMessageKey(lastPeer);
+        if (target) {
+          await sendReadReceipt(readCloud(), active.chatPK, active.chatPrivKey, chat.peerChatPK, target, {
+            chatId: chat.id,
+            senderUid: active.uid,
+            receiverUid: chat.peerUid,
+            linkId: chat.linkId,
+            peerActorPK: chat.actors?.[chat.peerChatPK],
+            ping: true
+          }).catch(() => {});
+        }
+      }
+    }
+    return {
+      chat: simplifyAccountChat(chat),
+      messages,
+      hasMore: page.hasMore === true,
+      nextOlderThan: page.nextOlderThan || null
+    };
+  }
+  async function messageForPeer(peer, messageId, options = {}) {
+    const target = cleanText(messageId);
+    if (!target) {
+      throw new Error("message id required");
+    }
+    const active = await readSession();
+    const chat = await chatForPeer(peer, options);
+    if (!chat) {
+      throw new Error("chat not found");
+    }
+    const { decrypted, display } = await readDisplayMessages(active, chat, { ...options, count: 100, limit: 100 });
+    const messages = [...display, ...decrypted];
+    const message = messages.find((item) => item?.id === target || item?.cid === target || getMessageKey(item) === target);
+    if (message) {
+      return { active, chat, message, target: getMessageKey(message) || target };
+    }
+    const record = await readCloud().chat.messages.read(chat.id, target).catch(() => null);
+    const direct = record ? await decryptMsg(record, active.chatPK, active.chatPrivKey, chat.peerChatPK, {
+      actors: chat.actors,
+      chatId: chat.id
+    }) : null;
+    if (!direct) {
+      throw new Error("message not found");
+    }
+    return { active, chat, message: direct, target: getMessageKey(direct) || target };
+  }
+  async function targetForPeer(peer, messageId, options = {}) {
+    try {
+      return await messageForPeer(peer, messageId, options);
+    } catch (error) {
+      if (error?.message !== "message not found") {
+        throw error;
+      }
+      const target = cleanText(messageId);
+      if (!target) {
+        throw new Error("message id required", { cause: error });
+      }
+      const active = await readSession();
+      const chat = await chatForPeer(peer, options);
+      if (!chat) {
+        throw new Error("chat not found", { cause: error });
+      }
+      return { active, chat, message: null, target };
+    }
+  }
+  async function sendPayload(peer, payload, options = {}) {
+    const active = await readSession();
+    const profile = await peers.resolve(peer);
+    if (!profile.chatPK) {
+      throw new Error("peer chat key missing");
+    }
+    if (profile.chatPK === active.chatPK) {
+      throw new Error("cannot message self");
+    }
+    const link = await resolvePeerChat(readCloud(), active.chatPK, active.chatPrivKey, profile.chatPK, options);
+    const message = {
+      ...payload,
+      s: payload?.s || active.chatPK,
+      cid: payload?.cid || makeCid()
+    };
+    const sent = await sendMsg(readCloud(), active.chatPK, active.chatPrivKey, profile.chatPK, message, {
+      ...options,
+      chatId: link.chatId,
+      linkId: link.linkId,
+      linkVersion: link.version,
+      protocol: link.protocol,
+      senderUid: active.uid,
+      receiverUid: profile.uid,
+      peerActorPK: profile.actorPK
+    });
+    return {
+      chat: {
+        id: sent.chatId,
+        peerChatPK: profile.chatPK,
+        username: profile.username
+      },
+      message: simplifyAccountMessage(sent.message, { id: sent.chatId, peerChatPK: profile.chatPK }, active.chatPK, options)
+    };
+  }
+  async function send(peer, message, options = {}) {
+    return sendPayload(peer, makeTxt(cleanMessage(message)), options);
+  }
+  async function reply(peer, messageId, message, options = {}) {
+    const { target } = await targetForPeer(peer, messageId, options);
+    return sendPayload(peer, setReply(makeTxt(cleanMessage(message)), target), options);
+  }
+  async function react(peer, messageId, emoji, options = {}) {
+    const { active, chat, target } = await targetForPeer(peer, messageId, options);
+    const sent = await sendReaction(readCloud(), active.chatPK, active.chatPrivKey, chat.peerChatPK, target, emoji, writeOptions(active, chat, options));
+    return {
+      chat: simplifyAccountChat(chat),
+      message: simplifyAccountMessage(sent.message, chat, active.chatPK, options)
+    };
+  }
+  async function unreact(peer, messageId, options = {}) {
+    return react(peer, messageId, null, options);
+  }
+  async function save(peer, messageId, options = {}) {
+    const { active, chat, message } = await messageForPeer(peer, messageId, options);
+    const updated = await makeMsgPermanent(readCloud(), chat.id, [message]);
+    return {
+      chat: simplifyAccountChat(chat),
+      message: simplifyAccountMessage(message, chat, active.chatPK, options),
+      saved: true,
+      updated
+    };
+  }
+  async function unsave(peer, messageId, options = {}) {
+    const { active, chat, message } = await messageForPeer(peer, messageId, options);
+    const updated = await makeMsgTemporary(readCloud(), chat.id, [message]);
+    return {
+      chat: simplifyAccountChat(chat),
+      message: simplifyAccountMessage(message, chat, active.chatPK, options),
+      saved: false,
+      updated
+    };
+  }
+  async function deleteMessage(peer, messageId, options = {}) {
+    const { active, chat, message, target } = await messageForPeer(peer, messageId, options);
+    const deleted = await deleteMsg(readCloud(), chat.id, message, active.chatPK, active.chatPrivKey, chat.peerChatPK, {
+      ...writeOptions(active, chat, options),
+      target,
+      docId: message.id
+    });
+    return {
+      chat: simplifyAccountChat(chat),
+      messageId: message.id,
+      target,
+      deleted: deleted === true
+    };
+  }
+  async function deleteChat(peer, options = {}) {
+    const active = await readSession();
+    const chat = await chatForPeer(peer, options);
+    if (!chat) {
+      return { deleted: false, chat: null };
+    }
+    const entryId = chat.entryId || ownChatEntryId(active.chatPrivKey, chat.id);
+    await readCloud().chat.delete([
+      {
+        chatId: chat.id,
+        entryId,
+        linkId: chat.linkId
+      }
+    ], { cleanup: options.cleanup !== false });
+    return {
+      chat: simplifyAccountChat(chat),
+      deleted: true
+    };
+  }
+  async function retention(peer, value, options = {}) {
+    const active = await readSession();
+    const chat = await chatForPeer(peer, options);
+    if (!chat) {
+      throw new Error("chat not found");
+    }
+    const saved = await setChatRetention(readCloud(), chat.id, active.chatPK, active.chatPrivKey, chat.peerChatPK, requireRetention(value), writeOptions(active, chat, options));
+    return {
+      chat: simplifyAccountChat({
+        ...chat,
+        settings: {
+          ...normalizeChatSettings(chat.settings),
+          retention: saved
+        }
+      }),
+      retention: saved
+    };
+  }
+  return {
+    list,
+    chatForPeer,
+    read,
+    send,
+    reply,
+    sendPayload,
+    react,
+    unreact,
+    save,
+    unsave,
+    deleteMessage,
+    deleteChat,
+    retention
+  };
+}
+
+// ../../shared/account/actions/inbox.js
+function createInboxSync({ readCloud }) {
+  async function load(active, count = 30) {
+    return loadAllChats(readCloud(), active.uid, active.chatPK, active.chatPrivKey, cleanLimit(count, 30));
+  }
+  async function sync(active, chats = null) {
+    let current = Array.isArray(chats) ? chats : await load(active, 50);
+    let processed = false;
+    for (let index = 0;index < 4; index += 1) {
+      const changed = await processInbox(readCloud(), active.uid, active.chatPK, active.chatPrivKey, { currentChats: current }).catch(() => false);
+      if (!changed) {
+        break;
+      }
+      processed = true;
+      current = await load(active, Math.max(current.length, 50));
+    }
+    return { chats: current, processed };
+  }
+  return { load, sync };
+}
+
+// ../../shared/navigation/params.js
+function firstRouteParam(value) {
+  return Array.isArray(value) ? value[0] : value;
+}
+function getRouteParam(params, key) {
+  const raw = typeof params?.get === "function" ? params.get(key) : params?.[key];
+  return firstRouteParam(raw) ?? null;
+}
+
+// ../../shared/username.js
+var MAX_USERNAME = USERNAME_MAX_CHARS;
+var usernameRegex = new RegExp(`^[a-z0-9]{1,${MAX_USERNAME}}$`);
+function normalizeUsername(value = "") {
+  return String(value).trim().toLowerCase();
+}
+function isUsername(value = "") {
+  return usernameRegex.test(value);
+}
+
+// ../../shared/qr.js
+function getQrOrigin() {
+  return origins.veyl;
+}
+var tx = {
+  request: "req",
+  payment: "pay"
+};
+var qrHosts = new Set(appLinkDomains);
+var qr = Object.freeze({
+  user: "user",
+  request: "request",
+  payment: "payment",
+  bitcoin: "bitcoin",
+  lightning: "lightning",
+  spark: "spark"
+});
+function maybe(value) {
+  const next = cleanText(value);
+  return next || null;
+}
+function userHandle(value) {
+  const next = maybe(value);
+  if (!next)
+    return null;
+  const raw = next.startsWith("@") ? next.slice(1) : next;
+  const username = normalizeUsername(raw);
+  return isUsername(username) ? username : null;
+}
+function readUser(value) {
+  const username = userHandle(typeof value === "string" ? value : value?.u ?? value?.username);
+  if (!username)
+    return null;
+  return {
+    kind: qr.user,
+    username
+  };
+}
+function readTx(value) {
+  if (!value || typeof value !== "object")
+    return null;
+  const tag = maybe(value.t ?? value.type);
+  const to = maybe(value.r ?? value.to ?? value.receiver);
+  if (!tag || !to)
+    return null;
+  if (tag !== tx.request && tag !== tx.payment)
+    return null;
+  return {
+    kind: tag === tx.request ? qr.request : qr.payment,
+    to,
+    from: maybe(value.s ?? value.from ?? value.sender),
+    amount: maybe(value.a ?? value.amount),
+    currency: maybe(value.c ?? value.currency),
+    pay: maybe(value.p ?? value.pay ?? value.payment ?? value.paymentType),
+    message: maybe(value.m ?? value.message)
+  };
+}
+function readQrUrlParams(value) {
+  try {
+    const url = new URL(value, getQrOrigin());
+    if (url.protocol !== "https:" || url.pathname !== "/qr" || !qrHosts.has(url.hostname)) {
+      return null;
+    }
+    return url.searchParams;
+  } catch {
+    return null;
+  }
+}
+function readParams(params) {
+  const user = readUser({
+    u: getRouteParam(params, "u"),
+    username: getRouteParam(params, "username")
+  });
+  if (user)
+    return user;
+  const request = readTx({
+    t: tx.request,
+    r: getRouteParam(params, "r"),
+    s: getRouteParam(params, "s"),
+    a: getRouteParam(params, "a"),
+    c: getRouteParam(params, "c"),
+    p: getRouteParam(params, "p"),
+    m: getRouteParam(params, "m")
+  });
+  if (request)
+    return request;
+  const lightning = readLightning({
+    invoice: getRouteParam(params, "l") || getRouteParam(params, "lightning") || getRouteParam(params, "invoice"),
+    username: getRouteParam(params, "lu") || getRouteParam(params, "lightningUser"),
+    walletPK: getRouteParam(params, "lw") || getRouteParam(params, "lightningWalletPK")
+  });
+  if (lightning)
+    return lightning;
+  const spark = readSpark(getRouteParam(params, "s") || getRouteParam(params, "spark"));
+  if (spark)
+    return spark;
+  const address = readBitcoin(getRouteParam(params, "b"));
+  if (!address)
+    return null;
+  return {
+    kind: qr.bitcoin,
+    address
+  };
+}
+function getLightningInvoice(value) {
+  const raw = cleanText(typeof value === "string" ? value : value?.invoice ?? value?.encodedInvoice ?? value?.bolt11);
+  const lower = lowerText(raw);
+  if (!lower)
+    return null;
+  const invoice = lower.startsWith("lightning://") ? raw.slice(12).trim() : lower.startsWith("lightning:") ? raw.slice(10).trim() : raw;
+  const normalized = lowerText(invoice);
+  return /^ln[a-z0-9]+$/.test(normalized) ? invoice : null;
+}
+function ceilDiv(value, divisor) {
+  return (value + divisor - 1n) / divisor;
+}
+function lightningAmountSats(invoice) {
+  const value = lowerText(invoice);
+  const match2 = value.match(/^ln(?:bcrt|bc|tb|sb|tbs)(\d+[munp]?)?1/);
+  const amount = match2?.[1];
+  if (!amount)
+    return null;
+  const unit = /[munp]$/.test(amount) ? amount.slice(-1) : "";
+  const raw = unit ? amount.slice(0, -1) : amount;
+  if (!/^\d+$/.test(raw))
+    return null;
+  const n = BigInt(raw);
+  switch (unit) {
+    case "m":
+      return n * 100000n;
+    case "u":
+      return n * 100n;
+    case "n":
+      return ceilDiv(n, 10n);
+    case "p":
+      return ceilDiv(n, 10000n);
+    default:
+      return n * 100000000n;
+  }
+}
+function readLightning(value) {
+  const invoice = getLightningInvoice(value);
+  if (!invoice)
+    return null;
+  const amountSats = lightningAmountSats(invoice);
+  const username = userHandle(typeof value === "object" ? value?.username ?? value?.user ?? value?.lu : null);
+  const walletPK = maybe(typeof value === "object" ? value?.walletPK ?? value?.receiver ?? value?.lw : null);
+  return {
+    kind: qr.lightning,
+    invoice,
+    ...username ? { username } : {},
+    ...walletPK ? { walletPK } : {},
+    ...amountSats != null && amountSats > 0n ? { amount: amountSats.toString() } : {}
+  };
+}
+function getSparkInvoice(value) {
+  const raw = cleanText(typeof value === "string" ? value : value?.invoice ?? value?.sparkInvoice ?? value?.address);
+  const lower = lowerText(raw);
+  if (!lower)
+    return null;
+  return /^(spark|sparkt|sparkrt|sparks|sparkl)1[023456789acdefghjklmnpqrstuvwxyz]+$/.test(lower) ? raw : null;
+}
+function readSpark(value) {
+  const invoice = getSparkInvoice(value);
+  return invoice ? {
+    kind: qr.spark,
+    invoice
+  } : null;
+}
+function readApp(raw) {
+  if (raw && typeof raw === "object") {
+    return readParams(raw);
+  }
+  const value = cleanText(raw);
+  if (!value)
+    return null;
+  const params = readQrUrlParams(value);
+  if (params)
+    return readParams(params);
+  return value.startsWith("@") ? readUser(value) : null;
+}
+function readBitcoin(value) {
+  const raw = cleanText(value);
+  let clean4 = raw;
+  if (lowerText(raw).startsWith("bitcoin:"))
+    clean4 = raw.slice(8);
+  const legacy = /^[13][a-km-zA-HJ-NP-Z1-9]{25,34}$/;
+  const bech323 = /^(bc1|bcrt1)[ac-hj-np-z02-9]{39,87}$/i;
+  return legacy.test(clean4) || bech323.test(clean4) ? clean4 : null;
+}
+function readQr(raw) {
+  const veyl = readApp(raw);
+  if (veyl)
+    return veyl;
+  const lightning = readLightning(raw);
+  if (lightning)
+    return lightning;
+  const spark = readSpark(raw);
+  if (spark)
+    return spark;
+  const address = readBitcoin(raw);
+  if (!address)
+    return null;
+  return {
+    kind: qr.bitcoin,
+    address
+  };
+}
+
+// ../../shared/wallet/claiming.js
+var activeWalletClaims = new WeakMap;
+function transferIds(transfers = []) {
+  return [...new Set((Array.isArray(transfers) ? transfers : []).map((tx2) => String(tx2?.id || "")).filter(Boolean))];
+}
+async function queryPendingTransferIds(wallet, ids = [], diag) {
+  if (!ids.length || typeof wallet?.transferService?.queryPendingTransfers !== "function") {
+    return new Set;
+  }
+  const startedAt = Date.now();
+  markDiag(diag, "wallet.pendingTxs.claim.verify.start", { count: ids.length });
+  const requestedIds = new Set(ids);
+  try {
+    const page = await wallet.transferService.queryPendingTransfers.call(wallet.transferService, ids);
+    const pendingTransfers = (Array.isArray(page?.transfers) ? page.transfers : []).filter((transfer) => requestedIds.has(String(transfer?.id || "")));
+    markDone(diag, "wallet.pendingTxs.claim.verify", startedAt, { count: ids.length, pending: pendingTransfers.length });
+    return new Set(pendingTransfers.map((transfer) => String(transfer?.id || "")).filter(Boolean));
+  } catch (error) {
+    markError(diag, "wallet.pendingTxs.claim.verify", startedAt, error, { count: ids.length });
+    throw error;
+  }
+}
+async function claimIncomingTransfersById(wallet, transfers = [], { onClaimed, emitClaimEvents = false, drainAll = true, diag } = {}) {
+  const ids = transferIds(transfers);
+  if (!ids.length || typeof wallet?.transferService?.queryPendingTransfers !== "function" || typeof wallet?.claimTransfers !== "function" && typeof wallet?.claimTransfer !== "function") {
+    return [];
+  }
+  const requestedIds = new Set(ids);
+  const activeClaim = activeWalletClaims.get(wallet);
+  if (activeClaim) {
+    const claimedIds = transferIds(await activeClaim).filter((id) => requestedIds.has(id));
+    if (claimedIds.length) {
+      onClaimed?.(claimedIds);
+    }
+    return claimedIds;
+  }
+  const claimPromise = (async () => {
+    if (drainAll !== false && typeof wallet?.claimTransfers === "function") {
+      const claimedIds2 = [];
+      const claimStartedAt = Date.now();
+      markDiag(diag, "wallet.pendingTxs.claim.sdk.start", { count: ids.length, mode: "all" });
+      try {
+        claimedIds2.push(...transferIds(await wallet.claimTransfers(undefined, emitClaimEvents === true)));
+        markDone(diag, "wallet.pendingTxs.claim.sdk", claimStartedAt, { count: ids.length, mode: "all", claimed: claimedIds2.length });
+      } catch (error) {
+        markError(diag, "wallet.pendingTxs.claim.sdk", claimStartedAt, error, { count: ids.length, mode: "all" });
+        console.debug?.("could not claim pending transfers", error?.message ?? error);
+      }
+      try {
+        const pendingIds2 = await queryPendingTransferIds(wallet, ids, diag);
+        claimedIds2.push(...ids.filter((id) => !pendingIds2.has(id)));
+      } catch (error) {
+        console.debug?.("could not verify pending transfers", error?.message ?? error);
+      }
+      const uniqueClaimedIds = [...new Set(claimedIds2)];
+      if (uniqueClaimedIds.length) {
+        onClaimed?.(uniqueClaimedIds);
+      }
+      return uniqueClaimedIds;
+    }
+    const queryStartedAt = Date.now();
+    markDiag(diag, "wallet.pendingTxs.claim.query.start", { count: ids.length });
+    let page;
+    try {
+      page = await wallet.transferService.queryPendingTransfers.call(wallet.transferService, ids);
+    } catch (error) {
+      markError(diag, "wallet.pendingTxs.claim.query", queryStartedAt, error, { count: ids.length });
+      throw error;
+    }
+    const pendingTransfers = (Array.isArray(page?.transfers) ? page.transfers : []).filter((transfer) => requestedIds.has(String(transfer?.id || "")));
+    markDone(diag, "wallet.pendingTxs.claim.query", queryStartedAt, { count: ids.length, pending: pendingTransfers.length });
+    const pendingIds = new Set(pendingTransfers.map((transfer) => String(transfer?.id || "")).filter(Boolean));
+    const claimedIds = [];
+    const alreadySettledIds = ids.filter((id) => !pendingIds.has(id));
+    if (alreadySettledIds.length) {
+      claimedIds.push(...alreadySettledIds);
+      onClaimed?.(alreadySettledIds);
+    }
+    for (const transfer of pendingTransfers) {
+      if (!isClaimablePendingTransfer(transfer)) {
+        continue;
+      }
+      let claimStartedAt = Date.now();
+      try {
+        await yieldToUi();
+        claimStartedAt = Date.now();
+        markDiag(diag, "wallet.pendingTxs.claim.sdk.start", { count: 1, leaves: Array.isArray(transfer?.leaves) ? transfer.leaves.length : 0 });
+        await wallet.claimTransfer({ transfer, emit: emitClaimEvents === true });
+        markDone(diag, "wallet.pendingTxs.claim.sdk", claimStartedAt, { count: 1 });
+        if (transfer?.id) {
+          const id = String(transfer.id);
+          claimedIds.push(id);
+          onClaimed?.([id]);
+        }
+      } catch (error) {
+        markError(diag, "wallet.pendingTxs.claim.sdk", claimStartedAt, error, { count: 1 });
+        console.debug?.("could not claim pending transfer", error?.message ?? error);
+      }
+      await yieldToUi();
+    }
+    return claimedIds;
+  })();
+  activeWalletClaims.set(wallet, claimPromise);
+  try {
+    return await claimPromise;
+  } finally {
+    if (activeWalletClaims.get(wallet) === claimPromise) {
+      activeWalletClaims.delete(wallet);
+    }
+  }
+}
+async function claimPendingIncomingTransfers(wallet, { limit = WALLET_PENDING_TRANSFER_CLAIM_BATCH_SIZE, onClaimed, emitClaimEvents = false, drainAll = true, diag } = {}) {
+  if (typeof wallet?.transferService?.queryPendingTransfers !== "function") {
+    return [];
+  }
+  const startedAt = Date.now();
+  const pageLimit = Math.max(1, Number(limit) || WALLET_PENDING_TRANSFER_CLAIM_BATCH_SIZE);
+  markDiag(diag, "wallet.pendingTxs.claim.scan.start", { limit: pageLimit });
+  let pendingTransfers;
+  try {
+    const page = await wallet.transferService.queryPendingTransfers.call(wallet.transferService, {
+      limit: pageLimit,
+      offset: 0
+    });
+    pendingTransfers = Array.isArray(page?.transfers) ? page.transfers : [];
+    markDone(diag, "wallet.pendingTxs.claim.scan", startedAt, { limit: pageLimit, pending: pendingTransfers.length });
+  } catch (error) {
+    markError(diag, "wallet.pendingTxs.claim.scan", startedAt, error, { limit: pageLimit });
+    throw error;
+  }
+  if (!pendingTransfers.length) {
+    return [];
+  }
+  return claimIncomingTransfersById(wallet, pendingTransfers, {
+    onClaimed,
+    emitClaimEvents,
+    drainAll,
+    diag
+  });
+}
+
+// ../../shared/network.js
+var DEFAULT_NETWORK = "REGTEST";
+var MAINNET_NETWORK = "MAINNET";
+var REGTEST_NETWORK = "REGTEST";
+var MAINNET_DOMAIN = domains.veyl;
+var REGTEST_DOMAIN = domains.veylTest;
+function resolveNetwork(env = {}) {
+  const raw = env?.EXPO_PUBLIC_NETWORK ?? env?.NEXT_PUBLIC_NETWORK ?? env?.VEYL_NETWORK ?? env?.NETWORK ?? DEFAULT_NETWORK;
+  return String(raw).toUpperCase();
+}
+function getAddressNetwork(address) {
+  const a = String(address ?? "").trim();
+  if (!a)
+    return null;
+  if (/^bcrt1[ac-hj-np-z02-9]{39,87}$/i.test(a))
+    return REGTEST_NETWORK;
+  if (/^bc1[ac-hj-np-z02-9]{39,87}$/i.test(a))
+    return MAINNET_NETWORK;
+  if (/^[13][a-km-zA-HJ-NP-Z1-9]{25,34}$/.test(a))
+    return MAINNET_NETWORK;
+  return null;
+}
+function isAddressOnNetwork(address, network) {
+  const detected = getAddressNetwork(address);
+  return detected !== null && detected === String(network ?? "").toUpperCase();
+}
+
+// ../../shared/wallet/deposits.js
+var AUTO_CLAIM_MAX_FEE_SATS = WALLET_AUTO_CLAIM_MAX_FEE_SATS;
+var CLAIM_PAGE_SIZE = WALLET_CLAIM_PAGE_SIZE;
+async function getStaticFundingAddress(wallet, network) {
+  if (!wallet) {
+    return null;
+  }
+  const address = await wallet.getStaticDepositAddress();
+  const nextAddress = typeof address === "string" && address.trim() ? address.trim() : null;
+  if (!nextAddress) {
+    return null;
+  }
+  if (network && !isAddressOnNetwork(nextAddress, network)) {
+    throw new Error(`funding address is not a ${network} address`);
+  }
+  return nextAddress;
+}
+async function getAddressDepositUtxos(wallet, getFundingAddress, { pageSize = CLAIM_PAGE_SIZE } = {}) {
+  const address = await getFundingAddress();
+  if (!address) {
+    return [];
+  }
+  const utxos = [];
+  let offset = 0;
+  while (true) {
+    const page = await wallet.getUtxosForDepositAddress(address, pageSize, offset, true);
+    if (!Array.isArray(page) || !page.length) {
+      break;
+    }
+    utxos.push(...page);
+    if (page.length < pageSize) {
+      break;
+    }
+    offset += page.length;
+  }
+  return utxos;
+}
+async function getClaimableDepositUtxos(wallet, getFundingAddress, options = {}) {
+  if (typeof wallet?.getUtxosForIdentity !== "function") {
+    return getAddressDepositUtxos(wallet, getFundingAddress, options);
+  }
+  try {
+    const pageSize = options.pageSize || CLAIM_PAGE_SIZE;
+    const utxos = [];
+    let cursor = "";
+    while (true) {
+      const page = await wallet.getUtxosForIdentity({
+        pageSize,
+        cursor,
+        excludeClaimed: true,
+        includePending: false
+      });
+      const pageUtxos = Array.isArray(page?.utxos) ? page.utxos.filter((utxo) => utxo?.isConfirmed !== false) : [];
+      utxos.push(...pageUtxos);
+      const nextCursor = page?.pageResponse?.nextCursor || "";
+      if (!page?.pageResponse?.hasNextPage || !nextCursor || nextCursor === cursor) {
+        break;
+      }
+      cursor = nextCursor;
+    }
+    return utxos;
+  } catch {
+    return getAddressDepositUtxos(wallet, getFundingAddress, options);
+  }
+}
+async function claimStaticDeposits(wallet, { getFundingAddress, maxFeeSats = AUTO_CLAIM_MAX_FEE_SATS, pageSize = CLAIM_PAGE_SIZE } = {}) {
+  if (!wallet) {
+    return false;
+  }
+  const readAddress = typeof getFundingAddress === "function" ? getFundingAddress : () => getStaticFundingAddress(wallet);
+  const utxos = await getClaimableDepositUtxos(wallet, readAddress, { pageSize });
+  if (!utxos.length) {
+    return false;
+  }
+  let claimed = false;
+  const seen = new Set;
+  for (const utxo of utxos) {
+    if (!utxo?.txid || !Number.isInteger(utxo.vout)) {
+      continue;
+    }
+    const key = `${utxo.txid}:${utxo.vout}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    try {
+      const claim = await wallet.claimStaticDepositWithMaxFee({
+        transactionId: utxo.txid,
+        outputIndex: utxo.vout,
+        maxFee: maxFeeSats
+      });
+      if (claim) {
+        claimed = true;
+      }
+    } catch (error) {
+      console.debug?.("could not claim deposit", key, error?.message ?? error);
+    }
+  }
+  return claimed;
+}
+
+// ../../shared/wallet/fees.js
+var DEFAULT_EXIT_SPEED = "MEDIUM";
+var EXIT_SPEEDS = Object.freeze(["SLOW", "MEDIUM", "FAST"]);
+var UNILATERAL_EXIT_PARENT_TX_FALLBACK_VBYTES = 191;
+var UNILATERAL_EXIT_FEE_BUMP_TX_VBYTES = 151;
+var UNILATERAL_EXIT_PACKAGES_PER_LEAF = 2;
+var UNILATERAL_EXIT_PREVIEW_VBYTES = UNILATERAL_EXIT_PACKAGES_PER_LEAF * (UNILATERAL_EXIT_PARENT_TX_FALLBACK_VBYTES + UNILATERAL_EXIT_FEE_BUMP_TX_VBYTES);
+var FEE_RATE_FALLBACKS = Object.freeze({
+  default: Object.freeze(["medium", "low", "high"]),
+  high: Object.freeze(["high", "medium", "low"]),
+  fastest: Object.freeze(["high", "medium", "low"]),
+  medium: Object.freeze(["medium", "low", "high"]),
+  halfHour: Object.freeze(["medium", "high", "low"]),
+  hour: Object.freeze(["medium", "low", "high"]),
+  low: Object.freeze(["low", "medium", "high"]),
+  economy: Object.freeze(["low", "medium", "high"]),
+  minimum: Object.freeze(["low", "medium", "high"]),
+  noPriority: Object.freeze(["low", "medium", "high"]),
+  average: Object.freeze(["medium", "low", "high"])
+});
+var WITHDRAWAL_FEE_FIELDS = Object.freeze({
+  FAST: Object.freeze({ user: "userFeeFast", l1: "l1BroadcastFeeFast" }),
+  MEDIUM: Object.freeze({ user: "userFeeMedium", l1: "l1BroadcastFeeMedium" }),
+  SLOW: Object.freeze({ user: "userFeeSlow", l1: "l1BroadcastFeeSlow" })
+});
+function getOptionalSats(value) {
+  if (value == null) {
+    return null;
+  }
+  const n = typeof value === "bigint" ? Number(value) : Number(value);
+  if (!Number.isSafeInteger(n) || n < 0) {
+    return null;
+  }
+  return n;
+}
+function toSafeSats(value, label = "amountSats") {
+  const n = getOptionalSats(value);
+  if (n == null || n <= 0) {
+    throw new Error(`${label} must be a positive safe integer`);
+  }
+  return n;
+}
+function toSafeNonNegativeSats(value, label = "amountSats") {
+  const n = getOptionalSats(value);
+  if (n == null) {
+    throw new Error(`${label} must be a non-negative safe integer`);
+  }
+  return n;
+}
+function getExitSpeed(value = DEFAULT_EXIT_SPEED) {
+  const speed = String(value || DEFAULT_EXIT_SPEED).toUpperCase();
+  if (!EXIT_SPEEDS.includes(speed)) {
+    throw new Error("invalid exit speed");
+  }
+  return speed;
+}
+function getCurrencyAmountSats(amount) {
+  const value = getOptionalSats(amount?.originalValue);
+  if (value == null) {
+    return 0;
+  }
+  if (amount?.originalUnit === "MILLISATOSHI") {
+    return Math.ceil(value / 1000);
   }
   return value;
 }
-function requireSession(session) {
-  if (!session?.uid || !session?.network || !session?.wallet || !session?.chatPK || !session?.chatPrivKey) {
-    throw new Error("account session unlocked required");
+function getWithdrawalFeeBreakdown(feeQuote, exitSpeed = DEFAULT_EXIT_SPEED) {
+  if (!feeQuote) {
+    return null;
   }
-  return session;
+  const speed = getExitSpeed(exitSpeed);
+  const fields = WITHDRAWAL_FEE_FIELDS[speed];
+  const userFeeSats = getCurrencyAmountSats(feeQuote[fields.user]);
+  const l1BroadcastFeeSats = getCurrencyAmountSats(feeQuote[fields.l1]);
+  return {
+    speed,
+    userFeeSats,
+    l1BroadcastFeeSats,
+    feeAmountSats: userFeeSats + l1BroadcastFeeSats,
+    quoteId: feeQuote.id ?? null,
+    expiresAt: feeQuote.expiresAt ?? null
+  };
 }
-function createAccountSessionActions({ cloud, getSession, session } = {}) {
-  const readCloud = () => requireCloud(typeof cloud === "function" ? cloud() : cloud);
-  const readSession = async () => requireSession(typeof getSession === "function" ? await getSession() : session);
-  async function resolvePeer(peer) {
+function getWithdrawalFeeAmountSats(feeQuote, exitSpeed = DEFAULT_EXIT_SPEED) {
+  return getWithdrawalFeeBreakdown(feeQuote, exitSpeed)?.feeAmountSats ?? null;
+}
+function normalizeWithdrawalFeeQuote(feeQuote) {
+  if (!feeQuote) {
+    return null;
+  }
+  const speeds = {};
+  for (const speed of EXIT_SPEEDS) {
+    speeds[speed] = getWithdrawalFeeBreakdown(feeQuote, speed);
+  }
+  return {
+    id: feeQuote.id ?? null,
+    expiresAt: feeQuote.expiresAt ?? null,
+    network: feeQuote.network ?? null,
+    totalAmountSats: getCurrencyAmountSats(feeQuote.totalAmount),
+    speeds,
+    raw: feeQuote
+  };
+}
+function normalizeLightningFeeEstimate(feeAmountSats) {
+  return {
+    feeAmountSats: toSafeNonNegativeSats(feeAmountSats, "feeAmountSats")
+  };
+}
+function normalizeLightningReceiveRequest(request) {
+  if (!request) {
+    return null;
+  }
+  const invoice = request.invoice ?? null;
+  return {
+    id: request.id ?? null,
+    status: request.status ?? null,
+    network: request.network ?? invoice?.bitcoinNetwork ?? null,
+    createdAt: request.createdAt ?? invoice?.createdAt ?? null,
+    updatedAt: request.updatedAt ?? null,
+    expiresAt: invoice?.expiresAt ?? null,
+    amountSats: getCurrencyAmountSats(invoice?.amount),
+    encodedInvoice: invoice?.encodedInvoice ?? null,
+    paymentHash: invoice?.paymentHash ?? null,
+    sparkInvoice: request.sparkInvoice ?? null,
+    transfer: request.transfer ?? null,
+    raw: request
+  };
+}
+function normalizeLightningPaymentResult(result) {
+  if (!result) {
+    return null;
+  }
+  if (result.encodedInvoice || result.fee || String(result.typename || "").includes("LightningSendRequest")) {
+    return {
+      kind: "lightning",
+      id: result.id ?? null,
+      status: result.status ?? null,
+      network: result.network ?? null,
+      encodedInvoice: result.encodedInvoice ?? null,
+      feeAmountSats: getCurrencyAmountSats(result.fee),
+      idempotencyKey: result.idempotencyKey ?? null,
+      transfer: result.transfer ?? null,
+      raw: result
+    };
+  }
+  return {
+    kind: "spark",
+    id: result.id ?? null,
+    status: result.status ?? null,
+    transfer: result,
+    raw: result
+  };
+}
+
+// ../../shared/wallet/lightningops.js
+async function createLightningInvoice(wallet, { amountSats = 0, memo, expirySeconds, includeSparkAddress = false, includeSparkInvoice = false, receiverIdentityPubkey, descriptionHash } = {}) {
+  if (!wallet) {
+    return { success: false, error: new Error("wallet not ready") };
+  }
+  if (memo && descriptionHash) {
+    return { success: false, error: new Error("lightning invoice memo and descriptionHash are mutually exclusive") };
+  }
+  if (includeSparkAddress && includeSparkInvoice) {
+    return { success: false, error: new Error("includeSparkAddress and includeSparkInvoice are mutually exclusive") };
+  }
+  try {
+    const request = await wallet.createLightningInvoice({
+      amountSats: toSafeNonNegativeSats(amountSats),
+      ...memo ? { memo } : {},
+      ...expirySeconds != null ? { expirySeconds } : {},
+      includeSparkAddress,
+      includeSparkInvoice,
+      ...receiverIdentityPubkey ? { receiverIdentityPubkey } : {},
+      ...descriptionHash ? { descriptionHash } : {}
+    });
+    return {
+      success: true,
+      request,
+      invoice: normalizeLightningReceiveRequest(request)
+    };
+  } catch (error) {
+    return { success: false, error };
+  }
+}
+async function quoteLightningFees(wallet, { invoice, amountSats } = {}) {
+  if (!wallet) {
+    return { success: false, error: new Error("wallet not ready") };
+  }
+  const encodedInvoice = cleanText(invoice);
+  if (!encodedInvoice) {
+    return { success: false, error: new Error("lightning invoice required") };
+  }
+  try {
+    const params = { encodedInvoice };
+    if (amountSats != null) {
+      params.amountSats = toSafeSats(amountSats);
+    }
+    const feeAmountSats = await wallet.getLightningSendFeeEstimate(params);
+    return {
+      success: true,
+      feeAmountSats,
+      fees: normalizeLightningFeeEstimate(feeAmountSats)
+    };
+  } catch (error) {
+    return { success: false, error };
+  }
+}
+async function sendLightningPayment(wallet, { invoice, maxFeeSats, preferSpark = false, amountSatsToSend, idempotencyKey } = {}) {
+  if (!wallet) {
+    return { success: false, error: new Error("wallet not ready") };
+  }
+  const encodedInvoice = cleanText(invoice);
+  if (!encodedInvoice) {
+    return { success: false, error: new Error("lightning invoice required") };
+  }
+  try {
+    const params = {
+      invoice: encodedInvoice,
+      maxFeeSats: toSafeNonNegativeSats(maxFeeSats, "maxFeeSats"),
+      preferSpark: !!preferSpark
+    };
+    if (amountSatsToSend != null) {
+      params.amountSatsToSend = toSafeSats(amountSatsToSend, "amountSatsToSend");
+    }
+    if (idempotencyKey) {
+      params.idempotencyKey = idempotencyKey;
+    }
+    const payment = await wallet.payLightningInvoice(params);
+    return {
+      success: true,
+      payment,
+      result: normalizeLightningPaymentResult(payment)
+    };
+  } catch (error) {
+    return { success: false, error };
+  }
+}
+async function getLightningReceiveRequest(wallet, id) {
+  if (!wallet) {
+    return { success: false, error: new Error("wallet not ready") };
+  }
+  const requestId = cleanText(id);
+  if (!requestId) {
+    return { success: false, error: new Error("lightning receive request id required") };
+  }
+  try {
+    const request = await wallet.getLightningReceiveRequest(requestId);
+    return {
+      success: true,
+      request,
+      invoice: normalizeLightningReceiveRequest(request)
+    };
+  } catch (error) {
+    return { success: false, error };
+  }
+}
+async function getLightningSendRequest(wallet, id) {
+  if (!wallet) {
+    return { success: false, error: new Error("wallet not ready") };
+  }
+  const requestId = cleanText(id);
+  if (!requestId) {
+    return { success: false, error: new Error("lightning send request id required") };
+  }
+  try {
+    const request = await wallet.getLightningSendRequest(requestId);
+    return {
+      success: true,
+      request,
+      result: normalizeLightningPaymentResult(request)
+    };
+  } catch (error) {
+    return { success: false, error };
+  }
+}
+
+// ../../shared/wallet/withdrawops.js
+function getWithdrawalReviewAmounts(withdrawal) {
+  const amountSats = toSafeSats(withdrawal?.amountSats);
+  const feeAmountSats = toSafeNonNegativeSats(withdrawal?.feeAmountSats ?? 0, "feeAmountSats");
+  const deductFeeFromWithdrawalAmount = withdrawal?.deductFeeFromWithdrawalAmount !== false;
+  const receiveAmountSats = deductFeeFromWithdrawalAmount ? Math.max(0, amountSats - feeAmountSats) : amountSats;
+  const sendAmountSats = deductFeeFromWithdrawalAmount ? amountSats : amountSats + feeAmountSats;
+  return {
+    sendAmountSats,
+    receiveAmountSats,
+    feeAmountSats
+  };
+}
+function assertWithdrawalReceivesFunds(withdrawal) {
+  const { receiveAmountSats } = getWithdrawalReviewAmounts(withdrawal);
+  if (receiveAmountSats <= 0) {
+    throw new Error("withdrawal fee is greater than or equal to the amount");
+  }
+}
+function getWithdrawalReview({ feeQuote, exitSpeed, amountSats, onchainAddress, deductFeeFromWithdrawalAmount = true }) {
+  const safeExitSpeed = getExitSpeed(exitSpeed);
+  const feeQuoteId = feeQuote?.id ?? null;
+  const feeAmountSats = getWithdrawalFeeAmountSats(feeQuote, safeExitSpeed);
+  if (!feeQuoteId || feeAmountSats == null) {
+    throw new Error("withdrawal fee quote unavailable");
+  }
+  const sparkFees = normalizeWithdrawalFeeQuote(feeQuote);
+  const withdrawal = {
+    kind: "cooperative_exit",
+    onchainAddress,
+    amountSats,
+    exitSpeed: safeExitSpeed,
+    deductFeeFromWithdrawalAmount,
+    feeQuote,
+    feeQuoteId,
+    feeAmountSats,
+    fees: {
+      spark: sparkFees
+    },
+    sparkFees,
+    expiresAt: sparkFees?.expiresAt ?? feeQuote.expiresAt ?? null
+  };
+  assertWithdrawalReceivesFunds(withdrawal);
+  return withdrawal;
+}
+async function quoteWithdrawalFees(wallet, network, { onchainAddress, amountSats } = {}) {
+  if (!wallet) {
+    return { success: false, error: new Error("wallet not ready") };
+  }
+  const address = cleanText(onchainAddress);
+  if (!isAddressOnNetwork(address, network)) {
+    return { success: false, error: new Error(`refusing to withdraw - address is not a ${network} address`) };
+  }
+  try {
+    const safeAmountSats = toSafeSats(amountSats);
+    const feeQuote = await wallet.getWithdrawalFeeQuote({
+      amountSats: safeAmountSats,
+      withdrawalAddress: address
+    });
+    if (!feeQuote?.id) {
+      throw new Error("withdrawal fee quote unavailable");
+    }
+    const sparkFees = normalizeWithdrawalFeeQuote(feeQuote);
+    return {
+      success: true,
+      feeQuote,
+      fees: {
+        spark: sparkFees
+      },
+      sparkFees,
+      amountSats: safeAmountSats,
+      onchainAddress: address
+    };
+  } catch (error) {
+    return { success: false, error };
+  }
+}
+async function prepareWithdrawal(wallet, network, { onchainAddress, amountSats, exitSpeed = DEFAULT_EXIT_SPEED, deductFeeFromWithdrawalAmount = true } = {}) {
+  const quoted = await quoteWithdrawalFees(wallet, network, { onchainAddress, amountSats });
+  if (!quoted.success) {
+    return quoted;
+  }
+  try {
+    const withdrawal = getWithdrawalReview({
+      feeQuote: quoted.feeQuote,
+      exitSpeed,
+      amountSats: quoted.amountSats,
+      onchainAddress: quoted.onchainAddress,
+      deductFeeFromWithdrawalAmount
+    });
+    return {
+      success: true,
+      withdrawal,
+      ...withdrawal
+    };
+  } catch (error) {
+    return { success: false, error };
+  }
+}
+async function withdrawFunds(wallet, network, { onchainAddress, amountSats, exitSpeed = DEFAULT_EXIT_SPEED, feeQuote = null, feeQuoteId = null, feeAmountSats = null, deductFeeFromWithdrawalAmount = true } = {}) {
+  if (!wallet) {
+    return { success: false, error: new Error("wallet not ready") };
+  }
+  const address = cleanText(onchainAddress);
+  if (!isAddressOnNetwork(address, network)) {
+    return { success: false, error: new Error(`refusing to withdraw - address is not a ${network} address`) };
+  }
+  try {
+    const safeAmountSats = toSafeSats(amountSats);
+    const safeExitSpeed = getExitSpeed(exitSpeed);
+    let readyFeeQuote = feeQuote;
+    if (!readyFeeQuote && (!feeQuoteId || feeAmountSats == null)) {
+      const quoted = await quoteWithdrawalFees(wallet, network, {
+        onchainAddress: address,
+        amountSats: safeAmountSats
+      });
+      if (!quoted.success) {
+        return quoted;
+      }
+      readyFeeQuote = quoted.feeQuote;
+    }
+    const readyFeeQuoteId = feeQuoteId || readyFeeQuote?.id;
+    const readyFeeAmountSats = feeAmountSats == null ? getWithdrawalFeeAmountSats(readyFeeQuote, safeExitSpeed) : toSafeNonNegativeSats(feeAmountSats, "feeAmountSats");
+    if (!readyFeeQuoteId || readyFeeAmountSats == null) {
+      throw new Error("withdrawal fee quote unavailable");
+    }
+    assertWithdrawalReceivesFunds({
+      amountSats: safeAmountSats,
+      feeAmountSats: readyFeeAmountSats,
+      deductFeeFromWithdrawalAmount
+    });
+    const tx2 = await wallet.withdraw({
+      onchainAddress: address,
+      amountSats: safeAmountSats,
+      exitSpeed: safeExitSpeed,
+      feeQuoteId: readyFeeQuoteId,
+      feeAmountSats: readyFeeAmountSats,
+      deductFeeFromWithdrawalAmount
+    });
+    return {
+      success: true,
+      tx: tx2,
+      feeQuote: readyFeeQuote,
+      fees: readyFeeQuote ? {
+        spark: normalizeWithdrawalFeeQuote(readyFeeQuote)
+      } : null,
+      feeAmountSats: readyFeeAmountSats
+    };
+  } catch (error) {
+    return { success: false, error };
+  }
+}
+
+// ../../shared/wallet/spark.js
+var import_bech32 = __toESM(require_dist(), 1);
+var SPARK_ADDRESS_PREFIX = Object.freeze({
+  MAINNET: "spark",
+  TESTNET: "sparkt",
+  REGTEST: "sparkrt",
+  SIGNET: "sparks",
+  LOCAL: "sparkl"
+});
+function getSparkAddressPrefix(network) {
+  const prefix2 = SPARK_ADDRESS_PREFIX[String(network ?? "").toUpperCase()];
+  if (!prefix2) {
+    throw new Error("invalid wallet network");
+  }
+  return prefix2;
+}
+function hexToBytes5(hex3) {
+  const value = String(hex3 ?? "").trim();
+  if (value.length % 2 !== 0) {
+    throw new Error("invalid hex");
+  }
+  const bytes = new Uint8Array(value.length / 2);
+  for (let i = 0;i < bytes.length; i++) {
+    const start = i * 2;
+    const byte = Number.parseInt(value.slice(start, start + 2), 16);
+    if (Number.isNaN(byte)) {
+      throw new Error("invalid hex");
+    }
+    bytes[i] = byte;
+  }
+  return bytes;
+}
+function walletPKtoSparkAddress(walletPK, network) {
+  const key = hexToBytes5(walletPK);
+  if (key.length !== 33) {
+    throw new Error("need 33-byte compressed pubkey");
+  }
+  const payload = new Uint8Array(2 + key.length);
+  payload[0] = 10;
+  payload[1] = 33;
+  payload.set(key, 2);
+  return import_bech32.bech32m.encode(getSparkAddressPrefix(network), import_bech32.bech32m.toWords(payload), 1500);
+}
+
+// ../../shared/account/actions/money.js
+function createMoneyActions({ readCloud, readSession, resolvePeer, sendPayload }) {
+  function throwIfFailed(result, fallback = "wallet operation failed") {
+    if (!result?.success) {
+      throw result?.error || new Error(fallback);
+    }
+    return result;
+  }
+  function optionalPositiveSats(value, label = "amountSats") {
+    if (value == null || value === "") {
+      return null;
+    }
+    try {
+      return cleanPositiveSats(value);
+    } catch (error) {
+      throw new Error(`${label} must be a positive safe integer`, { cause: error });
+    }
+  }
+  function stripRaw(value, options = {}) {
+    if (!value || typeof value !== "object") {
+      return value;
+    }
+    const { raw, ...rest } = value;
+    return options.raw ? { ...rest, raw: jsonSafe(raw) } : rest;
+  }
+  function stripFees(fees, options = {}) {
+    if (!fees || typeof fees !== "object") {
+      return fees || null;
+    }
+    return {
+      ...fees,
+      spark: stripRaw(fees.spark, options)
+    };
+  }
+  function cleanWithdrawal(withdrawal, options = {}) {
+    if (!withdrawal) {
+      return null;
+    }
+    return {
+      kind: withdrawal.kind,
+      onchainAddress: withdrawal.onchainAddress,
+      amountSats: withdrawal.amountSats,
+      exitSpeed: withdrawal.exitSpeed,
+      deductFeeFromWithdrawalAmount: withdrawal.deductFeeFromWithdrawalAmount,
+      feeQuoteId: withdrawal.feeQuoteId,
+      feeAmountSats: withdrawal.feeAmountSats,
+      fees: stripFees(withdrawal.fees, options),
+      amounts: getWithdrawalReviewAmounts(withdrawal),
+      expiresAt: withdrawal.expiresAt,
+      raw: options.raw ? jsonSafe(withdrawal.feeQuote) : undefined
+    };
+  }
+  function firstSparkInvoiceError(result) {
+    return result?.invalidInvoices?.[0]?.error || result?.satsTransactionErrors?.[0]?.error || result?.tokenTransactionErrors?.[0]?.error || null;
+  }
+  function firstSparkInvoiceSuccess(result) {
+    return result?.satsTransactionSuccess?.[0]?.transferResponse || result?.tokenTransactionSuccess?.[0] || null;
+  }
+  function invoicePayload(value, options = {}) {
+    const raw = cleanText(value);
+    if (!raw) {
+      throw new Error("invoice required");
+    }
+    const data = readQr(raw);
+    const type = cleanText(options.type || data?.kind);
+    const invoice2 = cleanText(data?.invoice || raw);
+    if (type !== qr.lightning && type !== qr.spark) {
+      throw new Error("invoice must be lightning or spark");
+    }
+    return { type, invoice: invoice2 };
+  }
+  async function balance(options = {}) {
+    const active = await readSession();
+    const raw = await active.wallet.getBalance();
+    return {
+      availableSats: balanceSats(raw),
+      raw: options.raw ? jsonSafe(raw) : undefined
+    };
+  }
+  async function address() {
+    const active = await readSession();
+    return {
+      address: await getStaticFundingAddress(active.wallet, active.network),
+      network: active.network
+    };
+  }
+  async function claim(options = {}) {
+    const active = await readSession();
+    const depositsClaimed = await claimStaticDeposits(active.wallet, {
+      getFundingAddress: () => getStaticFundingAddress(active.wallet, active.network)
+    });
+    const transferIds2 = await claimPendingIncomingTransfers(active.wallet, {
+      limit: cleanLimit(options.count || options.limit, undefined)
+    });
+    return {
+      claimed: depositsClaimed || transferIds2.length > 0,
+      depositsClaimed,
+      transferIds: transferIds2
+    };
+  }
+  async function send(peer, sats, options = {}) {
+    const active = await readSession();
+    const amountSats = cleanPositiveSats(sats);
+    const profile = await resolvePeer(peer);
+    if (!profile.walletPK) {
+      throw new Error("peer wallet key missing");
+    }
+    const receiverSparkAddress = walletPKtoSparkAddress(profile.walletPK, active.network);
+    const tx2 = await active.wallet.transfer({ receiverSparkAddress, amountSats });
+    return {
+      txId: tx2?.id || null,
+      amountSats,
+      peer: profile.username ? `@${profile.username}` : profile.uid,
+      raw: options.raw ? jsonSafe(tx2) : undefined
+    };
+  }
+  async function invoice(sats = 0, options = {}) {
+    const active = await readSession();
+    const amountSats = toSafeNonNegativeSats(sats || 0);
+    const result = throwIfFailed(await createLightningInvoice(active.wallet, {
+      amountSats,
+      memo: options.memo,
+      expirySeconds: options.expirySeconds,
+      includeSparkAddress: options.includeSparkAddress === true,
+      includeSparkInvoice: options.includeSparkInvoice === true,
+      receiverIdentityPubkey: options.receiverIdentityPubkey,
+      descriptionHash: options.descriptionHash
+    }), "could not create lightning invoice");
+    return stripRaw(result.invoice, options);
+  }
+  async function lightningQuote(encodedInvoice, options = {}) {
+    const active = await readSession();
+    const result = throwIfFailed(await quoteLightningFees(active.wallet, {
+      invoice: encodedInvoice,
+      amountSats: options.amountSats
+    }), "could not quote lightning fees");
+    return {
+      feeAmountSats: result.feeAmountSats,
+      fees: result.fees
+    };
+  }
+  async function lightningPay(encodedInvoice, options = {}) {
+    const active = await readSession();
+    const amountSatsToSend = options.amountSatsToSend ?? options.amountSats;
+    let maxFeeSats = options.maxFeeSats;
+    let fees = null;
+    if (maxFeeSats == null) {
+      const quote = throwIfFailed(await quoteLightningFees(active.wallet, {
+        invoice: encodedInvoice,
+        amountSats: amountSatsToSend
+      }), "could not quote lightning fees");
+      maxFeeSats = quote.feeAmountSats;
+      fees = quote.fees;
+    }
+    const result = throwIfFailed(await sendLightningPayment(active.wallet, {
+      invoice: encodedInvoice,
+      maxFeeSats,
+      preferSpark: options.preferSpark === true,
+      amountSatsToSend,
+      idempotencyKey: options.idempotencyKey
+    }), "could not pay lightning invoice");
+    return {
+      id: result.result?.id || result.payment?.id || null,
+      fees,
+      result: stripRaw(result.result, options),
+      raw: options.raw ? jsonSafe(result.payment) : undefined
+    };
+  }
+  async function lightningReceive(id, options = {}) {
+    const active = await readSession();
+    const result = throwIfFailed(await getLightningReceiveRequest(active.wallet, id), "could not read lightning receive request");
+    return stripRaw(result.invoice, options);
+  }
+  async function lightningSend(id, options = {}) {
+    const active = await readSession();
+    const result = throwIfFailed(await getLightningSendRequest(active.wallet, id), "could not read lightning send request");
+    return stripRaw(result.result, options);
+  }
+  async function payInvoice(value, options = {}) {
+    const active = await readSession();
+    const { type, invoice: invoice2 } = invoicePayload(value, options);
+    if (type === qr.lightning) {
+      return {
+        type,
+        ...await lightningPay(invoice2, { ...options, preferSpark: options.preferSpark !== false })
+      };
+    }
+    const amountSats = optionalPositiveSats(options.amountSats, "amountSats");
+    const result = await active.wallet.fulfillSparkInvoice([
+      {
+        invoice: invoice2,
+        ...amountSats != null ? { amount: BigInt(amountSats) } : {}
+      }
+    ]);
+    const error = firstSparkInvoiceError(result);
+    if (error) {
+      throw error instanceof Error ? error : new Error(String(error));
+    }
+    const success = firstSparkInvoiceSuccess(result);
+    if (!success) {
+      throw new Error("failed to pay spark invoice");
+    }
+    return {
+      type,
+      id: success.id || success.txid || null,
+      transfer: simplifyAccountTransfer(success),
+      raw: options.raw ? jsonSafe(result) : undefined
+    };
+  }
+  async function withdrawQuote(onchainAddress, sats, options = {}) {
+    const active = await readSession();
+    const result = throwIfFailed(await quoteWithdrawalFees(active.wallet, active.network, {
+      onchainAddress,
+      amountSats: sats
+    }), "could not quote withdrawal");
+    return {
+      amountSats: result.amountSats,
+      onchainAddress: result.onchainAddress,
+      feeQuoteId: result.feeQuote?.id || null,
+      fees: stripFees(result.fees, options),
+      raw: options.raw ? jsonSafe(result.feeQuote) : undefined
+    };
+  }
+  async function withdrawPrepare(onchainAddress, sats, options = {}) {
+    const active = await readSession();
+    const result = throwIfFailed(await prepareWithdrawal(active.wallet, active.network, {
+      onchainAddress,
+      amountSats: sats,
+      exitSpeed: options.exitSpeed || options.speed,
+      deductFeeFromWithdrawalAmount: options.deductFeeFromWithdrawalAmount !== false
+    }), "could not prepare withdrawal");
+    return cleanWithdrawal(result.withdrawal, options);
+  }
+  async function withdraw(onchainAddress, sats, options = {}) {
+    const active = await readSession();
+    const result = throwIfFailed(await withdrawFunds(active.wallet, active.network, {
+      onchainAddress,
+      amountSats: sats,
+      exitSpeed: options.exitSpeed || options.speed,
+      feeQuote: options.feeQuote,
+      feeQuoteId: options.feeQuoteId,
+      feeAmountSats: options.feeAmountSats,
+      deductFeeFromWithdrawalAmount: options.deductFeeFromWithdrawalAmount !== false
+    }), "could not withdraw funds");
+    return {
+      txId: result.tx?.id || result.tx?.txid || null,
+      feeAmountSats: result.feeAmountSats,
+      fees: stripFees(result.fees, options),
+      tx: options.raw ? jsonSafe(result.tx) : undefined
+    };
+  }
+  async function request(peer, sats, options = {}) {
+    return sendPayload(peer, makeReq(String(cleanPositiveSats(sats))), options);
+  }
+  async function pay(requestId, options = {}) {
+    const active = await readSession();
+    const { chatId, messageId } = parseRequestRef(requestId);
+    const chat = await getChat(readCloud(), active.uid, chatId, active.chatPK, active.chatPrivKey);
+    if (!chat) {
+      throw new Error("request chat not found");
+    }
+    const record = await readCloud().chat.messages.read(chat.id, messageId);
+    const message = await decryptMsg(record, active.chatPK, active.chatPrivKey, chat.peerChatPK, {
+      actors: chat.actors,
+      chatId: chat.id
+    });
+    if (!message || message.t !== "req") {
+      throw new Error("payment request not found");
+    }
+    if (message.tx) {
+      throw new Error("payment request already paid");
+    }
+    if (!isPeerMsg(message, active.chatPK)) {
+      throw new Error("cannot pay your own request");
+    }
+    const amountSats = cleanPositiveSats(message.a);
+    const profile = await resolvePeer(message.from || message.s || chat.peerChatPK);
+    if (!profile.walletPK) {
+      throw new Error("requester wallet key missing");
+    }
+    const paid = await send(profile.walletPK, amountSats, { raw: options.raw === true });
+    const newMessage = { ...setReqTx(message, paid.txId), cid: message.cid };
+    await updateMsg(readCloud(), chat.id, message.id, active.chatPK, active.chatPrivKey, chat.peerChatPK, newMessage, {
+      senderUid: active.uid,
+      receiverUid: chat.peerUid,
+      linkId: chat.linkId,
+      peerActorPK: chat.actors?.[chat.peerChatPK]
+    });
+    return {
+      ...paid,
+      requestId: requestRef(chat.id, message.id)
+    };
+  }
+  async function transactions(options = {}) {
+    const active = await readSession();
+    const limit = cleanLimit(options.count || options.limit, 50);
+    const offset = Math.max(0, Math.floor(Number(options.offset || 0)) || 0);
+    const page = await active.wallet.getTransfers(limit, offset);
+    const transfers = (page?.transfers || []).filter((tx2) => isVisibleTransfer(tx2) && transferBelongsToWallet(tx2, active.walletPK)).map(simplifyAccountTransfer);
+    return {
+      transfers,
+      raw: options.raw ? jsonSafe(page) : undefined
+    };
+  }
+  return {
+    address,
+    balance,
+    claim,
+    invoice,
+    lightningQuote,
+    lightningPay,
+    lightningReceive,
+    lightningSend,
+    payInvoice,
+    receive: address,
+    send,
+    request,
+    pay,
+    transactions,
+    withdrawQuote,
+    withdrawPrepare,
+    withdraw
+  };
+}
+
+// ../../shared/wallet/keys.js
+"use client";
+var VALID_WALLET_NETWORKS = new Set(["MAINNET", "REGTEST", "TESTNET", "SIGNET", "LOCAL"]);
+function normalizeWalletNetwork(network) {
+  const next = String(network ?? "").trim().toUpperCase();
+  if (!VALID_WALLET_NETWORKS.has(next)) {
+    throw new Error("invalid wallet network");
+  }
+  return next;
+}
+function walletPKField(network) {
+  return `walletPKs.${normalizeWalletNetwork(network)}`;
+}
+function resolveWalletPK(data, network) {
+  const key = normalizeWalletNetwork(network);
+  const walletPKs = data?.walletPKs;
+  const walletPK = walletPKs && typeof walletPKs === "object" && typeof walletPKs[key] === "string" ? walletPKs[key].trim() : "";
+  if (walletPK) {
+    return normalizeWalletPK(walletPK);
+  }
+  return null;
+}
+function normalizeWalletPK(walletPK) {
+  return typeof walletPK === "string" ? lowerText(walletPK) : walletPK;
+}
+
+// ../../shared/account/actions/peers.js
+function createPeerResolver({ readCloud, readSession }) {
+  async function resolve(peer) {
     const active = await readSession();
     const value = cleanPeer(peer);
+    const cloud = readCloud();
     let profile;
     if (CHAT_PK_RE.test(value)) {
-      profile = await readCloud().search.peer.byChatPK(value);
+      profile = await cloud.search.peer.byChatPK(value);
     } else if (WALLET_PK_RE.test(value)) {
-      profile = await readCloud().search.peer.byWalletPK(value, { network: active.network });
+      profile = await cloud.search.peer.byWalletPK(value, { network: active.network });
     } else {
-      profile = await readCloud().search.peer.byUsername(value);
+      profile = await cloud.search.peer.byUsername(value);
     }
     if (!profile) {
       throw new Error("peer not found");
@@ -94656,225 +96907,44 @@ function createAccountSessionActions({ cloud, getSession, session } = {}) {
       walletPK
     };
   }
-  async function peerMapForChats(chats) {
+  async function mapForChats(chats) {
     const peerChatPKs = [...new Set((chats || []).map((chat) => chat.peerChatPK).filter(Boolean))];
     const peers = peerChatPKs.length ? await readCloud().search.peer.byChatPKs(peerChatPKs) : [];
     return new Map((peers || []).map((peer) => [peer.chatPK, peer]));
   }
-  async function listChats(options = {}) {
-    const active = await readSession();
-    const chats = await loadAllChats(readCloud(), active.uid, active.chatPK, active.chatPrivKey, cleanLimit(options.count || options.limit, 30));
-    const peers = await peerMapForChats(chats);
-    return chats.map((chat) => simplifyAccountChat(chat, peers.get(chat.peerChatPK)));
-  }
-  async function chatForPeer(peer, options = {}) {
-    const active = await readSession();
-    if (CHAT_PK_RE.test(String(peer ?? "").trim())) {
-      const chatId = String(peer).trim().toLowerCase();
-      const chat = await getChat(readCloud(), active.uid, chatId, active.chatPK, active.chatPrivKey);
-      if (chat) {
-        return chat;
-      }
-    }
-    const profile = await resolvePeer(peer);
-    const chats = await loadAllChats(readCloud(), active.uid, active.chatPK, active.chatPrivKey, cleanLimit(options.count, 50));
-    return chats.find((chat) => chat.peerChatPK === profile.chatPK) || null;
-  }
-  async function readChat(peer, options = {}) {
-    const active = await readSession();
-    const chat = await chatForPeer(peer, options);
-    if (!chat) {
-      return { chat: null, messages: [] };
-    }
-    const page = await readCloud().chat.messages.list(chat.id, { count: cleanLimit(options.count || options.limit, 30) });
-    const decrypted = [];
-    for (const record of page.records || []) {
-      const message = await decryptMsg(record, active.chatPK, active.chatPrivKey, chat.peerChatPK, {
-        actors: chat.actors,
-        chatId: chat.id
-      });
-      if (message) {
-        decrypted.push(message);
-      }
-    }
-    const display = getDisplayMessages(decrypted, active.chatPK, chat.peerChatPK).filter(canShowMsg);
-    const messages = display.map((message) => simplifyAccountMessage(message, chat, active.chatPK, options));
-    if (options.markRead !== false) {
-      const lastPeer = [...display].reverse().find((message) => isPeerMsg(message, active.chatPK));
-      if (lastPeer?.id) {
-        await setChatRead(readCloud(), active.uid, active.chatPrivKey, chat.id, lastPeer.ts).catch(() => {});
-        const target = getMessageKey(lastPeer);
-        if (target) {
-          await sendReadReceipt(readCloud(), active.chatPK, active.chatPrivKey, chat.peerChatPK, target, {
-            chatId: chat.id,
-            senderUid: active.uid,
-            receiverUid: chat.peerUid,
-            linkId: chat.linkId,
-            peerActorPK: chat.actors?.[chat.peerChatPK],
-            ping: true
-          }).catch(() => {});
-        }
-      }
-    }
-    return {
-      chat: simplifyAccountChat(chat),
-      messages,
-      hasMore: page.hasMore === true,
-      nextOlderThan: page.nextOlderThan || null
-    };
-  }
-  async function sendPayload(peer, payload, options = {}) {
-    const active = await readSession();
-    const profile = await resolvePeer(peer);
-    if (!profile.chatPK) {
-      throw new Error("peer chat key missing");
-    }
-    if (profile.chatPK === active.chatPK) {
-      throw new Error("cannot message self");
-    }
-    const link = await resolvePeerChat(readCloud(), active.chatPK, active.chatPrivKey, profile.chatPK, options);
-    const sent = await sendMsg(readCloud(), active.chatPK, active.chatPrivKey, profile.chatPK, payload, {
-      ...options,
-      chatId: link.chatId,
-      linkId: link.linkId,
-      linkVersion: link.version,
-      protocol: link.protocol,
-      senderUid: active.uid,
-      receiverUid: profile.uid,
-      peerActorPK: profile.actorPK
-    });
-    return {
-      chat: {
-        id: sent.chatId,
-        peerChatPK: profile.chatPK,
-        username: profile.username
-      },
-      message: simplifyAccountMessage(sent.message, { id: sent.chatId, peerChatPK: profile.chatPK }, active.chatPK, options)
-    };
-  }
-  async function sendChat(peer, message, options = {}) {
-    return sendPayload(peer, makeTxt(cleanMessage(message)), options);
-  }
-  async function balance(options = {}) {
-    const active = await readSession();
-    const raw = await active.wallet.getBalance();
-    return {
-      availableSats: balanceSats(raw),
-      raw: options.raw === false ? undefined : jsonSafe(raw)
-    };
-  }
-  async function sendMoney(peer, sats, options = {}) {
-    const active = await readSession();
-    const amountSats = cleanPositiveSats(sats);
-    const profile = await resolvePeer(peer);
-    if (!profile.walletPK) {
-      throw new Error("peer wallet key missing");
-    }
-    const receiverSparkAddress = walletPKtoSparkAddress(profile.walletPK, active.network);
-    const tx = await active.wallet.transfer({ receiverSparkAddress, amountSats });
-    return {
-      txId: tx?.id || null,
-      amountSats,
-      peer: profile.username ? `@${profile.username}` : profile.uid,
-      raw: options.raw ? jsonSafe(tx) : undefined
-    };
-  }
-  async function requestMoney(peer, sats, options = {}) {
-    return sendPayload(peer, makeReq(String(cleanPositiveSats(sats))), options);
-  }
-  async function payRequest(requestId, options = {}) {
-    const active = await readSession();
-    const { chatId, messageId } = parseRequestRef(requestId);
-    const chat = await getChat(readCloud(), active.uid, chatId, active.chatPK, active.chatPrivKey);
-    if (!chat) {
-      throw new Error("request chat not found");
-    }
-    const record = await readCloud().chat.messages.read(chat.id, messageId);
-    const message = await decryptMsg(record, active.chatPK, active.chatPrivKey, chat.peerChatPK, {
-      actors: chat.actors,
-      chatId: chat.id
-    });
-    if (!message || message.t !== "req") {
-      throw new Error("payment request not found");
-    }
-    if (message.tx) {
-      throw new Error("payment request already paid");
-    }
-    if (!isPeerMsg(message, active.chatPK)) {
-      throw new Error("cannot pay your own request");
-    }
-    const amountSats = cleanPositiveSats(message.a);
-    const profile = await resolvePeer(message.from || message.s || chat.peerChatPK);
-    if (!profile.walletPK) {
-      throw new Error("requester wallet key missing");
-    }
-    const paid = await sendMoney(profile.walletPK, amountSats, { raw: true });
-    const newMessage = { ...setReqTx(message, paid.txId), cid: message.cid };
-    await updateMsg(readCloud(), chat.id, message.id, active.chatPK, active.chatPrivKey, chat.peerChatPK, newMessage, {
-      senderUid: active.uid,
-      receiverUid: chat.peerUid,
-      linkId: chat.linkId,
-      peerActorPK: chat.actors?.[chat.peerChatPK]
-    });
-    return {
-      ...paid,
-      requestId: requestRef(chat.id, message.id)
-    };
-  }
-  async function transactions(options = {}) {
-    const active = await readSession();
-    const limit = cleanLimit(options.count || options.limit, 50);
-    const offset = Math.max(0, Math.floor(Number(options.offset || 0)) || 0);
-    const page = await active.wallet.getTransfers(limit, offset);
-    const transfers = (page?.transfers || []).filter((tx) => isVisibleTransfer(tx) && transferBelongsToWallet(tx, active.walletPK)).map(simplifyAccountTransfer);
-    return {
-      transfers,
-      raw: options.raw ? jsonSafe(page) : undefined
-    };
-  }
+  return { resolve, mapForChats };
+}
+
+// ../../shared/account/actions.js
+function createAccountSessionActions({ cloud, getSession, session } = {}) {
+  const readCloud = () => requireCloud(typeof cloud === "function" ? cloud() : cloud);
+  const readSession = async () => requireSession(typeof getSession === "function" ? await getSession() : session);
+  const peers = createPeerResolver({ readCloud, readSession });
+  const inbox = createInboxSync({ readCloud });
+  const chat = createChatActions({
+    readCloud,
+    readSession,
+    inbox,
+    peers
+  });
+  const money = createMoneyActions({
+    readCloud,
+    readSession,
+    resolvePeer: peers.resolve,
+    sendPayload: chat.sendPayload
+  });
   return {
     peer: {
-      resolve: resolvePeer
-    },
-    chat: {
-      list: listChats,
-      chatForPeer,
-      read: readChat,
-      send: sendChat,
-      sendPayload
-    },
-    money: {
-      balance,
-      send: sendMoney,
-      request: requestMoney,
-      pay: payRequest,
-      transactions
+      resolve: peers.resolve
     },
+    chat,
+    money,
     transactions: {
-      list: transactions
+      list: money.transactions
     }
   };
 }
 
-// ../../shared/network.js
-var DEFAULT_NETWORK = "REGTEST";
-var MAINNET_DOMAIN = domains.veyl;
-var REGTEST_DOMAIN = domains.veylTest;
-function resolveNetwork(env = {}) {
-  const raw = env?.EXPO_PUBLIC_NETWORK ?? env?.NEXT_PUBLIC_NETWORK ?? env?.VEYL_NETWORK ?? env?.NETWORK ?? DEFAULT_NETWORK;
-  return String(raw).toUpperCase();
-}
-
-// ../../shared/username.js
-var MAX_USERNAME = USERNAME_MAX_CHARS;
-var usernameRegex = new RegExp(`^[a-z0-9]{1,${MAX_USERNAME}}$`);
-function normalizeUsername(value = "") {
-  return String(value).trim().toLowerCase();
-}
-function isUsername(value = "") {
-  return usernameRegex.test(value);
-}
-
 // ../../node_modules/.bun/@firebase+util@1.15.1/node_modules/@firebase/util/dist/postinstall.mjs
 var getDefaultsFromPostinstall = () => {
   return;
@@ -95899,28 +97969,28 @@ function promisifyRequest(request) {
   reverseTransformCache.set(promise, request);
   return promise;
 }
-function cacheDonePromiseForTransaction(tx) {
-  if (transactionDoneMap.has(tx))
+function cacheDonePromiseForTransaction(tx2) {
+  if (transactionDoneMap.has(tx2))
     return;
   const done = new Promise((resolve, reject) => {
     const unlisten = () => {
-      tx.removeEventListener("complete", complete);
-      tx.removeEventListener("error", error);
-      tx.removeEventListener("abort", error);
+      tx2.removeEventListener("complete", complete);
+      tx2.removeEventListener("error", error);
+      tx2.removeEventListener("abort", error);
     };
     const complete = () => {
       resolve();
       unlisten();
     };
     const error = () => {
-      reject(tx.error || new DOMException("AbortError", "AbortError"));
+      reject(tx2.error || new DOMException("AbortError", "AbortError"));
       unlisten();
     };
-    tx.addEventListener("complete", complete);
-    tx.addEventListener("error", error);
-    tx.addEventListener("abort", error);
+    tx2.addEventListener("complete", complete);
+    tx2.addEventListener("error", error);
+    tx2.addEventListener("abort", error);
   });
-  transactionDoneMap.set(tx, done);
+  transactionDoneMap.set(tx2, done);
 }
 var idbProxyTraps = {
   get(target, prop, receiver) {
@@ -95953,9 +98023,9 @@ function replaceTraps(callback) {
 function wrapFunction(func) {
   if (func === IDBDatabase.prototype.transaction && !("objectStoreNames" in IDBTransaction.prototype)) {
     return function(storeNames, ...args) {
-      const tx = func.call(unwrap(this), storeNames, ...args);
-      transactionStoreNamesMap.set(tx, storeNames.sort ? storeNames.sort() : [storeNames]);
-      return wrap3(tx);
+      const tx2 = func.call(unwrap(this), storeNames, ...args);
+      transactionStoreNamesMap.set(tx2, storeNames.sort ? storeNames.sort() : [storeNames]);
+      return wrap3(tx2);
     };
   }
   if (getCursorAdvanceMethods().includes(func)) {
@@ -96028,13 +98098,13 @@ function getMethod2(target, prop) {
     return;
   }
   const method = async function(storeName, ...args) {
-    const tx = this.transaction(storeName, isWrite ? "readwrite" : "readonly");
-    let target2 = tx.store;
+    const tx2 = this.transaction(storeName, isWrite ? "readwrite" : "readonly");
+    let target2 = tx2.store;
     if (useIndex)
       target2 = target2.index(args.shift());
     return (await Promise.all([
       target2[targetFuncName](...args),
-      isWrite && tx.done
+      isWrite && tx2.done
     ]))[0];
   };
   cachedMethods.set(prop, method);
@@ -96333,9 +98403,9 @@ function getDbPromise() {
 async function readHeartbeatsFromIndexedDB(app) {
   try {
     const db = await getDbPromise();
-    const tx = db.transaction(STORE_NAME);
-    const result = await tx.objectStore(STORE_NAME).get(computeKey(app));
-    await tx.done;
+    const tx2 = db.transaction(STORE_NAME);
+    const result = await tx2.objectStore(STORE_NAME).get(computeKey(app));
+    await tx2.done;
     return result;
   } catch (e) {
     if (e instanceof FirebaseError) {
@@ -96351,10 +98421,10 @@ async function readHeartbeatsFromIndexedDB(app) {
 async function writeHeartbeatsToIndexedDB(app, heartbeatObject) {
   try {
     const db = await getDbPromise();
-    const tx = db.transaction(STORE_NAME, "readwrite");
-    const objectStore = tx.objectStore(STORE_NAME);
+    const tx2 = db.transaction(STORE_NAME, "readwrite");
+    const objectStore = tx2.objectStore(STORE_NAME);
     await objectStore.put(heartbeatObject, computeKey(app));
-    await tx.done;
+    await tx2.done;
   } catch (e) {
     if (e instanceof FirebaseError) {
       logger2.warn(e.message);
@@ -123104,16 +125174,16 @@ function syncEngineGetRemoteKeysForTarget(syncEngine, targetId) {
   if (limboResolution && limboResolution.receivedDocument) {
     return documentKeySet().add(limboResolution.key);
   } else {
-    let keySet = documentKeySet();
+    let keySet2 = documentKeySet();
     const queries = syncEngineImpl.queriesByTarget.get(targetId);
     if (!queries) {
-      return keySet;
+      return keySet2;
     }
     for (const query of queries ?? []) {
       const queryView = syncEngineImpl.queryViewsByQuery.get(query);
-      keySet = keySet.unionWith(queryView.view.syncedDocuments);
+      keySet2 = keySet2.unionWith(queryView.view.syncedDocuments);
     }
-    return keySet;
+    return keySet2;
   }
 }
 function ensureWatchCallbacks(syncEngine) {
@@ -132196,6 +134266,9 @@ var DEFAULT_INTERVAL_MS = 3000;
 var DEFAULT_CHAT_COUNT = 20;
 var DEFAULT_MESSAGE_COUNT = 10;
 var DEFAULT_TX_COUNT = 50;
+function cleanString(value) {
+  return String(value ?? "").trim();
+}
 function cleanCount(value, fallback) {
   const count = Math.floor(Number(value));
   return Number.isFinite(count) && count > 0 ? Math.min(count, 100) : fallback;
@@ -132214,13 +134287,13 @@ function messageKey(message) {
     message?.ts || ""
   ].join(":");
 }
-function transferKey(tx) {
+function transferKey(tx2) {
   return [
-    tx?.id || "",
-    tx?.status || "",
-    tx?.direction || "",
-    tx?.amountSats || "",
-    tx?.updatedAt || ""
+    tx2?.id || "",
+    tx2?.status || "",
+    tx2?.direction || "",
+    tx2?.amountSats || "",
+    tx2?.updatedAt || ""
   ].join(":");
 }
 function event(type, data = {}) {
@@ -132230,10 +134303,112 @@ function event(type, data = {}) {
     ...data
   };
 }
+function peerTarget(chat) {
+  const username = cleanString(chat?.username).replace(/^@+/, "");
+  return username ? `@${username}` : cleanString(chat?.peerChatPK || chat?.id);
+}
+function compactAccount(account) {
+  return account ? {
+    uid: account.uid || null,
+    username: account.username || null,
+    network: account.network || null,
+    auth: account.auth || null,
+    bot: account.bot || null,
+    unlocked: account.unlocked === true
+  } : null;
+}
+function compactChat(chat) {
+  const peer = peerTarget(chat);
+  return {
+    id: chat?.id || null,
+    peer,
+    username: chat?.username || null,
+    peerChatPK: chat?.peerChatPK || null,
+    peerUid: chat?.peerUid || null,
+    unseen: chat?.unseen === true,
+    ts: chat?.ts || null
+  };
+}
+function compactPayload(message) {
+  const payload = message?.payload && typeof message.payload === "object" ? message.payload : {};
+  if (message?.type === "rxn") {
+    return {
+      target: payload.target || null,
+      emoji: payload.emoji || null
+    };
+  }
+  if (message?.type === "img" || message?.type === "gif" || message?.type === "m4a" || message?.type === "mp4" || message?.type === "file") {
+    return {
+      name: payload.n || null,
+      caption: payload.c || null,
+      mime: payload.m || null,
+      size: payload.z || null,
+      width: payload.w || null,
+      height: payload.h || null
+    };
+  }
+  if (message?.type === "sys") {
+    return {
+      action: payload.action || payload.kind || null,
+      value: payload.value || null
+    };
+  }
+  return {};
+}
+function compactMessage(message) {
+  const item = {
+    id: message?.id || null,
+    cid: message?.cid || null,
+    chatId: message?.chatId || null,
+    from: message?.from || null,
+    type: message?.type || null,
+    ts: message?.ts || null,
+    peerChatPK: message?.peerChatPK || null
+  };
+  if (message?.replyId) {
+    item.replyId = message.replyId;
+  }
+  if (message?.type === "txt") {
+    item.text = message.text || "";
+  } else if (message?.type === "req") {
+    item.amountSats = message.amountSats || 0;
+    item.paid = message.paid === true;
+    item.txId = message.txId || null;
+    item.requestId = message.requestId || null;
+  } else {
+    Object.assign(item, compactPayload(message));
+  }
+  return item;
+}
+function formatMessageEvent(chat, message, { compact = false } = {}) {
+  const targetChat = compact ? compactChat(chat) : chat;
+  const peer = peerTarget(chat);
+  const messageId = message?.id || message?.cid || null;
+  const target = messageId ? { peer, messageId } : null;
+  return event("message", {
+    peer,
+    replyTo: target,
+    reactTo: target,
+    chat: targetChat,
+    message: compact ? compactMessage(message) : message
+  });
+}
 function stopped(signal) {
   return signal?.aborted === true;
 }
+function eventChat(source, pageChat) {
+  return {
+    ...source || {},
+    ...pageChat || {},
+    username: pageChat?.username || source?.username || null,
+    peerUid: pageChat?.peerUid || source?.peerUid || null,
+    peerChatPK: pageChat?.peerChatPK || source?.peerChatPK || null,
+    id: pageChat?.id || source?.id || null
+  };
+}
 async function listenAccount(client2, options2 = {}) {
+  const compact = options2.compact === true || options2.agent === true;
+  const incomingOnly = options2.incomingOnly === false ? false : options2.incomingOnly === true || options2.incoming === true || options2.agent === true;
   const intervalMs = cleanInterval(options2.intervalMs || options2.interval);
   const chatCount = cleanCount(options2.chatCount || options2.chats, DEFAULT_CHAT_COUNT);
   const messageCount = cleanCount(options2.messageCount || options2.messages, DEFAULT_MESSAGE_COUNT);
@@ -132244,58 +134419,90 @@ async function listenAccount(client2, options2 = {}) {
   const emit = typeof options2.onEvent === "function" ? options2.onEvent : () => {};
   const seenMessages = new Set;
   const seenTransfers = new Map;
-  let initialized = false;
   await client2.ensureUnlocked();
-  emit(event("ready", { account: client2.accountSummary() }));
-  while (!stopped(options2.signal)) {
-    try {
-      if (includeChats) {
-        const chats = await client2.chat.list({ count: chatCount });
-        for (const chat of chats) {
-          const peer = chat.peerChatPK || chat.username || chat.id;
-          if (!peer) {
-            continue;
-          }
-          const page = await client2.chat.read(peer, {
+  const account = client2.accountSummary();
+  async function poll(emitChanges) {
+    if (includeChats) {
+      const chats = await client2.chat.list({ count: chatCount });
+      for (const chat of chats) {
+        const peer = chat.peerChatPK || chat.username || chat.id;
+        if (!peer) {
+          continue;
+        }
+        let page;
+        try {
+          page = await client2.chat.read(peer, {
             count: messageCount,
             markRead: false
           });
-          for (const message of page.messages || []) {
-            const key = messageKey(message);
-            if (!key || seenMessages.has(key)) {
-              continue;
-            }
-            seenMessages.add(key);
-            if (initialized || replay) {
-              emit(event("message", {
-                chat: page.chat || chat,
-                message
-              }));
-            }
+        } catch (error) {
+          emit(event("error", {
+            peer: peerTarget(chat),
+            message: error?.message || String(error)
+          }));
+          continue;
+        }
+        for (const message of page.messages || []) {
+          const key = messageKey(message);
+          if (!key || seenMessages.has(key)) {
+            continue;
+          }
+          seenMessages.add(key);
+          if (incomingOnly && message.from !== "peer") {
+            continue;
+          }
+          if (emitChanges) {
+            emit(formatMessageEvent(eventChat(chat, page.chat), message, { compact }));
           }
         }
       }
-      if (includeTransactions) {
+    }
+    if (includeTransactions) {
+      try {
         const page = await client2.money.transactions({ count: txCount });
-        for (const tx of page.transfers || []) {
-          const key = tx?.id || "";
-          const value = transferKey(tx);
+        for (const tx2 of page.transfers || []) {
+          const key = tx2?.id || "";
+          const value = transferKey(tx2);
           if (!key || seenTransfers.get(key) === value) {
             continue;
           }
           seenTransfers.set(key, value);
-          if (initialized || replay) {
-            emit(event("transaction", { transaction: tx }));
+          if (emitChanges) {
+            emit(event("transaction", { transaction: tx2 }));
           }
         }
+      } catch (error) {
+        emit(event("error", {
+          message: error?.message || String(error)
+        }));
       }
-      initialized = true;
+    }
+  }
+  if (replay) {
+    emit(event("ready", { account: compact ? compactAccount(account) : account }));
+  }
+  try {
+    await poll(replay);
+  } catch (error) {
+    emit(event("error", {
+      message: error?.message || String(error)
+    }));
+  }
+  if (!replay) {
+    emit(event("ready", { account: compact ? compactAccount(account) : account }));
+  }
+  while (!stopped(options2.signal)) {
+    await sleep2(intervalMs);
+    if (stopped(options2.signal)) {
+      break;
+    }
+    try {
+      await poll(true);
     } catch (error) {
       emit(event("error", {
         message: error?.message || String(error)
       }));
     }
-    await sleep2(intervalMs);
   }
 }
 
@@ -132499,6 +134706,7 @@ async function runPasskeyBrowserFlow(options2 = {}) {
 
 // src/storage.js
 import { access, chmod, mkdir, readFile, rename, writeFile } from "fs/promises";
+import { randomUUID } from "crypto";
 import { homedir } from "os";
 import { dirname, join as join4 } from "path";
 import process3 from "process";
@@ -132530,7 +134738,7 @@ async function readJson(path, fallback = null) {
 }
 async function writeJson(path, value) {
   await mkdir(dirname(path), { recursive: true, mode: DIR_MODE });
-  const tmp = `${path}.${process3.pid}.${Date.now()}.tmp`;
+  const tmp = `${path}.${process3.pid}.${Date.now()}.${randomUUID()}.tmp`;
   await writeFile(tmp, `${JSON.stringify(value, null, 2)}
 `, { mode: FILE_MODE });
   await chmod(tmp, FILE_MODE).catch(() => {});
@@ -132599,21 +134807,56 @@ class ProfileStore {
 // src/mcp.js
 import { createInterface } from "readline";
 import process4 from "process";
+function tool(name8, description, properties = {}, required = []) {
+  return {
+    name: name8,
+    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 = [
-  { name: "account_create", description: "Create a Veyl account headlessly.", inputSchema: { type: "object", properties: { username: { type: "string" }, network: { type: "string" } }, required: ["username"] } },
-  { name: "account_login", description: "Log in with the local machine credential.", inputSchema: { type: "object", properties: { username: { type: "string" } } } },
-  { name: "account_me", description: "Show the current local account.", inputSchema: { type: "object", properties: {} } },
-  { name: "vault_create", description: "Create and upload the local encrypted vault.", inputSchema: { type: "object", properties: { secret: { type: "string" }, saveSecret: { type: "boolean" } } } },
-  { name: "vault_unlock", description: "Unlock the local encrypted vault.", inputSchema: { type: "object", properties: { secret: { type: "string" } } } },
-  { name: "vault_lock", description: "Lock the wallet and chat session.", inputSchema: { type: "object", properties: {} } },
-  { name: "chat_list", description: "List chats.", inputSchema: { type: "object", properties: { count: { type: "number" } } } },
-  { name: "chat_read", description: "Read display messages from a chat.", inputSchema: { type: "object", properties: { peer: { type: "string" }, count: { type: "number" } }, required: ["peer"] } },
-  { name: "chat_send", description: "Send a text message.", inputSchema: { type: "object", properties: { peer: { type: "string" }, message: { type: "string" } }, required: ["peer", "message"] } },
-  { name: "money_balance", description: "Read wallet balance.", inputSchema: { type: "object", properties: {} } },
-  { name: "money_send", description: "Send sats to a peer.", inputSchema: { type: "object", properties: { peer: { type: "string" }, sats: { type: "number" } }, required: ["peer", "sats"] } },
-  { name: "money_request", description: "Request sats from a peer.", inputSchema: { type: "object", properties: { peer: { type: "string" }, sats: { type: "number" } }, required: ["peer", "sats"] } },
-  { name: "money_pay", description: "Pay a chat payment request.", inputSchema: { type: "object", properties: { requestId: { type: "string" } }, required: ["requestId"] } },
-  { name: "transactions_list", description: "List wallet transactions.", inputSchema: { type: "object", properties: { count: { type: "number" }, offset: { type: "number" } } } }
+  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 })
 ];
 function result(value) {
   return {
@@ -132637,13 +134880,35 @@ async function callTool(client2, name8, args = {}) {
   if (name8 === "vault_unlock")
     return client2.vault.unlock(args);
   if (name8 === "vault_lock")
-    return client2.vault.lock(args);
+    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")
@@ -132652,6 +134917,24 @@ async function callTool(client2, name8, args = {}) {
     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}`);
@@ -132708,8 +134991,8 @@ 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"]),
-  money: Object.freeze(["balance", "send", "request", "pay"]),
+  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"])
@@ -132738,6 +135021,43 @@ function randomSecret() {
   globalThis.crypto.getRandomValues(bytes);
   return Buffer4.from(bytes).toString("base64url");
 }
+function defaultAppName(profile) {
+  const name8 = cleanProfileName(profile, "");
+  return name8 ? `veyl-headless-${name8}` : "veyl-headless";
+}
+function cleanTargetValue(value) {
+  return String(value ?? "").trim();
+}
+function peerFromTarget(target, options2 = {}) {
+  if (typeof options2.peer === "string" && options2.peer.trim()) {
+    return options2.peer.trim();
+  }
+  if (typeof target === "string") {
+    return cleanTargetValue(target);
+  }
+  const chat = target?.chat || {};
+  const message = target?.message || {};
+  const username = cleanTargetValue(target?.username || chat.username).replace(/^@+/, "");
+  const replyPeer = typeof target?.replyTo === "string" ? target.replyTo : target?.replyTo?.peer;
+  const reactPeer = typeof target?.reactTo === "string" ? target.reactTo : target?.reactTo?.peer;
+  const peer = cleanTargetValue(replyPeer || reactPeer || target?.peer || chat.peer || chat.peerChatPK || message.peerChatPK || target?.peerChatPK);
+  if (peer) {
+    return peer;
+  }
+  return username ? `@${username}` : "";
+}
+function messageIdFromTarget(target, options2 = {}) {
+  if (typeof options2.replyId === "string" && options2.replyId.trim()) {
+    return options2.replyId.trim();
+  }
+  if (typeof options2.messageId === "string" && options2.messageId.trim()) {
+    return options2.messageId.trim();
+  }
+  if (typeof target === "string") {
+    return "";
+  }
+  return cleanTargetValue(target?.replyTo?.messageId || target?.reactTo?.messageId || target?.messageId || target?.message?.id || target?.message?.cid || target?.id || target?.cid);
+}
 
 class VeylHeadlessClient {
   constructor(options2 = {}) {
@@ -132746,7 +135066,7 @@ class VeylHeadlessClient {
     this.store = options2.store || new ProfileStore({ dir: options2.homeDir, profile: options2.profile });
     this.profile = options2.profileData || null;
     this.session = options2.session || null;
-    const cloud = options2.cloudContext || createHeadlessCloud(options2);
+    const cloud = options2.cloudContext || createHeadlessCloud({ ...options2, appName: options2.appName || defaultAppName(options2.profile || this.store.profile) });
     this.auth = cloud.auth;
     this.cloud = cloud.cloud;
     this.functionBaseUrl = options2.functionBaseUrl || cloud.functionBaseUrl;
@@ -132769,14 +135089,35 @@ class VeylHeadlessClient {
     this.chat = {
       list: (payload) => this.listChats(payload),
       read: (peer, payload) => this.readChat(peer, payload),
-      send: (peer, message, payload) => this.sendChat(peer, message, payload)
+      send: (peer, message, payload) => this.sendChat(peer, message, payload),
+      reply: (target, message, payload) => this.replyChat(target, message, payload),
+      react: (peer, messageId, emoji, payload) => this.reactChat(peer, messageId, emoji, payload),
+      reactTo: (target, emoji, payload) => this.reactToChat(target, emoji, payload),
+      unreact: (peer, messageId, payload) => this.unreactChat(peer, messageId, payload),
+      save: (peer, messageId, payload) => this.saveChatMessage(peer, messageId, payload),
+      unsave: (peer, messageId, payload) => this.unsaveChatMessage(peer, messageId, payload),
+      delete: (peer, messageId, payload) => this.deleteChatMessage(peer, messageId, payload),
+      deleteChat: (peer, payload) => this.deleteChat(peer, payload),
+      retention: (peer, value, payload) => this.setChatRetention(peer, value, payload)
     };
     this.money = {
+      address: (payload) => this.receiveMoney(payload),
       balance: (payload) => this.balance(payload),
+      claim: (payload) => this.claimMoney(payload),
+      invoice: (sats, payload) => this.createInvoice(sats, payload),
+      lightningQuote: (invoice, payload) => this.lightningQuote(invoice, payload),
+      lightningPay: (invoice, payload) => this.lightningPay(invoice, payload),
+      lightningReceive: (id, payload) => this.lightningReceive(id, payload),
+      lightningSend: (id, payload) => this.lightningSend(id, payload),
+      payInvoice: (invoice, payload) => this.payInvoice(invoice, payload),
+      receive: (payload) => this.receiveMoney(payload),
       send: (peer, sats, payload) => this.sendMoney(peer, sats, payload),
       request: (peer, sats, payload) => this.requestMoney(peer, sats, payload),
       pay: (requestId, payload) => this.payRequest(requestId, payload),
-      transactions: (payload) => this.transactions(payload)
+      transactions: (payload) => this.transactions(payload),
+      withdrawQuote: (address, sats, payload) => this.withdrawQuote(address, sats, payload),
+      withdrawPrepare: (address, sats, payload) => this.withdrawPrepare(address, sats, payload),
+      withdraw: (address, sats, payload) => this.withdraw(address, sats, payload)
     };
     this.mcp = {
       serve: (payload) => serveMcp(this, payload)
@@ -132821,6 +135162,7 @@ class VeylHeadlessClient {
       walletPK: profile.walletPK || null,
       chatPK: profile.chatPK || null,
       auth: profile.auth || "machine",
+      bot: profile.bot || null,
       signedIn: this.auth?.currentUser?.uid === profile.uid,
       unlocked: !!this.session
     };
@@ -132859,6 +135201,7 @@ class VeylHeadlessClient {
       publicKeyPem: machine.publicKeyPem,
       privateKeyPem: options2.saveCredential === false ? null : machine.privateKeyPem,
       auth: "machine",
+      bot: finish.bot || "bot",
       createdAt: Date.now(),
       hasVault: false
     });
@@ -132887,6 +135230,7 @@ class VeylHeadlessClient {
       uid: finish.uid || profile.uid,
       username: finish.username || profile.username,
       credentialId,
+      bot: finish.bot || profile.bot || null,
       lastLoginAt: Date.now()
     });
     return this.accountSummary(next);
@@ -133114,9 +135458,73 @@ class VeylHeadlessClient {
   async sendChat(peer, message, options2 = {}) {
     return this.actions.chat.send(peer, message, options2);
   }
+  async replyChat(target, message, options2 = {}) {
+    const peer = peerFromTarget(target, options2);
+    if (!peer) {
+      throw new Error("reply target required");
+    }
+    const messageId = messageIdFromTarget(target, options2);
+    return messageId ? this.actions.chat.reply(peer, messageId, message, options2) : this.sendChat(peer, message, options2);
+  }
+  async reactChat(peer, messageId, emoji, options2 = {}) {
+    return this.actions.chat.react(peer, messageId, emoji, options2);
+  }
+  async reactToChat(target, emoji, options2 = {}) {
+    const peer = peerFromTarget(target, options2);
+    const messageId = messageIdFromTarget(target, options2);
+    if (!peer) {
+      throw new Error("reaction peer required");
+    }
+    if (!messageId) {
+      throw new Error("reaction message id required");
+    }
+    return this.reactChat(peer, messageId, emoji, options2);
+  }
+  async unreactChat(peer, messageId, options2 = {}) {
+    return this.actions.chat.unreact(peer, messageId, options2);
+  }
+  async saveChatMessage(peer, messageId, options2 = {}) {
+    return this.actions.chat.save(peer, messageId, options2);
+  }
+  async unsaveChatMessage(peer, messageId, options2 = {}) {
+    return this.actions.chat.unsave(peer, messageId, options2);
+  }
+  async deleteChatMessage(peer, messageId, options2 = {}) {
+    return this.actions.chat.deleteMessage(peer, messageId, options2);
+  }
+  async deleteChat(peer, options2 = {}) {
+    return this.actions.chat.deleteChat(peer, options2);
+  }
+  async setChatRetention(peer, value, options2 = {}) {
+    return this.actions.chat.retention(peer, value, options2);
+  }
+  async receiveMoney(options2 = {}) {
+    return this.actions.money.receive(options2);
+  }
   async balance(options2 = {}) {
     return this.actions.money.balance(options2);
   }
+  async claimMoney(options2 = {}) {
+    return this.actions.money.claim(options2);
+  }
+  async createInvoice(sats = 0, options2 = {}) {
+    return this.actions.money.invoice(sats, options2);
+  }
+  async lightningQuote(invoice, options2 = {}) {
+    return this.actions.money.lightningQuote(invoice, options2);
+  }
+  async lightningPay(invoice, options2 = {}) {
+    return this.actions.money.lightningPay(invoice, options2);
+  }
+  async lightningReceive(id, options2 = {}) {
+    return this.actions.money.lightningReceive(id, options2);
+  }
+  async lightningSend(id, options2 = {}) {
+    return this.actions.money.lightningSend(id, options2);
+  }
+  async payInvoice(invoice, options2 = {}) {
+    return this.actions.money.payInvoice(invoice, options2);
+  }
   async sendMoney(peer, sats, options2 = {}) {
     return this.actions.money.send(peer, sats, options2);
   }
@@ -133129,6 +135537,15 @@ class VeylHeadlessClient {
   async transactions(options2 = {}) {
     return this.actions.money.transactions(options2);
   }
+  async withdrawQuote(address, sats, options2 = {}) {
+    return this.actions.money.withdrawQuote(address, sats, options2);
+  }
+  async withdrawPrepare(address, sats, options2 = {}) {
+    return this.actions.money.withdrawPrepare(address, sats, options2);
+  }
+  async withdraw(address, sats, options2 = {}) {
+    return this.actions.money.withdraw(address, sats, options2);
+  }
   async listenEvents(options2 = {}) {
     return listenAccount(this, options2);
   }
@@ -133150,9 +135567,18 @@ var HELP = `Usage:
   veyl unlock
   veyl send @name 1000
   veyl request @name 1000
+  veyl receive
+  veyl claim
+  veyl invoice 100 ["memo"]
+  veyl pay-invoice <invoice>
+  veyl withdraw <address> 1000
   veyl balance
   veyl read @name
   veyl say @name "message"
+  veyl reply @name <message-id> "message"
+  veyl react @name <message-id> <emoji>
+  veyl save @name <message-id>
+  veyl retention @name seen|24h
   veyl listen
 
 Structured:
@@ -133167,19 +135593,46 @@ Structured:
   veyl chats
   veyl chat read @name
   veyl chat send @name "message"
+  veyl chat reply @name <message-id> "message"
+  veyl chat react @name <message-id> <emoji>
+  veyl chat unreact @name <message-id>
+  veyl chat save @name <message-id>
+  veyl chat unsave @name <message-id>
+  veyl chat delete @name <message-id>
+  veyl chat delete-chat @name
+  veyl chat retention @name seen|24h
+  veyl money receive
   veyl money balance
+  veyl money claim
+  veyl money invoice 100 ["memo"]
+  veyl money pay-invoice <invoice>
   veyl money send @name 1000
   veyl money request @name 1000
   veyl money pay <request-id>
+  veyl money withdraw-quote <address> 1000
+  veyl money withdraw <address> 1000
   veyl transactions
   veyl mcp serve
 
 Listen:
   --interval ms        poll interval, minimum 1000
   --replay            emit current messages and transactions on startup
+  --incoming          emit only peer-authored messages
+  --compact           emit smaller event payloads
+  --agent             shorthand for --incoming --compact
   --no-chats          skip chat message events
   --no-transactions   skip transaction events
 
+Common options:
+  --count n           result count for list/read/claim/transactions
+  --raw               include raw SDK/backend data when supported
+  --memo text         lightning invoice memo
+  --expiry seconds    lightning invoice expiry
+  --max-fee sats      maximum lightning fee
+  --amount sats       variable invoice amount
+  --speed value       withdrawal speed, SLOW|MEDIUM|FAST
+  --no-deduct-fee     add withdrawal fee on top of the sent amount
+
 Env:
   VEYL_HOME           local profile directory
   VEYL_PROFILE        default profile
@@ -133207,6 +135660,27 @@ ${HELP}`);
   error.code = "usage";
   return error;
 }
+function commandOptions(options2 = {}) {
+  return {
+    count: options2.count,
+    limit: options2.limit,
+    offset: options2.offset,
+    raw: options2.raw,
+    memo: options2.memo,
+    expirySeconds: options2.expirySeconds,
+    maxFeeSats: options2.maxFeeSats,
+    amountSats: options2.amountSats,
+    amountSatsToSend: options2.amountSatsToSend,
+    speed: options2.speed,
+    exitSpeed: options2.speed,
+    type: options2.type,
+    preferSpark: options2.preferSpark,
+    includeSparkAddress: options2.includeSparkAddress,
+    includeSparkInvoice: options2.includeSparkInvoice,
+    deductFeeFromWithdrawalAmount: options2.deductFeeFromWithdrawalAmount,
+    cleanup: options2.cleanup
+  };
+}
 function parseArgs(argv) {
   const options2 = {};
   const args = [];
@@ -133234,8 +135708,50 @@ function parseArgs(argv) {
       options2.messageCount = argv[++index];
     } else if (item === "--tx-count") {
       options2.txCount = argv[++index];
+    } else if (item === "--count") {
+      options2.count = argv[++index];
+    } else if (item === "--limit") {
+      options2.limit = argv[++index];
+    } else if (item === "--offset") {
+      options2.offset = argv[++index];
+    } else if (item === "--raw") {
+      options2.raw = true;
+    } else if (item === "--memo") {
+      options2.memo = argv[++index];
+    } else if (item === "--expiry" || item === "--expiry-seconds") {
+      options2.expirySeconds = argv[++index];
+    } else if (item === "--max-fee" || item === "--max-fee-sats") {
+      options2.maxFeeSats = argv[++index];
+    } else if (item === "--amount" || item === "--amount-sats") {
+      options2.amountSats = argv[++index];
+    } else if (item === "--amount-to-send" || item === "--amount-sats-to-send") {
+      options2.amountSatsToSend = argv[++index];
+    } else if (item === "--speed" || item === "--exit-speed") {
+      options2.speed = argv[++index];
+    } else if (item === "--no-deduct-fee") {
+      options2.deductFeeFromWithdrawalAmount = false;
+    } else if (item === "--type") {
+      options2.type = argv[++index];
+    } else if (item === "--prefer-spark") {
+      options2.preferSpark = true;
+    } else if (item === "--no-prefer-spark") {
+      options2.preferSpark = false;
+    } else if (item === "--include-spark-address") {
+      options2.includeSparkAddress = true;
+    } else if (item === "--include-spark-invoice") {
+      options2.includeSparkInvoice = true;
+    } else if (item === "--no-cleanup") {
+      options2.cleanup = false;
     } else if (item === "--replay") {
       options2.replay = true;
+    } else if (item === "--incoming" || item === "--incoming-only") {
+      options2.incomingOnly = true;
+    } else if (item === "--all") {
+      options2.incomingOnly = false;
+    } else if (item === "--compact") {
+      options2.compact = true;
+    } else if (item === "--agent") {
+      options2.agent = true;
     } else if (item === "--no-chats") {
       options2.chats = false;
     } else if (item === "--no-transactions") {
@@ -133252,36 +135768,38 @@ async function runCommand(argv) {
     process.env.VEYL_VAULT_SECRET = parsed.options.secret;
   }
   const [area, command, ...args] = parsed.args;
+  const shortArgs = command === undefined ? [] : [command, ...args];
   const veyl = createClient2({
     profile: parsed.options.profile,
     network: parsed.options.network
   });
+  const opts = commandOptions(parsed.options);
   if (!area || area === "help" || area === "--help" || area === "-h") {
     return HELP;
   }
   if (area === "chats") {
-    return veyl.chat.list();
+    return veyl.chat.list(opts);
   }
   if (area === "transactions") {
-    return veyl.money.transactions();
+    return veyl.money.transactions(opts);
   }
   if (area === "create") {
     return parsed.options.passkey ? veyl.account.createPasskey({
-      username: args[0],
+      username: shortArgs[0],
       network: parsed.options.network,
       webUrl: parsed.options.webUrl,
       saveCredential: parsed.options.saveCredential,
       onPasskeyUrl: (url) => console.error(`open ${url}`)
-    }) : veyl.account.create({ username: args[0], network: parsed.options.network, saveCredential: parsed.options.saveCredential });
+    }) : veyl.account.create({ username: shortArgs[0], network: parsed.options.network, saveCredential: parsed.options.saveCredential });
   }
   if (area === "login") {
     return parsed.options.passkey ? veyl.account.loginPasskey({
-      username: args[0],
+      username: shortArgs[0],
       network: parsed.options.network,
       webUrl: parsed.options.webUrl,
       saveCredential: parsed.options.saveCredential,
       onPasskeyUrl: (url) => console.error(`open ${url}`)
-    }) : veyl.account.login({ username: args[0] });
+    }) : veyl.account.login({ username: shortArgs[0] });
   }
   if (area === "me") {
     return veyl.account.me();
@@ -133293,25 +135811,70 @@ async function runCommand(argv) {
     return veyl.vault.lock();
   }
   if (area === "balance") {
-    return veyl.money.balance();
+    return veyl.money.balance(opts);
+  }
+  if (area === "receive" || area === "address") {
+    return veyl.money.receive(opts);
+  }
+  if (area === "claim") {
+    return veyl.money.claim(opts);
+  }
+  if (area === "invoice") {
+    return veyl.money.invoice(shortArgs[0] || 0, { ...opts, memo: opts.memo || shortArgs.slice(1).join(" ") || undefined });
+  }
+  if (area === "pay-invoice" || area === "payinvoice") {
+    return veyl.money.payInvoice(shortArgs[0], opts);
+  }
+  if (area === "withdraw-quote") {
+    return veyl.money.withdrawQuote(shortArgs[0], shortArgs[1], opts);
+  }
+  if (area === "withdraw-prepare") {
+    return veyl.money.withdrawPrepare(shortArgs[0], shortArgs[1], opts);
+  }
+  if (area === "withdraw") {
+    return veyl.money.withdraw(shortArgs[0], shortArgs[1], opts);
   }
   if (area === "send") {
-    return veyl.money.send(args[0], args[1]);
+    return veyl.money.send(shortArgs[0], shortArgs[1], opts);
   }
   if (area === "request") {
-    return veyl.money.request(args[0], args[1]);
+    return veyl.money.request(shortArgs[0], shortArgs[1], opts);
   }
   if (area === "pay") {
-    return veyl.money.pay(args[0]);
+    return veyl.money.pay(shortArgs[0], opts);
   }
   if (area === "txs") {
-    return veyl.money.transactions();
+    return veyl.money.transactions(opts);
   }
   if (area === "read") {
-    return veyl.chat.read(args[0]);
+    return veyl.chat.read(shortArgs[0], opts);
   }
   if (area === "say" || area === "msg") {
-    return veyl.chat.send(args[0], args.slice(1).join(" "));
+    return veyl.chat.send(shortArgs[0], shortArgs.slice(1).join(" "), opts);
+  }
+  if (area === "reply") {
+    return veyl.chat.reply({ peer: shortArgs[0], messageId: shortArgs[1] }, shortArgs.slice(2).join(" "), opts);
+  }
+  if (area === "react") {
+    return veyl.chat.react(shortArgs[0], shortArgs[1], shortArgs.slice(2).join(" "), opts);
+  }
+  if (area === "unreact") {
+    return veyl.chat.unreact(shortArgs[0], shortArgs[1], opts);
+  }
+  if (area === "save") {
+    return veyl.chat.save(shortArgs[0], shortArgs[1], opts);
+  }
+  if (area === "unsave") {
+    return veyl.chat.unsave(shortArgs[0], shortArgs[1], opts);
+  }
+  if (area === "delete-message") {
+    return veyl.chat.delete(shortArgs[0], shortArgs[1], opts);
+  }
+  if (area === "delete-chat") {
+    return veyl.chat.deleteChat(shortArgs[0], opts);
+  }
+  if (area === "retention") {
+    return veyl.chat.retention(shortArgs[0], shortArgs[1], opts);
   }
   if (area === "listen") {
     const controller = new AbortController;
@@ -133323,6 +135886,9 @@ async function runCommand(argv) {
       messageCount: parsed.options.messageCount,
       txCount: parsed.options.txCount,
       replay: parsed.options.replay,
+      incomingOnly: parsed.options.incomingOnly,
+      compact: parsed.options.compact,
+      agent: parsed.options.agent,
       chats: parsed.options.chats,
       transactions: parsed.options.transactions,
       signal: controller.signal,
@@ -133359,24 +135925,64 @@ async function runCommand(argv) {
   }
   if (area === "chat") {
     if (command === "list")
-      return veyl.chat.list();
+      return veyl.chat.list(opts);
     if (command === "read")
-      return veyl.chat.read(args[0]);
+      return veyl.chat.read(args[0], opts);
     if (command === "send")
-      return veyl.chat.send(args[0], args.slice(1).join(" "));
+      return veyl.chat.send(args[0], args.slice(1).join(" "), opts);
+    if (command === "reply")
+      return veyl.chat.reply({ peer: args[0], messageId: args[1] }, args.slice(2).join(" "), opts);
+    if (command === "react")
+      return veyl.chat.react(args[0], args[1], args.slice(2).join(" "), opts);
+    if (command === "react-to")
+      return veyl.chat.reactTo({ peer: args[0], messageId: args[1] }, args.slice(2).join(" "), opts);
+    if (command === "unreact")
+      return veyl.chat.unreact(args[0], args[1], opts);
+    if (command === "save")
+      return veyl.chat.save(args[0], args[1], opts);
+    if (command === "unsave")
+      return veyl.chat.unsave(args[0], args[1], opts);
+    if (command === "delete")
+      return veyl.chat.delete(args[0], args[1], opts);
+    if (command === "delete-chat")
+      return veyl.chat.deleteChat(args[0], opts);
+    if (command === "retention")
+      return veyl.chat.retention(args[0], args[1], opts);
     throw usageError("unknown chat command");
   }
   if (area === "money") {
+    if (command === "address" || command === "receive")
+      return veyl.money.receive(opts);
     if (command === "balance")
-      return veyl.money.balance();
+      return veyl.money.balance(opts);
+    if (command === "claim")
+      return veyl.money.claim(opts);
+    if (command === "invoice")
+      return veyl.money.invoice(args[0] || 0, { ...opts, memo: opts.memo || args.slice(1).join(" ") || undefined });
+    if (command === "lightning-quote")
+      return veyl.money.lightningQuote(args[0], opts);
+    if (command === "lightning-pay")
+      return veyl.money.lightningPay(args[0], opts);
+    if (command === "lightning-receive")
+      return veyl.money.lightningReceive(args[0], opts);
+    if (command === "lightning-send")
+      return veyl.money.lightningSend(args[0], opts);
+    if (command === "pay-invoice")
+      return veyl.money.payInvoice(args[0], opts);
     if (command === "send")
-      return veyl.money.send(args[0], args[1]);
+      return veyl.money.send(args[0], args[1], opts);
     if (command === "request")
-      return veyl.money.request(args[0], args[1]);
+      return veyl.money.request(args[0], args[1], opts);
     if (command === "pay")
-      return veyl.money.pay(args[0]);
+      return veyl.money.pay(args[0], opts);
     if (command === "transactions")
-      return veyl.money.transactions();
+      return veyl.money.transactions(opts);
+    if (command === "withdraw-quote")
+      return veyl.money.withdrawQuote(args[0], args[1], opts);
+    if (command === "withdraw-prepare")
+      return veyl.money.withdrawPrepare(args[0], args[1], opts);
+    if (command === "withdraw")
+      return veyl.money.withdraw(args[0], args[1], opts);
     throw usageError("unknown money command");
   }
   if (area === "mcp") {
@@ -133389,14 +135995,15 @@ async function runCommand(argv) {
 async function main() {
   try {
     print2(await runCommand(process.argv.slice(2)));
+    process.exit(0);
   } catch (error) {
     if (error instanceof ClientNotReadyError) {
       console.error(error.message);
-      process.exitCode = 2;
+      process.exit(2);
       return;
     }
     console.error(error?.message || String(error));
-    process.exitCode = error?.code === "usage" ? 1 : 2;
+    process.exit(error?.code === "usage" ? 1 : 2);
   }
 }
 main();