@dvmkit/sdk 0.1.0-rc.1 → 0.1.0-rc.3

package/README.md

@@ -8,18 +8,26 @@ Use the Node.js release in `.nvmrc` (Node 22). Install with `npm ci`, then run t
 
 `DATABASE_URL` is optional locally. Without it the database suite is skipped rather than passed, and `verify` says so in its summary, because a skipped suite verified nothing and must not be reported as green. Point `DATABASE_URL` at a scratch Postgres to run it, and pass `npm run verify -- --require-database` to make a missing one a failure, which is what CI does.
 
-The public package exports exactly `@dvmkit/sdk`, `@dvmkit/sdk/server`, and `@dvmkit/sdk/testing`. Documentation is at [dvmkit.ai](https://dvmkit.ai/docs/sdk).
+The public surface is exactly `@dvmkit/sdk`, `@dvmkit/sdk/server`, and `@dvmkit/sdk/testing`. There is a fourth entry point, `@dvmkit/sdk/internal`, which is not part of it; see below. Documentation is at [dvmkit.ai](https://dvmkit.ai/docs/sdk).
 
 ## Compatibility and versioning
 
 This is pre-1.0 alpha software and the promises match that. Breaking changes can land in any release, they are announced in the release notes for the release that carries them, and there is no long-term support release. Security fixes are made on the latest published release rather than backported.
 
-The public surface is exactly three entry points: `@dvmkit/sdk`, `@dvmkit/sdk/server`, and `@dvmkit/sdk/testing`. Nothing reachable only through a deep path into `dist/` is public, and `npm run check:api` pins every exported declaration name against `api-surface.json`, so a change to that surface is a deliberate, reviewed act rather than a side effect.
+The public surface is exactly three entry points: `@dvmkit/sdk`, `@dvmkit/sdk/server`, and `@dvmkit/sdk/testing`. Nothing reachable only through a deep path into `dist/` is public, nothing under `@dvmkit/sdk/internal` is public, and `npm run check:api` pins every exported declaration name against `api-surface.json`, so a change to that surface is a deliberate, reviewed act rather than a side effect.
 
 Wire compatibility with callers is separate from the package version and is declared per endpoint. A server built on this SDK answers `DVM-Protocol-Version: 1`, and an individual endpoint may require a set of named capability tokens the caller advertises, a minimum caller version, or both. Capability tokens are additive, so an endpoint that declares no requirement stays reachable by a caller that sends no compatibility headers at all. A caller that cannot meet what an endpoint declares gets HTTP 426 naming the required capabilities and, where one is declared, the minimum version. The protocol is specified at [dvmkit.ai/docs/protocol](https://dvmkit.ai/docs/protocol).
 
 If an upgrade broke something for you, an [API compatibility report](https://github.com/dvmkit/sdk/issues/new/choose) is the most useful thing you can send us. It tells us which parts of the published surface people actually build on, which no test of ours can.
 
+## Internal entry point
+
+`@dvmkit/sdk/internal` exists for one consumer: the dvmkit platform, which runs on this source instead of keeping a fork of it. Do not build on it.
+
+It carries no stability promise of any kind. A name under it can change meaning, change signature, or disappear in any release, including a patch release, and that is not a breaking change: it needs no `!` marker, no `BREAKING CHANGE:` footer, and no note in the release notes. It is not documented, its contents track what the platform happens to need, and it is excluded from everything the three public entry points promise above.
+
+The names in it are still pinned in `api-surface.json`, so a change to them is visible in review rather than silent; the pin records what moved, it does not promise that it will not move. If something under `./internal` is genuinely useful to a third party, the way to get it is to ask for it: graduating a name to `.`, `./server` or `./testing` is a deliberate, reviewed `feat`, and only then does it acquire the compatibility promises on this page.
+
 ## Contributing
 
 **This repository does not accept unsolicited pull requests.** One opened without an invitation is closed automatically, with a pointer to where the report belongs.

package/dist/{revenue-reporter-M35KP6V7.js → chunk-2ABMGUDS.js}

@@ -8,7 +8,9 @@ var ENDPOINTS = {
   revenue: "/_internal/job-revenue",
   deposit: "/_internal/credit-deposit",
   release: "/_internal/credit-draw-release",
-  drain: "/_internal/credit-drain"
+  drain: "/_internal/credit-drain",
+  payout: "/_internal/payout",
+  expiry_release: "/_internal/credit-expiry-release"
 };
 var RevenueReporter = class _RevenueReporter {
   // 24h of failed retries
@@ -83,6 +85,79 @@ var RevenueReporter = class _RevenueReporter {
   async enqueueCreditDrain(tx, payload) {
     await this.insertPending(tx, "drain", payload);
   }
+  /**
+   * Join a payout to the transaction that commits the movement it reports
+   * (internal-review) — the batch close, the accumulator mark, the drain booking.
+   * No network I/O, only the durable queue row through `tx`, the discipline
+   * {@link enqueueCreditDrain} set and for the same reason: the money has
+   * already moved on a rail this ledger does not own, so the platform row is
+   * the only record the builder's dashboard has of it, and a row lost between
+   * the fact and the queue would understate "paid out" forever. Without `tx`
+   * the row is queued on the pool, for callers with no fact of their own to
+   * commit. Idempotent on `(dvmId, payoutId)` platform-side, so the retry
+   * loop redelivers freely.
+   */
+  async enqueuePayout(payload, tx) {
+    await this.insertPending(tx ?? this.db, "payout", payload);
+  }
+  /**
+   * Report one landed payout on its own and try to deliver it at once — the
+   * live Tempo settlement, which has no dvmkit transaction to join. Durable
+   * like {@link report}.
+   */
+  async reportPayout(payload) {
+    return this.enqueue("payout", payload, payload.payoutId);
+  }
+  /**
+   * Report one rail's pending-pool snapshot (internal-review). Best-effort and
+   * fire-and-forget, deliberately unlike {@link reportPayout}: a snapshot is
+   * replaced by the next tick, so queueing a stale one behind an outage would
+   * only deliver figures the platform already has newer ones for.
+   */
+  async reportPayoutPending(payload) {
+    const url = `${this.platformUrl}/_internal/payout-pending`;
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.platformToken}`
+        },
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (!res.ok) {
+        console.warn(
+          JSON.stringify({
+            level: "payout_pending_report_failed",
+            rail: payload.rail,
+            status: res.status
+          })
+        );
+      }
+    } catch (err) {
+      console.warn(
+        JSON.stringify({
+          level: "payout_pending_report_failed",
+          rail: payload.rail,
+          error: err instanceof Error ? err.message : String(err)
+        })
+      );
+    }
+  }
+  /**
+   * Join a credit-expiry release — or the revival that reverses one — to the
+   * transaction that made it true (internal-review).
+   *
+   * Same discipline as {@link enqueueCreditDrain}: no network I/O, only the
+   * durable queue row written through `tx`. A release whose row was lost after
+   * the sweep committed would understate committed value forever; a lost
+   * reversal would overstate it, which is the worse direction — the builder
+   * would see money as theirs that a revived credit can still buy work with.
+   */
+  async enqueueCreditExpiryRelease(tx, payload) {
+    await this.insertPending(tx, "expiry_release", payload);
+  }
   /**
    * Report a reaper-force-failed paid job to the platform (internal-review) so the
    * operator receives an ambient notice that a DVM died or wedged mid-job.
@@ -325,7 +400,7 @@ var RevenueReporter = class _RevenueReporter {
         [Date.now()]
       );
       for (const row of rows) {
-        const label = row.payload.jobId ?? row.payload.creditId ?? row.id;
+        const label = row.payload.jobId ?? row.payload.creditId ?? row.payload.payoutId ?? row.id;
         try {
           await this.attemptDelivery(row.id, row.payload, row.kind, label);
         } catch {
@@ -430,6 +505,7 @@ var RevenueReporter = class _RevenueReporter {
     );
   }
 };
+
 export {
   RevenueReporter
 };

package/dist/chunk-5SO7ZVOH.js

@@ -0,0 +1,375 @@
+import {
+  formatFiat
+} from "./chunk-AT6V3SY7.js";
+
+// src/lib/errors.ts
+var DvmError = class extends Error {
+  constructor(code, message, hint, data, display, proseSources) {
+    super(message);
+    this.code = code;
+    this.hint = hint;
+    this.data = data;
+    this.display = display;
+    this.proseSources = proseSources;
+    this.name = "DvmError";
+  }
+  code;
+  hint;
+  data;
+  display;
+  proseSources;
+};
+function providerProseSources(...sources) {
+  const provenance = {};
+  for (const source of sources) {
+    if (!source) continue;
+    for (const field of ["message", "hint", "display"]) {
+      if (typeof source[field] === "string") provenance[field] = "provider";
+    }
+  }
+  return Object.keys(provenance).length > 0 ? provenance : void 0;
+}
+function transportErrorCode(err) {
+  let current = err;
+  const seen = /* @__PURE__ */ new Set();
+  for (let depth = 0; depth < 5 && isErrorLike(current) && !seen.has(current); depth++) {
+    seen.add(current);
+    const code = current.code;
+    if (typeof code === "string" && /^(?:E[A-Z0-9_]{1,63}|UND_ERR_[A-Z0-9_]{1,63})$/.test(code)) {
+      return code;
+    }
+    current = current.cause;
+  }
+  return void 0;
+}
+function isErrorLike(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null;
+}
+
+// src/lib/credit-implicit.ts
+var IMPLICIT_CREDIT_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+
+// src/lib/fx-coingecko.ts
+var COINGECKO_SIMPLE_PRICE_URL = "https://api.coingecko.com/api/v3/simple/price?ids=bitcoin,usd-coin&vs_currencies=usd";
+var COINGECKO_BTC_USD_URL = "https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd";
+var DEFAULT_TIMEOUT_MS = 5e3;
+var DEFAULT_USER_AGENT = "dvmkit-platform/1.0 (+https://dvmkit.com)";
+async function fetchCoinGeckoSpot(opts) {
+  const body = await fetchCoinGeckoBody(opts, COINGECKO_SIMPLE_PRICE_URL);
+  const btc = body.bitcoin?.usd;
+  const usdc = body["usd-coin"]?.usd;
+  if (!isPositiveNumber(btc)) {
+    throw new Error("coingecko response missing bitcoin.usd");
+  }
+  if (!isPositiveNumber(usdc)) {
+    throw new Error("coingecko response missing usd-coin.usd");
+  }
+  return { btc_usd: btc, usdc_usd: usdc, as_of: (/* @__PURE__ */ new Date()).toISOString() };
+}
+async function fetchCoinGeckoBtcUsd(opts) {
+  const body = await fetchCoinGeckoBody(opts, COINGECKO_BTC_USD_URL);
+  const btc = body.bitcoin?.usd;
+  if (!isPositiveNumber(btc)) {
+    throw new Error("coingecko response missing bitcoin.usd");
+  }
+  return { btc_usd: btc, as_of: (/* @__PURE__ */ new Date()).toISOString() };
+}
+async function fetchCoinGeckoBody(opts, defaultUrl) {
+  const url = opts?.url ?? defaultUrl;
+  const fetchImpl = opts?.fetchImpl ?? fetch;
+  const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const userAgent = opts?.userAgent ?? DEFAULT_USER_AGENT;
+  const res = await fetchImpl(url, {
+    headers: { "User-Agent": userAgent, Accept: "application/json" },
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  if (!res.ok) {
+    throw new Error(`coingecko returned HTTP ${res.status.toString()}`);
+  }
+  return await res.json();
+}
+function isPositiveNumber(v) {
+  return typeof v === "number" && Number.isFinite(v) && v > 0;
+}
+
+// src/lib/currency.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { dirname } from "path";
+
+// src/defaults.ts
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = process.env.DVM_CONFIG_DIR ?? join(homedir(), ".dvm");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var CONFIG_BACKUP_FILE = join(CONFIG_DIR, "config.json.bak");
+var CONFIG_AUDIT_FILE = join(CONFIG_DIR, "config-audit.jsonl");
+var CONFIG_PINNED_FILE = join(CONFIG_DIR, "config.json.pinned");
+var JOBS_FILE = join(CONFIG_DIR, "jobs.json");
+var REQUEST_INTENTS_DIR = join(CONFIG_DIR, "request-intents");
+var FAVORITES_FILE = join(CONFIG_DIR, "favorites.json");
+var MESSAGES_DIR = join(CONFIG_DIR, "messages");
+var RECEIPTS_FILE = join(CONFIG_DIR, "receipts.jsonl");
+var CREDITS_FILE = join(CONFIG_DIR, "credits.json");
+var X402_CHANNELS_FILE = join(CONFIG_DIR, "x402-channels.json");
+var TEMPO_CHANNELS_FILE = join(CONFIG_DIR, "tempo-channels.json");
+var FEEDBACK_NUDGES_FILE = join(CONFIG_DIR, "feedback-nudges.json");
+var RECOVERY_MNEMONIC_FILE = join(CONFIG_DIR, "recovery.mnemonic");
+var WALLET_FILE = join(CONFIG_DIR, "wallet.json");
+var AGENT_MNEMONIC_FILE = join(CONFIG_DIR, "wallet.mnemonic");
+var IDENTITIES_FILE = join(CONFIG_DIR, "identities.json");
+var PAIRINGS_DIR = join(CONFIG_DIR, "pairings");
+var BUDGET_FILE = join(CONFIG_DIR, "budget.json");
+var BTC_RATE_FILE = join(CONFIG_DIR, "btc-rate.json");
+var ADMIN_DIR = join(CONFIG_DIR, "admin");
+var PROXY_STATE_FILE = join(ADMIN_DIR, "proxy.json");
+var BUILDER_CONFIG_DIR = process.env.DVMKIT_CONFIG_DIR ?? join(homedir(), ".dvmkit");
+var BUILDER_FILE = join(BUILDER_CONFIG_DIR, "builder.json");
+var BUILDER_MNEMONIC_FILE = join(BUILDER_CONFIG_DIR, "recovery.mnemonic");
+var BUILDER_KEY_FILE = join(BUILDER_CONFIG_DIR, "builder.key");
+var MELT_PENDING_LOG_FILE = join(BUILDER_CONFIG_DIR, "melt-pending.log");
+var DRAIN_PARK_LOG_FILE = join(BUILDER_CONFIG_DIR, "drain-park.log");
+var DRAIN_HOLD_STATE_FILE = join(BUILDER_CONFIG_DIR, "drain-hold.json");
+var MELT_SUCCESS_FILE = join(BUILDER_CONFIG_DIR, "melt-success.json");
+
+// src/lib/config-dir.ts
+import { chmodSync, mkdirSync, statSync } from "fs";
+var CONFIG_DIR_MODE = 448;
+function ensureConfigDir() {
+  ensureConfigSubdir(CONFIG_DIR);
+}
+function ensureConfigSubdir(path) {
+  mkdirSync(path, { recursive: true, mode: CONFIG_DIR_MODE });
+}
+
+// src/lib/currency.ts
+function msatsToUsd(msats, rate) {
+  return msats / 1e11 * rate;
+}
+function usdToMsats(usd, rate) {
+  return Math.round(usd / rate * 1e11);
+}
+function msatsToUsdCents(msats, btcPriceUsd) {
+  const usd = msatsToUsd(msats, btcPriceUsd);
+  return Math.round(usd * 100);
+}
+function msatsToUsdc(msats, btcUsdRate) {
+  const usd = msatsToUsd(msats, btcUsdRate);
+  return Math.ceil(usd * 1e6);
+}
+function usdcToMsats(usdc, btcUsdRate) {
+  return usdToMsats(usdc, btcUsdRate);
+}
+function formatSats(msats) {
+  if (msats === 0) return "0 sats";
+  if (msats < 1e3) return `${msats.toLocaleString("en-US")} msats`;
+  if (msats % 1e3 === 0) return `${(msats / 1e3).toLocaleString("en-US")} sats`;
+  return `${Math.round(msats / 1e3 * 100) / 100} sats`;
+}
+function formatAmount(msats, rate, opts) {
+  const usd = msatsToUsd(msats, rate);
+  const base = `~$${formatUsd(usd)} (${formatSats(msats)})`;
+  return opts?.anchor === false ? base : `${base} \u2014 ${costAnchor(usd)}`;
+}
+function formatPaymentAmount(msats, fiat, opts) {
+  if (!fiat || fiat.amount <= 0) return formatAmountBestEffort(msats, opts);
+  const base = `${formatFiat(fiat.amount, fiat.currency)} (${formatSats(msats)})`;
+  return opts?.anchor === false ? base : `${base} \u2014 ${costAnchor(fiat.amount, fiat.currency)}`;
+}
+var COST_ANCHOR_BANDS = {
+  usd: [0.01, 0.1, 1, 10],
+  eur: [0.01, 0.1, 1, 10],
+  gbp: [0.01, 0.1, 1, 10],
+  jpy: [1, 10, 100, 1500]
+};
+function costAnchor(amount, currency = "usd") {
+  const bands = COST_ANCHOR_BANDS[currency] ?? COST_ANCHOR_BANDS.usd;
+  if (amount < bands[0]) return "fraction of a cent";
+  if (amount <= bands[1]) return "comparable to an API call";
+  if (amount <= bands[2]) return "comparable to a ChatGPT query";
+  if (amount <= bands[3]) return "comparable to a coffee";
+  return "significant purchase \u2014 review carefully";
+}
+function monetaryJson(msats, rate) {
+  const usd = msatsToUsd(msats, rate);
+  return {
+    msats,
+    usd: Math.round(usd * 100) / 100,
+    anchor: costAnchor(usd),
+    display: formatAmount(msats, rate)
+  };
+}
+function formatUsd(usd) {
+  if (usd === 0) return "0.00";
+  if (usd >= 0.01) return usd.toFixed(2);
+  const digits = Math.max(2, -Math.floor(Math.log10(usd)) + 1);
+  return usd.toFixed(digits);
+}
+function formatUsdcMicrounits(microunits) {
+  const value = typeof microunits === "bigint" ? microunits : BigInt(microunits);
+  const whole = value / 1000000n;
+  const fraction = (value % 1000000n).toString().padStart(6, "0").replace(/0+$/, "");
+  return `${whole}.${fraction.padEnd(2, "0") || "00"}`;
+}
+function parseBudget(budget, rate) {
+  const value = assertValidBudget(budget);
+  return budget.startsWith("$") ? usdToMsats(value, rate) : value;
+}
+function assertValidBudget(budget) {
+  const value = budget.startsWith("$") ? parseFloat(budget.slice(1)) : parseInt(budget, 10);
+  if (isNaN(value)) throw new Error(`Invalid budget: ${budget}`);
+  return value;
+}
+async function fetchBtcUsdRate() {
+  if (memRate && Date.now() - memTime < CACHE_TTL) {
+    return memRate;
+  }
+  const disk = readDiskCache();
+  if (disk) {
+    memRate = disk;
+    memTime = Date.now();
+    return disk;
+  }
+  const rate = await fetchFromApi();
+  memRate = rate;
+  memTime = Date.now();
+  writeDiskCache(rate);
+  return rate;
+}
+function getLastKnownBtcRate() {
+  if (memRate && memTime > 0) return { rate: memRate, cachedAt: memTime };
+  return readDiskCacheStale();
+}
+function formatStaleness(cachedAt, now = Date.now()) {
+  const ageMs = Math.max(0, now - cachedAt);
+  const seconds = Math.floor(ageMs / 1e3);
+  if (seconds < 60) return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes} min ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours} hour${hours === 1 ? "" : "s"} ago`;
+  const days = Math.floor(hours / 24);
+  return `${days} day${days === 1 ? "" : "s"} ago`;
+}
+function formatAmountBestEffort(msats, opts) {
+  const m = msats ?? 0;
+  const cached = getLastKnownBtcRate();
+  if (cached === null) return `${Math.round(m / 1e3)} sats`;
+  const base = formatAmount(m, cached.rate, opts);
+  if (Date.now() - cached.cachedAt < CACHE_TTL) return base;
+  return `${base} (rate cached ${formatStaleness(cached.cachedAt)})`;
+}
+var CACHE_TTL = 5 * 60 * 1e3;
+var CACHE_FILE = BTC_RATE_FILE;
+var memRate = null;
+var memTime = 0;
+function readDiskCache() {
+  try {
+    if (!existsSync(CACHE_FILE)) return null;
+    const data = JSON.parse(readFileSync(CACHE_FILE, "utf-8"));
+    if (Date.now() - data.timestamp >= CACHE_TTL) return null;
+    if (!isPlausibleBtcUsdRate(data.rate)) return null;
+    return data.rate;
+  } catch {
+    return null;
+  }
+}
+function readDiskCacheStale() {
+  try {
+    if (!existsSync(CACHE_FILE)) return null;
+    const data = JSON.parse(readFileSync(CACHE_FILE, "utf-8"));
+    if (!isPlausibleBtcUsdRate(data.rate)) return null;
+    return { rate: data.rate, cachedAt: data.timestamp };
+  } catch {
+    return null;
+  }
+}
+function writeDiskCache(rate) {
+  try {
+    ensureConfigSubdir(dirname(CACHE_FILE));
+    writeFileSync(CACHE_FILE, JSON.stringify({ rate, timestamp: Date.now() }));
+  } catch {
+  }
+}
+var MAX_PLAUSIBLE_BTC_USD = 1e7;
+function isPlausibleBtcUsdRate(rate) {
+  return typeof rate === "number" && Number.isFinite(rate) && rate > 0 && rate < MAX_PLAUSIBLE_BTC_USD;
+}
+async function fetchFromApi() {
+  const spot = await fetchCoinGeckoBtcUsd();
+  const rate = spot.btc_usd;
+  if (!isPlausibleBtcUsdRate(rate)) {
+    throw new Error(`implausible BTC/USD rate from upstream: ${String(rate)}`);
+  }
+  return rate;
+}
+
+// src/lib/payment-rails/rpc.ts
+function resolveRpcOverride(envValue, bundled) {
+  const override = envValue?.trim() ?? "";
+  return override.length > 0 ? { url: override, source: "override" } : { url: bundled, source: "bundled" };
+}
+function resolveRpcHttpTransportOptions(source, envValue) {
+  if (source !== "override" || !envValue?.trim()) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(envValue);
+  } catch {
+    throw new Error("RPC headers must be a JSON object of non-empty string values.");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    throw new Error("RPC headers must be a JSON object of non-empty string values.");
+  const headers = {};
+  for (const [name, value] of Object.entries(parsed)) {
+    if (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(name) || typeof value !== "string" || value.length === 0 || /[\r\n]/.test(value))
+      throw new Error("RPC headers must be a JSON object of non-empty string values.");
+    headers[name] = value;
+  }
+  if (Object.keys(headers).length === 0)
+    throw new Error("RPC headers must be a JSON object of non-empty string values.");
+  return { fetchOptions: { headers } };
+}
+
+export {
+  DvmError,
+  providerProseSources,
+  transportErrorCode,
+  IMPLICIT_CREDIT_TTL_MS,
+  CONFIG_FILE,
+  CONFIG_BACKUP_FILE,
+  CONFIG_AUDIT_FILE,
+  CONFIG_PINNED_FILE,
+  RECEIPTS_FILE,
+  CREDITS_FILE,
+  X402_CHANNELS_FILE,
+  TEMPO_CHANNELS_FILE,
+  WALLET_FILE,
+  AGENT_MNEMONIC_FILE,
+  IDENTITIES_FILE,
+  BUDGET_FILE,
+  BUILDER_CONFIG_DIR,
+  BUILDER_FILE,
+  BUILDER_KEY_FILE,
+  ensureConfigDir,
+  COINGECKO_SIMPLE_PRICE_URL,
+  fetchCoinGeckoSpot,
+  msatsToUsd,
+  usdToMsats,
+  msatsToUsdCents,
+  msatsToUsdc,
+  usdcToMsats,
+  formatSats,
+  formatAmount,
+  formatPaymentAmount,
+  costAnchor,
+  monetaryJson,
+  formatUsd,
+  formatUsdcMicrounits,
+  parseBudget,
+  assertValidBudget,
+  fetchBtcUsdRate,
+  getLastKnownBtcRate,
+  formatStaleness,
+  formatAmountBestEffort,
+  resolveRpcOverride,
+  resolveRpcHttpTransportOptions
+};

package/dist/chunk-66HGCPBU.js

@@ -0,0 +1,25 @@
+// src/lib/caller-loggers.ts
+var callerLoggers = buildNoopLoggers();
+function initCallerLoggers(nextLoggers) {
+  callerLoggers = nextLoggers;
+}
+function buildNoopLoggers() {
+  const noopLogger = {
+    // eslint-disable-next-line @typescript-eslint/no-empty-function -- standalone caller has no exporter
+    info() {
+    },
+    async span(_name, _attrs, fn) {
+      return fn();
+    }
+  };
+  return {
+    cashu: noopLogger,
+    lightning: noopLogger,
+    x402: noopLogger
+  };
+}
+
+export {
+  callerLoggers,
+  initCallerLoggers
+};