@glyphteck/veyl 0.51.0 → 0.55.0

package/dist/index.js

@@ -6498,10 +6498,10 @@ var init_origins = __esm(() => {
   origins = Object.freeze({
     root: `https://${domains.root}`,
     rootDev: `https://${domains.rootDev}`,
-    rootDevWeb: `https://${domains.rootDev}:3001`,
     veyl: `https://${domains.veyl}`,
     veylDev: `https://${domains.veylDev}`,
-    veylDevWeb: `https://${domains.veylDev}:3000`
+    veylDevWeb: `https://${domains.veylDev}:3000`,
+    veylDevFeatureWeb: `https://${domains.veylDev}:3001`
   });
   appDomains = Object.freeze([
     domains.veyl
@@ -7468,6 +7468,85 @@ var init_settingscloud = __esm(() => {
   "use client";
 });
 
+// ../../core/utils/number.js
+function nonNegativeNumber(value, fallback) {
+  const next = Number(value);
+  return Number.isFinite(next) && next >= 0 ? next : fallback;
+}
+function positiveNumber(value, fallback) {
+  const next = Number(value);
+  return Number.isFinite(next) && next > 0 ? next : fallback;
+}
+function positiveInt(value, fallback) {
+  const next = Math.trunc(Number(value));
+  return Number.isFinite(next) && next > 0 ? next : fallback;
+}
+function nonNegativeInt(value, fallback) {
+  const next = Math.trunc(Number(value));
+  return Number.isFinite(next) && next >= 0 ? next : fallback;
+}
+
+// ../../core/utils/async.js
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, nonNegativeNumber(ms, 0)));
+}
+function createOwnedWaits() {
+  const waits = new Set;
+  let closed = false;
+  const wait = (schedule, cancel) => new Promise((resolve) => {
+    if (closed) {
+      resolve();
+      return;
+    }
+    const pending = { cancel, id: null, resolve };
+    pending.id = schedule(() => {
+      waits.delete(pending);
+      resolve();
+    });
+    waits.add(pending);
+  });
+  return {
+    delay(ms) {
+      return wait((done) => globalThis.setTimeout(done, nonNegativeNumber(ms, 0)), (id) => globalThis.clearTimeout(id));
+    },
+    idle({ timeout = 0, delay = 0 } = {}) {
+      const requestIdle = globalThis.requestIdleCallback?.bind(globalThis);
+      const cancelIdle = globalThis.cancelIdleCallback?.bind(globalThis);
+      if (typeof requestIdle === "function" && typeof cancelIdle === "function") {
+        return wait((done) => requestIdle(done, { timeout: nonNegativeNumber(timeout, 0) }), cancelIdle);
+      }
+      return wait((done) => globalThis.setTimeout(done, nonNegativeNumber(delay, 0)), (id) => globalThis.clearTimeout(id));
+    },
+    close() {
+      if (closed)
+        return;
+      closed = true;
+      for (const pending of waits) {
+        pending.cancel(pending.id);
+        pending.resolve();
+      }
+      waits.clear();
+    }
+  };
+}
+async function yieldToUi() {
+  if (typeof requestAnimationFrame === "function") {
+    await new Promise((resolve) => requestAnimationFrame(resolve));
+  }
+  await sleep(0);
+}
+function waitForIdle({ timeout = 0, delay = 0 } = {}) {
+  return new Promise((resolve) => {
+    const idle = globalThis.requestIdleCallback?.bind(globalThis);
+    if (typeof idle === "function") {
+      idle(() => resolve(), { timeout: nonNegativeNumber(timeout, 0) });
+      return;
+    }
+    globalThis.setTimeout(resolve, nonNegativeNumber(delay, 0));
+  });
+}
+var init_async = () => {};
+
 // ../../core/crypto/sign.js
 function orderKeys(a, b) {
   if (!a || !b) {
@@ -8528,6 +8607,8 @@ async function openVaultAccountSession(vault, password, options = {}) {
     mark(diag, "vault.unlock.decrypt.done", { elapsedMs: Date.now() - decryptStartedAt, source });
     onStage?.("seed-decrypted");
     notifySeedDecrypted(onSeedDecrypted, diag, source);
+    await yieldToUi();
+    requireCurrent(isCurrent);
     onStage?.("deriving");
     const deriveStartedAt = Date.now();
     const registry = await openSecretRegistry(masterSeed, registryEnvelope);
@@ -8673,6 +8754,7 @@ var init_session = __esm(() => {
   init_password();
   init_settings();
   init_settingscloud();
+  init_async();
   init_vault();
 });
 
@@ -8820,10 +8902,7 @@ var init_display = __esm(() => {
 
 // ../../core/profile.js
 function readBotMarker(profile) {
-  const bot = profile?.bot;
-  if (!bot)
-    return null;
-  return typeof bot === "string" ? bot : BOT_PROFILE_MARKER;
+  return profile?.bot === BOT_PROFILE_MARKER ? BOT_PROFILE_MARKER : null;
 }
 function hasPeerKeys(profile) {
   return !!(profile?.walletPK || profile?.chatPK);
@@ -8865,7 +8944,7 @@ function formatUserDisplay(user, showAtSymbol = false) {
   }
   return "unknown user";
 }
-var BOT_PROFILE_MARKER = "bot";
+var BOT_PROFILE_MARKER = "glyphteck";
 var init_profile = __esm(() => {
   init_avatar();
   init_display();
@@ -9920,24 +9999,6 @@ var init_filepayload = __esm(() => {
   SHARED_MEDIA_FILE_PATTERN = new RegExp(`^${SHARED_MEDIA_ROOT}/(${SHARED_MEDIA_ID_PATTERN})$`);
 });
 
-// ../../core/utils/number.js
-function nonNegativeNumber(value, fallback) {
-  const next = Number(value);
-  return Number.isFinite(next) && next >= 0 ? next : fallback;
-}
-function positiveNumber(value, fallback) {
-  const next = Number(value);
-  return Number.isFinite(next) && next > 0 ? next : fallback;
-}
-function positiveInt(value, fallback) {
-  const next = Math.trunc(Number(value));
-  return Number.isFinite(next) && next > 0 ? next : fallback;
-}
-function nonNegativeInt(value, fallback) {
-  const next = Math.trunc(Number(value));
-  return Number.isFinite(next) && next >= 0 ? next : fallback;
-}
-
 // ../../core/chat/messages/files.js
 function hasLocalFileRef(msg) {
   if (!hasText(msg?.p) || !hasText(msg?.k)) {
@@ -13524,8 +13585,8 @@ function isPendingTransfer(tx) {
 function isWalletTransfer(tx) {
   return hasTransferType(tx, WALLET_TRANSFER_TYPES, WALLET_TRANSFER_TYPE_CODES);
 }
-function isWithdrawalTransfer(tx) {
-  return hasTransferType(tx, WITHDRAWAL_TRANSFER_TYPES, WITHDRAWAL_TRANSFER_TYPE_CODES);
+function isBitcoinPaymentTransfer(tx) {
+  return hasTransferType(tx, BITCOIN_PAYMENT_TRANSFER_TYPES, BITCOIN_PAYMENT_TRANSFER_TYPE_CODES);
 }
 function isFundingTransfer(tx) {
   if (hasTransferType(tx, BITCOIN_DEPOSIT_TYPES, BITCOIN_DEPOSIT_TYPE_CODES)) {
@@ -13541,7 +13602,7 @@ function isVisibleTransferStatus(tx) {
   return !status || !HIDDEN_TRANSFER_STATUSES.has(status);
 }
 function isVisibleTransfer(tx) {
-  return isVisibleTransferStatus(tx) && (isWalletTransfer(tx) || isFundingTransfer(tx) || isWithdrawalTransfer(tx));
+  return isVisibleTransferStatus(tx) && (isWalletTransfer(tx) || isFundingTransfer(tx) || isBitcoinPaymentTransfer(tx));
 }
 function isClaimablePendingTransfer(tx, types2 = null) {
   if (Array.isArray(types2) && types2.length && !types2.includes(tx?.type)) {
@@ -13552,7 +13613,7 @@ function isClaimablePendingTransfer(tx, types2 = null) {
 function transferBelongsToWallet(tx, walletPK) {
   return !!walletPK && (sameText(tx?.senderIdentityPublicKey, walletPK) || sameText(tx?.receiverIdentityPublicKey, walletPK));
 }
-var TRANSFER_STATUS_COMPLETED = "TRANSFER_STATUS_COMPLETED", TRANSFER_TYPE_BITCOIN_DEPOSIT = "BITCOIN_DEPOSIT", TRANSFER_TYPE_COOPERATIVE_EXIT = "COOPERATIVE_EXIT", TRANSFER_TYPE_TRANSFER = "TRANSFER", TRANSFER_TYPE_UTXO_SWAP = "UTXO_SWAP", CLAIMABLE_TRANSFER_STATUS_CODES, CLAIMABLE_TRANSFER_STATUSES, TRANSFER_TYPE_COOPERATIVE_EXIT_CODE = 1, TRANSFER_TYPE_TRANSFER_CODE = 2, TRANSFER_TYPE_UTXO_SWAP_CODE = 3, FINAL_TRANSFER_STATUS_CODES, FINAL_TRANSFER_STATUSES, HIDDEN_TRANSFER_STATUS_CODES, HIDDEN_TRANSFER_STATUSES, LIGHTNING_RECEIVE_DONE_STATUSES, WALLET_TRANSFER_TYPE_CODES, WALLET_TRANSFER_TYPES, WITHDRAWAL_TRANSFER_TYPE_CODES, WITHDRAWAL_TRANSFER_TYPES, BITCOIN_DEPOSIT_TYPE_CODES, BITCOIN_DEPOSIT_TYPES, FUNDING_TRANSFER_TYPE_CODES, FUNDING_TRANSFER_TYPES;
+var TRANSFER_STATUS_COMPLETED = "TRANSFER_STATUS_COMPLETED", TRANSFER_TYPE_BITCOIN_DEPOSIT = "BITCOIN_DEPOSIT", TRANSFER_TYPE_COOPERATIVE_EXIT = "COOPERATIVE_EXIT", TRANSFER_TYPE_TRANSFER = "TRANSFER", TRANSFER_TYPE_UTXO_SWAP = "UTXO_SWAP", CLAIMABLE_TRANSFER_STATUS_CODES, CLAIMABLE_TRANSFER_STATUSES, TRANSFER_TYPE_COOPERATIVE_EXIT_CODE = 1, TRANSFER_TYPE_TRANSFER_CODE = 2, TRANSFER_TYPE_UTXO_SWAP_CODE = 3, FINAL_TRANSFER_STATUS_CODES, FINAL_TRANSFER_STATUSES, HIDDEN_TRANSFER_STATUS_CODES, HIDDEN_TRANSFER_STATUSES, LIGHTNING_RECEIVE_DONE_STATUSES, WALLET_TRANSFER_TYPE_CODES, WALLET_TRANSFER_TYPES, BITCOIN_PAYMENT_TRANSFER_TYPE_CODES, BITCOIN_PAYMENT_TRANSFER_TYPES, BITCOIN_DEPOSIT_TYPE_CODES, BITCOIN_DEPOSIT_TYPES, FUNDING_TRANSFER_TYPE_CODES, FUNDING_TRANSFER_TYPES;
 var init_tx = __esm(() => {
   init_time();
   CLAIMABLE_TRANSFER_STATUS_CODES = new Set([2, 3, 4, 9, 10]);
@@ -13570,8 +13631,8 @@ var init_tx = __esm(() => {
   LIGHTNING_RECEIVE_DONE_STATUSES = new Set(["transfer_completed", "lightning_payment_received", "payment_preimage_recovered", "completed"]);
   WALLET_TRANSFER_TYPE_CODES = new Set([TRANSFER_TYPE_TRANSFER_CODE]);
   WALLET_TRANSFER_TYPES = new Set([TRANSFER_TYPE_TRANSFER]);
-  WITHDRAWAL_TRANSFER_TYPE_CODES = new Set([TRANSFER_TYPE_COOPERATIVE_EXIT_CODE]);
-  WITHDRAWAL_TRANSFER_TYPES = new Set([TRANSFER_TYPE_COOPERATIVE_EXIT]);
+  BITCOIN_PAYMENT_TRANSFER_TYPE_CODES = new Set([TRANSFER_TYPE_COOPERATIVE_EXIT_CODE]);
+  BITCOIN_PAYMENT_TRANSFER_TYPES = new Set([TRANSFER_TYPE_COOPERATIVE_EXIT]);
   BITCOIN_DEPOSIT_TYPE_CODES = new Set;
   BITCOIN_DEPOSIT_TYPES = new Set([TRANSFER_TYPE_BITCOIN_DEPOSIT]);
   FUNDING_TRANSFER_TYPE_CODES = new Set([TRANSFER_TYPE_UTXO_SWAP_CODE]);
@@ -17635,67 +17696,6 @@ var init_equal = __esm(() => {
   init_core();
 });
 
-// ../../core/utils/async.js
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, nonNegativeNumber(ms, 0)));
-}
-function createOwnedWaits() {
-  const waits = new Set;
-  let closed = false;
-  const wait = (schedule, cancel) => new Promise((resolve) => {
-    if (closed) {
-      resolve();
-      return;
-    }
-    const pending = { cancel, id: null, resolve };
-    pending.id = schedule(() => {
-      waits.delete(pending);
-      resolve();
-    });
-    waits.add(pending);
-  });
-  return {
-    delay(ms) {
-      return wait((done) => globalThis.setTimeout(done, nonNegativeNumber(ms, 0)), (id) => globalThis.clearTimeout(id));
-    },
-    idle({ timeout = 0, delay = 0 } = {}) {
-      const requestIdle = globalThis.requestIdleCallback?.bind(globalThis);
-      const cancelIdle = globalThis.cancelIdleCallback?.bind(globalThis);
-      if (typeof requestIdle === "function" && typeof cancelIdle === "function") {
-        return wait((done) => requestIdle(done, { timeout: nonNegativeNumber(timeout, 0) }), cancelIdle);
-      }
-      return wait((done) => globalThis.setTimeout(done, nonNegativeNumber(delay, 0)), (id) => globalThis.clearTimeout(id));
-    },
-    close() {
-      if (closed)
-        return;
-      closed = true;
-      for (const pending of waits) {
-        pending.cancel(pending.id);
-        pending.resolve();
-      }
-      waits.clear();
-    }
-  };
-}
-async function yieldToUi() {
-  if (typeof requestAnimationFrame === "function") {
-    await new Promise((resolve) => requestAnimationFrame(resolve));
-  }
-  await sleep(0);
-}
-function waitForIdle({ timeout = 0, delay = 0 } = {}) {
-  return new Promise((resolve) => {
-    const idle = globalThis.requestIdleCallback?.bind(globalThis);
-    if (typeof idle === "function") {
-      idle(() => resolve(), { timeout: nonNegativeNumber(timeout, 0) });
-      return;
-    }
-    globalThis.setTimeout(resolve, nonNegativeNumber(delay, 0));
-  });
-}
-var init_async = () => {};
-
 // ../../core/chat/messages/payloadlog.js
 function messagePayloadKind(message) {
   if (!message || typeof message !== "object") {
@@ -23019,12 +23019,12 @@ function getCurrencyAmountSats(amount) {
   }
   return value;
 }
-function getWithdrawalFeeBreakdown(feeQuote, exitSpeed = DEFAULT_EXIT_SPEED) {
+function getBitcoinPaymentFeeBreakdown(feeQuote, exitSpeed = DEFAULT_EXIT_SPEED) {
   if (!feeQuote) {
     return null;
   }
   const speed = getExitSpeed(exitSpeed);
-  const fields = WITHDRAWAL_FEE_FIELDS[speed];
+  const fields = BITCOIN_PAYMENT_FEE_FIELDS[speed];
   const userFeeSats = getCurrencyAmountSats(feeQuote[fields.user]);
   const l1BroadcastFeeSats = getCurrencyAmountSats(feeQuote[fields.l1]);
   return {
@@ -23036,16 +23036,16 @@ function getWithdrawalFeeBreakdown(feeQuote, exitSpeed = DEFAULT_EXIT_SPEED) {
     expiresAt: feeQuote.expiresAt ?? null
   };
 }
-function getWithdrawalFeeAmountSats(feeQuote, exitSpeed = DEFAULT_EXIT_SPEED) {
-  return getWithdrawalFeeBreakdown(feeQuote, exitSpeed)?.feeAmountSats ?? null;
+function getBitcoinPaymentFeeAmountSats(feeQuote, exitSpeed = DEFAULT_EXIT_SPEED) {
+  return getBitcoinPaymentFeeBreakdown(feeQuote, exitSpeed)?.feeAmountSats ?? null;
 }
-function normalizeWithdrawalFeeQuote(feeQuote) {
+function normalizeBitcoinPaymentFeeQuote(feeQuote) {
   if (!feeQuote) {
     return null;
   }
   const speeds = {};
   for (const speed of EXIT_SPEEDS) {
-    speeds[speed] = getWithdrawalFeeBreakdown(feeQuote, speed);
+    speeds[speed] = getBitcoinPaymentFeeBreakdown(feeQuote, speed);
   }
   return {
     id: feeQuote.id ?? null,
@@ -23155,7 +23155,7 @@ function normalizeLightningPaymentResult(result) {
     raw: result
   };
 }
-var DEFAULT_EXIT_SPEED = "MEDIUM", EXIT_SPEEDS, UNILATERAL_EXIT_PARENT_TX_FALLBACK_VBYTES = 191, UNILATERAL_EXIT_FEE_BUMP_TX_VBYTES = 151, UNILATERAL_EXIT_PACKAGES_PER_LEAF = 2, UNILATERAL_EXIT_PREVIEW_VBYTES, DEFAULT_FEE_RATE_SPEED = "medium", FEE_RATE_FALLBACKS, WITHDRAWAL_FEE_FIELDS;
+var DEFAULT_EXIT_SPEED = "MEDIUM", EXIT_SPEEDS, UNILATERAL_EXIT_PARENT_TX_FALLBACK_VBYTES = 191, UNILATERAL_EXIT_FEE_BUMP_TX_VBYTES = 151, UNILATERAL_EXIT_PACKAGES_PER_LEAF = 2, UNILATERAL_EXIT_PREVIEW_VBYTES, DEFAULT_FEE_RATE_SPEED = "medium", FEE_RATE_FALLBACKS, BITCOIN_PAYMENT_FEE_FIELDS;
 var init_fees = __esm(() => {
   EXIT_SPEEDS = Object.freeze(["SLOW", "MEDIUM", "FAST"]);
   UNILATERAL_EXIT_PREVIEW_VBYTES = UNILATERAL_EXIT_PACKAGES_PER_LEAF * (UNILATERAL_EXIT_PARENT_TX_FALLBACK_VBYTES + UNILATERAL_EXIT_FEE_BUMP_TX_VBYTES);
@@ -23172,7 +23172,7 @@ var init_fees = __esm(() => {
     noPriority: Object.freeze(["low", "medium", "high"]),
     average: Object.freeze(["medium", "low", "high"])
   });
-  WITHDRAWAL_FEE_FIELDS = Object.freeze({
+  BITCOIN_PAYMENT_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" })
@@ -25768,59 +25768,6 @@ async function createLightningInvoice(wallet, { amountSats = 0, memo, expirySeco
     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") };
@@ -25864,17 +25811,9 @@ var init_lightningops = __esm(() => {
 });
 
 // ../../core/wallet/lightning.js
-function createLightning({ wallet, updateWalletData }) {
+function createLightning({ wallet }) {
   return {
     createLightningInvoice: (params) => createLightningInvoice(wallet, params),
-    quoteLightningFees: (params) => quoteLightningFees(wallet, params),
-    async sendLightningPayment(params) {
-      const result = await sendLightningPayment(wallet, params);
-      if (result.success) {
-        await updateWalletData({ reason: "lightning-send" });
-      }
-      return result;
-    },
     getLightningReceiveRequest: (id) => getLightningReceiveRequest(wallet, id),
     getLightningSendRequest: (id) => getLightningSendRequest(wallet, id)
   };
@@ -26381,61 +26320,6 @@ var init_lifecycle = __esm(() => {
   });
 });
 
-// ../../core/wallet/privacy.js
-function createWalletPrivacy({ wallet, ghostWallet, diag }) {
-  let desiredPrivacy = ghostWallet === true;
-  let revision = 0;
-  let closed = false;
-  let privacySync = Promise.resolve();
-  const waits = createOwnedWaits();
-  const setGhostWallet = (nextGhostWallet) => {
-    const nextDesiredPrivacy = nextGhostWallet === true;
-    if (revision > 0 && desiredPrivacy === nextDesiredPrivacy) {
-      return privacySync;
-    }
-    desiredPrivacy = nextDesiredPrivacy;
-    const requestRevision = ++revision;
-    if (!wallet || typeof wallet.setPrivacyEnabled !== "function" || closed) {
-      return privacySync;
-    }
-    privacySync = privacySync.catch(() => {}).then(async () => {
-      await waits.delay(PRIVACY_SYNC_DELAY_MS);
-      if (closed || requestRevision !== revision) {
-        return;
-      }
-      await waits.idle({ timeout: PRIVACY_SYNC_DELAY_MS, delay: PRIVACY_SYNC_DELAY_MS });
-      if (closed || requestRevision !== revision) {
-        return;
-      }
-      const startedAt = Date.now();
-      const desired = desiredPrivacy;
-      markDiag(diag, "wallet.privacy.start", { ghostWallet: desired });
-      await wallet.setPrivacyEnabled(desired);
-      markDone(diag, "wallet.privacy", startedAt, { changed: true });
-    }).catch((error) => {
-      markDiag(diag, "wallet.privacy.error", { code: error?.code || "", message: error?.message || String(error) });
-    });
-    return privacySync;
-  };
-  setGhostWallet(ghostWallet);
-  return {
-    setGhostWallet,
-    close() {
-      if (closed)
-        return;
-      closed = true;
-      revision += 1;
-      waits.close();
-    }
-  };
-}
-var PRIVACY_SYNC_DELAY_MS;
-var init_privacy = __esm(() => {
-  init_config();
-  init_async();
-  PRIVACY_SYNC_DELAY_MS = WALLET_BOOT_CACHED_REFRESH_DELAY_MS * 2;
-});
-
 // ../../node_modules/.bun/bech32@2.0.0/node_modules/bech32/dist/index.js
 var require_dist = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
@@ -26646,7 +26530,43 @@ var init_spark = __esm(() => {
   });
 });
 
-// ../../core/wallet/send.js
+// ../../core/wallet/payment.js
+function paymentKind(value) {
+  const kind = cleanText(value).toLowerCase();
+  if (!PAYMENT_KINDS.has(kind)) {
+    throw new Error("unsupported payment kind");
+  }
+  return kind;
+}
+function paymentDestination(value) {
+  const destination = cleanText(value);
+  if (!destination) {
+    throw new Error("payment destination required");
+  }
+  return destination;
+}
+function optionalPaymentAmount(value) {
+  return value == null ? null : toSafeSats(value);
+}
+function normalizeIntent(intent = {}) {
+  const kind = paymentKind(intent.kind);
+  const destination = paymentDestination(intent.destination);
+  const amountSats = optionalPaymentAmount(intent.amountSats);
+  if ((kind === PAYMENT_KIND_BITCOIN || kind === PAYMENT_KIND_SPARK) && amountSats == null) {
+    throw new Error("payment amount required");
+  }
+  return {
+    kind,
+    destination,
+    amountSats,
+    variableAmount: intent.variableAmount === true,
+    preferSpark: intent.preferSpark === true,
+    idempotencyKey: cleanText(intent.idempotencyKey) || null,
+    maxFeeSats: intent.maxFeeSats == null ? null : toSafeNonNegativeSats(intent.maxFeeSats, "maxFeeSats"),
+    exitSpeed: getExitSpeed(intent.exitSpeed),
+    deductFeeFromAmount: intent.deductFeeFromAmount !== false
+  };
+}
 function firstSparkInvoiceError(result) {
   return result?.invalidInvoices?.[0]?.error || result?.satsTransactionErrors?.[0]?.error || result?.tokenTransactionErrors?.[0]?.error || null;
 }
@@ -26662,139 +26582,360 @@ function publicSparkInvoiceResult(transfer) {
     amountSats: Number.isSafeInteger(transfer?.totalValue) ? transfer.totalValue : null
   };
 }
-function createWalletSend({ wallet, network, updateWalletData, refreshBalance = null, rememberTransfer, refreshPendingTransfers = null, sentTransferRefreshDelayMs = null, beginSdkActivity = null, diag }) {
-  const refreshTimers = new Set;
-  let closed = false;
-  const sendMoneyWithSpark = async (receiverWalletPK, amountSats) => {
-    if (!wallet || closed) {
-      throw new Error("wallet not ready");
+function getBitcoinPaymentMinimumReceiveSats(addressInput) {
+  const address = cleanText(addressInput).toLowerCase();
+  if (address.startsWith("1"))
+    return P2PKH_DUST_SATS;
+  if (address.startsWith("3"))
+    return P2SH_DUST_SATS;
+  const p2wpkhLength = address.startsWith("bcrt1q") ? 44 : 42;
+  if ((address.startsWith("bc1q") || address.startsWith("bcrt1q")) && address.length === p2wpkhLength) {
+    return P2WPKH_DUST_SATS;
+  }
+  return SEGWIT_SCRIPT_DUST_SATS;
+}
+function getBitcoinPaymentAmounts(payment) {
+  const amountSats = toSafeSats(payment?.amountSats);
+  const feeAmountSats = toSafeNonNegativeSats(payment?.feeAmountSats ?? 0, "feeAmountSats");
+  const deductFeeFromAmount = payment?.deductFeeFromAmount !== false;
+  const receiveAmountSats = deductFeeFromAmount ? Math.max(0, amountSats - feeAmountSats) : amountSats;
+  const sendAmountSats = deductFeeFromAmount ? amountSats : amountSats + feeAmountSats;
+  return {
+    sendAmountSats,
+    receiveAmountSats,
+    feeAmountSats
+  };
+}
+function assertBitcoinPaymentReceivesFunds(payment) {
+  const { receiveAmountSats } = getBitcoinPaymentAmounts(payment);
+  const minimumReceiveAmountSats = getBitcoinPaymentMinimumReceiveSats(payment?.destination);
+  if (receiveAmountSats < minimumReceiveAmountSats) {
+    throw new Error(`bitcoin payment would create a dust output below ${minimumReceiveAmountSats} sats`);
+  }
+}
+function bitcoinPaymentReview(intent, feeQuote) {
+  const feeQuoteId = feeQuote?.id ?? null;
+  const feeAmountSats = getBitcoinPaymentFeeAmountSats(feeQuote, intent.exitSpeed);
+  if (!feeQuoteId || feeAmountSats == null) {
+    throw new Error("bitcoin payment fee quote unavailable");
+  }
+  const sparkFees = normalizeBitcoinPaymentFeeQuote(feeQuote);
+  const payment = {
+    ...intent,
+    state: PAYMENT_STATE_PREPARED,
+    feeQuote,
+    feeQuoteId,
+    feeAmountSats,
+    fees: { spark: sparkFees },
+    expiresAt: sparkFees?.expiresAt ?? feeQuote.expiresAt ?? null
+  };
+  assertBitcoinPaymentReceivesFunds(payment);
+  return Object.freeze(payment);
+}
+function preparedPayment(intent, extra = {}) {
+  return Object.freeze({
+    ...intent,
+    state: PAYMENT_STATE_PREPARED,
+    fees: null,
+    expiresAt: null,
+    ...extra
+  });
+}
+async function prepare(wallet, network, paymentInput) {
+  if (!wallet) {
+    throw new Error("wallet not ready");
+  }
+  const intent = normalizeIntent(paymentInput);
+  if (intent.kind === PAYMENT_KIND_BITCOIN) {
+    if (!isAddressOnNetwork(intent.destination, network)) {
+      throw new Error(`refusing to pay - address is not a ${network} address`);
     }
-    const startedAt = Date.now();
-    markDiag(diag, "wallet.send.start", {});
-    const endSdkActivity = typeof beginSdkActivity === "function" ? beginSdkActivity("send") : null;
-    try {
-      const receiverSparkAddress = walletPKtoSparkAddress(receiverWalletPK, network);
-      const tx = await wallet.transfer({
-        receiverSparkAddress,
-        amountSats: toSafeSats(amountSats)
-      });
-      endSdkActivity?.();
-      markDone(diag, "wallet.send.sdk", startedAt, { hasTransfer: !!tx?.id });
-      const rememberStartedAt = Date.now();
-      await rememberTransfer?.(tx, { pending: true });
-      markDone(diag, "wallet.send.remember", rememberStartedAt, { hasTransfer: !!tx?.id });
-      await refreshBalance?.();
-      const refreshDelayMs = Number(sentTransferRefreshDelayMs);
-      if (!closed && tx?.id && typeof refreshPendingTransfers === "function" && Number.isFinite(refreshDelayMs) && refreshDelayMs >= 0) {
-        markDiag(diag, "wallet.send.refresh.schedule", { delayMs: refreshDelayMs });
-        const timer = setTimeout(() => {
-          refreshTimers.delete(timer);
-          if (closed)
-            return;
-          markDiag(diag, "wallet.send.refresh.start", {});
-          refreshPendingTransfers([tx.id]);
-        }, refreshDelayMs);
-        refreshTimers.add(timer);
+    const feeQuote = await wallet.getWithdrawalFeeQuote({
+      amountSats: intent.amountSats,
+      withdrawalAddress: intent.destination
+    });
+    return bitcoinPaymentReview(intent, feeQuote);
+  }
+  if (intent.kind === PAYMENT_KIND_LIGHTNING) {
+    let maxFeeSats = intent.maxFeeSats;
+    let fees = maxFeeSats == null ? null : normalizeLightningFeeEstimate(maxFeeSats);
+    if (maxFeeSats == null) {
+      const estimateParams = { encodedInvoice: intent.destination };
+      if (intent.variableAmount && intent.amountSats != null) {
+        estimateParams.amountSats = intent.amountSats;
       }
-      markDone(diag, "wallet.send", startedAt, { hasTransfer: !!tx?.id });
-      return tx?.id;
-    } catch (error) {
-      endSdkActivity?.();
-      markError(diag, "wallet.send", startedAt, error);
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(`failed to send money: ${message}`, { cause: error });
+      maxFeeSats = await wallet.getLightningSendFeeEstimate(estimateParams);
+      fees = normalizeLightningFeeEstimate(maxFeeSats);
     }
+    return preparedPayment(intent, { maxFeeSats, fees });
+  }
+  return preparedPayment(intent);
+}
+function normalizePreparedPayment(paymentInput, network) {
+  const intent = normalizeIntent(paymentInput);
+  if (paymentInput?.state !== PAYMENT_STATE_PREPARED) {
+    throw new Error("prepared payment required");
+  }
+  if (intent.kind !== PAYMENT_KIND_BITCOIN) {
+    return preparedPayment(intent, {
+      fees: paymentInput.fees || null,
+      expiresAt: paymentInput.expiresAt ?? null
+    });
+  }
+  if (!isAddressOnNetwork(intent.destination, network)) {
+    throw new Error(`refusing to pay - address is not a ${network} address`);
+  }
+  const feeQuoteId = cleanText(paymentInput.feeQuoteId);
+  if (!feeQuoteId) {
+    throw new Error("bitcoin payment fee quote missing");
+  }
+  const payment = {
+    ...intent,
+    state: PAYMENT_STATE_PREPARED,
+    feeQuote: paymentInput.feeQuote || null,
+    feeQuoteId,
+    feeAmountSats: toSafeNonNegativeSats(paymentInput.feeAmountSats, "feeAmountSats"),
+    fees: paymentInput.fees || null,
+    expiresAt: paymentInput.expiresAt ?? null
+  };
+  assertBitcoinPaymentReceivesFunds(payment);
+  return Object.freeze(payment);
+}
+async function sendBitcoin(wallet, walletPK, network, payment, rememberTransfer) {
+  if (!isAddressOnNetwork(payment.destination, network)) {
+    throw new Error(`refusing to pay - address is not a ${network} address`);
+  }
+  if (!payment.feeQuoteId || payment.feeAmountSats == null) {
+    throw new Error("bitcoin payment review missing");
+  }
+  assertBitcoinPaymentReceivesFunds(payment);
+  const tx = await wallet.withdraw({
+    onchainAddress: payment.destination,
+    amountSats: payment.amountSats,
+    exitSpeed: payment.exitSpeed,
+    feeQuoteId: payment.feeQuoteId,
+    feeAmountSats: payment.feeAmountSats,
+    deductFeeFromWithdrawalAmount: payment.deductFeeFromAmount
+  });
+  const transferId = tx?.transfer?.sparkId || tx?.transfer?.id || null;
+  if (transferId) {
+    const createdTime = tx?.createdAt || new Date().toISOString();
+    await rememberTransfer?.({
+      id: transferId,
+      senderIdentityPublicKey: walletPK,
+      receiverIdentityPublicKey: "",
+      status: "TRANSFER_STATUS_SENDER_INITIATED",
+      totalValue: payment.amountSats,
+      createdTime,
+      updatedTime: tx?.updatedAt || createdTime,
+      type: "COOPERATIVE_EXIT",
+      transferDirection: "OUTGOING"
+    }, {
+      pending: true,
+      bitcoinAddress: payment.destination,
+      bitcoinTxid: tx?.coopExitTxid || null
+    });
+  }
+  return {
+    id: transferId || tx?.id || tx?.coopExitTxid || null,
+    result: tx
   };
-  const payExternalInvoice = async ({ type, invoice, amountSats, variableAmount = false } = {}) => {
+}
+function createPayment({
+  wallet,
+  walletPK,
+  network,
+  updateWalletData,
+  refreshBalance = null,
+  rememberTransfer,
+  refreshPendingTransfers = null,
+  sentTransferRefreshDelayMs = null,
+  beginSdkActivity = null,
+  diag = null
+}) {
+  const refreshTimers = new Set;
+  let closed = false;
+  const assertReady = () => {
     if (!wallet || closed) {
       throw new Error("wallet not ready");
     }
-    const value = cleanText(invoice);
-    if (!value) {
-      throw new Error("invoice required");
+  };
+  const preparePayment = async (intent) => {
+    assertReady();
+    return prepare(wallet, network, intent);
+  };
+  const scheduleTransferRefresh = (id) => {
+    const refreshDelayMs = Number(sentTransferRefreshDelayMs);
+    if (closed || !id || typeof refreshPendingTransfers !== "function" || !Number.isFinite(refreshDelayMs) || refreshDelayMs < 0) {
+      return;
     }
+    markDiag(diag, "wallet.send.refresh.schedule", { delayMs: refreshDelayMs });
+    const timer = setTimeout(() => {
+      refreshTimers.delete(timer);
+      if (closed)
+        return;
+      markDiag(diag, "wallet.send.refresh.start", {});
+      refreshPendingTransfers([id]);
+    }, refreshDelayMs);
+    refreshTimers.add(timer);
+  };
+  const sendPayment = async (paymentInput) => {
+    assertReady();
+    if (paymentInput?.kind === PAYMENT_KIND_BITCOIN && paymentInput?.state !== PAYMENT_STATE_PREPARED) {
+      throw new Error("bitcoin payment must be reviewed before sending");
+    }
+    const payment = paymentInput?.state === PAYMENT_STATE_PREPARED ? normalizePreparedPayment(paymentInput, network) : await preparePayment(paymentInput);
     const startedAt = Date.now();
-    markDiag(diag, "wallet.externalPay.start", { type });
-    if (type === "lightning") {
-      try {
-        const sendAmountSats = variableAmount ? toSafeSats(amountSats, "amountSatsToSend") : null;
-        const estimateParams = {
-          encodedInvoice: value,
-          ...sendAmountSats != null ? { amountSats: sendAmountSats } : {}
-        };
-        const feeAmountSats = await wallet.getLightningSendFeeEstimate(estimateParams);
-        const fees = normalizeLightningFeeEstimate(feeAmountSats);
-        const payment = await wallet.payLightningInvoice({
-          invoice: value,
-          maxFeeSats: fees.feeAmountSats,
-          preferSpark: true,
-          ...sendAmountSats != null ? { amountSatsToSend: sendAmountSats } : {}
+    const diagKind = payment.kind;
+    markDiag(diag, "wallet.payment.start", { kind: diagKind });
+    const endSdkActivity = typeof beginSdkActivity === "function" ? beginSdkActivity("payment") : null;
+    try {
+      let outcome;
+      if (payment.kind === PAYMENT_KIND_SPARK) {
+        if (sameText(payment.destination, walletPK)) {
+          throw new Error("cannot send money to the same wallet");
+        }
+        const tx = await wallet.transfer({
+          receiverSparkAddress: walletPKtoSparkAddress(payment.destination, network),
+          amountSats: payment.amountSats
+        });
+        await rememberTransfer?.(tx, { pending: true });
+        await refreshBalance?.();
+        scheduleTransferRefresh(tx?.id);
+        outcome = { id: tx?.id || null, result: tx };
+      } else if (payment.kind === PAYMENT_KIND_LIGHTNING) {
+        const sent = await wallet.payLightningInvoice({
+          invoice: payment.destination,
+          maxFeeSats: payment.maxFeeSats,
+          preferSpark: payment.preferSpark,
+          ...payment.variableAmount && payment.amountSats != null ? { amountSatsToSend: payment.amountSats } : {},
+          ...payment.idempotencyKey ? { idempotencyKey: payment.idempotencyKey } : {}
         });
-        const result = normalizeLightningPaymentResult(payment);
+        const result = normalizeLightningPaymentResult(sent);
         if (result?.kind === "spark" && result?.transfer) {
           await rememberTransfer?.(result.transfer, { pending: true });
         } else {
-          await rememberTransfer?.(result?.id || payment?.id);
+          await rememberTransfer?.(result?.id || sent?.id);
           await updateWalletData({ reason: "external-lightning-send" });
         }
-        markDone(diag, "wallet.externalPay", startedAt, { type, hasTransfer: !!result?.transfer });
-        return {
-          id: result?.id || payment?.id || null,
-          payment,
-          result,
-          fees
-        };
-      } catch (error) {
-        markError(diag, "wallet.externalPay", startedAt, error, { type });
-        throw error;
-      }
-    }
-    if (type === "spark") {
-      try {
-        const safeAmountSats = amountSats != null ? toSafeSats(amountSats, "amountSats") : null;
+        outcome = { id: result?.id || sent?.id || null, result, raw: sent };
+      } else if (payment.kind === PAYMENT_KIND_SPARK_INVOICE) {
         const result = await wallet.fulfillSparkInvoice([
           {
-            invoice: value,
-            ...safeAmountSats != null ? { amount: BigInt(safeAmountSats) } : {}
+            invoice: payment.destination,
+            ...payment.amountSats != null ? { amount: BigInt(payment.amountSats) } : {}
           }
         ]);
         const error = firstSparkInvoiceError(result);
-        if (error) {
+        if (error)
           throw error;
-        }
         const success = firstSparkInvoiceSuccess(result);
-        if (!success) {
+        if (!success)
           throw new Error("failed to pay spark invoice");
-        }
         const id = success.id || success.txid || null;
         await rememberTransfer?.(success.id ? success : id, { pending: true });
-        markDone(diag, "wallet.externalPay", startedAt, { type, hasTransfer: !!id });
-        return {
-          id,
-          result: publicSparkInvoiceResult(success)
-        };
-      } catch (error) {
-        markError(diag, "wallet.externalPay", startedAt, error, { type });
-        throw error;
+        outcome = { id, result: publicSparkInvoiceResult(success), raw: result };
+      } else if (payment.kind === PAYMENT_KIND_BITCOIN) {
+        outcome = await sendBitcoin(wallet, walletPK, network, payment, rememberTransfer);
+        await updateWalletData({ reason: "bitcoin-payment" });
+      } else {
+        throw new Error("unsupported payment kind");
       }
+      endSdkActivity?.();
+      markDone(diag, "wallet.payment", startedAt, { kind: diagKind, hasTransfer: !!outcome?.id });
+      return Object.freeze({
+        kind: payment.kind,
+        destination: payment.destination,
+        amountSats: payment.amountSats,
+        id: outcome?.id || null,
+        fees: payment.fees || null,
+        result: outcome?.result || null,
+        raw: outcome?.raw || null
+      });
+    } catch (error) {
+      endSdkActivity?.();
+      markError(diag, "wallet.payment", startedAt, error, { kind: diagKind });
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`failed to send payment: ${message}`, { cause: error });
     }
-    throw new Error("unsupported invoice type");
   };
   return {
-    sendMoneyWithSpark,
-    payExternalInvoice,
+    preparePayment,
+    sendPayment,
     close() {
       closed = true;
-      for (const timer of refreshTimers) {
+      for (const timer of refreshTimers)
         clearTimeout(timer);
-      }
       refreshTimers.clear();
     }
   };
 }
-var init_send2 = __esm(() => {
+var PAYMENT_KIND_BITCOIN = "bitcoin", PAYMENT_KIND_LIGHTNING = "lightning", PAYMENT_KIND_SPARK = "spark", PAYMENT_KIND_SPARK_INVOICE = "spark_invoice", PAYMENT_STATE_PREPARED = "prepared", PAYMENT_KINDS, P2PKH_DUST_SATS = 546, P2SH_DUST_SATS = 540, P2WPKH_DUST_SATS = 294, SEGWIT_SCRIPT_DUST_SATS = 330;
+var init_payment = __esm(() => {
+  init_network();
   init_fees();
   init_spark();
+  PAYMENT_KINDS = new Set([
+    PAYMENT_KIND_BITCOIN,
+    PAYMENT_KIND_LIGHTNING,
+    PAYMENT_KIND_SPARK,
+    PAYMENT_KIND_SPARK_INVOICE
+  ]);
+});
+
+// ../../core/wallet/privacy.js
+function createWalletPrivacy({ wallet, ghostWallet, diag }) {
+  let desiredPrivacy = ghostWallet === true;
+  let revision = 0;
+  let closed = false;
+  let privacySync = Promise.resolve();
+  const waits = createOwnedWaits();
+  const setGhostWallet = (nextGhostWallet) => {
+    const nextDesiredPrivacy = nextGhostWallet === true;
+    if (revision > 0 && desiredPrivacy === nextDesiredPrivacy) {
+      return privacySync;
+    }
+    desiredPrivacy = nextDesiredPrivacy;
+    const requestRevision = ++revision;
+    if (!wallet || typeof wallet.setPrivacyEnabled !== "function" || closed) {
+      return privacySync;
+    }
+    privacySync = privacySync.catch(() => {}).then(async () => {
+      await waits.delay(PRIVACY_SYNC_DELAY_MS);
+      if (closed || requestRevision !== revision) {
+        return;
+      }
+      await waits.idle({ timeout: PRIVACY_SYNC_DELAY_MS, delay: PRIVACY_SYNC_DELAY_MS });
+      if (closed || requestRevision !== revision) {
+        return;
+      }
+      const startedAt = Date.now();
+      const desired = desiredPrivacy;
+      markDiag(diag, "wallet.privacy.start", { ghostWallet: desired });
+      await wallet.setPrivacyEnabled(desired);
+      markDone(diag, "wallet.privacy", startedAt, { changed: true });
+    }).catch((error) => {
+      markDiag(diag, "wallet.privacy.error", { code: error?.code || "", message: error?.message || String(error) });
+    });
+    return privacySync;
+  };
+  setGhostWallet(ghostWallet);
+  return {
+    setGhostWallet,
+    close() {
+      if (closed)
+        return;
+      closed = true;
+      revision += 1;
+      waits.close();
+    }
+  };
+}
+var PRIVACY_SYNC_DELAY_MS;
+var init_privacy = __esm(() => {
+  init_config();
+  init_async();
+  PRIVACY_SYNC_DELAY_MS = WALLET_BOOT_CACHED_REFRESH_DELAY_MS * 2;
 });
 
 // ../../core/wallet/history.js
@@ -26818,7 +26959,7 @@ function compareRecentTransfer(a, b) {
   return String(b?.id || "").localeCompare(String(a?.id || ""));
 }
 function sameTransfer(left, right) {
-  return left?.id === right?.id && left?.status === right?.status && txCreatedMs(left) === txCreatedMs(right) && txUpdatedMs(left) === txUpdatedMs(right) && left?.totalValue === right?.totalValue && left?.type === right?.type && left?.transferDirection === right?.transferDirection && left?.senderIdentityPublicKey === right?.senderIdentityPublicKey && left?.receiverIdentityPublicKey === right?.receiverIdentityPublicKey;
+  return left?.id === right?.id && left?.status === right?.status && txCreatedMs(left) === txCreatedMs(right) && txUpdatedMs(left) === txUpdatedMs(right) && left?.totalValue === right?.totalValue && left?.type === right?.type && left?.transferDirection === right?.transferDirection && left?.senderIdentityPublicKey === right?.senderIdentityPublicKey && left?.receiverIdentityPublicKey === right?.receiverIdentityPublicKey && left?.bitcoinAddress === right?.bitcoinAddress && left?.bitcoinTxid === right?.bitcoinTxid;
 }
 function sameTransfers(a = [], b = []) {
   if (a === b) {
@@ -26860,10 +27001,13 @@ function satValue(value) {
   const amount = Number(value);
   return Number.isFinite(amount) ? amount : 0;
 }
-function compactTransfer(tx, { incoming = false } = {}) {
+function compactTransfer(tx, { incoming = false, bitcoinAddress = null, bitcoinTxid = null } = {}) {
   if (!tx?.id) {
     return null;
   }
+  const isBitcoinPayment = enumName(tx.type, TRANSFER_TYPE_BY_CODE) === "COOPERATIVE_EXIT";
+  const storedBitcoinAddress = String(bitcoinAddress || tx.bitcoinAddress || "").trim() || null;
+  const storedBitcoinTxid = String(bitcoinTxid || tx.bitcoinTxid || (isBitcoinPayment ? tx.userRequest?.coopExitTxid : "") || "").trim() || null;
   return {
     id: tx.id,
     senderIdentityPublicKey: hexKey(tx.senderIdentityPublicKey),
@@ -26873,11 +27017,13 @@ function compactTransfer(tx, { incoming = false } = {}) {
     createdTime: tx.createdTime,
     updatedTime: tx.updatedTime,
     type: enumName(tx.type, TRANSFER_TYPE_BY_CODE),
-    transferDirection: tx.transferDirection || (incoming ? "INCOMING" : undefined)
+    transferDirection: tx.transferDirection || (incoming ? "INCOMING" : undefined),
+    ...isBitcoinPayment && storedBitcoinAddress ? { bitcoinAddress: storedBitcoinAddress } : {},
+    ...isBitcoinPayment && storedBitcoinTxid ? { bitcoinTxid: storedBitcoinTxid } : {}
   };
 }
 function compactRememberedTransfer(tx, options = {}) {
-  const compact2 = compactTransfer(tx, { incoming: options?.incoming === true });
+  const compact2 = compactTransfer(tx, options);
   if (!compact2) {
     return null;
   }
@@ -26951,12 +27097,30 @@ function getOldestAnyTransferMs(transfers = []) {
 function shouldReplaceTransfer(current, next) {
   return isPendingTransfer(current) && (!isPendingTransfer(next) || current?.status !== next?.status || txUpdatedMs(next) > txUpdatedMs(current));
 }
+function mergeTransferDetails(current, next) {
+  if (!current)
+    return next;
+  const base = shouldReplaceTransfer(current, next) ? next : current;
+  const bitcoinAddress = next?.bitcoinAddress || current.bitcoinAddress || null;
+  const bitcoinTxid = next?.bitcoinTxid || current.bitcoinTxid || null;
+  if (base === current && bitcoinAddress === current?.bitcoinAddress && bitcoinTxid === current?.bitcoinTxid) {
+    return current;
+  }
+  if (base === next && bitcoinAddress === next?.bitcoinAddress && bitcoinTxid === next?.bitcoinTxid) {
+    return next;
+  }
+  return {
+    ...base,
+    ...bitcoinAddress ? { bitcoinAddress } : {},
+    ...bitcoinTxid ? { bitcoinTxid } : {}
+  };
+}
 function indexTransfersById(transfers = []) {
   const byId = new Map;
   for (const tx of Array.isArray(transfers) ? transfers : []) {
     const id = String(tx?.id || "");
     if (id) {
-      byId.set(id, tx);
+      byId.set(id, mergeTransferDetails(byId.get(id), tx));
     }
   }
   return byId;
@@ -26968,7 +27132,7 @@ function hasMergeableTransferChanges(transfers = [], transferById = new Map) {
       continue;
     }
     const current = transferById.get(id);
-    if (!current || shouldReplaceTransfer(current, tx)) {
+    if (!current || mergeTransferDetails(current, tx) !== current) {
       return true;
     }
   }
@@ -26985,8 +27149,9 @@ function dedupeSortedTransfers(transfers = []) {
       continue;
     }
     const current = byId.get(id);
-    if (!current || shouldReplaceTransfer(current, tx)) {
-      byId.set(id, tx);
+    const merged = mergeTransferDetails(current, tx);
+    if (!current || merged !== current) {
+      byId.set(id, merged);
     }
   }
   return sortRecentTransfers([...byId.values()]);
@@ -27054,11 +27219,14 @@ function mergeCompactedTransferPage(current = [], pageTransfers = [], position =
   const updatedCurrent = replacements.size ? current.map((tx) => {
     const id = String(tx?.id || "");
     const replacement = id ? replacements.get(id) : null;
-    if (!replacement || !shouldReplaceTransfer(tx, replacement)) {
+    if (!replacement) {
       return tx;
     }
+    const merged = mergeTransferDetails(tx, replacement);
+    if (merged === tx)
+      return tx;
     changed = true;
-    return replacement;
+    return merged;
   }) : current;
   if (!newItems.length) {
     return changed ? updatedCurrent : current;
@@ -27081,7 +27249,8 @@ function mergeTransferPageForWallet(currentTransfers = [], pageTransfers = [], w
   return mergeCompactedTransferPage(current, page, position);
 }
 function mergeRecentSnapshotForWallet(currentTransfers = [], latestTransfers = [], walletPK) {
-  const latest = mergeTransferPageForWallet([], latestTransfers, walletPK, "append");
+  const currentById = new Map(currentTransfers.map((tx) => [String(tx?.id || ""), tx]));
+  const latest = mergeTransferPageForWallet([], latestTransfers, walletPK, "append").map((tx) => mergeTransferDetails(currentById.get(String(tx?.id || "")), tx));
   if (!latest.length) {
     return filterTransfersForWallet(currentTransfers, walletPK);
   }
@@ -27210,7 +27379,7 @@ function pendingReconcileAgeMs(tx, now = Date.now(), firstSeenAt = null) {
   return baseMs ? Math.max(0, now - baseMs) : null;
 }
 function getPendingTransferRetryMs(tx, ageMs, unresolvedCount = 0) {
-  if (isWithdrawalTransfer(tx)) {
+  if (isBitcoinPaymentTransfer(tx)) {
     if (!Number.isFinite(ageMs) || ageMs <= PENDING_TRANSFER_WARM_AGE_MS) {
       return PENDING_TRANSFER_WARM_RETRY_MS;
     }
@@ -29243,210 +29412,6 @@ var init_transfers2 = __esm(() => {
   ]);
 });
 
-// ../../core/wallet/withdrawops.js
-function getWithdrawalMinimumReceiveSats(onchainAddress) {
-  const address = cleanText(onchainAddress).toLowerCase();
-  if (address.startsWith("1"))
-    return P2PKH_DUST_SATS;
-  if (address.startsWith("3"))
-    return P2SH_DUST_SATS;
-  const p2wpkhLength = address.startsWith("bcrt1q") ? 44 : 42;
-  if ((address.startsWith("bc1q") || address.startsWith("bcrt1q")) && address.length === p2wpkhLength) {
-    return P2WPKH_DUST_SATS;
-  }
-  return SEGWIT_SCRIPT_DUST_SATS;
-}
-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);
-  const minimumReceiveAmountSats = getWithdrawalMinimumReceiveSats(withdrawal?.onchainAddress);
-  if (receiveAmountSats < minimumReceiveAmountSats) {
-    throw new Error(`withdrawal would create a dust output below ${minimumReceiveAmountSats} sats`);
-  }
-}
-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({
-      onchainAddress: address,
-      amountSats: safeAmountSats,
-      feeAmountSats: readyFeeAmountSats,
-      deductFeeFromWithdrawalAmount
-    });
-    const tx = await wallet.withdraw({
-      onchainAddress: address,
-      amountSats: safeAmountSats,
-      exitSpeed: safeExitSpeed,
-      feeQuoteId: readyFeeQuoteId,
-      feeAmountSats: readyFeeAmountSats,
-      deductFeeFromWithdrawalAmount
-    });
-    return {
-      success: true,
-      tx,
-      feeQuote: readyFeeQuote,
-      fees: readyFeeQuote ? {
-        spark: normalizeWithdrawalFeeQuote(readyFeeQuote)
-      } : null,
-      feeAmountSats: readyFeeAmountSats
-    };
-  } catch (error) {
-    return { success: false, error };
-  }
-}
-async function confirmWithdrawal(wallet, network, withdrawal) {
-  if (!withdrawal) {
-    return { success: false, error: new Error("withdrawal review missing") };
-  }
-  return withdrawFunds(wallet, network, {
-    onchainAddress: withdrawal.onchainAddress,
-    amountSats: withdrawal.amountSats,
-    exitSpeed: withdrawal.exitSpeed,
-    feeQuoteId: withdrawal.feeQuoteId,
-    feeAmountSats: withdrawal.feeAmountSats,
-    deductFeeFromWithdrawalAmount: withdrawal.deductFeeFromWithdrawalAmount
-  });
-}
-var P2PKH_DUST_SATS = 546, P2SH_DUST_SATS = 540, P2WPKH_DUST_SATS = 294, SEGWIT_SCRIPT_DUST_SATS = 330;
-var init_withdrawops = __esm(() => {
-  init_network();
-  init_fees();
-});
-
-// ../../core/wallet/withdraw.js
-function createWithdrawal({ wallet, network, updateWalletData }) {
-  const refreshOnSuccess = async (result) => {
-    if (result.success) {
-      await updateWalletData({ reason: "withdraw" });
-    }
-    return result;
-  };
-  return {
-    quoteWithdrawalFees: (params) => quoteWithdrawalFees(wallet, network, params),
-    prepareWithdrawal: (params) => prepareWithdrawal(wallet, network, params),
-    confirmWithdrawal: async (withdrawal) => refreshOnSuccess(await confirmWithdrawal(wallet, network, withdrawal)),
-    withdrawFunds: async (params) => refreshOnSuccess(await withdrawFunds(wallet, network, params))
-  };
-}
-var init_withdraw = __esm(() => {
-  init_withdrawops();
-});
-
 // ../../core/wallet/session.js
 function sameShallowObject(left, right) {
   if (left === right)
@@ -29498,18 +29463,12 @@ function createEmptyWalletSessionSnapshot(network, transferSnapshot = null, cach
       requestTransferDiscoveryHotWindow: NOOP5,
       claimDeposits: ASYNC_FALSE,
       getFundingAddress: ASYNC_NOOP,
-      sendMoneyWithSpark: WALLET_NOT_READY,
-      payExternalInvoice: WALLET_NOT_READY,
+      preparePayment: WALLET_NOT_READY,
+      sendPayment: WALLET_NOT_READY,
       createLightningInvoice: WALLET_NOT_READY,
-      quoteLightningFees: WALLET_NOT_READY,
-      sendLightningPayment: WALLET_NOT_READY,
       getLightningReceiveRequest: WALLET_NOT_READY,
       getLightningSendRequest: WALLET_NOT_READY,
-      quoteWithdrawalFees: WALLET_NOT_READY,
-      prepareWithdrawal: WALLET_NOT_READY,
-      confirmWithdrawal: WALLET_NOT_READY,
-      withdrawFunds: WALLET_NOT_READY,
-      runWalletMutation: WALLET_NOT_READY
+      runPayment: WALLET_NOT_READY
     },
     txValue: {
       oldestTxMs: null,
@@ -29640,8 +29599,9 @@ function createWalletSession({
     diag
   });
   const transferState = getTransferState();
-  const send = createWalletSend({
+  const payment = createPayment({
     wallet,
+    walletPK,
     network,
     updateWalletData,
     refreshBalance: balance.getBalance,
@@ -29651,28 +29611,15 @@ function createWalletSession({
     beginSdkActivity: transferState.beginSdkActivity,
     diag
   });
-  const lightning = createLightning({ wallet, updateWalletData });
-  const withdrawal = createWithdrawal({ wallet, network, updateWalletData });
+  const lightning = createLightning({ wallet });
   const privacy = createWalletPrivacy({ wallet, ghostWallet, diag });
   const mutations = createWalletMutationQueue();
-  const sendMoneyWithSpark = (receiverWalletPK, ...args) => {
-    if (sameText(receiverWalletPK, walletPK)) {
-      throw new Error("cannot send money to the same wallet");
-    }
-    return send.sendMoneyWithSpark(receiverWalletPK, ...args);
-  };
   const mutationActions = {
-    sendMoneyWithSpark: (...args) => mutations.run(() => sendMoneyWithSpark(...args)),
-    payExternalInvoice: (...args) => mutations.run(() => send.payExternalInvoice(...args)),
-    sendLightningPayment: (...args) => mutations.run(() => lightning.sendLightningPayment(...args)),
-    confirmWithdrawal: (...args) => mutations.run(() => withdrawal.confirmWithdrawal(...args)),
-    withdrawFunds: (...args) => mutations.run(() => withdrawal.withdrawFunds(...args)),
-    runWalletMutation: (task) => mutations.run(() => task({
-      sendMoneyWithSpark,
-      payExternalInvoice: send.payExternalInvoice,
-      sendLightningPayment: lightning.sendLightningPayment,
-      confirmWithdrawal: withdrawal.confirmWithdrawal,
-      withdrawFunds: withdrawal.withdrawFunds
+    preparePayment: (...args) => mutations.run(() => payment.preparePayment(...args)),
+    sendPayment: (...args) => mutations.run(() => payment.sendPayment(...args)),
+    runPayment: (task) => mutations.run(() => task({
+      preparePayment: payment.preparePayment,
+      sendPayment: payment.sendPayment
     }))
   };
   function buildSnapshot() {
@@ -29694,18 +29641,12 @@ function createWalletSession({
       requestTransferDiscoveryHotWindow: polling.requestTransferDiscoveryHotWindow,
       claimDeposits: claims.claimDeposits,
       getFundingAddress: funding.getFundingAddress,
-      sendMoneyWithSpark: mutationActions.sendMoneyWithSpark,
-      payExternalInvoice: mutationActions.payExternalInvoice,
+      preparePayment: mutationActions.preparePayment,
+      sendPayment: mutationActions.sendPayment,
       createLightningInvoice: lightning.createLightningInvoice,
-      quoteLightningFees: lightning.quoteLightningFees,
-      sendLightningPayment: mutationActions.sendLightningPayment,
       getLightningReceiveRequest: lightning.getLightningReceiveRequest,
       getLightningSendRequest: lightning.getLightningSendRequest,
-      quoteWithdrawalFees: withdrawal.quoteWithdrawalFees,
-      prepareWithdrawal: withdrawal.prepareWithdrawal,
-      confirmWithdrawal: mutationActions.confirmWithdrawal,
-      withdrawFunds: mutationActions.withdrawFunds,
-      runWalletMutation: mutationActions.runWalletMutation
+      runPayment: mutationActions.runPayment
     };
     const txValue = {
       oldestTxMs: currentTransferState.oldestLoadedMs,
@@ -29768,7 +29709,7 @@ function createWalletSession({
       polling.close();
       privacy.close();
       mutations.close();
-      send.close();
+      payment.close();
       claims.close();
       funding.close();
       updateWalletData.close();
@@ -29789,10 +29730,9 @@ var init_session5 = __esm(() => {
   init_funding();
   init_lightning();
   init_lifecycle();
+  init_payment();
   init_privacy();
-  init_send2();
   init_transfers2();
-  init_withdraw();
   init_localdata();
 });
 
@@ -30143,7 +30083,9 @@ function txSearchFields(tx) {
     tx?.amount == null ? "" : String(tx.amount),
     tx?.incoming ? "incoming received inflow" : "outgoing sent outflow",
     tx?.funding ? "funded fund deposit" : "",
-    tx?.withdrawal ? "withdrawn withdraw" : "",
+    tx?.bitcoin ? "bitcoin payment onchain on-chain l1" : "",
+    tx?.bitcoinAddress,
+    tx?.bitcoinTxid,
     tx?.pending ? "pending" : "completed"
   ];
 }
@@ -30359,7 +30301,7 @@ function getRecentWalletPeers(transfers, walletPK) {
       continue;
     }
     const tx = enrichTx(raw);
-    if (!isVisibleTransfer(tx) || tx.funding || tx.withdrawal || !tx.peerPK || tx.peerPK === walletPK) {
+    if (!isVisibleTransfer(tx) || tx.funding || tx.bitcoin || !tx.peerPK || tx.peerPK === walletPK) {
       continue;
     }
     const txMs = tx.createdMs || 0;
@@ -30398,7 +30340,7 @@ function getPeerDataFromTransfers(transfers, walletPK, peerPK) {
     if (rawPeerPK !== peerPK)
       continue;
     const tx = enrichTx(raw);
-    if (tx.funding || tx.withdrawal) {
+    if (tx.funding || tx.bitcoin) {
       continue;
     }
     txs.push(tx);
@@ -30762,7 +30704,7 @@ var byRecentTx = (a, b) => {
   return String(b?.id || "").localeCompare(String(a?.id || ""));
 }, TX_TIME_RANGES, enrichTx = (tx) => {
   const incoming = tx.transferDirection === "INCOMING";
-  const isWithdrawal = isWithdrawalTransfer(tx);
+  const isBitcoinPayment = isBitcoinPaymentTransfer(tx);
   const isFunding = isFundingTransfer(tx);
   const pending = !isCompletedTransfer(tx);
   const peerPK = incoming ? tx.senderIdentityPublicKey : tx.receiverIdentityPublicKey;
@@ -30774,10 +30716,10 @@ var byRecentTx = (a, b) => {
     totalValue: tx.totalValue,
     amount: incoming ? tx.totalValue : -tx.totalValue,
     funding: isFunding,
-    withdrawal: isWithdrawal,
+    bitcoin: isBitcoinPayment,
     pending,
     pendingCredit: pending && (incoming || isFunding),
-    summaryPending: pending && (incoming || isFunding || isWithdrawal)
+    summaryPending: pending && (incoming || isFunding || isBitcoinPayment)
   };
 }, aggregateTxs = (transfers, userPK) => {
   const dayMap = new Map;
@@ -30809,7 +30751,7 @@ var byRecentTx = (a, b) => {
     }
     if (!firstDate || txDate < firstDate)
       firstDate = txDate;
-    if (tx.peerPK && tx.peerPK !== userPK && !tx.funding && !tx.withdrawal) {
+    if (tx.peerPK && tx.peerPK !== userPK && !tx.funding && !tx.bitcoin) {
       const txMs = txDate.getTime();
       if (!peerMap.has(tx.peerPK)) {
         peerMap.set(tx.peerPK, {
@@ -31712,16 +31654,16 @@ var PASSKEY_ENVIRONMENT_MISMATCH = "passkey-environment-mismatch", PASSKEY_PROVI
 var init_passkey = () => {};
 
 // ../../product/links.js
-var links, localHosts, allowedPasskeyOrigins, storageCorsOrigins, webApps;
+var links, localHosts, prodPasskeyOrigins, devPasskeyOrigins, allowedPasskeyOrigins, storageCorsOrigins, devStorageCorsOrigins, webApps;
 var init_links = __esm(() => {
   init_origins();
   links = Object.freeze({
     root: origins.root,
     rootDev: origins.rootDev,
-    rootDevWeb: origins.rootDevWeb,
     veyl: origins.veyl,
     veylDev: origins.veylDev,
     veylDevWeb: origins.veylDevWeb,
+    veylDevFeatureWeb: origins.veylDevFeatureWeb,
     terms: `${origins.veyl}/legal#terms`,
     communityRules: `${origins.veyl}/community-rules`,
     contact: `mailto:contact@${ROOT_DOMAIN}`,
@@ -31731,19 +31673,26 @@ var init_links = __esm(() => {
     domains.rootDev,
     domains.veylDev
   ]);
-  allowedPasskeyOrigins = Object.freeze([
+  prodPasskeyOrigins = Object.freeze([
     origins.root,
-    origins.rootDev,
-    origins.rootDevWeb,
+    origins.veyl
+  ]);
+  devPasskeyOrigins = Object.freeze([
     origins.veylDev,
     origins.veylDevWeb,
-    origins.veyl
+    origins.veylDevFeatureWeb
+  ]);
+  allowedPasskeyOrigins = Object.freeze([
+    ...prodPasskeyOrigins,
+    ...devPasskeyOrigins
   ]);
   storageCorsOrigins = Object.freeze([
-    origins.rootDevWeb,
+    origins.veyl
+  ]);
+  devStorageCorsOrigins = Object.freeze([
     origins.veylDev,
     origins.veylDevWeb,
-    origins.veyl
+    origins.veylDevFeatureWeb
   ]);
   webApps = Object.freeze({
     veyl: Object.freeze({
@@ -33065,8 +33014,8 @@ function makeInvite(value = {}) {
   const cleanedKind = cleanKind(kind);
   const rawTo = value.to ?? value.recipient;
   const toIsUsername = !!cleanUsername2(rawTo);
-  const paymentKind = cleanedKind === invite.send || cleanedKind === invite.request;
-  const receiver = value.r ?? value.walletPK ?? value.receiver ?? (paymentKind && !toIsUsername ? rawTo : null);
+  const paymentKind2 = cleanedKind === invite.send || cleanedKind === invite.request;
+  const receiver = value.r ?? value.walletPK ?? value.receiver ?? (paymentKind2 && !toIsUsername ? rawTo : null);
   const data = readParams({
     kind,
     from: value.from ?? value.sender,
@@ -33367,8 +33316,8 @@ function createRuntimeProductActions({
       await getUser();
       return supportOwner.feedback(message, {
         type: options.type,
-        platform: "headless",
-        route: cleanText(options.route) || "cli",
+        platform: "sdk",
+        route: cleanText(options.route) || "sdk",
         appVersion: version || "",
         context: options.context
       });
@@ -33376,8 +33325,8 @@ function createRuntimeProductActions({
     async bug(message, options = {}) {
       await getUser();
       return supportOwner.bug(message, {
-        platform: "headless",
-        route: cleanText(options.route) || "cli",
+        platform: "sdk",
+        route: cleanText(options.route) || "sdk",
         appVersion: version || ""
       });
     },
@@ -40811,21 +40760,21 @@ function createRuntimeMoneyActions({ getRuntime, getSession, resolvePeer, chat }
       transfer
     };
   }
-  function cleanWithdrawal(withdrawal, options = {}) {
-    if (!withdrawal)
+  function cleanBitcoinPayment(payment, options = {}) {
+    if (!payment)
       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
+      kind: payment.kind,
+      onchainAddress: payment.destination,
+      amountSats: payment.amountSats,
+      exitSpeed: payment.exitSpeed,
+      deductFeeFromWithdrawalAmount: payment.deductFeeFromAmount,
+      feeQuoteId: payment.feeQuoteId,
+      feeAmountSats: payment.feeAmountSats,
+      fees: stripFees(payment.fees, options),
+      amounts: getBitcoinPaymentAmounts(payment),
+      expiresAt: payment.expiresAt,
+      raw: options.raw ? jsonSafe(payment.feeQuote) : undefined
     };
   }
   async function uncertainMutation(operation, operationId, retryable, run) {
@@ -40871,20 +40820,25 @@ function createRuntimeMoneyActions({ getRuntime, getSession, resolvePeer, chat }
     await snapshot2.value.refresh();
     return { claimed: depositsClaimed === true || transferIds2.length > 0, depositsClaimed, transferIds: transferIds2 };
   }
-  async function sendWith(peer, sats, options = {}, sendMoneyWithSpark = null) {
+  async function sendWith(peer, sats, options = {}, paymentSender = null) {
     const { snapshot: snapshot2 } = await readyWallet();
     const amountSats = cleanPositiveSats(sats);
     const profile = await resolvePeer(peer);
     if (!profile.walletPK)
       throw new Error("peer wallet key missing");
-    const sendMoney = sendMoneyWithSpark || snapshot2.value.sendMoneyWithSpark;
-    const txId = await uncertainMutation("wallet.send", options.operationId, false, () => sendMoney(profile.walletPK, amountSats));
+    const sendPayment = paymentSender || snapshot2.value.sendPayment;
+    const receipt = await uncertainMutation("wallet.send", options.operationId, false, () => sendPayment({
+      kind: PAYMENT_KIND_SPARK,
+      destination: profile.walletPK,
+      amountSats
+    }));
+    const txId = receipt?.id || null;
     return {
-      txId: txId || null,
+      txId,
       operationId: options.operationId || txId || null,
       amountSats,
       peer: profile.username ? `@${profile.username}` : profile.uid,
-      raw: options.raw ? { id: txId || null } : undefined
+      raw: options.raw ? jsonSafe(receipt) : undefined
     };
   }
   const send = (peer, sats, options = {}) => sendWith(peer, sats, options);
@@ -40903,37 +40857,34 @@ function createRuntimeMoneyActions({ getRuntime, getSession, resolvePeer, chat }
   }
   async function lightningQuote(encodedInvoice, options = {}) {
     const { snapshot: snapshot2 } = await readyWallet();
-    const result = throwIfFailed(await snapshot2.value.quoteLightningFees({
-      invoice: encodedInvoice,
-      amountSats: options.amountSats
-    }), "could not quote lightning fees");
-    return { feeAmountSats: result.feeAmountSats, fees: result.fees };
+    const payment = await snapshot2.value.preparePayment({
+      kind: PAYMENT_KIND_LIGHTNING,
+      destination: encodedInvoice,
+      amountSats: options.amountSats,
+      variableAmount: options.amountSats != null
+    });
+    return { feeAmountSats: payment.maxFeeSats, fees: payment.fees };
   }
   async function lightningPay(encodedInvoice, options = {}) {
     const { snapshot: snapshot2 } = await readyWallet();
     const amountSatsToSend = options.amountSatsToSend ?? options.amountSats;
-    let maxFeeSats = options.maxFeeSats;
-    let fees = null;
-    if (maxFeeSats == null) {
-      const quote = throwIfFailed(await snapshot2.value.quoteLightningFees({ invoice: encodedInvoice, amountSats: amountSatsToSend }), "could not quote lightning fees");
-      maxFeeSats = quote.feeAmountSats;
-      fees = quote.fees;
-    }
     const operationId = cleanText(options.idempotencyKey || options.operationId);
-    const result = await uncertainMutation("lightning.pay", operationId, !!options.idempotencyKey, async () => throwIfFailed(await snapshot2.value.sendLightningPayment({
-      invoice: encodedInvoice,
-      maxFeeSats,
+    const receipt = await uncertainMutation("lightning.pay", operationId, !!options.idempotencyKey, () => snapshot2.value.sendPayment({
+      kind: PAYMENT_KIND_LIGHTNING,
+      destination: encodedInvoice,
+      amountSats: amountSatsToSend,
+      variableAmount: amountSatsToSend != null,
+      maxFeeSats: options.maxFeeSats,
       preferSpark: options.preferSpark === true,
-      amountSatsToSend,
       idempotencyKey: options.idempotencyKey
-    }), "could not pay lightning invoice"));
-    const resultId = result.result?.id || result.payment?.id || null;
+    }));
+    const resultId = receipt?.id || null;
     return {
       id: resultId,
       operationId: operationId || resultId,
-      fees,
-      result: summarizePaymentResult(result.result),
-      raw: options.raw ? jsonSafe(result) : undefined
+      fees: receipt?.fees || null,
+      result: summarizePaymentResult(receipt?.result),
+      raw: options.raw ? jsonSafe(receipt) : undefined
     };
   }
   async function lightningReceive(id, options = {}) {
@@ -40959,44 +40910,53 @@ function createRuntimeMoneyActions({ getRuntime, getSession, resolvePeer, chat }
       throw new Error("invoice must be a direct lightning or spark invoice string");
     }
     const { snapshot: snapshot2 } = await readyWallet();
-    const result = await uncertainMutation("wallet.pay-invoice", options.operationId, false, () => snapshot2.value.payExternalInvoice({
-      type,
-      invoice: parsed.invoice,
+    const receipt = await uncertainMutation("wallet.pay-invoice", options.operationId, false, () => snapshot2.value.sendPayment({
+      kind: type === "lightning" ? PAYMENT_KIND_LIGHTNING : PAYMENT_KIND_SPARK_INVOICE,
+      destination: parsed.invoice,
       amountSats: options.amountSats,
-      variableAmount: options.amountSats != null
+      variableAmount: options.amountSats != null,
+      preferSpark: type === "lightning"
     }));
-    const resultId = result?.id || result?.result?.id || null;
+    const resultId = receipt?.id || null;
     return {
       type,
       id: resultId,
       operationId: options.operationId || resultId || null,
-      fees: result?.fees || null,
-      result: summarizePaymentResult(result?.result),
-      raw: options.raw ? jsonSafe(result) : undefined
+      fees: receipt?.fees || null,
+      result: summarizePaymentResult(receipt?.result),
+      raw: options.raw ? jsonSafe(receipt) : undefined
     };
   }
-  async function withdrawQuote(onchainAddress, sats, options = {}) {
+  async function quoteBitcoinPayment(onchainAddress, sats, options = {}) {
     const { snapshot: snapshot2 } = await readyWallet();
-    const result = throwIfFailed(await snapshot2.value.quoteWithdrawalFees({ onchainAddress, amountSats: sats }), "could not quote withdrawal");
+    const payment = await snapshot2.value.preparePayment({
+      kind: PAYMENT_KIND_BITCOIN,
+      destination: onchainAddress,
+      amountSats: sats,
+      exitSpeed: options.exitSpeed || options.speed,
+      deductFeeFromAmount: options.deductFeeFromWithdrawalAmount !== false
+    });
     return {
-      amountSats: result.amountSats,
-      onchainAddress: result.onchainAddress,
-      feeQuoteId: result.feeQuote?.id || null,
-      fees: stripFees(result.fees, options),
-      raw: options.raw ? jsonSafe(result.feeQuote) : undefined
+      amountSats: payment.amountSats,
+      onchainAddress: payment.destination,
+      feeQuoteId: payment.feeQuoteId,
+      feeAmountSats: payment.feeAmountSats,
+      fees: stripFees(payment.fees, options),
+      raw: options.raw ? jsonSafe(payment.feeQuote) : undefined
     };
   }
-  async function withdrawPrepare(onchainAddress, sats, options = {}) {
+  async function prepareBitcoinPayment(onchainAddress, sats, options = {}) {
     const { snapshot: snapshot2 } = await readyWallet();
-    const result = throwIfFailed(await snapshot2.value.prepareWithdrawal({
-      onchainAddress,
+    const payment = await snapshot2.value.preparePayment({
+      kind: PAYMENT_KIND_BITCOIN,
+      destination: onchainAddress,
       amountSats: sats,
       exitSpeed: options.exitSpeed || options.speed,
-      deductFeeFromWithdrawalAmount: options.deductFeeFromWithdrawalAmount !== false
-    }), "could not prepare withdrawal");
-    return cleanWithdrawal(result.withdrawal, options);
+      deductFeeFromAmount: options.deductFeeFromWithdrawalAmount !== false
+    });
+    return cleanBitcoinPayment(payment, options);
   }
-  async function withdraw(onchainAddress, sats, options = {}) {
+  async function sendBitcoinPayment(onchainAddress, sats, options = {}) {
     const hasFeeQuoteId = !!cleanText(options.feeQuoteId);
     const hasFeeAmountSats = options.feeAmountSats != null;
     if (hasFeeQuoteId !== hasFeeAmountSats) {
@@ -41004,22 +40964,28 @@ function createRuntimeMoneyActions({ getRuntime, getSession, resolvePeer, chat }
     }
     const { snapshot: snapshot2 } = await readyWallet();
     const operationId = cleanText(options.operationId || options.feeQuoteId);
-    const result = await uncertainMutation("withdrawal.confirm", operationId, false, async () => throwIfFailed(await snapshot2.value.withdrawFunds({
-      onchainAddress,
+    const intent = {
+      kind: PAYMENT_KIND_BITCOIN,
+      destination: onchainAddress,
       amountSats: sats,
       exitSpeed: options.exitSpeed || options.speed,
-      feeQuote: options.feeQuote,
+      deductFeeFromAmount: options.deductFeeFromWithdrawalAmount !== false
+    };
+    const payment = hasFeeQuoteId ? {
+      ...intent,
+      state: PAYMENT_STATE_PREPARED,
+      feeQuote: options.feeQuote || null,
       feeQuoteId: options.feeQuoteId,
-      feeAmountSats: options.feeAmountSats,
-      deductFeeFromWithdrawalAmount: options.deductFeeFromWithdrawalAmount !== false
-    }), "could not withdraw funds"));
-    const txId = result.tx?.id || result.tx?.txid || null;
+      feeAmountSats: options.feeAmountSats
+    } : await snapshot2.value.preparePayment(intent);
+    const receipt = await uncertainMutation("withdrawal.confirm", operationId, false, () => snapshot2.value.sendPayment(payment));
+    const txId = receipt?.result?.coopExitTxid || receipt?.result?.id || receipt?.id || null;
     return {
       txId,
       operationId: operationId || txId || null,
-      feeAmountSats: result.feeAmountSats,
-      fees: stripFees(result.fees, options),
-      tx: options.raw ? jsonSafe(result.tx) : undefined
+      feeAmountSats: payment.feeAmountSats,
+      fees: stripFees(payment.fees, options),
+      tx: options.raw ? jsonSafe(receipt?.result) : undefined
     };
   }
   async function request2(peer, sats, options = {}) {
@@ -41042,7 +41008,7 @@ function createRuntimeMoneyActions({ getRuntime, getSession, resolvePeer, chat }
     const peer = profile.username ? `@${profile.username}` : peerChatPK;
     let mutationStarted = false;
     try {
-      return await snapshot2.value.runWalletMutation(async ({ sendMoneyWithSpark }) => {
+      return await snapshot2.value.runPayment(async ({ sendPayment }) => {
         const target = await chat.messageForPeer(peer, messageId, { count: 100 });
         const message = target.message;
         if (!message || message.t !== "req")
@@ -41054,9 +41020,9 @@ function createRuntimeMoneyActions({ getRuntime, getSession, resolvePeer, chat }
         if (!isRequestOnNetwork(message, target.session.network)) {
           throw new Error(`switch wallet network to ${requestNetwork(message)?.toLowerCase() || "the request network"} before paying`);
         }
-        const paid = await sendWith(peer, cleanPositiveSats(message.a), options, (...args) => {
+        const paid = await sendWith(peer, cleanPositiveSats(message.a), options, (intent) => {
           mutationStarted = true;
-          return sendMoneyWithSpark(...args);
+          return sendPayment(intent);
         });
         const updated = { ...setReqTx(message, paid.txId), cid: message.cid };
         await runtime.chat.getSnapshot().updateMessage(chatId, message.id, updated, peerChatPK);
@@ -41132,9 +41098,9 @@ function createRuntimeMoneyActions({ getRuntime, getSession, resolvePeer, chat }
     transactions,
     searchTransactions,
     transaction,
-    withdrawQuote,
-    withdrawPrepare,
-    withdraw
+    quoteBitcoinPayment,
+    prepareBitcoinPayment,
+    sendBitcoinPayment
   };
 }
 var DEFAULT_TIMEOUT_MS4 = 15000, HISTORY_LOAD_ATTEMPTS = 4, messageWindowSequence = 0;
@@ -41146,7 +41112,7 @@ var init_runtime_actions = __esm(() => {
   init_values();
   init_fees();
   init_claiming();
-  init_withdrawops();
+  init_payment();
   init_tx();
   init_invoice();
   init_messages3();
@@ -41159,9 +41125,9 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "veyl",
-    version: "0.51.0",
+    version: "0.55.0",
     private: true,
-    license: "Apache-2.0",
+    license: "UNLICENSED",
     workspaces: {
       packages: [
         "clients/*",
@@ -41213,7 +41179,8 @@ var init_package = __esm(() => {
       "install:clean": "bun scripts/deps.mjs clean-install",
       update: "bun scripts/deps.mjs update",
       "sync:frameworks": "bun scripts/sync-frameworks.mjs",
-      "check:frameworks": "bun scripts/sync-frameworks.mjs --check"
+      "check:frameworks": "bun scripts/sync-frameworks.mjs --check",
+      "test:repo": "bun scripts/test.mjs"
     },
     dependencies: {
       "@buildonspark/spark-sdk": "^0.9.0",
@@ -41513,9 +41480,9 @@ class AccountRuntime {
       send: (id, payload) => this.lightningSend(id, payload)
     };
     this.withdrawal = {
-      quote: (address, sats, payload) => this.withdrawQuote(address, sats, payload),
-      prepare: (address, sats, payload) => this.withdrawPrepare(address, sats, payload),
-      confirm: (address, sats, payload) => this.withdraw(address, sats, payload)
+      quote: (address, sats, payload) => this.quoteBitcoinPayment(address, sats, payload),
+      prepare: (address, sats, payload) => this.prepareBitcoinPayment(address, sats, payload),
+      confirm: (address, sats, payload) => this.sendBitcoinPayment(address, sats, payload)
     };
     this.profile = this.runtimeProduct.profile;
     this.settings = this.runtimeProduct.settings;
@@ -41565,7 +41532,7 @@ class AccountRuntime {
       chatPK: profile.chatPK || null,
       notificationPK: profile.notificationPK || null,
       auth: profile.auth || "machine",
-      bot: profile.bot || null,
+      bot: profile.bot === BOT_PROFILE_MARKER ? BOT_PROFILE_MARKER : null,
       signedIn: this.auth?.currentUser?.uid === profile.uid,
       unlocked: !!this.session
     };
@@ -41616,7 +41583,7 @@ class AccountRuntime {
       publicKeyPem: machine.publicKeyPem,
       privateKeyPem: options.saveCredential === false ? null : machine.privateKeyPem,
       auth: "machine",
-      bot: finish.bot || "bot",
+      bot: finish.bot === BOT_PROFILE_MARKER ? BOT_PROFILE_MARKER : null,
       createdAt: Date.now(),
       hasVault: false
     });
@@ -41635,7 +41602,17 @@ class AccountRuntime {
     if (!credentialId || !privateKeyPem) {
       throw new Error("machine credential required");
     }
-    const start = await this.callAccountEndpoint("/account/login/start", { credentialId });
+    const namespaceKeyPath = options.namespaceKeyPath || this.options.namespaceKeyPath;
+    const namespaceClaim = options.namespaceClaim || (namespaceKeyPath ? await this.ports.signNamespaceClaim({
+      path: namespaceKeyPath,
+      optional: options.namespaceKeyOptional === true || this.options.namespaceKeyOptional === true,
+      username: profile.username || username,
+      credentialId
+    }) : null);
+    const start = await this.callAccountEndpoint("/account/login/start", {
+      credentialId,
+      ...namespaceClaim ? { namespaceClaim } : {}
+    });
     const finish = await this.callAccountEndpoint("/account/login/finish", {
       challengeId: start.challengeId,
       signature: this.ports.signChallenge(privateKeyPem, start.challenge)
@@ -41647,7 +41624,7 @@ class AccountRuntime {
       uid: finish.uid || profile.uid,
       username: finish.username || profile.username,
       credentialId,
-      bot: finish.bot || profile.bot || null,
+      bot: finish.bot === BOT_PROFILE_MARKER ? BOT_PROFILE_MARKER : null,
       lastLoginAt: Date.now()
     });
     return this.accountSummary(next);
@@ -41729,6 +41706,7 @@ class AccountRuntime {
       publicKeyPem: machine?.publicKeyPem || stored?.publicKeyPem || null,
       privateKeyPem: options.saveCredential === false ? stored?.privateKeyPem || null : machine?.privateKeyPem || stored?.privateKeyPem || null,
       auth: "passkey",
+      bot: null,
       lastLoginAt: Date.now()
     });
     return {
@@ -42143,14 +42121,14 @@ class AccountRuntime {
   async transaction(id, options = {}) {
     return this.runtimeMoney.transaction(id, options);
   }
-  async withdrawQuote(address, sats, options = {}) {
-    return this.runtimeMoney.withdrawQuote(address, sats, options);
+  async quoteBitcoinPayment(address, sats, options = {}) {
+    return this.runtimeMoney.quoteBitcoinPayment(address, sats, options);
   }
-  async withdrawPrepare(address, sats, options = {}) {
-    return this.runtimeMoney.withdrawPrepare(address, sats, options);
+  async prepareBitcoinPayment(address, sats, options = {}) {
+    return this.runtimeMoney.prepareBitcoinPayment(address, sats, options);
   }
-  async withdraw(address, sats, options = {}) {
-    return this.runtimeMoney.withdraw(address, sats, options);
+  async sendBitcoinPayment(address, sats, options = {}) {
+    return this.runtimeMoney.sendBitcoinPayment(address, sats, options);
   }
   async listenEvents(options = {}) {
     return listenAccount(this, options);
@@ -42186,6 +42164,7 @@ var init_client = __esm(() => {
   init_core();
   init_agreement();
   init_network();
+  init_profile();
   init_username();
   init_time();
   init_vault();
@@ -88806,7 +88785,7 @@ var OutP2A, OutPK, OutPKH, OutSH, OutWSH, OutWPKH, OutMS, OutTR, OutTRNS, OutTRM
     hash
   };
 }, TAP_LEAF_VERSION = 192, tapLeafHash = (script, version = TAP_LEAF_VERSION) => tagSchnorr("TapLeaf", new Uint8Array([version]), VarBytes.encode(script)), base58check;
-var init_payment = __esm(() => {
+var init_payment2 = __esm(() => {
   init_esm();
   init_esm2();
   init_psbt();
@@ -89969,7 +89948,7 @@ var EMPTY32, EMPTY_OUTPUT, toVsize = (weight) => Math.ceil(weight / 4), PRECISIO
 var init_transaction = __esm(() => {
   init_esm();
   init_esm2();
-  init_payment();
+  init_payment2();
   init_psbt();
   init_script();
   init_utils6();
@@ -90002,11 +89981,11 @@ var init_transaction = __esm(() => {
 
 // ../../node_modules/.bun/@scure+btc-signer@1.8.1/node_modules/@scure/btc-signer/esm/index.js
 var init_esm3 = __esm(() => {
-  init_payment();
+  init_payment2();
   init_script();
   init_transaction();
   init_utils6();
-  init_payment();
+  init_payment2();
   init_transaction();
   /*! scure-btc-signer - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 });
@@ -104365,7 +104344,7 @@ var init_spark_wallet_CwB3Fuv1 = __esm(() => {
   init_esm3();
   init_utils6();
   init_psbt();
-  init_payment();
+  init_payment2();
   init_hmac2();
   init_esm4();
   init_esm5();
@@ -175977,7 +175956,7 @@ function createFirebaseCloud({ db, auth: auth2, getAuth: getAuth2, functions: fu
       return [];
     let roleQuery = null;
     if (role.id === "bots") {
-      roleQuery = query(collection(db, "profiles"), where("bot", "!=", false), limit(SEARCH_ROLE_LIMIT));
+      roleQuery = query(collection(db, "profiles"), where("bot", "==", BOT_PROFILE_MARKER), limit(SEARCH_ROLE_LIMIT));
     } else if (role.id === "active") {
       roleQuery = query(collection(db, "profiles"), where("active", "==", true), limit(SEARCH_ROLE_LIMIT));
     }
@@ -176897,6 +176876,7 @@ var init_cloud = __esm(() => {
   init_dist5();
   init_dist6();
   init_avatar();
+  init_profile();
   init_filepayload();
   init_protocol();
   init_config();
@@ -176920,7 +176900,7 @@ function sdkFunctionBaseUrl(config = firebaseConfig, region = DEFAULT_FUNCTION_R
   if (!projectId) {
     throw new Error("firebase project id required");
   }
-  return `https://${region}-${projectId}.cloudfunctions.net/headless`;
+  return `https://${region}-${projectId}.cloudfunctions.net/machineAuth`;
 }
 function createCloudRuntime(options2 = {}) {
   const config = options2.firebaseConfig || firebaseConfig;
@@ -177595,7 +177575,7 @@ async function runPasskeyBrowserFlow(options2 = {}) {
     throw error;
   }
   const callback = `http://127.0.0.1:${address.port}${CALLBACK_PATH}`;
-  const target = appendSearch(new URL("/cli/passkey", cleanWebUrl(options2.webUrl)), {
+  const target = appendSearch(new URL("/sdk/passkey", cleanWebUrl(options2.webUrl)), {
     mode,
     state,
     callback,
@@ -179145,6 +179125,7 @@ class FleetOwner {
         activate: false,
         credential: material.credential,
         vaultSecret: material.vaultSecret,
+        namespaceKeyPath: this.options.namespaceKeyPath,
         getVaultMasterSeed: () => {
           const derived = deriveFleetAccount(this.seed, accountIndex);
           try {
@@ -179330,7 +179311,6 @@ class FleetOwner {
         publicKeyPem: material.credential.publicKeyPem,
         privateKeyPem: null,
         auth: "machine",
-        bot: "bot",
         hasVault: false,
         createdAt: Date.now()
       });