@dvmkit/sdk 0.6.0-rc.1 → 0.7.0-rc.10

package/dist/chunk-B2IROPQF.js

@@ -1,1844 +0,0 @@
-import {
-  IMPLICIT_CREDIT_TTL_MS,
-  isDrainReceipt
-} from "./chunk-PAIM66YA.js";
-import {
-  CREDITS_FILE,
-  ensureConfigDir
-} from "./chunk-CZULM42S.js";
-import {
-  DvmError
-} from "./chunk-LIRAHP7B.js";
-
-// src/lib/payment-rails/types.ts
-var RAIL_FLAGS = ["cashu", "tempo", "x402"];
-var ADVERTISED_AMOUNT_TOLERANCE_BPS = 1000n;
-function maxAdvertisedMicro(localMicro) {
-  return localMicro * (10000n + ADVERTISED_AMOUNT_TOLERANCE_BPS) / 10000n;
-}
-function withinAdvertisedTolerance(advertisedMicro, localMicro) {
-  return advertisedMicro * 10000n <= localMicro * (10000n + ADVERTISED_AMOUNT_TOLERANCE_BPS);
-}
-
-// src/lib/transport/types.ts
-var SUPPORTED_PROTOCOL_VERSION = 1;
-function parseCreditTerms(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
-  const credit = raw;
-  if (typeof credit.min_micro !== "number" || typeof credit.max_micro !== "number" || typeof credit.ttl_ms !== "number" || typeof credit.currency !== "string" || !Array.isArray(credit.funding) || !credit.funding.every((method) => typeof method === "string") || credit.lightning_min_micro !== void 0 && typeof credit.lightning_min_micro !== "number")
-    return void 0;
-  const tempo = credit.tempo === void 0 ? void 0 : parseCreditTempoTerms(credit.tempo);
-  if (credit.tempo !== void 0 && !tempo) return void 0;
-  const x402 = credit.x402 === void 0 ? void 0 : parseCreditX402Terms(credit.x402);
-  if (credit.x402 !== void 0 && !x402) return void 0;
-  return {
-    min_micro: credit.min_micro,
-    max_micro: credit.max_micro,
-    ttl_ms: credit.ttl_ms,
-    currency: credit.currency,
-    funding: [...credit.funding],
-    ...tempo && { tempo },
-    ...x402 && { x402 },
-    ...typeof credit.lightning_min_micro === "number" && {
-      lightning_min_micro: credit.lightning_min_micro
-    }
-  };
-}
-function parseCreditMenu(raw) {
-  const terms = parseCreditTerms(raw);
-  if (!terms) return void 0;
-  const credit = raw;
-  return {
-    ...terms,
-    ...typeof credit.credit_id === "string" && { credit_id: credit.credit_id },
-    ...typeof credit.balance_micro === "number" && { balance_micro: credit.balance_micro },
-    ...typeof credit.remaining_micro === "number" && {
-      remaining_micro: credit.remaining_micro
-    },
-    ...typeof credit.expiry_ms === "number" && { expiry_ms: credit.expiry_ms }
-  };
-}
-function parseCreditTempoTerms(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
-  const block = raw;
-  if (!Array.isArray(block.methods) || !block.methods.every(isCreditTempoMethod)) return void 0;
-  if (block.withheld !== void 0 && (!Array.isArray(block.withheld) || !block.withheld.every(isCreditTempoWithheldMethod)))
-    return void 0;
-  return {
-    methods: block.methods.map((method) => ({
-      method: method.method,
-      intent: method.intent
-    })),
-    ...Array.isArray(block.withheld) && {
-      withheld: block.withheld.map((method) => ({
-        method: method.method,
-        intent: method.intent,
-        reason: method.reason
-      }))
-    }
-  };
-}
-function isCreditTempoMethod(raw) {
-  return !!raw && typeof raw === "object" && typeof raw.method === "string" && (raw.intent === "charge" || raw.intent === "session");
-}
-function isCreditTempoWithheldMethod(raw) {
-  return isCreditTempoMethod(raw) && typeof raw.reason === "string";
-}
-function parseCreditX402Terms(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
-  const schemes = raw.schemes;
-  if (!Array.isArray(schemes) || !schemes.every(
-    (entry) => !!entry && typeof entry === "object" && typeof entry.scheme === "string" && typeof entry.network === "string"
-  ))
-    return void 0;
-  return {
-    schemes: schemes.map((entry) => ({
-      scheme: entry.scheme,
-      network: entry.network
-    }))
-  };
-}
-
-// src/lib/credit-store.ts
-import { existsSync, readFileSync as readFileSync2, renameSync, unlinkSync, writeFileSync } from "fs";
-import { dirname } from "path";
-import lockfile from "proper-lockfile";
-
-// src/lib/credit-history.ts
-import { createHash } from "crypto";
-import {
-  closeSync,
-  fsyncSync,
-  openSync,
-  readFileSync,
-  writeSync,
-  ftruncateSync
-} from "fs";
-function historyPath() {
-  return `${CREDITS_FILE.slice(0, -5)}-history.jsonl`;
-}
-function hash(value) {
-  return createHash("sha256").update(value).digest("hex");
-}
-function fail(detail) {
-  throw new DvmError(
-    "credit_history_unavailable",
-    `Completed credit history could not be preserved: ${detail}`,
-    "Keep the credit store and history file intact, fix the file access or damage, and retry. Working evidence was not evicted."
-  );
-}
-var receiptKeys = /* @__PURE__ */ new Set([
-  "v",
-  "kind",
-  "credit_id",
-  "drain_id",
-  "event",
-  "method",
-  "amount_micro",
-  "balance_after_micro",
-  "ledger_seq",
-  "issued_at",
-  "caller_pubkey",
-  "dvm_id",
-  "dvm",
-  "receipt_pubkey",
-  "signature"
-]);
-var attestationKeys = /* @__PURE__ */ new Set([
-  "dvm_id",
-  "slug",
-  "capabilities_hash",
-  "builder_pubkey",
-  "receipt_pubkey",
-  "deployed_at"
-]);
-function safeReceipts(bundle) {
-  const receipts = [];
-  for (const receipt of bundle.receipts) {
-    if (!isDrainReceipt(receipt))
-      fail("a completed bundle contains an unrecognized receipt");
-    if (Object.keys(receipt).some((key) => !receiptKeys.has(key)))
-      fail("a receipt contains unsupported fields");
-    if (Object.values(receipt).some(
-      (value) => typeof value !== "string" && typeof value !== "number" || typeof value === "number" && (!Number.isSafeInteger(value) || value < 0)
-    ))
-      fail("a receipt contains unsupported values");
-    receipts.push(receipt);
-  }
-  return receipts;
-}
-function safeAnchor(anchor) {
-  if (!anchor) return void 0;
-  if (typeof anchor.pubkey !== "string" || typeof anchor.signature !== "string" || !anchor.attestation || Object.keys(anchor.attestation).some((key) => !attestationKeys.has(key)) || Object.values(anchor.attestation).some(
-    (value) => typeof value !== "string" && typeof value !== "number"
-  ))
-    fail("an advertisement contains unsupported fields");
-  return {
-    pubkey: anchor.pubkey,
-    signature: anchor.signature,
-    attestation: anchor.attestation
-  };
-}
-function hasAttestedIdentity(record) {
-  return Boolean(record.dvmId && record.attestedBuilderPubkey);
-}
-function compatibleLocations(left, right) {
-  if (hasAttestedIdentity(left) && hasAttestedIdentity(right))
-    return left.dvmId === right.dvmId && left.attestedBuilderPubkey === right.attestedBuilderPubkey;
-  return [left.endpoint, ...left.endpointAliases].some(
-    (origin) => [right.endpoint, ...right.endpointAliases].includes(origin)
-  );
-}
-function base(record, identity, occurredAt) {
-  return {
-    v: 1,
-    id: hash(
-      JSON.stringify([
-        record.callerPubkey,
-        hasAttestedIdentity(record) ? record.dvmId : record.endpoint,
-        hasAttestedIdentity(record) ? record.attestedBuilderPubkey : null,
-        record.creditId,
-        identity
-      ])
-    ),
-    endpoint: record.endpoint,
-    endpointAliases: record.endpointAliases ?? [],
-    dvmId: record.dvmId ?? null,
-    attestedBuilderPubkey: record.attestedBuilderPubkey ?? null,
-    callerPubkey: record.callerPubkey,
-    creditId: record.creditId,
-    occurredAt,
-    rail: null,
-    currency: null,
-    amountMicro: null,
-    feeMicro: null
-  };
-}
-function completedRefund(record, bundle) {
-  const receipts = safeReceipts(bundle);
-  const anchor = safeAnchor(bundle.anchor);
-  const receipt = receipts.find(
-    (r) => r.drain_id === bundle.drainId && r.credit_id === bundle.creditId
-  );
-  const metadata = bundle.settlement;
-  if (metadata && (metadata.rail !== null && typeof metadata.rail !== "string" || metadata.currency !== null && typeof metadata.currency !== "string" || [metadata.amountMicro, metadata.feeMicro].some(
-    (value) => value !== null && (!Number.isSafeInteger(value) || value < 0)
-  )))
-    fail("invalid settlement metadata");
-  return {
-    ...base(
-      { ...record, creditId: bundle.creditId },
-      `refund:${bundle.drainId}`,
-      bundle.settledAt
-    ),
-    kind: "completed_refund",
-    outcome: "refunded",
-    drainId: bundle.drainId,
-    settledAt: bundle.settledAt,
-    collectedAt: bundle.collectedAt === 0 ? null : bundle.collectedAt,
-    rail: metadata?.rail ?? receipt?.method ?? null,
-    currency: metadata?.currency ?? null,
-    amountMicro: metadata?.amountMicro ?? receipt?.amount_micro ?? null,
-    feeMicro: metadata?.feeMicro ?? null,
-    receipts,
-    ...anchor ? { anchor } : {},
-    provenance: {
-      settlement: "local_observation",
-      receipts: "unverified_observations",
-      advertisement: anchor ? "present" : "absent"
-    }
-  };
-}
-function completedLoss(record) {
-  return {
-    ...base(record, "loss", record.updatedAt),
-    kind: "expired_credit_loss",
-    outcome: "lost",
-    rail: record.creditId.startsWith("imp:") ? record.creditId.split(":")[1] || null : null,
-    currency: record.currency,
-    amountMicro: record.remainingMicro,
-    reason: record.lossReason ?? "expired",
-    releasedAt: record.releasedAt,
-    expiryMs: record.expiryMs,
-    releasedByJobId: record.releasedByJobId
-  };
-}
-function validateHistoryRecord(row) {
-  if (!row || row.v !== 1 || typeof row.id !== "string" || !Number.isSafeInteger(row.occurredAt) || typeof row.endpoint !== "string" || typeof row.callerPubkey !== "string" || typeof row.creditId !== "string" || !Array.isArray(row.endpointAliases) || row.endpointAliases.some((value) => typeof value !== "string") || [row.dvmId, row.attestedBuilderPubkey, row.currency, row.rail].some(
-    (value) => value !== null && typeof value !== "string"
-  ) || [row.amountMicro, row.feeMicro].some(
-    (value) => value !== null && (!Number.isSafeInteger(value) || value < 0)
-  ))
-    fail("invalid complete journal entry");
-  if (row.kind === "completed_refund") {
-    if (row.outcome !== "refunded" || typeof row.drainId !== "string" || !Number.isSafeInteger(row.settledAt) || row.collectedAt !== null && !Number.isSafeInteger(row.collectedAt) || !Array.isArray(row.receipts) || row.provenance?.settlement !== "local_observation" || row.provenance.receipts !== "unverified_observations" || !["present", "absent"].includes(row.provenance.advertisement))
-      fail("invalid refund entry");
-    safeReceipts({
-      drainId: row.drainId,
-      creditId: row.creditId,
-      receipts: row.receipts,
-      collectedAt: row.collectedAt ?? 0
-    });
-    safeAnchor(row.anchor);
-  } else if (row.kind === "expired_credit_loss") {
-    if (row.outcome !== "lost" || !["expired", "not_found"].includes(row.reason) || !Number.isSafeInteger(row.releasedAt) || !Number.isSafeInteger(row.expiryMs) || typeof row.releasedByJobId !== "string")
-      fail("invalid loss entry");
-  } else fail("invalid complete journal entry");
-}
-function journal() {
-  let bytes;
-  try {
-    bytes = readFileSync(historyPath());
-  } catch (error) {
-    if (error.code === "ENOENT")
-      return { bytes: Buffer.alloc(0), complete: 0, rows: [] };
-    fail(error instanceof Error ? error.message : String(error));
-  }
-  const complete = bytes.lastIndexOf(10) + 1;
-  const rows = bytes.subarray(0, complete).toString("utf8").split("\n").filter(Boolean).map((line) => {
-    let row;
-    try {
-      row = JSON.parse(line);
-    } catch {
-      fail("damaged complete journal line");
-    }
-    validateHistoryRecord(row);
-    return row;
-  });
-  return { bytes, complete, rows };
-}
-function archiveCompletedCreditRecords(records) {
-  if (!records.length) return;
-  try {
-    const current = journal();
-    const latest = new Map(
-      current.rows.map((record) => [record.id, JSON.stringify(record)])
-    );
-    const observed = new Map(current.rows.map((record) => [record.id, record]));
-    const additions = [];
-    for (const incoming of records) {
-      const prior = [...observed.values()].reverse().find(
-        (row) => row.kind === incoming.kind && row.callerPubkey === incoming.callerPubkey && row.creditId === incoming.creditId && (row.kind !== "completed_refund" || incoming.kind === "completed_refund" && row.drainId === incoming.drainId) && compatibleLocations(row, incoming)
-      );
-      const newerPrior = prior && (incoming.kind === "completed_refund" && prior.kind === "completed_refund" ? (prior.collectedAt ?? 0) > (incoming.collectedAt ?? 0) : prior.occurredAt > incoming.occurredAt);
-      const facts = newerPrior ? prior : incoming;
-      const identity = prior && hasAttestedIdentity(prior) ? prior : hasAttestedIdentity(incoming) ? incoming : newerPrior || !incoming.dvmId && !incoming.attestedBuilderPubkey ? prior ?? incoming : incoming;
-      const record = prior ? {
-        ...facts,
-        id: prior.id,
-        dvmId: identity.dvmId,
-        attestedBuilderPubkey: identity.attestedBuilderPubkey,
-        endpointAliases: [
-          .../* @__PURE__ */ new Set([
-            prior.endpoint,
-            ...prior.endpointAliases,
-            incoming.endpoint,
-            ...incoming.endpointAliases
-          ])
-        ].filter((origin) => origin !== facts.endpoint)
-      } : incoming;
-      validateHistoryRecord(record);
-      const encoded = JSON.stringify(record);
-      if (latest.get(record.id) === encoded) continue;
-      additions.push(encoded + "\n");
-      latest.set(record.id, encoded);
-      observed.set(record.id, record);
-    }
-    const fd = openSync(historyPath(), "a", 384);
-    try {
-      if (current.complete !== current.bytes.length)
-        ftruncateSync(fd, current.complete);
-      const bytes = Buffer.from(additions.join(""));
-      let written = 0;
-      while (written < bytes.length) {
-        const count = writeSync(fd, bytes, written, bytes.length - written);
-        if (!count) fail("zero-length append");
-        written += count;
-      }
-      fsyncSync(fd);
-    } finally {
-      closeSync(fd);
-    }
-    {
-      const directory = openSync(
-        historyPath().slice(0, historyPath().lastIndexOf("/")),
-        "r"
-      );
-      try {
-        fsyncSync(directory);
-      } finally {
-        closeSync(directory);
-      }
-    }
-  } catch (error) {
-    fail(error instanceof Error ? error.message : String(error));
-  }
-}
-function readCreditHistoryPage(query) {
-  const limit = query.limit ?? 50;
-  if (!Number.isInteger(limit) || limit < 1 || limit > 100)
-    throw new DvmError(
-      "invalid_credit_history_query",
-      "History page limit must be an integer from 1 through 100."
-    );
-  const order = query.order ?? "asc";
-  if (order !== "asc" && order !== "desc")
-    throw new DvmError(
-      "invalid_credit_history_query",
-      "History order must be asc or desc."
-    );
-  const direction = order === "asc" ? 1 : -1;
-  const filter = JSON.stringify([
-    order,
-    query.endpoint ? new URL(query.endpoint).origin : null,
-    query.dvmId ?? null,
-    query.callerPubkey ?? null
-  ]);
-  const current = journal();
-  let end = current.complete;
-  let after;
-  if (query.cursor) {
-    try {
-      const cursor = JSON.parse(
-        Buffer.from(query.cursor, "base64url").toString("utf8")
-      );
-      if (cursor.v !== 1 || !Number.isSafeInteger(cursor.end) || cursor.end < 0 || cursor.end > current.complete || cursor.end > 0 && current.bytes[cursor.end - 1] !== 10 || cursor.filter !== filter || cursor.prefix !== hash(current.bytes.subarray(0, cursor.end).toString("utf8")) || !Array.isArray(cursor.after) || !Number.isFinite(cursor.after[0]) || typeof cursor.after[1] !== "string")
-        throw new Error("cursor mismatch");
-      end = cursor.end;
-      after = cursor.after;
-    } catch {
-      throw new DvmError(
-        "invalid_credit_history_cursor",
-        "History cursor is invalid, stale, or belongs to different filters."
-      );
-    }
-  }
-  const rows = current.bytes.subarray(0, end).toString("utf8").split("\n").filter(Boolean).map((line) => JSON.parse(line));
-  const endpoint = query.endpoint ? new URL(query.endpoint).origin : void 0;
-  const ordered = [...new Map(rows.map((row) => [row.id, row])).values()].filter(
-    (row) => (!endpoint || row.endpoint === endpoint || row.endpointAliases.includes(endpoint)) && (!query.dvmId || row.dvmId === query.dvmId) && (!query.callerPubkey || row.callerPubkey === query.callerPubkey)
-  ).sort(
-    (a, b) => direction * (a.occurredAt - b.occurredAt || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
-  );
-  const remaining = ordered.filter(
-    (row) => !after || direction * (row.occurredAt - after[0]) > 0 || row.occurredAt === after[0] && (direction === 1 ? row.id > after[1] : row.id < after[1])
-  );
-  const records = remaining.slice(0, limit);
-  const last = records.at(-1);
-  return {
-    records,
-    ...remaining.length > limit && last ? {
-      nextCursor: Buffer.from(
-        JSON.stringify({
-          v: 1,
-          end,
-          prefix: hash(current.bytes.subarray(0, end).toString("utf8")),
-          filter,
-          after: [last.occurredAt, last.id]
-        })
-      ).toString("base64url")
-    } : {}
-  };
-}
-
-// src/lib/credit-store.ts
-function withCreditLock(fn, opts = {}) {
-  if (lockDepth > 0) {
-    lockDepth += 1;
-    try {
-      return rejectAsyncBody(fn());
-    } finally {
-      lockDepth -= 1;
-    }
-  }
-  const release = acquireCreditLock(opts);
-  lockDepth = 1;
-  try {
-    return rejectAsyncBody(fn());
-  } finally {
-    lockDepth = 0;
-    try {
-      release();
-    } catch {
-    }
-  }
-}
-function normalizeCreditEndpoint(endpoint) {
-  try {
-    return new URL(endpoint).origin;
-  } catch {
-    return endpoint.replace(/\/+$/, "");
-  }
-}
-function dvmLocationIdentity(record) {
-  if (typeof record.dvmId !== "string" || record.dvmId.length === 0) return void 0;
-  const pubkey = typeof record.attestedBuilderPubkey === "string" ? record.attestedBuilderPubkey.trim().toLowerCase() : "";
-  if (!/^[0-9a-f]{64}$/.test(pubkey)) return void 0;
-  return { dvmId: record.dvmId, builderPubkey: pubkey };
-}
-function findDvmLocated(records, args) {
-  const where = args.where ?? (() => true);
-  const identity = args.identity;
-  if (identity) {
-    const attested = records.find(
-      (record) => where(record) && matchesDvmIdentity(record, identity)
-    );
-    if (attested) return attested;
-  }
-  return records.find(
-    (record) => where(record) && matchesDvmOrigin(record, args.endpoint, identity)
-  );
-}
-function attachDvmLocation(record, endpoint, identity) {
-  let changed = false;
-  if (identity) {
-    if (record.dvmId !== identity.dvmId) {
-      record.dvmId = identity.dvmId;
-      changed = true;
-    }
-    if (record.attestedBuilderPubkey !== identity.builderPubkey) {
-      record.attestedBuilderPubkey = identity.builderPubkey;
-      changed = true;
-    }
-  }
-  if (endpoint !== record.endpoint && !dvmLocationOrigins(record).includes(endpoint)) {
-    record.endpointAliases = [...record.endpointAliases ?? [], endpoint];
-    changed = true;
-  }
-  return changed;
-}
-function dvmLocationOrigins(record) {
-  const aliases = Array.isArray(record.endpointAliases) ? record.endpointAliases.filter((endpoint) => typeof endpoint === "string") : [];
-  const primary = typeof record.endpoint === "string" ? [record.endpoint] : [];
-  return [...primary, ...aliases].map(normalizeCreditEndpoint);
-}
-function fundingReachableAt(funding, endpoint, credits) {
-  const at = normalizeCreditEndpoint(funding.endpoint);
-  const named = normalizeCreditEndpoint(endpoint);
-  if (at === named) return true;
-  const record = credits.find(
-    (c) => c.callerPubkey === funding.callerPubkey && c.creditId === funding.creditId
-  );
-  if (!record) return false;
-  const origins = dvmLocationOrigins(record);
-  return origins.includes(at) && origins.includes(named);
-}
-function pendingDrainFor(record, creditId) {
-  return record?.pendingDrains?.find((d) => d.creditId === creditId);
-}
-function pendingDrainById(record, drainId) {
-  return record?.pendingDrains?.find((d) => d.drainId === drainId);
-}
-function loadCredit(endpoint, callerPubkey, identity) {
-  return withCreditLock(() => {
-    const key = normalizeCreditEndpoint(endpoint);
-    const store = loadStore();
-    const record = findDvmLocated(store.credits, {
-      endpoint: key,
-      ...identity ? { identity } : {},
-      where: (c) => c.callerPubkey === callerPubkey
-    });
-    if (record && attachDvmLocation(record, key, identity)) saveStore(store);
-    return record;
-  });
-}
-function clearCreditSelection(endpoint, callerPubkey, creditId, identity) {
-  return withCreditLock(() => {
-    const key = normalizeCreditEndpoint(endpoint);
-    const store = loadStore();
-    const record = findDvmLocated(store.credits, {
-      endpoint: key,
-      ...identity ? { identity } : {},
-      where: (candidate) => candidate.callerPubkey === callerPubkey && candidate.creditId === creditId
-    });
-    if (!record) {
-      throw new DvmError(
-        "credit_not_found",
-        `Credit ${creditId} is not the selected local credit at ${key}.`
-      );
-    }
-    attachDvmLocation(record, key, identity);
-    record.selectionCleared = true;
-    record.updatedAt = Date.now();
-    saveStore(store);
-    return structuredClone(record);
-  });
-}
-function readCompletedCreditHistory(query = {}) {
-  return withCreditLock(() => {
-    loadStore(true);
-    return readCreditHistoryPage(query);
-  });
-}
-function listCredits() {
-  return withCreditLock(() => [...loadStore().credits].sort((a, b) => b.updatedAt - a.updatedAt));
-}
-function listImplicitCredits(now = Date.now()) {
-  return withCreditLock(() => {
-    const store = loadStore();
-    const aged = ageImplicitCredits(store.implicitCredits, now);
-    const capped = capLostImplicitCredits(store.implicitCredits);
-    if (aged || capped.changed) {
-      store.implicitCredits = capped.credits;
-      saveStore(store);
-    }
-    return [...store.implicitCredits].sort(compareImplicitCredits);
-  });
-}
-function loadImplicitCredits(endpoint, callerPubkey, identity, now = Date.now()) {
-  return withCreditLock(() => {
-    const store = loadStore();
-    const key = normalizeCreditEndpoint(endpoint);
-    let changed = ageImplicitCredits(store.implicitCredits, now);
-    const matches = store.implicitCredits.filter(
-      (record) => Boolean(
-        findDvmLocated([record], {
-          endpoint: key,
-          ...identity ? { identity } : {},
-          where: (candidate) => candidate.callerPubkey === callerPubkey
-        })
-      )
-    );
-    for (const record of matches) {
-      changed = attachDvmLocation(record, key, identity) || changed;
-    }
-    const capped = capLostImplicitCredits(store.implicitCredits);
-    if (changed || capped.changed) {
-      store.implicitCredits = capped.credits;
-      saveStore(store);
-    }
-    return matches.filter((record) => store.implicitCredits.includes(record)).sort(compareImplicitCredits);
-  });
-}
-function markImplicitCreditLost(args) {
-  return withCreditLock(() => {
-    const store = loadStore();
-    const key = normalizeCreditEndpoint(args.endpoint);
-    const record = findDvmLocated(store.implicitCredits, {
-      endpoint: key,
-      ...args.identity ? { identity: args.identity } : {},
-      where: (candidate) => candidate.callerPubkey === args.callerPubkey && candidate.creditId === args.creditId
-    });
-    if (!record) return void 0;
-    const locationChanged = attachDvmLocation(record, key, args.identity);
-    if (record.status === "lost" && !archiveOrKeep(
-      () => archiveCompletedCreditRecords([completedLoss(record)])
-    )) {
-      if (locationChanged) saveStore(store);
-      return record;
-    }
-    record.status = "lost";
-    record.lossReason = args.reason;
-    record.updatedAt = args.now ?? Date.now();
-    const capped = capLostImplicitCredits(store.implicitCredits);
-    store.implicitCredits = capped.credits;
-    saveStore(store);
-    return store.implicitCredits.includes(record) ? record : void 0;
-  });
-}
-function listFundingMenuSnapshots() {
-  return withCreditLock(
-    () => [...loadStore().fundingMenuSnapshots].sort((a, b) => b.observedAt - a.observedAt)
-  );
-}
-function recordFundingMenuSnapshot(args) {
-  const menu = parseCreditMenu(args.menu);
-  if (!menu) return;
-  withCreditLock(() => {
-    const store = loadStore();
-    const key = normalizeCreditEndpoint(args.endpoint);
-    const previous = findDvmLocated(store.fundingMenuSnapshots, {
-      endpoint: key,
-      ...args.identity ? { identity: args.identity } : {},
-      where: (entry) => entry.callerPubkey === args.callerPubkey
-    });
-    const index = previous ? store.fundingMenuSnapshots.indexOf(previous) : -1;
-    const builderPubkey = args.builderPubkey ?? previous?.builderPubkey;
-    const snapshot = {
-      // The row keeps the origin it was opened at and learns the new spelling
-      // as an alias, so a caller who alternates hostnames still reads one menu.
-      endpoint: previous?.endpoint ?? key,
-      ...previous?.endpointAliases ? { endpointAliases: [...previous.endpointAliases] } : {},
-      ...previous?.dvmId ? { dvmId: previous.dvmId } : {},
-      ...previous?.attestedBuilderPubkey ? { attestedBuilderPubkey: previous.attestedBuilderPubkey } : {},
-      callerPubkey: args.callerPubkey,
-      menu,
-      observedAt: args.now ?? Date.now(),
-      ...builderPubkey ? { builderPubkey } : {}
-    };
-    attachDvmLocation(snapshot, key, args.identity);
-    if (index === -1) store.fundingMenuSnapshots.push(snapshot);
-    else store.fundingMenuSnapshots[index] = snapshot;
-    saveStore(store);
-  });
-}
-function listPendingFundings(args = {}) {
-  const endpoint = args.endpoint ? normalizeCreditEndpoint(args.endpoint) : void 0;
-  return withCreditLock(() => {
-    const store = loadStore();
-    return store.pendingFundings.filter(
-      (funding) => (!endpoint || fundingReachableAt(funding, endpoint, store.credits)) && (!args.callerPubkey || funding.callerPubkey === args.callerPubkey) && (!args.creditId || funding.creditId === args.creditId)
-    ).sort((a, b) => a.requestedAt - b.requestedAt);
-  });
-}
-function loadPendingFunding(endpoint, callerPubkey, creditId) {
-  return listPendingFundings({ endpoint, callerPubkey, ...creditId ? { creditId } : {} })[0];
-}
-function recordPendingFunding(funding) {
-  withCreditLock(() => {
-    const store = loadStore();
-    const normalized = { ...funding, endpoint: normalizeCreditEndpoint(funding.endpoint) };
-    const index = store.pendingFundings.findIndex(
-      (entry) => entry.callerPubkey === normalized.callerPubkey && entry.creditId === normalized.creditId && entry.fundId === normalized.fundId && fundingReachableAt(entry, normalized.endpoint, store.credits)
-    );
-    if (index === -1) store.pendingFundings.push(normalized);
-    else
-      store.pendingFundings[index] = {
-        ...normalized,
-        endpoint: store.pendingFundings[index].endpoint
-      };
-    saveStore(store);
-  });
-}
-function clearPendingFunding(endpoint, callerPubkey, creditId, fundId) {
-  withCreditLock(() => {
-    const store = loadStore();
-    const normalized = normalizeCreditEndpoint(endpoint);
-    const remaining = store.pendingFundings.filter(
-      (entry) => !(entry.callerPubkey === callerPubkey && entry.creditId === creditId && entry.fundId === fundId && fundingReachableAt(entry, normalized, store.credits))
-    );
-    if (remaining.length === store.pendingFundings.length) return;
-    saveStore({ ...store, pendingFundings: remaining });
-  });
-}
-function recordFundResponse(args) {
-  const now = args.now ?? Date.now();
-  return withCreditLock(() => {
-    const store = loadStore();
-    const key = normalizeCreditEndpoint(args.endpoint);
-    let record = findDvmLocated(store.credits, {
-      endpoint: key,
-      ...args.identity ? { identity: args.identity } : {},
-      where: (c) => c.callerPubkey === args.callerPubkey
-    });
-    if (!record) {
-      record = {
-        endpoint: key,
-        ...identityFields(args.identity),
-        callerPubkey: args.callerPubkey,
-        creditId: args.credit.credit_id,
-        currency: args.credit.currency,
-        balanceMicro: 0,
-        remainingMicro: 0,
-        ledgerSeq: 0,
-        expiryMs: 0,
-        targetMicro: args.targetMicro,
-        status: "active",
-        openedAt: now,
-        updatedAt: now
-      };
-      store.credits.push(record);
-    }
-    attachDvmLocation(record, key, args.identity);
-    adoptCreditId(record, args.credit.credit_id);
-    record.currency = args.credit.currency;
-    record.balanceMicro = args.credit.balance_micro;
-    record.remainingMicro = args.credit.remaining_micro;
-    record.ledgerSeq = Math.max(record.ledgerSeq, args.credit.ledger_seq);
-    record.expiryMs = args.credit.expiry_ms;
-    record.targetMicro = args.targetMicro;
-    record.status = args.credit.status === "unbacked" ? "unbacked" : args.credit.expired ? "expired" : "active";
-    record.reconciliationPending = args.credit.reconciliation_pending;
-    record.updatedAt = now;
-    delete record.provisional;
-    if (args.sequenced === false) record.unsequencedBalance = true;
-    else delete record.unsequencedBalance;
-    if (args.menu) record.menu = args.menu;
-    if (args.rail) {
-      record.rail = args.rail;
-      delete record.refillUnavailableRail;
-    }
-    if (args.x402Instrument) record.x402Instrument = args.x402Instrument;
-    if (args.x402ChannelNetwork) record.x402ChannelNetwork = args.x402ChannelNetwork;
-    if (args.builderPubkey) record.builderPubkey = args.builderPubkey;
-    if (args.select) delete record.selectionCleared;
-    delete record.discrepancy;
-    saveStore(store);
-    return record;
-  });
-}
-function recordBalanceResponse(args) {
-  const now = args.now ?? Date.now();
-  return withCreditLock(() => {
-    const existing = loadCredit(args.endpoint, args.callerPubkey, args.identity);
-    const prepaidCredits = args.credits.filter((credit) => !credit.credit_id.startsWith("imp:"));
-    const selectedPrimary = args.primary && !args.primary.credit_id.startsWith("imp:") ? args.primary : void 0;
-    const primary = selectedPrimary ?? prepaidCredits.find((credit) => credit.credit_id === existing?.creditId);
-    if (!primary) {
-      if (existing) {
-        mutateCredit(
-          {
-            endpoint: args.endpoint,
-            callerPubkey: args.callerPubkey,
-            ...args.identity ? { identity: args.identity } : {}
-          },
-          (record2) => {
-            record2.siblingCredits = [];
-            return void 0;
-          }
-        );
-      }
-      return existing;
-    }
-    const record = recordFundResponse({
-      endpoint: args.endpoint,
-      ...args.identity ? { identity: args.identity } : {},
-      callerPubkey: args.callerPubkey,
-      credit: primary,
-      targetMicro: args.targetMicro ?? existing?.targetMicro ?? primary.remaining_micro,
-      ...args.menu ? { menu: args.menu } : {},
-      ...args.builderPubkey ? { builderPubkey: args.builderPubkey } : {},
-      ...args.selectPrimary ? { select: true } : {},
-      ...args.sequenced === false ? { sequenced: false } : {},
-      now
-    });
-    mutateCredit(
-      {
-        endpoint: args.endpoint,
-        callerPubkey: args.callerPubkey,
-        ...args.identity ? { identity: args.identity } : {}
-      },
-      (current) => {
-        current.siblingCredits = prepaidCredits.filter((credit) => credit.credit_id !== current.creditId).map((credit) => siblingFromWire(credit, now));
-        return void 0;
-      }
-    );
-    return loadCredit(args.endpoint, args.callerPubkey, args.identity) ?? record;
-  });
-}
-function applyReceiptCredit(args) {
-  const now = args.now ?? Date.now();
-  return withCreditLock(() => {
-    const store = loadStore();
-    const key = normalizeCreditEndpoint(args.endpoint);
-    const record = findDvmLocated(store.credits, {
-      endpoint: key,
-      ...args.identity ? { identity: args.identity } : {},
-      where: (c) => c.callerPubkey === args.callerPubkey && c.creditId === args.credit.credit_id
-    });
-    if (!record) return {};
-    attachDvmLocation(record, key, args.identity);
-    let mismatch;
-    const sequential = args.credit.ledger_seq === record.ledgerSeq + 1;
-    if (sequential && args.outcome === "completed" && record.status === "active" && !record.provisional && !record.unsequencedBalance) {
-      const expected = record.remainingMicro - args.credit.amount;
-      if (args.credit.balance_after !== expected) {
-        mismatch = {
-          atMs: now,
-          expectedMicro: expected,
-          reportedMicro: args.credit.balance_after,
-          drawId: args.credit.draw_id,
-          ledgerSeq: args.credit.ledger_seq,
-          ...record.lastReceiptJobId ? { priorJobId: record.lastReceiptJobId } : {},
-          jobId: args.jobId
-        };
-        record.discrepancy = mismatch;
-      }
-    }
-    if (args.credit.ledger_seq >= record.ledgerSeq) {
-      record.remainingMicro = args.credit.balance_after;
-      record.ledgerSeq = args.credit.ledger_seq;
-      delete record.unsequencedBalance;
-    }
-    delete record.provisional;
-    if (args.outcome === "completed") record.lastPriceMicro = args.credit.amount;
-    if (!mismatch && record.discrepancy && args.credit.ledger_seq > record.discrepancy.ledgerSeq) {
-      delete record.discrepancy;
-    }
-    record.lastReceiptJobId = args.jobId;
-    record.updatedAt = now;
-    saveStore(store);
-    return { credit: record, ...mismatch ? { mismatch } : {} };
-  });
-}
-function applyImplicitReceiptCredit(args) {
-  if (!args.credit.credit_id.startsWith("imp:")) return {};
-  const now = args.now ?? Date.now();
-  return withCreditLock(() => {
-    const store = loadStore();
-    const key = normalizeCreditEndpoint(args.endpoint);
-    let record = findDvmLocated(store.implicitCredits, {
-      endpoint: key,
-      ...args.identity ? { identity: args.identity } : {},
-      where: (candidate) => candidate.callerPubkey === args.callerPubkey && candidate.creditId === args.credit.credit_id
-    });
-    if (!record && (args.outcome === "completed" || args.credit.balance_after <= 0)) return {};
-    if (!record) {
-      record = {
-        endpoint: key,
-        ...identityFields(args.identity),
-        callerPubkey: args.callerPubkey,
-        creditId: args.credit.credit_id,
-        currency: args.currency,
-        remainingMicro: args.credit.balance_after,
-        ledgerSeq: args.credit.ledger_seq,
-        expiryMs: args.issuedAtMs + IMPLICIT_CREDIT_TTL_MS,
-        status: args.issuedAtMs + IMPLICIT_CREDIT_TTL_MS <= now ? "lost" : "active",
-        releasedByJobId: args.jobId,
-        releasedAt: args.issuedAtMs,
-        updatedAt: now,
-        lastReceiptJobId: args.jobId
-      };
-      store.implicitCredits.push(record);
-      const capped2 = capLostImplicitCredits(store.implicitCredits);
-      store.implicitCredits = capped2.credits;
-      saveStore(store);
-      return store.implicitCredits.includes(record) ? { credit: record } : {};
-    }
-    const locationChanged = attachDvmLocation(record, key, args.identity);
-    if (record.status === "lost" && !archiveOrKeep(
-      () => archiveCompletedCreditRecords([completedLoss(record)])
-    )) {
-      if (locationChanged) saveStore(store);
-      return { credit: record };
-    }
-    let mismatch;
-    const sequential = args.credit.ledger_seq === record.ledgerSeq + 1;
-    if (sequential && args.outcome === "completed" && record.status === "active") {
-      const expected = record.remainingMicro - args.credit.amount;
-      if (args.credit.balance_after !== expected) {
-        mismatch = {
-          atMs: now,
-          expectedMicro: expected,
-          reportedMicro: args.credit.balance_after,
-          drawId: args.credit.draw_id,
-          ledgerSeq: args.credit.ledger_seq,
-          ...record.lastReceiptJobId ? { priorJobId: record.lastReceiptJobId } : {},
-          jobId: args.jobId
-        };
-        record.discrepancy = mismatch;
-      }
-    }
-    if (args.credit.ledger_seq >= record.ledgerSeq) {
-      record.remainingMicro = args.credit.balance_after;
-      record.ledgerSeq = args.credit.ledger_seq;
-    }
-    if (!mismatch && record.discrepancy && args.credit.ledger_seq > record.discrepancy.ledgerSeq) {
-      delete record.discrepancy;
-    }
-    record.currency = args.currency;
-    record.lastReceiptJobId = args.jobId;
-    record.updatedAt = now;
-    if (record.remainingMicro <= 0) {
-      store.implicitCredits = store.implicitCredits.filter((candidate) => candidate !== record);
-      saveStore(store);
-      return { ...mismatch ? { mismatch } : {}, pruned: true };
-    }
-    if (record.expiryMs <= now) record.status = "lost";
-    const capped = capLostImplicitCredits(store.implicitCredits);
-    store.implicitCredits = capped.credits;
-    saveStore(store);
-    return {
-      ...store.implicitCredits.includes(record) ? { credit: record } : {},
-      ...mismatch ? { mismatch } : {}
-    };
-  });
-}
-function ensureProvisionalCredit(args) {
-  const now = args.now ?? Date.now();
-  withCreditLock(() => {
-    const store = loadStore();
-    const key = normalizeCreditEndpoint(args.endpoint);
-    let record = findDvmLocated(store.credits, {
-      endpoint: key,
-      ...args.identity ? { identity: args.identity } : {},
-      where: (c) => c.callerPubkey === args.callerPubkey
-    });
-    if (!record) {
-      record = {
-        endpoint: key,
-        ...identityFields(args.identity),
-        callerPubkey: args.callerPubkey,
-        creditId: args.creditId,
-        currency: args.currency,
-        balanceMicro: 0,
-        remainingMicro: 0,
-        ledgerSeq: 0,
-        expiryMs: 0,
-        targetMicro: args.targetMicro,
-        status: "active",
-        openedAt: now,
-        updatedAt: now
-      };
-      store.credits.push(record);
-    }
-    attachDvmLocation(record, key, args.identity);
-    adoptCreditId(record, args.creditId);
-    record.currency = args.currency;
-    record.targetMicro = args.targetMicro;
-    record.status = "active";
-    record.provisional = true;
-    record.updatedAt = now;
-    if (args.menu) record.menu = args.menu;
-    saveStore(store);
-  });
-}
-function markCredit(endpoint, callerPubkey, status, opts = {}) {
-  mutateCredit(
-    { endpoint, callerPubkey, ...opts.identity ? { identity: opts.identity } : {} },
-    (record) => {
-      if (opts.ifCreditId !== void 0 && record.creditId !== opts.ifCreditId) return "skip";
-      record.status = status;
-      if (status !== "active") {
-        delete record.refillUnavailableRail;
-        delete record.refillDrainNoticed;
-      }
-      if (status === "drained") record.remainingMicro = 0;
-      return void 0;
-    }
-  );
-}
-function loadCreditX402Binding(endpoint, callerPubkey, creditId, identity) {
-  const record = loadCredit(endpoint, callerPubkey, identity);
-  if (record?.creditId !== creditId) return {};
-  if (record.status !== "active" && record.status !== "expired") return {};
-  return {
-    ...record.x402Instrument ? { instrument: record.x402Instrument } : {},
-    ...record.x402ChannelNetwork ? { channelNetwork: record.x402ChannelNetwork } : {}
-  };
-}
-function recordCreditX402Instrument(endpoint, callerPubkey, creditId, instrument, identity, channelNetwork) {
-  mutateCredit(mutationAt(endpoint, callerPubkey, identity), (record) => {
-    if (record.creditId !== creditId) return "skip";
-    const instrumentChanged = record.x402Instrument !== instrument;
-    const channelNetworkChanged = instrument === "x402_channel" && channelNetwork !== void 0 && record.x402ChannelNetwork !== channelNetwork;
-    if (!instrumentChanged && !channelNetworkChanged) return "skip";
-    if (instrumentChanged) {
-      record.x402Instrument = instrument;
-      delete record.x402ChannelNetwork;
-    }
-    if (instrument === "x402_channel" && channelNetwork !== void 0) {
-      record.x402ChannelNetwork = channelNetwork;
-    }
-    return void 0;
-  });
-}
-function recordRefusedDrawBalance(args) {
-  const remaining = safeMicro(args.remainingMicro);
-  if (remaining === void 0) return;
-  const balance = safeMicro(args.balanceMicro);
-  mutateCredit(mutationAt(args.endpoint, args.callerPubkey, args.identity), (record) => {
-    if (record.creditId !== args.creditId) return "skip";
-    const unchanged = record.remainingMicro === remaining && (balance === void 0 || record.balanceMicro === balance) && record.unsequencedBalance === true && !record.provisional;
-    if (unchanged) return "skip";
-    record.remainingMicro = remaining;
-    if (balance !== void 0) record.balanceMicro = balance;
-    record.unsequencedBalance = true;
-    delete record.provisional;
-    return void 0;
-  });
-}
-function markRefillRailUnavailable(endpoint, callerPubkey, creditId, rail, identity) {
-  let firstObservation = false;
-  mutateCredit(mutationAt(endpoint, callerPubkey, identity), (record) => {
-    if (record.creditId !== creditId) return "skip";
-    if (record.refillUnavailableRail === rail) return "skip";
-    record.refillUnavailableRail = rail;
-    firstObservation = true;
-    return void 0;
-  });
-  return firstObservation;
-}
-function markRefillDrainNoticed(endpoint, callerPubkey, creditId, drainId, identity) {
-  let firstObservation = false;
-  mutateCredit(mutationAt(endpoint, callerPubkey, identity), (record) => {
-    if (record.creditId !== creditId) return "skip";
-    if (record.refillDrainNoticed === drainId) return "skip";
-    record.refillDrainNoticed = drainId;
-    firstObservation = true;
-    return void 0;
-  });
-  return firstObservation;
-}
-function clearRefillRailUnavailable(endpoint, callerPubkey, creditId, identity) {
-  mutateCredit(mutationAt(endpoint, callerPubkey, identity), (record) => {
-    if (record.creditId !== creditId) return "skip";
-    if (record.refillUnavailableRail === void 0) return "skip";
-    delete record.refillUnavailableRail;
-    return void 0;
-  });
-}
-function forgetCredit(endpoint, callerPubkey, identity) {
-  withCreditLock(() => {
-    const store = loadStore();
-    const key = normalizeCreditEndpoint(endpoint);
-    const record = findDvmLocated(store.credits, {
-      endpoint: key,
-      ...identity ? { identity } : {},
-      where: (c) => c.callerPubkey === callerPubkey
-    });
-    if (!record) return;
-    archiveCompletedCreditRecords(
-      (record.drainEvidence ?? []).filter((bundle) => bundle.settledAt !== void 0).map((bundle) => completedRefund(record, bundle))
-    );
-    saveStore({ ...store, credits: store.credits.filter((c) => c !== record) });
-  });
-}
-function recordPendingDrain(endpoint, callerPubkey, drain, identity) {
-  mutateCredit(mutationAt(endpoint, callerPubkey, identity), (record) => {
-    const drains = record.pendingDrains ?? [];
-    const index = drains.findIndex(
-      (d) => d.drainId === drain.drainId && d.creditId === drain.creditId
-    );
-    if (index === -1) drains.push(drain);
-    else drains[index] = drain;
-    record.pendingDrains = drains;
-    return void 0;
-  });
-}
-function clearPendingDrain(endpoint, callerPubkey, drain, identity) {
-  mutateCredit(mutationAt(endpoint, callerPubkey, identity), (record) => {
-    const before = record.pendingDrains ?? [];
-    const remaining = before.filter(
-      (d) => !(d.drainId === drain.drainId && d.creditId === drain.creditId)
-    );
-    if (remaining.length === before.length) return "skip";
-    if (remaining.length === 0) delete record.pendingDrains;
-    else record.pendingDrains = remaining;
-    return void 0;
-  });
-}
-function recordDrainReceipts(args) {
-  const {
-    endpoint,
-    identity,
-    callerPubkey,
-    drainId,
-    creditId,
-    receipts,
-    read,
-    now = Date.now()
-  } = args;
-  if (receipts.length === 0) return;
-  mutateCredit(mutationAt(endpoint, callerPubkey, identity), (record) => {
-    const evidence = record.drainEvidence ??= [];
-    let bundle = evidence.find((e) => e.drainId === drainId);
-    if (bundle?.settledAt !== void 0 && !archiveOrKeep(
-      () => archiveCompletedCreditRecords([completedRefund(record, bundle)])
-    )) {
-      return "skip";
-    }
-    if (!bundle) {
-      bundle = { drainId, creditId, receipts: [], collectedAt: now };
-      evidence.push(bundle);
-    }
-    bundle.creditId = creditId;
-    bundle.receipts = receipts;
-    bundle.collectedAt = now;
-    bundle.settlement ??= {
-      rail: null,
-      currency: record.creditId === creditId ? record.currency : null,
-      amountMicro: null,
-      feeMicro: null
-    };
-    if (read.anchor) bundle.anchor = read.anchor;
-    else if (read.reachable) delete bundle.anchor;
-    record.drainEvidence = evidence;
-    return void 0;
-  });
-}
-function settleDrainEvidence(args) {
-  const { endpoint, identity, callerPubkey, drainId, now = Date.now() } = args;
-  mutateCredit(mutationAt(endpoint, callerPubkey, identity), (record) => {
-    const evidence = record.drainEvidence ?? [];
-    const bundle = evidence.find((e) => e.drainId === drainId);
-    if (!bundle || bundle.settledAt !== void 0) return "skip";
-    bundle.settledAt = now;
-    if (args.settlement) bundle.settlement = args.settlement;
-    record.drainEvidence = evidence;
-    return void 0;
-  });
-}
-function identityFields(identity) {
-  if (!identity) return {};
-  return { dvmId: identity.dvmId, attestedBuilderPubkey: identity.builderPubkey };
-}
-function mutationAt(endpoint, callerPubkey, identity) {
-  return { endpoint, callerPubkey, ...identity ? { identity } : {} };
-}
-function matchesDvmIdentity(record, identity) {
-  const stored = dvmLocationIdentity(record);
-  return stored?.dvmId === identity.dvmId && stored.builderPubkey === identity.builderPubkey;
-}
-function matchesDvmOrigin(record, endpoint, identity) {
-  if (identity) {
-    if (dvmLocationIdentity(record) !== void 0) return false;
-    if (record.dvmId !== void 0 && record.dvmId !== identity.dvmId) return false;
-  }
-  return dvmLocationOrigins(record).includes(endpoint);
-}
-function adoptCreditId(record, creditId) {
-  if (record.creditId === creditId) return;
-  if (record.status === "active" || record.status === "expired" || record.status === "unbacked") {
-    const prior = {
-      creditId: record.creditId,
-      status: record.status === "unbacked" ? "unbacked" : "active",
-      currency: record.currency,
-      balanceMicro: record.balanceMicro,
-      remainingMicro: record.remainingMicro,
-      ledgerSeq: record.ledgerSeq,
-      expiryMs: record.expiryMs,
-      expired: record.status === "expired",
-      drainable: record.status !== "unbacked" && record.balanceMicro > 0,
-      ...record.reconciliationPending ? { reconciliationPending: true } : {},
-      observedAt: record.updatedAt
-    };
-    record.siblingCredits = [
-      ...(record.siblingCredits ?? []).filter(
-        (sibling) => sibling.creditId !== prior.creditId && sibling.creditId !== creditId
-      ),
-      prior
-    ];
-  } else if (record.siblingCredits) {
-    record.siblingCredits = record.siblingCredits.filter(
-      (sibling) => sibling.creditId !== creditId
-    );
-  }
-  record.creditId = creditId;
-  record.ledgerSeq = 0;
-  record.balanceMicro = 0;
-  record.remainingMicro = 0;
-  record.expiryMs = 0;
-  delete record.unsequencedBalance;
-  delete record.rail;
-  delete record.x402Instrument;
-  delete record.x402ChannelNetwork;
-  delete record.refillUnavailableRail;
-  delete record.refillDrainNoticed;
-  delete record.discrepancy;
-  delete record.lastReceiptJobId;
-}
-var MAX_SETTLED_DRAIN_EVIDENCE = 8;
-var MAX_LOST_IMPLICIT_CREDITS = 8;
-var MAX_DATE_MS = 864e13;
-function loadStore(requireArchive = false) {
-  if (!existsSync(CREDITS_FILE)) {
-    return { credits: [], implicitCredits: [], pendingFundings: [], fundingMenuSnapshots: [] };
-  }
-  let raw;
-  try {
-    raw = readFileSync2(CREDITS_FILE, "utf-8");
-  } catch (cause) {
-    throw unreadableStore(cause);
-  }
-  let data;
-  try {
-    const parsed = JSON.parse(raw);
-    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      throw new Error("the file parsed as JSON but is not a credit-store object");
-    }
-    data = parsed;
-  } catch (cause) {
-    throw quarantineCorruptStore(cause);
-  }
-  const merged = mergeDuplicateCredits(
-    Array.isArray(data.credits) ? data.credits.filter((record) => isObjectRecord(record)).map(
-      (record) => normalizeRailKey(normalizeEvidence(normalizeDrains(normalizeSiblingCredits(record))))
-    ) : []
-  );
-  const snapshots = mergeDuplicateSnapshots(
-    Array.isArray(data.fundingMenuSnapshots) ? data.fundingMenuSnapshots.filter(isFundingMenuSnapshot) : [],
-    merged.credits
-  );
-  const fundings = dedupePendingFundings(
-    Array.isArray(data.pendingFundings) ? data.pendingFundings.filter((funding) => isObjectRecord(funding)).map(normalizeRailKey) : []
-  );
-  const implicit = dedupeImplicitCredits(
-    Array.isArray(data.implicitCredits) ? data.implicitCredits.filter(isStoredImplicitCredit) : [],
-    requireArchive
-  );
-  const store = {
-    credits: merged.credits,
-    implicitCredits: implicit.credits,
-    pendingFundings: fundings.fundings,
-    fundingMenuSnapshots: snapshots.snapshots
-  };
-  if (requireArchive) archiveStore(store);
-  if (merged.changed || snapshots.changed || fundings.changed || implicit.changed) saveStore(store);
-  else if (!requireArchive) archiveOrKeep(() => archiveStore(store));
-  return store;
-}
-function isStoredImplicitCredit(value) {
-  if (!isObjectRecord(value)) return false;
-  return typeof value.endpoint === "string" && typeof value.callerPubkey === "string" && typeof value.creditId === "string" && value.creditId.startsWith("imp:") && typeof value.currency === "string" && typeof value.remainingMicro === "number" && Number.isFinite(value.remainingMicro) && typeof value.ledgerSeq === "number" && Number.isInteger(value.ledgerSeq) && typeof value.expiryMs === "number" && Number.isFinite(value.expiryMs) && (value.status === "active" || value.status === "lost") && typeof value.releasedByJobId === "string" && typeof value.releasedAt === "number" && Number.isFinite(value.releasedAt) && typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt);
-}
-function dedupeImplicitCredits(credits, requireArchive = false) {
-  const merged = [];
-  let changed = false;
-  for (const candidate of credits) {
-    candidate.endpoint = normalizeCreditEndpoint(candidate.endpoint);
-    const identity = dvmLocationIdentity(candidate);
-    const existing = findDvmLocated(merged, {
-      endpoint: candidate.endpoint,
-      ...identity ? { identity } : {},
-      where: (record) => record.callerPubkey === candidate.callerPubkey && record.creditId === candidate.creditId
-    });
-    if (!existing) {
-      merged.push(candidate);
-      continue;
-    }
-    if (!archiveOrKeep(() => archiveCompletedCreditRecords(
-      [existing, candidate].filter((record) => record.status === "lost").map(completedLoss)
-    ), requireArchive)) return { credits, changed: false };
-    changed = true;
-    for (const origin of dvmLocationOrigins(candidate)) {
-      attachDvmLocation(existing, origin, identity);
-    }
-    if (candidate.ledgerSeq > existing.ledgerSeq || candidate.ledgerSeq === existing.ledgerSeq && candidate.updatedAt > existing.updatedAt) {
-      existing.currency = candidate.currency;
-      existing.remainingMicro = candidate.remainingMicro;
-      existing.ledgerSeq = candidate.ledgerSeq;
-      existing.status = candidate.status;
-      if (candidate.lossReason) existing.lossReason = candidate.lossReason;
-      else delete existing.lossReason;
-      existing.updatedAt = candidate.updatedAt;
-      existing.lastReceiptJobId = candidate.lastReceiptJobId;
-      existing.discrepancy = candidate.discrepancy;
-    }
-    existing.expiryMs = Math.min(existing.expiryMs, candidate.expiryMs);
-    if (candidate.releasedAt < existing.releasedAt) {
-      existing.releasedAt = candidate.releasedAt;
-      existing.releasedByJobId = candidate.releasedByJobId;
-    }
-  }
-  const capped = capLostImplicitCredits(merged, requireArchive);
-  return { credits: capped.credits, changed: changed || capped.changed };
-}
-function ageImplicitCredits(credits, now) {
-  let changed = false;
-  for (const credit of credits) {
-    if (credit.status === "active" && credit.expiryMs <= now) {
-      credit.status = "lost";
-      credit.lossReason = "expired";
-      credit.updatedAt = now;
-      changed = true;
-    }
-  }
-  return changed;
-}
-function capLostImplicitCredits(credits, requireArchive = false) {
-  const archived = archiveOrKeep(
-    () => archiveCompletedCreditRecords(
-      credits.filter((credit) => credit.status === "lost").map(completedLoss)
-    ),
-    requireArchive
-  );
-  if (!archived) return { credits, changed: false };
-  const lostByOwner = /* @__PURE__ */ new Map();
-  for (const credit of credits) {
-    if (credit.status !== "lost") continue;
-    const identity = dvmLocationIdentity(credit);
-    const dvmKey = identity ? `${identity.dvmId}\0${identity.builderPubkey}` : normalizeCreditEndpoint(credit.endpoint);
-    const key = `${credit.callerPubkey}\0${dvmKey}`;
-    const group = lostByOwner.get(key) ?? [];
-    group.push(credit);
-    lostByOwner.set(key, group);
-  }
-  const dropped = /* @__PURE__ */ new Set();
-  for (const group of lostByOwner.values()) {
-    group.sort((a, b) => b.updatedAt - a.updatedAt);
-    for (const credit of group.slice(MAX_LOST_IMPLICIT_CREDITS)) dropped.add(credit);
-  }
-  return dropped.size === 0 ? { credits, changed: false } : { credits: credits.filter((credit) => !dropped.has(credit)), changed: true };
-}
-function compareImplicitCredits(a, b) {
-  if (a.status !== b.status) return a.status === "active" ? -1 : 1;
-  return a.status === "active" ? a.expiryMs - b.expiryMs : b.updatedAt - a.updatedAt;
-}
-function mergeDuplicateSnapshots(snapshots, credits) {
-  const identities = originIdentityMap(credits);
-  const merged = [];
-  const byIdentity = /* @__PURE__ */ new Map();
-  let changed = false;
-  for (const snapshot of snapshots) {
-    const stamped = identities.get(`${snapshot.callerPubkey}\0${snapshot.endpoint}`);
-    if (stamped !== void 0 && snapshot.dvmId === void 0) {
-      snapshot.dvmId = stamped.dvmId;
-      if (stamped.attestedBuilderPubkey !== void 0) {
-        snapshot.attestedBuilderPubkey = stamped.attestedBuilderPubkey;
-      }
-      changed = true;
-    }
-    if (snapshot.dvmId === void 0) {
-      merged.push(snapshot);
-      continue;
-    }
-    const key = `${snapshot.callerPubkey}\0${snapshot.dvmId}\0${snapshot.attestedBuilderPubkey ?? ""}`;
-    const index = byIdentity.get(key);
-    if (index === void 0) {
-      byIdentity.set(key, merged.length);
-      merged.push(snapshot);
-      continue;
-    }
-    merged[index] = mergeSnapshots(merged[index], snapshot);
-    changed = true;
-  }
-  return { snapshots: merged, changed };
-}
-function mergeSnapshots(left, right) {
-  const leftSeen = Number.isFinite(left.observedAt) ? left.observedAt : 0;
-  const rightSeen = Number.isFinite(right.observedAt) ? right.observedAt : 0;
-  const [newer, older] = rightSeen >= leftSeen ? [right, left] : [left, right];
-  const snapshot = { ...newer };
-  if (snapshot.builderPubkey === void 0 && older.builderPubkey !== void 0) {
-    snapshot.builderPubkey = older.builderPubkey;
-  }
-  const origins = dvmLocationOrigins(newer).concat(dvmLocationOrigins(older));
-  const aliases = [...new Set(origins)].filter((origin) => origin !== snapshot.endpoint);
-  if (aliases.length > 0) snapshot.endpointAliases = aliases;
-  else delete snapshot.endpointAliases;
-  return snapshot;
-}
-function originIdentityMap(credits) {
-  const identities = /* @__PURE__ */ new Map();
-  const ambiguous = /* @__PURE__ */ new Set();
-  for (const record of credits) {
-    if (typeof record.dvmId !== "string" || typeof record.callerPubkey !== "string") continue;
-    const identity = {
-      dvmId: record.dvmId,
-      ...record.attestedBuilderPubkey !== void 0 ? { attestedBuilderPubkey: record.attestedBuilderPubkey } : {}
-    };
-    for (const origin of dvmLocationOrigins(record)) {
-      const key = `${record.callerPubkey}\0${origin}`;
-      const seen = identities.get(key);
-      if (seen !== void 0 && (seen.dvmId !== identity.dvmId || seen.attestedBuilderPubkey !== identity.attestedBuilderPubkey)) {
-        ambiguous.add(key);
-        continue;
-      }
-      identities.set(key, identity);
-    }
-  }
-  for (const key of ambiguous) identities.delete(key);
-  return identities;
-}
-function dedupePendingFundings(fundings) {
-  const kept = [];
-  const byIntent = /* @__PURE__ */ new Map();
-  let changed = false;
-  for (const funding of fundings) {
-    if (typeof funding.callerPubkey !== "string" || typeof funding.creditId !== "string" || typeof funding.fundId !== "string") {
-      kept.push(funding);
-      continue;
-    }
-    const key = `${funding.callerPubkey}\0${funding.creditId}\0${funding.fundId}`;
-    const index = byIntent.get(key);
-    if (index === void 0) {
-      byIntent.set(key, kept.length);
-      kept.push(funding);
-      continue;
-    }
-    const seen = kept[index];
-    const seenAt = Number.isFinite(seen.requestedAt) ? seen.requestedAt : 0;
-    const at = Number.isFinite(funding.requestedAt) ? funding.requestedAt : 0;
-    if (at > seenAt) kept[index] = funding;
-    changed = true;
-  }
-  return { fundings: kept, changed };
-}
-function isObjectRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function mergeDuplicateCredits(credits) {
-  const merged = [];
-  const byCredit = /* @__PURE__ */ new Map();
-  let changed = false;
-  for (const record of credits) {
-    if (typeof record.creditId !== "string" || typeof record.callerPubkey !== "string") {
-      merged.push(record);
-      continue;
-    }
-    const key = `${record.callerPubkey}\0${record.creditId}`;
-    const index = byCredit.get(key);
-    if (index === void 0) {
-      byCredit.set(key, merged.length);
-      merged.push(record);
-      continue;
-    }
-    merged[index] = mergeCreditRecords(merged[index], record);
-    changed = true;
-  }
-  return { credits: merged, changed };
-}
-function mergeCreditRecords(left, right) {
-  const leftUpdated = Number.isFinite(left.updatedAt) ? left.updatedAt : 0;
-  const rightUpdated = Number.isFinite(right.updatedAt) ? right.updatedAt : 0;
-  const [newer, older] = rightUpdated >= leftUpdated ? [right, left] : [left, right];
-  const record = { ...newer };
-  if (record.dvmId === void 0 && older.dvmId !== void 0) record.dvmId = older.dvmId;
-  if (record.attestedBuilderPubkey === void 0 && older.attestedBuilderPubkey !== void 0 && record.dvmId === older.dvmId) {
-    record.attestedBuilderPubkey = older.attestedBuilderPubkey;
-  }
-  if (record.rail === void 0 && older.rail !== void 0) record.rail = older.rail;
-  if (record.x402Instrument === void 0 && older.x402Instrument !== void 0) {
-    record.x402Instrument = older.x402Instrument;
-  }
-  if (record.x402ChannelNetwork === void 0 && older.x402ChannelNetwork !== void 0) {
-    record.x402ChannelNetwork = older.x402ChannelNetwork;
-  }
-  if (record.menu === void 0 && older.menu !== void 0) record.menu = older.menu;
-  if (record.builderPubkey === void 0 && older.builderPubkey !== void 0) {
-    record.builderPubkey = older.builderPubkey;
-  }
-  const endpoints = dvmLocationOrigins(newer).concat(dvmLocationOrigins(older));
-  const aliases = [...new Set(endpoints)].filter((endpoint) => endpoint !== record.endpoint);
-  if (aliases.length > 0) record.endpointAliases = aliases;
-  else delete record.endpointAliases;
-  const pendingDrains = unionPendingDrains(newer.pendingDrains, older.pendingDrains);
-  if (pendingDrains.length > 0) record.pendingDrains = pendingDrains;
-  else delete record.pendingDrains;
-  const drainEvidence = unionDrainEvidence(newer.drainEvidence, older.drainEvidence);
-  if (drainEvidence.length > 0) record.drainEvidence = drainEvidence;
-  else delete record.drainEvidence;
-  const siblings = Array.isArray(newer.siblingCredits) ? newer.siblingCredits : older.siblingCredits;
-  if (siblings) {
-    record.siblingCredits = siblings.filter((sibling) => sibling.creditId !== record.creditId);
-  } else {
-    delete record.siblingCredits;
-  }
-  return record;
-}
-function unionPendingDrains(preferred, fallback) {
-  const byDrain = /* @__PURE__ */ new Map();
-  for (const drain of [...fallback ?? [], ...preferred ?? []]) {
-    const key = `${drain.drainId}\0${drain.creditId ?? ""}`;
-    byDrain.set(key, { ...byDrain.get(key) ?? {}, ...drain });
-  }
-  return [...byDrain.values()];
-}
-function unionDrainEvidence(preferred, fallback) {
-  const byDrain = /* @__PURE__ */ new Map();
-  for (const evidence of [...fallback ?? [], ...preferred ?? []]) {
-    const key = `${evidence.drainId}\0${evidence.creditId}`;
-    const existing = byDrain.get(key);
-    if (!existing) {
-      byDrain.set(key, evidence);
-      continue;
-    }
-    const [newer, older] = evidence.collectedAt >= existing.collectedAt ? [evidence, existing] : [existing, evidence];
-    const receipts = unionUnknown(newer.receipts, older.receipts);
-    byDrain.set(key, {
-      ...older,
-      ...newer,
-      receipts,
-      collectedAt: Math.max(existing.collectedAt, evidence.collectedAt),
-      ...existing.settledAt !== void 0 || evidence.settledAt !== void 0 ? { settledAt: Math.max(existing.settledAt ?? 0, evidence.settledAt ?? 0) } : {}
-    });
-  }
-  return [...byDrain.values()];
-}
-function unionUnknown(preferred, fallback) {
-  const seen = /* @__PURE__ */ new Set();
-  const values = [];
-  for (const value of [...preferred, ...fallback]) {
-    let key;
-    try {
-      const serialized = JSON.stringify(value);
-      key = typeof serialized === "string" ? serialized : String(value);
-    } catch {
-      key = String(value);
-    }
-    if (seen.has(key)) continue;
-    seen.add(key);
-    values.push(value);
-  }
-  return values;
-}
-function isFundingMenuSnapshot(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const snapshot = value;
-  return typeof snapshot.endpoint === "string" && typeof snapshot.callerPubkey === "string" && typeof snapshot.observedAt === "number" && Number.isFinite(snapshot.observedAt) && Math.abs(snapshot.observedAt) <= MAX_DATE_MS && parseCreditMenu(snapshot.menu) !== void 0 && (snapshot.builderPubkey === void 0 || typeof snapshot.builderPubkey === "string");
-}
-function siblingFromWire(credit, observedAt) {
-  return {
-    creditId: credit.credit_id,
-    status: credit.status ?? "active",
-    currency: credit.currency,
-    balanceMicro: credit.balance_micro,
-    remainingMicro: credit.remaining_micro,
-    ledgerSeq: credit.ledger_seq,
-    expiryMs: credit.expiry_ms,
-    expired: credit.expired,
-    drainable: credit.drainable,
-    ...credit.reconciliation_pending ? { reconciliationPending: true } : {},
-    observedAt
-  };
-}
-function normalizeRailKey(record) {
-  const loose = record;
-  if (loose.rail === LEGACY_TEMPO_RAIL_KEY) loose.rail = "tempo";
-  if (loose.refillUnavailableRail === LEGACY_TEMPO_RAIL_KEY) loose.refillUnavailableRail = "tempo";
-  if (Array.isArray(loose.pendingDrains)) {
-    for (const drain of loose.pendingDrains) {
-      if (drain?.method === LEGACY_TEMPO_RAIL_KEY) drain.method = "tempo";
-    }
-  }
-  return record;
-}
-var LEGACY_TEMPO_RAIL_KEY = "mpp";
-function normalizeSiblingCredits(record) {
-  if (!Array.isArray(record.siblingCredits)) {
-    delete record.siblingCredits;
-    return record;
-  }
-  record.siblingCredits = record.siblingCredits.filter(
-    (sibling) => isSiblingCredit(sibling) && sibling.creditId !== record.creditId
-  );
-  return record;
-}
-function isSiblingCredit(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const sibling = value;
-  const status = value.status;
-  return typeof sibling.creditId === "string" && typeof sibling.currency === "string" && Number.isSafeInteger(sibling.balanceMicro) && Number.isSafeInteger(sibling.remainingMicro) && Number.isSafeInteger(sibling.ledgerSeq) && Number.isFinite(sibling.expiryMs) && Math.abs(sibling.expiryMs) <= MAX_DATE_MS && typeof sibling.expired === "boolean" && typeof sibling.drainable === "boolean" && (status === void 0 || status === "active" || status === "unbacked") && (sibling.reconciliationPending === void 0 || typeof sibling.reconciliationPending === "boolean") && Number.isFinite(sibling.observedAt) && Math.abs(sibling.observedAt) <= MAX_DATE_MS;
-}
-function normalizeDrains(record) {
-  const legacy = record;
-  const drains = (Array.isArray(record.pendingDrains) ? record.pendingDrains : []).filter(
-    isDrainish
-  );
-  if (isDrainish(legacy.pendingDrain)) drains.unshift(legacy.pendingDrain);
-  delete legacy.pendingDrain;
-  if (drains.length === 0) delete record.pendingDrains;
-  else record.pendingDrains = drains;
-  return record;
-}
-function normalizeEvidence(record) {
-  if (!Array.isArray(record.drainEvidence)) {
-    delete record.drainEvidence;
-    return record;
-  }
-  const evidence = record.drainEvidence.filter(isEvidenceish).map((e) => {
-    const bundle = {
-      ...e,
-      creditId: typeof e.creditId === "string" ? e.creditId : "",
-      collectedAt: Number.isFinite(e.collectedAt) ? e.collectedAt : 0
-    };
-    if (!Number.isFinite(bundle.settledAt)) delete bundle.settledAt;
-    return bundle;
-  });
-  if (evidence.length === 0) delete record.drainEvidence;
-  else record.drainEvidence = evidence;
-  return record;
-}
-function isEvidenceish(value) {
-  return typeof value === "object" && value !== null && typeof value.drainId === "string" && Array.isArray(value.receipts);
-}
-function isDrainish(value) {
-  return typeof value === "object" && value !== null && typeof value.drainId === "string";
-}
-function archiveOrKeep(action, requireArchive = false) {
-  try {
-    action();
-    return true;
-  } catch (error) {
-    if (requireArchive || !(error instanceof DvmError) || error.code !== "credit_history_unavailable") {
-      throw error;
-    }
-    return false;
-  }
-}
-function archiveStore(store) {
-  archiveCompletedCreditRecords([
-    ...store.credits.flatMap(
-      (credit) => (credit.drainEvidence ?? []).filter((bundle) => bundle.settledAt !== void 0).map((bundle) => completedRefund(credit, bundle))
-    ),
-    ...store.implicitCredits.filter((credit) => credit.status === "lost").map(completedLoss)
-  ]);
-}
-function capDrainEvidence(evidence) {
-  const settled = evidence.filter((e) => e.settledAt !== void 0).sort((a, b) => a.settledAt - b.settledAt);
-  const dropped = new Set(
-    settled.slice(0, Math.max(0, settled.length - MAX_SETTLED_DRAIN_EVIDENCE))
-  );
-  return evidence.filter((e) => !dropped.has(e));
-}
-function saveStore(store) {
-  ensureConfigDir();
-  if (archiveOrKeep(() => archiveStore(store))) {
-    for (const credit of store.credits) {
-      if (credit.drainEvidence) credit.drainEvidence = capDrainEvidence(credit.drainEvidence);
-    }
-  }
-  const tmp = `${CREDITS_FILE}.${String(process.pid)}.tmp`;
-  writeFileSync(tmp, JSON.stringify(store, null, 2) + "\n", { mode: 384 });
-  try {
-    renameSync(tmp, CREDITS_FILE);
-  } catch (err) {
-    try {
-      unlinkSync(tmp);
-    } catch {
-    }
-    throw err;
-  }
-}
-function unreadableStore(cause) {
-  const detail = cause instanceof Error ? cause.message : String(cause);
-  return new DvmError(
-    "credit_store_unreadable",
-    `The prepaid-credit record at ${CREDITS_FILE} exists but could not be opened: ${detail}`,
-    `The file was left untouched. Check that you own it and can read it ('ls -l ${CREDITS_FILE}'), then retry \u2014 'chmod 600 ${CREDITS_FILE}' fixes the common case. Do not delete it: it may hold DVM-signed drain receipts for a refund that is still owed.`,
-    { credits_file: CREDITS_FILE, cause: detail },
-    `Your local record of prepaid credits could not be opened \u2014 this looks like a file-permissions problem on this machine, not damage to the record. Nothing was changed or deleted, so any signed proof of a refund you are owed is still there.`
-  );
-}
-function quarantineCorruptStore(cause) {
-  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const quarantined = `${CREDITS_FILE}.corrupt-${stamp}-${String(process.pid)}`;
-  let moved = false;
-  try {
-    renameSync(CREDITS_FILE, quarantined);
-    moved = true;
-  } catch {
-  }
-  const kept = moved ? quarantined : CREDITS_FILE;
-  return new DvmError(
-    "credit_store_corrupt",
-    moved ? `The prepaid-credit record at ${CREDITS_FILE} is damaged and could not be parsed; it was moved aside to ${quarantined}.` : `The prepaid-credit record at ${CREDITS_FILE} is damaged and could not be parsed, and could not be moved aside.`,
-    `Do not delete ${kept} \u2014 it may hold DVM-signed drain receipts for a refund that is still owed. Balances themselves live on the DVM, so 'dvm credit balance <dvm>' re-reads them.`,
-    {
-      credits_file: CREDITS_FILE,
-      ...moved ? { quarantined_path: quarantined } : {},
-      cause: cause instanceof Error ? cause.message : String(cause)
-    },
-    `The local record of your prepaid credits is damaged. It was set aside at ${kept} rather than overwritten, so any signed proof of a refund you are owed is still in that file. Your credits are held by each DVM, not by this file, so re-reading a balance will restore what the CLI shows.`
-  );
-}
-function safeMicro(value) {
-  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
-}
-function mutateCredit(location, mutate) {
-  withCreditLock(() => {
-    const store = loadStore();
-    const key = normalizeCreditEndpoint(location.endpoint);
-    const record = findDvmLocated(store.credits, {
-      endpoint: key,
-      ...location.identity ? { identity: location.identity } : {},
-      where: (c) => c.callerPubkey === location.callerPubkey
-    });
-    if (!record) return;
-    const locationChanged = attachDvmLocation(record, key, location.identity);
-    if (mutate(record) === "skip") {
-      if (locationChanged) saveStore(store);
-      return;
-    }
-    record.updatedAt = Date.now();
-    saveStore(store);
-  });
-}
-var DEFAULT_LOCK_STALE_MS = 1e4;
-var DEFAULT_LOCK_RETRIES = 600;
-var DEFAULT_LOCK_RETRY_INTERVAL_MS = 25;
-var lockDepth = 0;
-function acquireCreditLock(opts) {
-  ensureConfigDir();
-  const lockPath = `${CREDITS_FILE}.lock`;
-  const stale = opts.stale ?? DEFAULT_LOCK_STALE_MS;
-  const retries = opts.retries ?? DEFAULT_LOCK_RETRIES;
-  const interval = opts.retryIntervalMs ?? DEFAULT_LOCK_RETRY_INTERVAL_MS;
-  let lastError;
-  for (let attempt = 0; attempt <= retries; attempt += 1) {
-    try {
-      return lockfile.lockSync(CREDITS_FILE, {
-        lockfilePath: lockPath,
-        stale,
-        realpath: false
-      });
-    } catch (err) {
-      lastError = err;
-      if (err.code !== "ELOCKED") {
-        const detail = err instanceof Error ? err.message : String(err);
-        const configDir = dirname(lockPath);
-        throw new DvmError(
-          "credit_store_lock_failed",
-          `Could not create the prepaid-credit lock at ${lockPath}: ${detail}`,
-          `This is not contention \u2014 nothing is holding the lock. Check that ${configDir} exists and is writable by you ('ls -ld ${configDir}'), then retry.`,
-          {
-            lock_file: lockPath,
-            config_dir: configDir,
-            underlying: detail,
-            errno_code: err.code
-          },
-          `The dvm CLI could not create the small lock file it uses to keep two commands from writing your credit record at once. Its folder looks unwritable \u2014 nothing about your credits is wrong, and nothing was changed.`
-        );
-      }
-      if (attempt === retries) break;
-      sleepSync(interval);
-    }
-  }
-  throw new DvmError(
-    "credit_store_locked",
-    `Could not acquire the prepaid-credit lock at ${lockPath} within the retry budget.`,
-    `Another dvm CLI may be writing to ${CREDITS_FILE}. Wait a moment and retry. If no other dvm CLI is running, remove ${lockPath} and try again.`,
-    {
-      lock_file: lockPath,
-      underlying: lastError instanceof Error ? lastError.message : String(lastError)
-    }
-  );
-}
-function rejectAsyncBody(result) {
-  if (typeof result?.then !== "function") {
-    return result;
-  }
-  throw new DvmError(
-    "credit_store_lock_misuse",
-    "withCreditLock was called with an asynchronous body. The lock is released when the body returns, so a promise's writes would run unprotected.",
-    "Make the locked body synchronous \u2014 the credit store's whole surface is sync \u2014 and do any awaiting outside the lock."
-  );
-}
-function sleepSync(ms) {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
-
-export {
-  RAIL_FLAGS,
-  maxAdvertisedMicro,
-  withinAdvertisedTolerance,
-  SUPPORTED_PROTOCOL_VERSION,
-  parseCreditTerms,
-  parseCreditMenu,
-  normalizeCreditEndpoint,
-  dvmLocationIdentity,
-  fundingReachableAt,
-  pendingDrainFor,
-  pendingDrainById,
-  loadCredit,
-  clearCreditSelection,
-  readCompletedCreditHistory,
-  listCredits,
-  listImplicitCredits,
-  loadImplicitCredits,
-  markImplicitCreditLost,
-  listFundingMenuSnapshots,
-  recordFundingMenuSnapshot,
-  listPendingFundings,
-  loadPendingFunding,
-  recordPendingFunding,
-  clearPendingFunding,
-  recordFundResponse,
-  recordBalanceResponse,
-  applyReceiptCredit,
-  applyImplicitReceiptCredit,
-  ensureProvisionalCredit,
-  markCredit,
-  loadCreditX402Binding,
-  recordCreditX402Instrument,
-  recordRefusedDrawBalance,
-  markRefillRailUnavailable,
-  markRefillDrainNoticed,
-  clearRefillRailUnavailable,
-  forgetCredit,
-  recordPendingDrain,
-  clearPendingDrain,
-  recordDrainReceipts,
-  settleDrainEvidence
-};