@pome-sh/cli 0.19.0 → 0.21.0

package/dist/src-4SVLX7UK.js

@@ -0,0 +1,4398 @@
+import { failureInjectionRuleSchema, openTwinDatabase, createFailureInjectionStore, defineTwin, twinBuildInfo, failureInjectionMiddleware, createApp, FAILURE_INJECTION_OVERRIDE_KEY, recordedRequestHeaders, UnknownToolError } from './chunk-LZIPGCQJ.js';
+import './chunk-VBATFCWR.js';
+import './chunk-SG6ZTIMT.js';
+import { z, ZodError } from 'zod';
+import { createHash, randomUUID, randomBytes } from 'node:crypto';
+
+var BASE62 = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var ID_PREFIXES = {
+  customer: "cus_",
+  payment_method: "pm_",
+  payment_intent: "pi_",
+  charge: "ch_",
+  refund: "re_",
+  product: "prod_",
+  price: "price_",
+  subscription: "sub_",
+  subscription_item: "si_",
+  setup_intent: "seti_",
+  checkout_session: "cs_test_",
+  webhook_endpoint: "we_",
+  event: "evt_",
+  shared_payment_issued: "spt_",
+  shared_payment_granted: "spt_",
+  profile: "profile_",
+  balance_transaction: "txn_",
+  // API keys are minted via api-keys.ts but the prefix lives here for parity.
+  api_key: "sk_test_pome_",
+  api_key_restricted: "rk_test_pome_"
+};
+function randomBase62(count) {
+  const buf = randomBytes(count * 2);
+  let out = "";
+  let i = 0;
+  while (out.length < count && i < buf.length) {
+    const byte = buf[i++];
+    if (byte < 248) {
+      out += BASE62[byte % 62];
+    }
+  }
+  if (out.length < count) {
+    out += randomBase62(count - out.length);
+  }
+  return out;
+}
+function newId(kind) {
+  return `${ID_PREFIXES[kind]}${randomBase62(24)}`;
+}
+function newClientSecret(piId) {
+  return `${piId}_secret_${randomBase62(24)}`;
+}
+function newApiKey() {
+  return newId("api_key");
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function nowUnix() {
+  return Math.floor(Date.now() / 1e3);
+}
+function requestId() {
+  return `req_${randomUUID()}`;
+}
+
+// ../packages/twin-stripe/dist/src/api-keys.js
+function mintApiKey(db, input) {
+  const key = input.key ?? newApiKey();
+  const account_id = input.account_id ?? `acct_${input.sid}`;
+  const created_at = nowIso();
+  db.prepare(`INSERT INTO api_keys (key, sid, account_id, created_at, revoked_at)
+     VALUES (?, ?, ?, ?, NULL)
+     ON CONFLICT(key) DO UPDATE SET
+       sid = excluded.sid,
+       account_id = excluded.account_id,
+       revoked_at = NULL`).run(key, input.sid, account_id, created_at);
+  return { key, sid: input.sid, account_id, created_at, revoked_at: null };
+}
+function revokeApiKey(db, key) {
+  db.prepare(`UPDATE api_keys SET revoked_at = ? WHERE key = ?`).run(nowIso(), key);
+}
+function resolveSidFromKey(db, token) {
+  const row = db.prepare(`SELECT key, sid, account_id, created_at, revoked_at
+         FROM api_keys
+        WHERE key = ? AND revoked_at IS NULL`).get(token);
+  if (!row)
+    return void 0;
+  return { sid: row.sid, account_id: row.account_id };
+}
+function looksLikeApiKey(token) {
+  return token.startsWith("sk_test_pome_") || token.startsWith("rk_test_pome_") || // Tolerate raw Stripe-style sk_test_* / rk_test_* in case a downstream
+  // user mints their own non-pome-prefixed test keys via the admin API.
+  token.startsWith("sk_test_") || token.startsWith("rk_test_");
+}
+
+// ../packages/twin-stripe/dist/src/domain/schema.js
+var STRIPE_TABLES_SQL = `
+CREATE TABLE IF NOT EXISTS payment_intents (
+  id TEXT PRIMARY KEY,
+  account_id TEXT NOT NULL,
+  amount INTEGER NOT NULL,
+  currency TEXT NOT NULL,
+  status TEXT NOT NULL,
+  payment_method_types_json TEXT NOT NULL,
+  next_action_json TEXT,
+  latest_charge_id TEXT,
+  capture_method TEXT NOT NULL DEFAULT 'automatic',
+  confirmation_method TEXT NOT NULL DEFAULT 'automatic',
+  idempotency_key TEXT,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  crypto_deposit_json TEXT,
+  client_secret TEXT NOT NULL,
+  created INTEGER NOT NULL,
+  updated INTEGER NOT NULL,
+  canceled_at INTEGER,
+  captured_at INTEGER,
+  payment_method_id TEXT,
+  customer_id TEXT,
+  last_payment_error_json TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_payment_intents_created ON payment_intents(created);
+CREATE INDEX IF NOT EXISTS idx_payment_intents_status ON payment_intents(status);
+CREATE INDEX IF NOT EXISTS idx_payment_intents_account_id ON payment_intents(account_id);
+
+CREATE TABLE IF NOT EXISTS charges (
+  id TEXT PRIMARY KEY,
+  account_id TEXT NOT NULL,
+  payment_intent_id TEXT NOT NULL,
+  amount INTEGER NOT NULL,
+  amount_captured INTEGER NOT NULL DEFAULT 0,
+  amount_refunded INTEGER NOT NULL DEFAULT 0,
+  status TEXT NOT NULL,
+  balance_transaction_id TEXT,
+  captured INTEGER NOT NULL DEFAULT 0,
+  currency TEXT NOT NULL,
+  created INTEGER NOT NULL,
+  payment_method_id TEXT,
+  payment_method_details_json TEXT,
+  failure_code TEXT,
+  failure_decline_code TEXT,
+  failure_message TEXT,
+  customer_id TEXT,
+  FOREIGN KEY (payment_intent_id) REFERENCES payment_intents(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_charges_pi ON charges(payment_intent_id);
+CREATE INDEX IF NOT EXISTS idx_charges_created ON charges(created);
+CREATE INDEX IF NOT EXISTS idx_charges_account_id ON charges(account_id);
+
+CREATE TABLE IF NOT EXISTS balance_transactions (
+  id TEXT PRIMARY KEY,
+  account_id TEXT NOT NULL,
+  type TEXT NOT NULL,
+  amount INTEGER NOT NULL,
+  fee INTEGER NOT NULL DEFAULT 0,
+  net INTEGER NOT NULL,
+  currency TEXT NOT NULL,
+  source_id TEXT,
+  source_type TEXT,
+  available_on INTEGER NOT NULL,
+  status TEXT NOT NULL DEFAULT 'available',
+  created INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_balance_tx_created ON balance_transactions(created);
+CREATE INDEX IF NOT EXISTS idx_balance_tx_source ON balance_transactions(source_id);
+CREATE INDEX IF NOT EXISTS idx_balance_tx_account_id ON balance_transactions(account_id);
+
+CREATE TABLE IF NOT EXISTS events (
+  id TEXT PRIMARY KEY,
+  account_id TEXT NOT NULL,
+  type TEXT NOT NULL,
+  data_json TEXT NOT NULL,
+  request_idempotency_key TEXT,
+  livemode INTEGER NOT NULL DEFAULT 0,
+  api_version TEXT NOT NULL,
+  created INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_events_type ON events(type);
+CREATE INDEX IF NOT EXISTS idx_events_created ON events(created);
+CREATE INDEX IF NOT EXISTS idx_events_account_id ON events(account_id);
+
+CREATE TABLE IF NOT EXISTS refunds (
+  id TEXT PRIMARY KEY,
+  account_id TEXT NOT NULL,
+  charge_id TEXT NOT NULL,
+  payment_intent_id TEXT NOT NULL,
+  amount INTEGER NOT NULL,
+  currency TEXT NOT NULL,
+  status TEXT NOT NULL,
+  reason TEXT,
+  balance_transaction_id TEXT,
+  idempotency_key TEXT,
+  created INTEGER NOT NULL,
+  FOREIGN KEY (charge_id) REFERENCES charges(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_refunds_charge ON refunds(charge_id);
+CREATE INDEX IF NOT EXISTS idx_refunds_payment_intent ON refunds(payment_intent_id);
+CREATE INDEX IF NOT EXISTS idx_refunds_created ON refunds(created);
+CREATE INDEX IF NOT EXISTS idx_refunds_account_id ON refunds(account_id);
+
+CREATE TABLE IF NOT EXISTS customers (
+  id TEXT PRIMARY KEY,
+  account_id TEXT NOT NULL,
+  name TEXT,
+  email TEXT,
+  description TEXT,
+  phone TEXT,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  deleted INTEGER NOT NULL DEFAULT 0,
+  created INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_customers_created ON customers(created);
+CREATE INDEX IF NOT EXISTS idx_customers_email ON customers(email);
+CREATE INDEX IF NOT EXISTS idx_customers_account_id ON customers(account_id);
+
+CREATE TABLE IF NOT EXISTS payment_methods (
+  id TEXT PRIMARY KEY,
+  account_id TEXT NOT NULL,
+  type TEXT NOT NULL,
+  card_brand TEXT NOT NULL,
+  card_last4 TEXT NOT NULL,
+  card_exp_month INTEGER NOT NULL,
+  card_exp_year INTEGER NOT NULL,
+  card_fingerprint TEXT NOT NULL,
+  customer_id TEXT,
+  detached INTEGER NOT NULL DEFAULT 0,
+  created INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_payment_methods_customer ON payment_methods(customer_id);
+CREATE INDEX IF NOT EXISTS idx_payment_methods_created ON payment_methods(created);
+CREATE INDEX IF NOT EXISTS idx_payment_methods_account_id ON payment_methods(account_id);
+
+-- F-734 billing tables (warm surfaces, shape tier): plain stored rows served
+-- back in Stripe shape. No invoices table \u2014 invoices are reads-only and
+-- nothing in the twin mints one (loud shape divergence, see FIDELITY.md).
+
+CREATE TABLE IF NOT EXISTS products (
+  id TEXT PRIMARY KEY,
+  account_id TEXT NOT NULL,
+  name TEXT NOT NULL,
+  description TEXT,
+  active INTEGER NOT NULL DEFAULT 1,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  created INTEGER NOT NULL,
+  updated INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_products_created ON products(created);
+CREATE INDEX IF NOT EXISTS idx_products_account_id ON products(account_id);
+
+CREATE TABLE IF NOT EXISTS prices (
+  id TEXT PRIMARY KEY,
+  account_id TEXT NOT NULL,
+  product_id TEXT NOT NULL,
+  currency TEXT NOT NULL,
+  unit_amount INTEGER,
+  recurring_interval TEXT,
+  recurring_interval_count INTEGER,
+  active INTEGER NOT NULL DEFAULT 1,
+  nickname TEXT,
+  lookup_key TEXT,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  created INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_prices_created ON prices(created);
+CREATE INDEX IF NOT EXISTS idx_prices_product ON prices(product_id);
+CREATE INDEX IF NOT EXISTS idx_prices_account_id ON prices(account_id);
+
+CREATE TABLE IF NOT EXISTS subscriptions (
+  id TEXT PRIMARY KEY,
+  account_id TEXT NOT NULL,
+  customer_id TEXT NOT NULL,
+  status TEXT NOT NULL,
+  items_json TEXT NOT NULL,
+  cancel_at_period_end INTEGER NOT NULL DEFAULT 0,
+  canceled_at INTEGER,
+  ended_at INTEGER,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  created INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_subscriptions_created ON subscriptions(created);
+CREATE INDEX IF NOT EXISTS idx_subscriptions_customer ON subscriptions(customer_id);
+CREATE INDEX IF NOT EXISTS idx_subscriptions_account_id ON subscriptions(account_id);
+`;
+var STRIPE_TABLES = [
+  "refunds",
+  "events",
+  "balance_transactions",
+  "charges",
+  "payment_intents",
+  "payment_methods",
+  "customers",
+  "subscriptions",
+  "prices",
+  "products"
+];
+function ensureStripeTables(db) {
+  db.pragma("busy_timeout = 5000");
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.exec(STRIPE_TABLES_SQL);
+  ensureMigratedColumns(db);
+}
+var MIGRATED_COLUMNS = {
+  payment_intents: [
+    ["payment_method_id", "payment_method_id TEXT"],
+    ["customer_id", "customer_id TEXT"],
+    ["last_payment_error_json", "last_payment_error_json TEXT"]
+  ],
+  charges: [
+    ["payment_method_id", "payment_method_id TEXT"],
+    ["payment_method_details_json", "payment_method_details_json TEXT"],
+    ["failure_code", "failure_code TEXT"],
+    ["failure_decline_code", "failure_decline_code TEXT"],
+    ["failure_message", "failure_message TEXT"],
+    ["customer_id", "customer_id TEXT"]
+  ],
+  refunds: [["balance_transaction_id", "balance_transaction_id TEXT"]]
+};
+function ensureMigratedColumns(db) {
+  for (const [table, columns] of Object.entries(MIGRATED_COLUMNS)) {
+    const existing = new Set(db.prepare(`SELECT name FROM pragma_table_info(?)`).all(table).map((row) => row.name));
+    if (existing.size === 0)
+      continue;
+    for (const [column, ddl] of columns) {
+      if (!existing.has(column))
+        db.exec(`ALTER TABLE ${table} ADD COLUMN ${ddl};`);
+    }
+  }
+}
+function resetStripeTables(db) {
+  for (const table of STRIPE_TABLES) {
+    db.exec(`DELETE FROM ${table};`);
+  }
+}
+
+// ../packages/twin-stripe/dist/src/db.js
+var MIGRATION_SQL = `
+-- ----- chassis tables -------------------------------------------------------
+
+CREATE TABLE IF NOT EXISTS api_keys (
+  key TEXT PRIMARY KEY,
+  sid TEXT NOT NULL,
+  account_id TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  revoked_at TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_api_keys_sid ON api_keys(sid);
+
+CREATE TABLE IF NOT EXISTS idempotency_keys (
+  key TEXT NOT NULL,
+  account_id TEXT NOT NULL,
+  method TEXT NOT NULL,
+  path TEXT NOT NULL,
+  request_hash TEXT NOT NULL,
+  response_status INTEGER NOT NULL,
+  response_body_json TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  PRIMARY KEY (key, account_id, method, path)
+);
+
+-- ----- v1 Stripe domain tables ---------------------------------------------
+
+CREATE TABLE IF NOT EXISTS payment_intents (
+  id TEXT PRIMARY KEY,
+  account_id TEXT NOT NULL,
+  amount INTEGER NOT NULL,
+  currency TEXT NOT NULL,
+  status TEXT NOT NULL,
+  payment_method_types_json TEXT NOT NULL DEFAULT '[]',
+  next_action_json TEXT,
+  latest_charge_id TEXT,
+  capture_method TEXT NOT NULL DEFAULT 'automatic',
+  confirmation_method TEXT NOT NULL DEFAULT 'automatic',
+  idempotency_key TEXT,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  crypto_deposit_json TEXT,
+  client_secret TEXT NOT NULL,
+  created INTEGER NOT NULL,
+  updated INTEGER NOT NULL,
+  canceled_at INTEGER,
+  captured_at INTEGER,
+  payment_method_id TEXT,
+  customer_id TEXT,
+  last_payment_error_json TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_payment_intents_created ON payment_intents(created);
+CREATE INDEX IF NOT EXISTS idx_payment_intents_status ON payment_intents(status);
+CREATE INDEX IF NOT EXISTS idx_payment_intents_account_id ON payment_intents(account_id);
+
+CREATE TABLE IF NOT EXISTS charges (
+  id TEXT PRIMARY KEY,
+  account_id TEXT NOT NULL,
+  payment_intent_id TEXT NOT NULL,
+  amount INTEGER NOT NULL,
+  amount_captured INTEGER NOT NULL DEFAULT 0,
+  amount_refunded INTEGER NOT NULL DEFAULT 0,
+  status TEXT NOT NULL,
+  balance_transaction_id TEXT,
+  captured INTEGER NOT NULL DEFAULT 0,
+  created INTEGER NOT NULL,
+  currency TEXT NOT NULL,
+  payment_method_id TEXT,
+  payment_method_details_json TEXT,
+  failure_code TEXT,
+  failure_decline_code TEXT,
+  failure_message TEXT,
+  customer_id TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_charges_payment_intent ON charges(payment_intent_id);
+CREATE INDEX IF NOT EXISTS idx_charges_created ON charges(created);
+CREATE INDEX IF NOT EXISTS idx_charges_account_id ON charges(account_id);
+
+CREATE TABLE IF NOT EXISTS balance_transactions (
+  id TEXT PRIMARY KEY,
+  account_id TEXT NOT NULL,
+  type TEXT NOT NULL,
+  amount INTEGER NOT NULL,
+  fee INTEGER NOT NULL DEFAULT 0,
+  net INTEGER NOT NULL,
+  currency TEXT NOT NULL,
+  source_id TEXT,
+  source_type TEXT,
+  available_on INTEGER NOT NULL,
+  created INTEGER NOT NULL,
+  status TEXT NOT NULL DEFAULT 'pending'
+);
+
+CREATE INDEX IF NOT EXISTS idx_balance_transactions_created ON balance_transactions(created);
+CREATE INDEX IF NOT EXISTS idx_balance_transactions_source ON balance_transactions(source_id);
+CREATE INDEX IF NOT EXISTS idx_balance_transactions_account_id ON balance_transactions(account_id);
+
+CREATE TABLE IF NOT EXISTS events (
+  id TEXT PRIMARY KEY,
+  account_id TEXT NOT NULL,
+  type TEXT NOT NULL,
+  data_json TEXT NOT NULL,
+  request_idempotency_key TEXT,
+  livemode INTEGER NOT NULL DEFAULT 0,
+  created INTEGER NOT NULL,
+  api_version TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_events_type ON events(type);
+CREATE INDEX IF NOT EXISTS idx_events_created ON events(created);
+CREATE INDEX IF NOT EXISTS idx_events_account_id ON events(account_id);
+
+-- ----- audit log (writes through admin/seed/reset) ------------------------
+
+CREATE TABLE IF NOT EXISTS audit_log (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  ts TEXT NOT NULL,
+  action TEXT NOT NULL,
+  payload_json TEXT NOT NULL
+);
+`;
+var RESET_SQL = `
+DELETE FROM audit_log;
+DELETE FROM refunds;
+DELETE FROM events;
+DELETE FROM balance_transactions;
+DELETE FROM charges;
+DELETE FROM payment_intents;
+DELETE FROM payment_methods;
+DELETE FROM customers;
+DELETE FROM subscriptions;
+DELETE FROM prices;
+DELETE FROM products;
+DELETE FROM idempotency_keys;
+DELETE FROM api_keys;
+`;
+function openTwinStripeDatabase(path = process.env.STRIPE_CLONE_DB ?? ":memory:") {
+  return openTwinDatabase(path, { migrate });
+}
+function migrate(db) {
+  db.exec(MIGRATION_SQL);
+  ensureMigratedColumns(db);
+}
+function resetDatabase(db) {
+  ensureStripeTables(db);
+  db.exec(RESET_SQL);
+}
+
+// ../packages/twin-stripe/dist/src/errors.js
+var TwinError = class extends Error {
+  status;
+  type;
+  code;
+  param;
+  doc_url;
+  fidelity;
+  supported_surfaces;
+  decline_code;
+  payment_intent;
+  state_mutation;
+  state_delta;
+  constructor(type, code, message, opts = {}) {
+    super(message);
+    this.type = type;
+    this.code = code;
+    this.status = opts.statusCode ?? 400;
+    this.param = opts.param;
+    this.doc_url = opts.doc_url;
+    this.fidelity = opts.fidelity;
+    this.supported_surfaces = opts.supported_surfaces;
+    this.decline_code = opts.decline_code;
+    this.payment_intent = opts.payment_intent;
+    this.state_mutation = opts.state_mutation;
+    this.state_delta = opts.state_delta;
+  }
+  toEnvelope() {
+    return stripeError(this.type, this.code, this.message, {
+      param: this.param,
+      doc_url: this.doc_url,
+      fidelity: this.fidelity,
+      supported_surfaces: this.supported_surfaces,
+      decline_code: this.decline_code,
+      payment_intent: this.payment_intent
+    }).body;
+  }
+};
+function stripeError(type, code, message, opts = {}) {
+  const error = { type, code, message };
+  if (opts.param !== void 0)
+    error.param = opts.param;
+  if (opts.doc_url !== void 0)
+    error.doc_url = opts.doc_url;
+  if (opts.fidelity !== void 0)
+    error.fidelity = opts.fidelity;
+  if (opts.supported_surfaces !== void 0) {
+    error.supported_surfaces = opts.supported_surfaces;
+  }
+  if (opts.decline_code !== void 0)
+    error.decline_code = opts.decline_code;
+  if (opts.payment_intent !== void 0)
+    error.payment_intent = opts.payment_intent;
+  return {
+    status: opts.statusCode ?? 400,
+    body: { error }
+  };
+}
+function unauthorized(message = "Invalid API Key provided.") {
+  return stripeError("invalid_request_error", "unauthorized", message, {
+    statusCode: 401
+  });
+}
+function forbidden(message = "Forbidden") {
+  return stripeError("invalid_request_error", "forbidden", message, {
+    statusCode: 403
+  });
+}
+function unsupported() {
+  return stripeError("invalid_request_error", "endpoint_not_supported", "This endpoint is not supported by this Stripe twin clone.", {
+    statusCode: 501,
+    fidelity: "unsupported",
+    supported_surfaces: [
+      "Stripe-shaped REST under /v1/*",
+      "GET /s/:sid/mcp/tools",
+      "POST /s/:sid/mcp/call",
+      "POST /s/:sid/mcp/tools/:name"
+    ]
+  });
+}
+
+// ../packages/twin-stripe/dist/src/domain/constants.js
+var STRIPE_API_VERSION = "2026-03-04.preview";
+var DEFAULT_CAPTURE_METHOD = "automatic";
+var DEFAULT_CONFIRMATION_METHOD = "automatic";
+var BASE_USDC_CONTRACT_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+var SUPPORTED_NETWORKS = ["base"];
+var CRYPTO_CURRENCIES = ["usd"];
+
+// ../packages/twin-stripe/dist/src/domain/payment-intents.js
+var PaymentIntentsDomain = class {
+  db;
+  constructor(db) {
+    this.db = db;
+    ensureStripeTables(db);
+  }
+  // ---------- create ----------
+  /**
+   * Insert a fresh PI. The caller (StripeDomain) has already resolved and
+   * cross-validated `payment_method` / `customer` for the card rail —
+   * `resolved` carries the validated ids so this module stays free of the
+   * sibling domains.
+   */
+  create(accountId2, input, resolved) {
+    if (!Number.isInteger(input.amount) || input.amount <= 0) {
+      throw new TwinError("invalid_request_error", "parameter_invalid_integer", "Amount must be a positive integer.", { param: "amount", statusCode: 400 });
+    }
+    const currency = (input.currency ?? "").toLowerCase();
+    if (!currency) {
+      throw new TwinError("invalid_request_error", "parameter_missing", "Missing required param: currency.", { param: "currency", statusCode: 400 });
+    }
+    if (!CRYPTO_CURRENCIES.includes(currency)) {
+      throw new TwinError("invalid_request_error", "currency_not_supported", `Currency '${currency}' is not supported by this twin (v1 supports: ${CRYPTO_CURRENCIES.join(", ")}).`, { param: "currency", statusCode: 400 });
+    }
+    const pmTypes = input.payment_method_types ?? [];
+    const pmType = pmTypes.length === 1 ? pmTypes[0] : void 0;
+    if (pmType !== "crypto" && pmType !== "card") {
+      throw new TwinError("invalid_request_error", "parameter_invalid_string", 'payment_method_types must be exactly ["crypto"] or ["card"] for this twin.', { param: "payment_method_types", statusCode: 400 });
+    }
+    const id = newId("payment_intent");
+    const clientSecret = newClientSecret(id);
+    const now = nowUnix();
+    let status;
+    let nextActionJson = null;
+    let cryptoDepositJson = null;
+    if (pmType === "crypto") {
+      if (input.payment_method || input.customer || input.confirm) {
+        throw new TwinError("invalid_request_error", "parameter_invalid_string", 'payment_method, customer, and confirm are only valid with payment_method_types ["card"].', { param: "payment_method", statusCode: 400 });
+      }
+      const cryptoOpts = input.payment_method_options?.crypto;
+      if (!cryptoOpts || cryptoOpts.mode !== "deposit") {
+        throw new TwinError("invalid_request_error", "parameter_invalid_string", 'payment_method_options.crypto.mode must be "deposit" for crypto PaymentIntents.', { param: "payment_method_options[crypto][mode]", statusCode: 400 });
+      }
+      const networks = cryptoOpts.deposit_options?.networks ?? [];
+      const network = networks[0];
+      if (!network || !SUPPORTED_NETWORKS.includes(network)) {
+        throw new TwinError("invalid_request_error", "parameter_invalid_string", `payment_method_options.crypto.deposit_options.networks must include one of: ${SUPPORTED_NETWORKS.join(", ")}.`, { param: "payment_method_options[crypto][deposit_options][networks]", statusCode: 400 });
+      }
+      const address = depositAddressFromId(id);
+      const cryptoDeposit = {
+        deposit_addresses: {
+          [network]: {
+            address,
+            supported_tokens: [
+              {
+                token_currency: "usdc",
+                token_contract_address: BASE_USDC_CONTRACT_ADDRESS
+              }
+            ]
+          }
+        }
+      };
+      status = "requires_action";
+      nextActionJson = JSON.stringify({
+        type: "display_crypto_deposit_information",
+        crypto_display_details: cryptoDeposit
+      });
+      cryptoDepositJson = JSON.stringify(cryptoDeposit);
+    } else {
+      if (input.payment_method_options?.crypto) {
+        throw new TwinError("invalid_request_error", "parameter_invalid_string", 'payment_method_options.crypto is only valid with payment_method_types ["crypto"].', { param: "payment_method_options[crypto]", statusCode: 400 });
+      }
+      status = resolved.paymentMethodId ? "requires_confirmation" : "requires_payment_method";
+    }
+    this.db.prepare(`INSERT INTO payment_intents (
+          id, account_id, amount, currency, status,
+          payment_method_types_json, next_action_json,
+          latest_charge_id, capture_method, confirmation_method,
+          idempotency_key, metadata_json, crypto_deposit_json,
+          client_secret, created, updated, canceled_at, captured_at,
+          payment_method_id, customer_id, last_payment_error_json
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, ?, ?, NULL)`).run(id, accountId2, input.amount, currency, status, JSON.stringify(pmTypes), nextActionJson, input.capture_method ?? DEFAULT_CAPTURE_METHOD, input.confirmation_method ?? DEFAULT_CONFIRMATION_METHOD, input.idempotency_key ?? null, JSON.stringify(input.metadata ?? {}), cryptoDepositJson, clientSecret, now, now, resolved.paymentMethodId, resolved.customerId);
+    return this.requireById(accountId2, id);
+  }
+  // ---------- confirm ----------
+  /**
+   * Crypto-deposit confirm is idempotent. If the PI is already in
+   * `requires_action`, return it unchanged. If it's mid- or post-flight
+   * (`processing` / `succeeded`), return it. Only `canceled` is rejected.
+   */
+  confirm(accountId2, id) {
+    const pi = this.requireById(accountId2, id);
+    if (pi.status === "canceled") {
+      throw piUnexpectedState(pi.status);
+    }
+    return pi;
+  }
+  /**
+   * Card confirm leg 1: CAS the observed pre-confirm status
+   * (`requires_confirmation` or `requires_payment_method`) → `processing`,
+   * stamping the PM being attempted. Exactly one of N parallel confirms
+   * wins this CAS; losers see `payment_intent_unexpected_state`.
+   */
+  confirmCardLeg1(accountId2, id, expected, paymentMethodId) {
+    return this.casStatusOrThrow(accountId2, id, expected, "processing", {
+      payment_method_id: paymentMethodId
+    });
+  }
+  /** Card confirm leg 2, success: processing → succeeded with the charge. */
+  finalizeCardSuccess(accountId2, id, latestChargeId) {
+    return this.casStatusOrThrow(accountId2, id, "processing", "succeeded", {
+      latest_charge_id: latestChargeId,
+      captured_at: nowUnix(),
+      last_payment_error_json: null
+    });
+  }
+  /**
+   * Card confirm leg 2, decline: processing → requires_payment_method with
+   * the failed charge and `last_payment_error` on the record. The declined
+   * PM is dropped from the PI, like real Stripe.
+   */
+  finalizeCardDecline(accountId2, id, failedChargeId, lastPaymentErrorJson) {
+    return this.casStatusOrThrow(accountId2, id, "processing", "requires_payment_method", {
+      latest_charge_id: failedChargeId,
+      payment_method_id: null,
+      last_payment_error_json: lastPaymentErrorJson
+    });
+  }
+  // ---------- update (POST /v1/payment_intents/:id, F-731) ----------
+  /**
+   * Update a non-terminal PI. Metadata merges per-key (empty/null unsets,
+   * Stripe's metadata contract). `payment_method` / `customer` are only
+   * valid on the card rail and have been resolved by the caller;
+   * attaching a PM moves requires_payment_method → requires_confirmation.
+   * The UPDATE is guarded on the observed status so a racing confirm wins.
+   */
+  update(accountId2, id, input, resolved = {}) {
+    const pi = this.requireById(accountId2, id);
+    const updatable = /* @__PURE__ */ new Set([
+      "requires_payment_method",
+      "requires_confirmation",
+      "requires_action"
+    ]);
+    if (!updatable.has(pi.status)) {
+      throw piUnexpectedState(pi.status);
+    }
+    const isCard = piTypes(pi).includes("card");
+    if (!isCard && (input.amount !== void 0 || input.payment_method !== void 0 || input.customer !== void 0)) {
+      throw new TwinError("invalid_request_error", "parameter_invalid_string", "Only metadata can be updated on crypto PaymentIntents.", { param: "payment_method", statusCode: 400 });
+    }
+    if (input.amount !== void 0 && (!Number.isInteger(input.amount) || input.amount <= 0)) {
+      throw new TwinError("invalid_request_error", "parameter_invalid_integer", "Amount must be a positive integer.", { param: "amount", statusCode: 400 });
+    }
+    const metadata = JSON.parse(pi.metadata_json);
+    for (const [key, value] of Object.entries(input.metadata ?? {})) {
+      if (value === null || value === "")
+        delete metadata[key];
+      else
+        metadata[key] = value;
+    }
+    const nextPaymentMethodId = input.payment_method !== void 0 ? resolved.paymentMethodId ?? null : pi.payment_method_id;
+    const nextCustomerId = input.customer !== void 0 ? resolved.customerId ?? null : pi.customer_id;
+    let nextStatus = pi.status;
+    if (isCard) {
+      if (nextPaymentMethodId && pi.status === "requires_payment_method") {
+        nextStatus = "requires_confirmation";
+      } else if (!nextPaymentMethodId && pi.status === "requires_confirmation") {
+        nextStatus = "requires_payment_method";
+      }
+    }
+    const updated = this.db.prepare(`UPDATE payment_intents SET
+           amount = ?, metadata_json = ?, payment_method_id = ?, customer_id = ?,
+           status = ?, updated = ?
+         WHERE id = ? AND account_id = ? AND status = ? RETURNING *`).get(input.amount ?? pi.amount, JSON.stringify(metadata), nextPaymentMethodId, nextCustomerId, nextStatus, nowUnix(), id, accountId2, pi.status);
+    if (!updated) {
+      const fresh = this.requireById(accountId2, id);
+      throw piUnexpectedState(fresh.status);
+    }
+    return updated;
+  }
+  // ---------- cancel ----------
+  cancel(accountId2, id) {
+    const pi = this.requireById(accountId2, id);
+    if (pi.status === "succeeded") {
+      throw piUnexpectedState(pi.status, "Cannot cancel a succeeded PaymentIntent.");
+    }
+    if (pi.status === "canceled") {
+      return pi;
+    }
+    const updated = this.casStatus(accountId2, id, pi.status, "canceled", { canceled_at: nowUnix() });
+    if (!updated)
+      throw piUnexpectedState(pi.status);
+    return updated;
+  }
+  // ---------- simulate_crypto_deposit (test_helpers) ----------
+  /**
+   * Drive a PI from requires_action → processing → succeeded.
+   * Both transitions are CAS — exactly one parallel call wins each leg.
+   * Returns { pi, charge, balanceTx, events: rows of side-effect ids }.
+   * Side-effect emission (events, charge mint, balance txn) is the
+   * caller's job — `simulate` is the bare state-advancement here. To keep
+   * the routes simple we colocate it. See routes/payment-intents.ts.
+   */
+  simulateCryptoDepositLeg1(accountId2, id) {
+    const pi = this.requireById(accountId2, id);
+    if (pi.status === "succeeded" || pi.status === "canceled") {
+      throw piUnexpectedState(pi.status, `PaymentIntent is in terminal state '${pi.status}' and cannot be advanced.`);
+    }
+    if (pi.status !== "requires_action") {
+      throw piUnexpectedState(pi.status);
+    }
+    return this.casStatusOrThrow(accountId2, id, "requires_action", "processing");
+  }
+  /** Second CAS leg: processing → succeeded. */
+  simulateCryptoDepositLeg2(accountId2, id, latestChargeId) {
+    return this.casStatusOrThrow(accountId2, id, "processing", "succeeded", {
+      latest_charge_id: latestChargeId,
+      captured_at: nowUnix()
+    });
+  }
+  // ---------- read ----------
+  getById(accountId2, id) {
+    return this.db.prepare("SELECT * FROM payment_intents WHERE id = ? AND account_id = ?").get(id, accountId2) ?? null;
+  }
+  requireById(accountId2, id) {
+    const pi = this.getById(accountId2, id);
+    if (!pi) {
+      throw new TwinError("invalid_request_error", "resource_missing", `No such payment_intent: '${id}'.`, { param: "intent", statusCode: 404 });
+    }
+    return pi;
+  }
+  list(accountId2, input) {
+    return listPaginated(this.db, "payment_intents", accountId2, input);
+  }
+  // ---------- internals ----------
+  /**
+   * casStatus + the shared lost-the-race contract: re-read the fresh row
+   * so the loser's `payment_intent_unexpected_state` names the status that
+   * actually beat it. Every CAS leg on both rails goes through here.
+   */
+  casStatusOrThrow(accountId2, id, expected, next, extras = {}) {
+    const updated = this.casStatus(accountId2, id, expected, next, extras);
+    if (!updated) {
+      const fresh = this.requireById(accountId2, id);
+      throw piUnexpectedState(fresh.status);
+    }
+    return updated;
+  }
+  /**
+   * Compare-and-swap on `status`. Returns the new row, or `null` if no row
+   * matched the predicate. The predicate is `(id = ? AND account_id = ? AND status = ?)`.
+   */
+  casStatus(accountId2, id, expected, next, extras = {}) {
+    const sets = ["status = ?", "updated = ?"];
+    const values = [next, nowUnix()];
+    if ("latest_charge_id" in extras) {
+      sets.push("latest_charge_id = ?");
+      values.push(extras.latest_charge_id ?? null);
+    }
+    if ("canceled_at" in extras) {
+      sets.push("canceled_at = ?");
+      values.push(extras.canceled_at ?? null);
+    }
+    if ("captured_at" in extras) {
+      sets.push("captured_at = ?");
+      values.push(extras.captured_at ?? null);
+    }
+    if ("payment_method_id" in extras) {
+      sets.push("payment_method_id = ?");
+      values.push(extras.payment_method_id ?? null);
+    }
+    if ("last_payment_error_json" in extras) {
+      sets.push("last_payment_error_json = ?");
+      values.push(extras.last_payment_error_json ?? null);
+    }
+    const sql = `UPDATE payment_intents SET ${sets.join(", ")} WHERE id = ? AND account_id = ? AND status = ? RETURNING *`;
+    values.push(id, accountId2, expected);
+    return this.db.prepare(sql).get(...values) ?? null;
+  }
+};
+function piTypes(pi) {
+  try {
+    const parsed = JSON.parse(pi.payment_method_types_json);
+    return Array.isArray(parsed) ? parsed : ["crypto"];
+  } catch {
+    return ["crypto"];
+  }
+}
+function piUnexpectedState(currentStatus, message) {
+  return new TwinError("invalid_request_error", "payment_intent_unexpected_state", message ?? `The PaymentIntent has a status of '${currentStatus}'. The requested action could not be performed.`, { statusCode: 400 });
+}
+function depositAddressFromId(id) {
+  const digest = createHash("sha256").update(id).digest("hex");
+  return `0x${digest.slice(0, 40)}`;
+}
+function listPaginated(db, table, accountId2, input, extraWheres = []) {
+  const limitRaw = input.limit ?? 10;
+  const limit = Math.min(100, Math.max(1, Math.floor(limitRaw)));
+  const wheres = ["account_id = ?"];
+  const args = [accountId2];
+  if (input.starting_after) {
+    const cursor = cursorRow(db, table, accountId2, input.starting_after);
+    if (cursor) {
+      wheres.push("(created < ? OR (created = ? AND id < ?))");
+      args.push(cursor.created, cursor.created, cursor.id);
+    }
+  }
+  if (input.ending_before) {
+    const cursor = cursorRow(db, table, accountId2, input.ending_before);
+    if (cursor) {
+      wheres.push("(created > ? OR (created = ? AND id > ?))");
+      args.push(cursor.created, cursor.created, cursor.id);
+    }
+  }
+  if (typeof input.created_gt === "number") {
+    wheres.push("created > ?");
+    args.push(input.created_gt);
+  }
+  if (typeof input.created_gte === "number") {
+    wheres.push("created >= ?");
+    args.push(input.created_gte);
+  }
+  if (typeof input.created_lt === "number") {
+    wheres.push("created < ?");
+    args.push(input.created_lt);
+  }
+  if (typeof input.created_lte === "number") {
+    wheres.push("created <= ?");
+    args.push(input.created_lte);
+  }
+  if (input.type) {
+    wheres.push("type = ?");
+    args.push(input.type);
+  }
+  if (input.payment_intent) {
+    wheres.push("payment_intent_id = ?");
+    args.push(input.payment_intent);
+  }
+  for (const extra of extraWheres) {
+    wheres.push(extra.sql);
+    args.push(...extra.args);
+  }
+  const where = `WHERE ${wheres.join(" AND ")}`;
+  const sql = `SELECT * FROM ${table} ${where} ORDER BY created DESC, id DESC LIMIT ?`;
+  const rows = db.prepare(sql).all(...args, limit + 1);
+  const hasMore = rows.length > limit;
+  return { rows: hasMore ? rows.slice(0, limit) : rows, hasMore, limit };
+}
+function cursorRow(db, table, accountId2, id) {
+  return db.prepare(`SELECT id, created FROM ${table} WHERE id = ? AND account_id = ?`).get(id, accountId2) ?? null;
+}
+var PaymentMethodsDomain = class {
+  db;
+  constructor(db) {
+    this.db = db;
+    ensureStripeTables(db);
+  }
+  create(accountId2, input) {
+    if (typeof input.type !== "string" || input.type.length === 0) {
+      throw new TwinError("invalid_request_error", "parameter_missing", "Missing required param: type.", { param: "type", statusCode: 400 });
+    }
+    if (input.type !== "card") {
+      throw new TwinError("invalid_request_error", "parameter_invalid_string", `payment method type must be "card" for v1 of this twin (got '${input.type}').`, { param: "type", statusCode: 400 });
+    }
+    const card = input.card;
+    if (!card || typeof card !== "object") {
+      throw new TwinError("invalid_request_error", "parameter_missing", "Missing required param: card.", { param: "card", statusCode: 400 });
+    }
+    const number = typeof card.number === "string" ? card.number.replace(/[\s-]/g, "") : "";
+    if (!/^\d{12,19}$/.test(number) || !passesLuhn(number)) {
+      throw new TwinError("card_error", "incorrect_number", "Your card number is incorrect.", {
+        param: "card[number]",
+        statusCode: 402
+      });
+    }
+    const expMonth = Number(card.exp_month);
+    if (!Number.isInteger(expMonth) || expMonth < 1 || expMonth > 12) {
+      throw new TwinError("card_error", "invalid_expiry_month", "Your card's expiration month is invalid.", { param: "card[exp_month]", statusCode: 402 });
+    }
+    const expYear = Number(card.exp_year);
+    const now = new Date(nowUnix() * 1e3);
+    const currentYear = now.getUTCFullYear();
+    if (!Number.isInteger(expYear) || expYear < currentYear) {
+      throw new TwinError("card_error", "invalid_expiry_year", "Your card's expiration year is invalid.", { param: "card[exp_year]", statusCode: 402 });
+    }
+    if (expYear === currentYear && expMonth < now.getUTCMonth() + 1) {
+      throw new TwinError("card_error", "invalid_expiry_month", "Your card's expiration month is invalid.", { param: "card[exp_month]", statusCode: 402 });
+    }
+    const id = newId("payment_method");
+    this.db.prepare(`INSERT INTO payment_methods (
+          id, account_id, type, card_brand, card_last4, card_exp_month,
+          card_exp_year, card_fingerprint, customer_id, detached, created
+        ) VALUES (?, ?, 'card', ?, ?, ?, ?, ?, NULL, 0, ?)`).run(
+      id,
+      accountId2,
+      brandFromNumber(number),
+      number.slice(-4),
+      expMonth,
+      expYear,
+      // Stable per PAN, like Stripe's card fingerprint — but derived, so
+      // the PAN itself is never persisted anywhere.
+      fingerprintOf(number),
+      nowUnix()
+    );
+    return this.requireById(accountId2, id);
+  }
+  getById(accountId2, id) {
+    return this.db.prepare("SELECT * FROM payment_methods WHERE id = ? AND account_id = ?").get(id, accountId2) ?? null;
+  }
+  requireById(accountId2, id) {
+    const row = this.getById(accountId2, id);
+    if (!row) {
+      throw new TwinError("invalid_request_error", "resource_missing", `No such payment_method: '${id}'.`, { param: "payment_method", statusCode: 404 });
+    }
+    return row;
+  }
+  /**
+   * Attach to a customer. Caller has already resolved the customer as live.
+   * Stripe rules: one customer per PM, and a previously-detached PM may
+   * never be reattached.
+   */
+  attach(accountId2, id, customerId) {
+    const pm = this.requireById(accountId2, id);
+    if (pm.customer_id) {
+      throw new TwinError("invalid_request_error", "payment_method_already_attached", "This PaymentMethod has already been attached to a customer.", { param: "payment_method", statusCode: 400 });
+    }
+    if (pm.detached) {
+      throw new TwinError("invalid_request_error", "payment_method_previously_detached", "A payment method that has been previously detached from a customer may not be reattached.", { param: "payment_method", statusCode: 400 });
+    }
+    this.db.prepare("UPDATE payment_methods SET customer_id = ? WHERE id = ? AND account_id = ?").run(customerId, id, accountId2);
+    return this.requireById(accountId2, id);
+  }
+  detach(accountId2, id) {
+    const pm = this.requireById(accountId2, id);
+    if (!pm.customer_id) {
+      throw new TwinError("invalid_request_error", "payment_method_not_attached", "The payment method you provided is not attached to a customer.", { param: "payment_method", statusCode: 400 });
+    }
+    this.db.prepare("UPDATE payment_methods SET customer_id = NULL, detached = 1 WHERE id = ? AND account_id = ?").run(id, accountId2);
+    return this.requireById(accountId2, id);
+  }
+  /** All PMs currently attached to a customer (no pagination — used by
+   *  customer deletion to emit one detached event per PM). */
+  allAttachedToCustomer(accountId2, customerId) {
+    return this.db.prepare("SELECT * FROM payment_methods WHERE customer_id = ? AND account_id = ?").all(customerId, accountId2);
+  }
+  listForCustomer(accountId2, customerId, input) {
+    return listPaginated(this.db, "payment_methods", accountId2, input, [
+      { sql: "customer_id = ?", args: [customerId] }
+    ]);
+  }
+};
+var MAGIC_DECLINES = [
+  ["4000000000000002", { code: "card_declined", decline_code: "generic_decline", message: "Your card was declined." }],
+  ["4000000000009995", { code: "card_declined", decline_code: "insufficient_funds", message: "Your card has insufficient funds." }],
+  ["4000000000000069", { code: "expired_card", decline_code: "expired_card", message: "Your card has expired." }],
+  ["4000000000000127", { code: "incorrect_cvc", decline_code: "incorrect_cvc", message: "Your card's security code is incorrect." }]
+];
+var DECLINE_BY_FINGERPRINT = new Map(MAGIC_DECLINES.map(([pan, decline]) => [fingerprintOf(pan), decline]));
+function fingerprintOf(number) {
+  return createHash("sha256").update(number).digest("hex").slice(0, 16);
+}
+function declineForFingerprint(fingerprint) {
+  return DECLINE_BY_FINGERPRINT.get(fingerprint) ?? null;
+}
+function passesLuhn(number) {
+  let sum = 0;
+  let double = false;
+  for (let i = number.length - 1; i >= 0; i--) {
+    let digit = number.charCodeAt(i) - 48;
+    if (double) {
+      digit *= 2;
+      if (digit > 9)
+        digit -= 9;
+    }
+    sum += digit;
+    double = !double;
+  }
+  return sum % 10 === 0;
+}
+function brandFromNumber(number) {
+  if (/^4/.test(number))
+    return "visa";
+  if (/^(5[1-5]|2[2-7])/.test(number))
+    return "mastercard";
+  if (/^3[47]/.test(number))
+    return "amex";
+  if (/^6(011|5)/.test(number))
+    return "discover";
+  return "unknown";
+}
+
+// ../packages/twin-stripe/dist/src/domain/charges.js
+var ChargesDomain = class {
+  db;
+  constructor(db) {
+    this.db = db;
+    ensureStripeTables(db);
+  }
+  /**
+   * Mint a fresh charge attached to a PI. Defaults to `succeeded` +
+   * `captured` (the settle paths); a declined card attempt passes
+   * `status: "failed"` and the failure columns instead.
+   */
+  createForPI(accountId2, input) {
+    const id = newId("charge");
+    const now = nowUnix();
+    const status = input.status ?? "succeeded";
+    const succeeded = status === "succeeded";
+    this.db.prepare(`INSERT INTO charges (
+          id, account_id, payment_intent_id, amount, amount_captured, amount_refunded,
+          status, balance_transaction_id, captured, currency, created,
+          payment_method_id, payment_method_details_json,
+          failure_code, failure_decline_code, failure_message, customer_id
+        ) VALUES (?, ?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, accountId2, input.payment_intent_id, input.amount, succeeded ? input.amount : 0, status, input.balance_transaction_id ?? null, succeeded ? 1 : 0, input.currency, now, input.payment_method_id ?? null, input.payment_method_details_json ?? null, input.failure_code ?? null, input.failure_decline_code ?? null, input.failure_message ?? null, input.customer_id ?? null);
+    return this.requireById(accountId2, id);
+  }
+  getById(accountId2, id) {
+    return this.db.prepare("SELECT * FROM charges WHERE id = ? AND account_id = ?").get(id, accountId2) ?? null;
+  }
+  requireById(accountId2, id) {
+    const row = this.getById(accountId2, id);
+    if (!row) {
+      throw new TwinError("invalid_request_error", "resource_missing", `No such charge: '${id}'.`, { param: "charge", statusCode: 404 });
+    }
+    return row;
+  }
+  list(accountId2, input) {
+    const { customer, ...rest } = input;
+    const extra = customer ? [{ sql: "customer_id = ?", args: [customer] }] : [];
+    return listPaginated(this.db, "charges", accountId2, rest, extra);
+  }
+  /** Count charges for a PI. Used by the concurrency test. */
+  countForPI(accountId2, piId) {
+    const row = this.db.prepare("SELECT COUNT(*) as n FROM charges WHERE payment_intent_id = ? AND account_id = ?").get(piId, accountId2);
+    return row.n;
+  }
+};
+
+// ../packages/twin-stripe/dist/src/domain/balance.js
+var BalanceDomain = class {
+  db;
+  constructor(db) {
+    this.db = db;
+    ensureStripeTables(db);
+  }
+  create(accountId2, input) {
+    const id = newId("balance_transaction");
+    const now = nowUnix();
+    const fee = input.fee ?? 0;
+    const net = input.amount - fee;
+    this.db.prepare(`INSERT INTO balance_transactions (
+          id, account_id, type, amount, fee, net, currency, source_id, source_type,
+          available_on, status, created
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'available', ?)`).run(id, accountId2, input.type, input.amount, fee, net, input.currency, input.source_id ?? null, input.source_type ?? null, now, now);
+    return this.requireById(accountId2, id);
+  }
+  getById(accountId2, id) {
+    return this.db.prepare("SELECT * FROM balance_transactions WHERE id = ? AND account_id = ?").get(id, accountId2) ?? null;
+  }
+  requireById(accountId2, id) {
+    const row = this.getById(accountId2, id);
+    if (!row) {
+      throw new TwinError("invalid_request_error", "resource_missing", `No such balance_transaction: '${id}'.`, { param: "balance_transaction", statusCode: 404 });
+    }
+    return row;
+  }
+  list(accountId2, input) {
+    return listPaginated(this.db, "balance_transactions", accountId2, input);
+  }
+  /**
+   * Compute current balance grouped by currency. v1 deviation: we lump
+   * everything into `available`; `pending` is always [].
+   */
+  current(accountId2) {
+    const rows = this.db.prepare("SELECT currency, COALESCE(SUM(net), 0) AS amount FROM balance_transactions WHERE account_id = ? GROUP BY currency").all(accountId2);
+    const available = rows.map((row) => ({
+      currency: row.currency,
+      amount: row.amount,
+      source_types: { card: 0 }
+    }));
+    return { available, pending: [] };
+  }
+  /** Count balance txns for a given source (PI). Used by concurrency test. */
+  countForSource(accountId2, sourceId) {
+    const row = this.db.prepare("SELECT COUNT(*) as n FROM balance_transactions WHERE source_id = ? AND account_id = ?").get(sourceId, accountId2);
+    return row.n;
+  }
+  /** Sum of all `net` amounts. Used by concurrency test (assert total == PI amount). */
+  totalNet(accountId2, currency = "usd") {
+    const row = this.db.prepare("SELECT COALESCE(SUM(net), 0) AS total FROM balance_transactions WHERE currency = ? AND account_id = ?").get(currency, accountId2);
+    return row.total;
+  }
+};
+
+// ../packages/twin-stripe/dist/src/domain/events.js
+var EventsDomain = class {
+  db;
+  constructor(db) {
+    this.db = db;
+    ensureStripeTables(db);
+  }
+  create(accountId2, input) {
+    const id = newId("event");
+    const now = nowUnix();
+    this.db.prepare(`INSERT INTO events (
+          id, account_id, type, data_json, request_idempotency_key, livemode,
+          api_version, created
+        ) VALUES (?, ?, ?, ?, ?, 0, ?, ?)`).run(id, accountId2, input.type, JSON.stringify({ object: input.object }), input.request_idempotency_key ?? null, STRIPE_API_VERSION, now);
+    return this.requireById(accountId2, id);
+  }
+  getById(accountId2, id) {
+    return this.db.prepare("SELECT * FROM events WHERE id = ? AND account_id = ?").get(id, accountId2) ?? null;
+  }
+  requireById(accountId2, id) {
+    const row = this.getById(accountId2, id);
+    if (!row) {
+      throw new TwinError("invalid_request_error", "resource_missing", `No such event: '${id}'.`, { param: "event", statusCode: 404 });
+    }
+    return row;
+  }
+  list(accountId2, input) {
+    return listPaginated(this.db, "events", accountId2, input);
+  }
+};
+
+// ../packages/twin-stripe/dist/src/domain/refunds.js
+var RefundsDomain = class {
+  db;
+  constructor(db) {
+    this.db = db;
+    ensureStripeTables(db);
+  }
+  /**
+   * Create a refund against an existing charge. The INSERT into `refunds`
+   * and the UPDATE of `charges.amount_refunded` run inside a single
+   * better-sqlite3 transaction (synchronous + atomic). Returns the new
+   * refund row alongside the post-update charge row so the route can
+   * emit the recorder `state_delta`.
+   */
+  create(accountId2, input) {
+    if (!input.charge) {
+      throw new TwinError("invalid_request_error", "parameter_missing", "Missing required param: charge.", { param: "charge", statusCode: 400 });
+    }
+    if (input.amount !== void 0) {
+      if (!Number.isInteger(input.amount) || input.amount <= 0) {
+        throw new TwinError("invalid_request_error", "parameter_invalid_integer", "Amount must be a positive integer.", { param: "amount", statusCode: 400 });
+      }
+    }
+    const tx = this.db.transaction(() => {
+      const charge = this.requireCharge(accountId2, input.charge);
+      if (charge.status !== "succeeded") {
+        throw new TwinError("invalid_request_error", "charge_not_refundable", `This charge (${charge.id}) has a status of '${charge.status}' and cannot be refunded.`, { param: "charge", statusCode: 400 });
+      }
+      const refundable = charge.amount - charge.amount_refunded;
+      const amount = input.amount ?? refundable;
+      if (amount <= 0 || amount > refundable) {
+        throw new TwinError("invalid_request_error", "charge_already_refunded", amount <= 0 ? "Refund amount must be positive." : `Refund amount exceeds the remaining refundable balance of ${refundable}.`, { param: "amount", statusCode: 400 });
+      }
+      const id = newId("refund");
+      const now = nowUnix();
+      this.db.prepare(`INSERT INTO refunds (
+            id, account_id, charge_id, payment_intent_id, amount, currency,
+            status, reason, idempotency_key, created
+          ) VALUES (?, ?, ?, ?, ?, ?, 'succeeded', ?, ?, ?)`).run(id, accountId2, charge.id, charge.payment_intent_id, amount, charge.currency, input.reason ?? null, input.idempotency_key ?? null, now);
+      this.db.prepare("UPDATE charges SET amount_refunded = amount_refunded + ? WHERE id = ? AND account_id = ?").run(amount, charge.id, accountId2);
+      const row = this.requireById(accountId2, id);
+      const updatedCharge = this.requireCharge(accountId2, charge.id);
+      return { row, charge: updatedCharge };
+    });
+    return tx();
+  }
+  /**
+   * Backfill the ledger link after StripeDomain mints the refund's balance
+   * transaction (the txn needs the refund row's id/amount first, so the two
+   * inserts can't be reordered). Runs inside the coordinator's transaction.
+   */
+  linkBalanceTransaction(accountId2, id, balanceTransactionId) {
+    this.db.prepare("UPDATE refunds SET balance_transaction_id = ? WHERE id = ? AND account_id = ?").run(balanceTransactionId, id, accountId2);
+    return this.requireById(accountId2, id);
+  }
+  getById(accountId2, id) {
+    return this.db.prepare("SELECT * FROM refunds WHERE id = ? AND account_id = ?").get(id, accountId2) ?? null;
+  }
+  requireById(accountId2, id) {
+    const row = this.getById(accountId2, id);
+    if (!row) {
+      throw new TwinError("invalid_request_error", "resource_missing", `No such refund: '${id}'.`, { param: "refund", statusCode: 404 });
+    }
+    return row;
+  }
+  list(accountId2, input) {
+    if (input.charge) {
+      const wide = listPaginated(this.db, "refunds", accountId2, input);
+      const filtered = wide.rows.filter((r) => r.charge_id === input.charge);
+      return { rows: filtered, hasMore: wide.hasMore, limit: wide.limit };
+    }
+    return listPaginated(this.db, "refunds", accountId2, input);
+  }
+  requireCharge(accountId2, id) {
+    const row = this.db.prepare("SELECT * FROM charges WHERE id = ? AND account_id = ?").get(id, accountId2);
+    if (!row) {
+      throw new TwinError("invalid_request_error", "resource_missing", `No such charge: '${id}'.`, { param: "charge", statusCode: 404 });
+    }
+    return row;
+  }
+};
+
+// ../packages/twin-stripe/dist/src/domain/customers.js
+var CustomersDomain = class {
+  db;
+  constructor(db) {
+    this.db = db;
+    ensureStripeTables(db);
+  }
+  create(accountId2, input) {
+    const id = newId("customer");
+    const metadata = {};
+    for (const [key, value] of Object.entries(input.metadata ?? {})) {
+      if (value !== null && value !== "")
+        metadata[key] = value;
+    }
+    this.db.prepare(`INSERT INTO customers (
+          id, account_id, name, email, description, phone, metadata_json, deleted, created
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?)`).run(id, accountId2, input.name ?? null, input.email ?? null, input.description ?? null, input.phone ?? null, JSON.stringify(metadata), nowUnix());
+    return this.requireById(accountId2, id);
+  }
+  getById(accountId2, id) {
+    return this.db.prepare("SELECT * FROM customers WHERE id = ? AND account_id = ?").get(id, accountId2) ?? null;
+  }
+  /** Any row, deleted or live. Missing id → Stripe's 404 resource_missing. */
+  requireById(accountId2, id) {
+    const row = this.getById(accountId2, id);
+    if (!row)
+      throw noSuchCustomer(id);
+    return row;
+  }
+  /** Live row only. Deleted customers 404 for writes and sub-resources. */
+  requireLive(accountId2, id) {
+    const row = this.requireById(accountId2, id);
+    if (row.deleted)
+      throw noSuchCustomer(id);
+    return row;
+  }
+  /**
+   * Update fields; metadata merges per-key, an empty/null value unsets the
+   * key (real Stripe's metadata contract).
+   */
+  update(accountId2, id, input) {
+    const existing = this.requireLive(accountId2, id);
+    const metadata = JSON.parse(existing.metadata_json);
+    for (const [key, value] of Object.entries(input.metadata ?? {})) {
+      if (value === null || value === "")
+        delete metadata[key];
+      else
+        metadata[key] = value;
+    }
+    this.db.prepare(`UPDATE customers SET name = ?, email = ?, description = ?, phone = ?, metadata_json = ?
+          WHERE id = ? AND account_id = ?`).run(input.name !== void 0 ? input.name : existing.name, input.email !== void 0 ? input.email : existing.email, input.description !== void 0 ? input.description : existing.description, input.phone !== void 0 ? input.phone : existing.phone, JSON.stringify(metadata), id, accountId2);
+    return this.requireById(accountId2, id);
+  }
+  /**
+   * Soft-delete. Detaches the customer's payment methods in the same
+   * transaction (real Stripe invalidates them on customer deletion).
+   * Idempotent: deleting an already-deleted customer returns the row.
+   */
+  delete(accountId2, id) {
+    const tx = this.db.transaction(() => {
+      const existing = this.requireById(accountId2, id);
+      if (existing.deleted)
+        return { row: existing, alreadyDeleted: true };
+      this.db.prepare("UPDATE customers SET deleted = 1 WHERE id = ? AND account_id = ?").run(id, accountId2);
+      this.db.prepare("UPDATE payment_methods SET customer_id = NULL, detached = 1 WHERE customer_id = ? AND account_id = ?").run(id, accountId2);
+      return { row: this.requireById(accountId2, id), alreadyDeleted: false };
+    });
+    return tx();
+  }
+  list(accountId2, input) {
+    const extra = [{ sql: "deleted = 0", args: [] }];
+    if (input.email)
+      extra.push({ sql: "email = ?", args: [input.email] });
+    return listPaginated(this.db, "customers", accountId2, input, extra);
+  }
+};
+function noSuchCustomer(id) {
+  return new TwinError("invalid_request_error", "resource_missing", `No such customer: '${id}'.`, { param: "customer", statusCode: 404 });
+}
+
+// ../packages/twin-stripe/dist/src/domain/billing.js
+var BillingDomain = class {
+  db;
+  constructor(db) {
+    this.db = db;
+    ensureStripeTables(db);
+  }
+  // ---------- Products ----------
+  createProduct(accountId2, input) {
+    if (!input.name)
+      throw missingParam("name");
+    const now = nowUnix();
+    const id = newId("product");
+    this.db.prepare(`INSERT INTO products (id, account_id, name, description, active, metadata_json, created, updated)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(id, accountId2, input.name, input.description ?? null, input.active === false ? 0 : 1, JSON.stringify(liveMetadata(input.metadata)), now, now);
+    return this.requireProduct(accountId2, id);
+  }
+  requireProduct(accountId2, id) {
+    const row = this.db.prepare("SELECT * FROM products WHERE id = ? AND account_id = ?").get(id, accountId2);
+    if (!row)
+      throw noSuch("product", id);
+    return row;
+  }
+  listProducts(accountId2, input) {
+    const extra = [];
+    if (input.active !== void 0) {
+      extra.push({ sql: "active = ?", args: [input.active ? 1 : 0] });
+    }
+    return listPaginated(this.db, "products", accountId2, input, extra);
+  }
+  // ---------- Prices ----------
+  createPrice(accountId2, input) {
+    if (!input.currency)
+      throw missingParam("currency");
+    if (!input.product)
+      throw missingParam("product");
+    this.requireProduct(accountId2, input.product);
+    const id = newId("price");
+    this.db.prepare(`INSERT INTO prices (
+          id, account_id, product_id, currency, unit_amount, recurring_interval,
+          recurring_interval_count, active, nickname, lookup_key, metadata_json, created
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, accountId2, input.product, input.currency.toLowerCase(), input.unit_amount ?? null, input.recurring?.interval ?? null, input.recurring ? input.recurring.interval_count ?? 1 : null, input.active === false ? 0 : 1, input.nickname ?? null, input.lookup_key ?? null, JSON.stringify(liveMetadata(input.metadata)), nowUnix());
+    return this.requirePrice(accountId2, id);
+  }
+  requirePrice(accountId2, id) {
+    const row = this.db.prepare("SELECT * FROM prices WHERE id = ? AND account_id = ?").get(id, accountId2);
+    if (!row)
+      throw noSuch("price", id);
+    return row;
+  }
+  listPrices(accountId2, input) {
+    const extra = [];
+    if (input.product)
+      extra.push({ sql: "product_id = ?", args: [input.product] });
+    if (input.active !== void 0) {
+      extra.push({ sql: "active = ?", args: [input.active ? 1 : 0] });
+    }
+    return listPaginated(this.db, "prices", accountId2, input, extra);
+  }
+  // ---------- Subscriptions ----------
+  createSubscription(accountId2, input) {
+    if (!input.customer)
+      throw missingParam("customer");
+    if (!Array.isArray(input.items) || input.items.length === 0) {
+      throw missingParam("items");
+    }
+    const items = input.items.map((item, index) => {
+      if (!item.price)
+        throw missingParam(`items[${index}][price]`);
+      this.requirePrice(accountId2, item.price);
+      return {
+        id: newId("subscription_item"),
+        price: item.price,
+        quantity: item.quantity ?? 1
+      };
+    });
+    const id = newId("subscription");
+    this.db.prepare(`INSERT INTO subscriptions (
+          id, account_id, customer_id, status, items_json, cancel_at_period_end,
+          canceled_at, ended_at, metadata_json, created
+        ) VALUES (?, ?, ?, 'active', ?, ?, NULL, NULL, ?, ?)`).run(id, accountId2, input.customer, JSON.stringify(items), input.cancel_at_period_end ? 1 : 0, JSON.stringify(liveMetadata(input.metadata)), nowUnix());
+    return this.requireSubscription(accountId2, id);
+  }
+  requireSubscription(accountId2, id) {
+    const row = this.db.prepare("SELECT * FROM subscriptions WHERE id = ? AND account_id = ?").get(id, accountId2);
+    if (!row)
+      throw noSuch("subscription", id);
+    return row;
+  }
+  /**
+   * Update: metadata merges per-key (empty/null unsets — Stripe's metadata
+   * contract, same as customers), cancel_at_period_end flips. A canceled
+   * subscription accepts metadata-only updates and refuses everything else,
+   * like real Stripe.
+   */
+  updateSubscription(accountId2, id, input) {
+    const existing = this.requireSubscription(accountId2, id);
+    if (existing.status === "canceled" && input.cancel_at_period_end !== void 0) {
+      throw new TwinError("invalid_request_error", "subscription_canceled", "You cannot update a subscription that is `canceled` or `incomplete_expired`.", { param: "subscription", statusCode: 400 });
+    }
+    const metadata = JSON.parse(existing.metadata_json);
+    for (const [key, value] of Object.entries(input.metadata ?? {})) {
+      if (value === null || value === "")
+        delete metadata[key];
+      else
+        metadata[key] = value;
+    }
+    this.db.prepare("UPDATE subscriptions SET cancel_at_period_end = ?, metadata_json = ? WHERE id = ? AND account_id = ?").run(input.cancel_at_period_end === void 0 ? existing.cancel_at_period_end : input.cancel_at_period_end ? 1 : 0, JSON.stringify(metadata), id, accountId2);
+    return this.requireSubscription(accountId2, id);
+  }
+  /**
+   * DELETE /v1/subscriptions/:id — immediate cancel: status → canceled with
+   * canceled_at/ended_at stamped. Idempotent (re-cancel returns the row);
+   * shape tier, so no invoice settlement or proration runs.
+   */
+  cancelSubscription(accountId2, id) {
+    const existing = this.requireSubscription(accountId2, id);
+    if (existing.status === "canceled")
+      return existing;
+    const now = nowUnix();
+    this.db.prepare("UPDATE subscriptions SET status = 'canceled', canceled_at = ?, ended_at = ? WHERE id = ? AND account_id = ?").run(now, now, id, accountId2);
+    return this.requireSubscription(accountId2, id);
+  }
+  /**
+   * Like real Stripe, the default list excludes canceled subscriptions;
+   * `status=canceled` selects them and `status=all` lifts the filter.
+   */
+  listSubscriptions(accountId2, input) {
+    const extra = [];
+    if (input.customer)
+      extra.push({ sql: "customer_id = ?", args: [input.customer] });
+    if (input.status === void 0) {
+      extra.push({ sql: "status != 'canceled'", args: [] });
+    } else if (input.status !== "all") {
+      extra.push({ sql: "status = ?", args: [input.status] });
+    }
+    return listPaginated(this.db, "subscriptions", accountId2, input, extra);
+  }
+};
+function liveMetadata(metadata) {
+  const out = {};
+  for (const [key, value] of Object.entries(metadata ?? {})) {
+    if (value !== null && value !== "")
+      out[key] = value;
+  }
+  return out;
+}
+function missingParam(param) {
+  return new TwinError("invalid_request_error", "parameter_missing", `Missing required param: ${param}.`, { param, statusCode: 400 });
+}
+function noSuch(kind, id) {
+  return new TwinError("invalid_request_error", "resource_missing", `No such ${kind}: '${id}'.`, { param: kind, statusCode: 404 });
+}
+
+// ../packages/twin-stripe/dist/src/serializers.js
+function paymentIntentJson(row) {
+  const types = piTypes(row);
+  const wireLift = {
+    payment_method_options: types.includes("card") ? {
+      card: {
+        installments: null,
+        mandate_options: null,
+        network: null,
+        request_three_d_secure: "automatic"
+      }
+    } : {
+      crypto: {
+        mode: "deposit",
+        deposit_options: { networks: ["base"] }
+      }
+    },
+    invoice: null
+  };
+  return {
+    id: row.id,
+    object: "payment_intent",
+    amount: row.amount,
+    amount_capturable: 0,
+    amount_received: row.status === "succeeded" ? row.amount : 0,
+    amount_details: { tip: {} },
+    application: null,
+    application_fee_amount: null,
+    automatic_payment_methods: null,
+    canceled_at: row.canceled_at,
+    cancellation_reason: null,
+    // Twin row columns carry the literal Stripe values; the row type is a free
+    // `string`. Narrow to the upstream literal union for the type anchor only
+    // (FDRS-454: the twin faithfully emits a real upstream value), runtime unchanged.
+    capture_method: row.capture_method,
+    client_secret: row.client_secret,
+    confirmation_method: row.confirmation_method,
+    created: row.created,
+    currency: row.currency,
+    customer: row.customer_id,
+    description: null,
+    // Card declines (F-731): the last failed attempt, parsed from the row.
+    // The stored blob is Stripe's LastPaymentError shape; narrow for the
+    // type anchor only (FDRS-454), runtime unchanged.
+    last_payment_error: parseJson(row.last_payment_error_json, null),
+    latest_charge: row.latest_charge_id,
+    livemode: false,
+    metadata: parseJson(row.metadata_json, {}),
+    next_action: row.status === "requires_action" ? parseJson(row.next_action_json, null) : null,
+    on_behalf_of: null,
+    payment_method: row.payment_method_id,
+    payment_method_configuration_details: null,
+    payment_method_types: types,
+    processing: null,
+    receipt_email: null,
+    review: null,
+    setup_future_usage: null,
+    shipping: null,
+    statement_descriptor: null,
+    statement_descriptor_suffix: null,
+    status: row.status,
+    transfer_data: null,
+    transfer_group: null,
+    ...wireLift
+  };
+}
+function chargeJson(row) {
+  const wireLift = { invoice: null };
+  const failed = row.status === "failed";
+  const paymentMethodDetails = parseJson(row.payment_method_details_json, {
+    type: "crypto",
+    crypto: {
+      // Upstream `Charge.PaymentMethodDetails.Crypto.{buyer_address,transaction_hash}`
+      // are `string | undefined`; the twin surfaces `null` pre-settlement (no
+      // on-chain tx yet). Narrow the pre-resolution null for the type anchor only
+      // (FDRS-454), runtime value (null) unchanged.
+      buyer_address: null,
+      network: "base",
+      token_currency: "usdc",
+      transaction_hash: null
+    }
+  });
+  return {
+    id: row.id,
+    object: "charge",
+    amount: row.amount,
+    amount_captured: row.amount_captured,
+    amount_refunded: row.amount_refunded,
+    application: null,
+    application_fee: null,
+    application_fee_amount: null,
+    balance_transaction: row.balance_transaction_id,
+    billing_details: {
+      address: { city: null, country: null, line1: null, line2: null, postal_code: null, state: null },
+      email: null,
+      name: null,
+      phone: null
+    },
+    calculated_statement_descriptor: null,
+    captured: Boolean(row.captured),
+    created: row.created,
+    currency: row.currency,
+    customer: row.customer_id,
+    description: null,
+    disputed: false,
+    failure_balance_transaction: null,
+    // Twin failure columns carry Stripe's literal decline codes; the row
+    // type is a free `string`. Narrow for the type anchor only (FDRS-454).
+    failure_code: row.failure_code,
+    failure_message: row.failure_message,
+    fraud_details: {},
+    livemode: false,
+    metadata: {},
+    on_behalf_of: null,
+    outcome: failed ? {
+      network_status: "declined_by_network",
+      reason: row.failure_decline_code,
+      risk_level: "normal",
+      seller_message: "The bank did not return any further details with this decline.",
+      type: "issuer_declined"
+    } : {
+      network_status: "approved_by_network",
+      reason: null,
+      risk_level: "normal",
+      seller_message: "Payment complete.",
+      type: "authorized"
+    },
+    paid: row.status === "succeeded",
+    payment_intent: row.payment_intent_id,
+    payment_method: row.payment_method_id,
+    // Stored blob is spec-faithful (built from the PM row at mint time);
+    // narrow for the type anchor only (FDRS-454).
+    payment_method_details: paymentMethodDetails,
+    receipt_email: null,
+    receipt_number: null,
+    receipt_url: null,
+    // Stripe semantics: `refunded` is true iff the charge is FULLY refunded.
+    // Partial refunds leave `amount_refunded > 0` but `refunded === false`.
+    refunded: row.amount_refunded >= row.amount,
+    review: null,
+    shipping: null,
+    source_transfer: null,
+    statement_descriptor: null,
+    statement_descriptor_suffix: null,
+    status: row.status,
+    transfer_data: null,
+    transfer_group: null,
+    ...wireLift
+  };
+}
+function refundJson(row) {
+  return {
+    id: row.id,
+    object: "refund",
+    amount: row.amount,
+    balance_transaction: row.balance_transaction_id,
+    charge: row.charge_id,
+    created: row.created,
+    currency: row.currency,
+    metadata: {},
+    payment_intent: row.payment_intent_id,
+    // Twin row `reason` is a free `string`; upstream `Refund.Reason` is a literal
+    // union. Narrow for the type anchor only (FDRS-454), runtime unchanged.
+    reason: row.reason,
+    receipt_number: null,
+    source_transfer_reversal: null,
+    status: row.status,
+    transfer_reversal: null
+  };
+}
+function customerJson(row) {
+  return {
+    id: row.id,
+    object: "customer",
+    address: null,
+    balance: 0,
+    created: row.created,
+    currency: null,
+    default_source: null,
+    delinquent: false,
+    description: row.description,
+    discount: null,
+    email: row.email,
+    invoice_settings: {
+      custom_fields: null,
+      default_payment_method: null,
+      footer: null,
+      rendering_options: null
+    },
+    livemode: false,
+    metadata: parseJson(row.metadata_json, {}),
+    name: row.name,
+    phone: row.phone,
+    preferred_locales: [],
+    shipping: null,
+    tax_exempt: "none",
+    test_clock: null
+  };
+}
+function deletedCustomerJson(row) {
+  return {
+    id: row.id,
+    object: "customer",
+    deleted: true
+  };
+}
+function cardJson(row) {
+  return {
+    brand: row.card_brand,
+    exp_month: row.card_exp_month,
+    exp_year: row.card_exp_year,
+    fingerprint: row.card_fingerprint,
+    funding: "credit",
+    last4: row.card_last4
+  };
+}
+function paymentMethodJson(row) {
+  return {
+    id: row.id,
+    object: "payment_method",
+    billing_details: {
+      address: { city: null, country: null, line1: null, line2: null, postal_code: null, state: null },
+      email: null,
+      name: null,
+      phone: null
+    },
+    card: cardJson(row),
+    created: row.created,
+    customer: row.customer_id,
+    livemode: false,
+    metadata: {},
+    // Twin row `type` is a free `string`; upstream `PaymentMethod.type` is a
+    // literal union. Narrow for the type anchor only (FDRS-454), runtime
+    // value ("card") unchanged.
+    type: row.type
+  };
+}
+function balanceTransactionJson(row) {
+  return {
+    id: row.id,
+    object: "balance_transaction",
+    amount: row.amount,
+    available_on: row.available_on,
+    created: row.created,
+    currency: row.currency,
+    description: null,
+    exchange_rate: null,
+    fee: row.fee,
+    fee_details: [],
+    net: row.net,
+    reporting_category: row.type,
+    source: row.source_id,
+    status: row.status,
+    // Upstream `BalanceTransaction.Type` is a literal union; the twin's ledger
+    // `type` column is a free `string` (carries the x402 deposit categories).
+    // Narrow for the type anchor only (FDRS-454), runtime value unchanged.
+    type: row.type
+  };
+}
+function eventJson(row) {
+  const parsedData = parseJson(row.data_json, { object: null });
+  return {
+    id: row.id,
+    object: "event",
+    api_version: row.api_version,
+    created: row.created,
+    // LIFT (ST-DIV-014): the twin stores the event payload as an opaque parsed
+    // JSON blob (`data.object: unknown`); upstream `Event.Data.object` is a typed
+    // resource union. Narrow for the type anchor only (FDRS-454), runtime unchanged.
+    data: parsedData,
+    livemode: Boolean(row.livemode),
+    pending_webhooks: 0,
+    request: {
+      id: null,
+      idempotency_key: row.request_idempotency_key
+    },
+    // LIFT (ST-DIV-014): twin emits a free `string`; official `EventBase.type`
+    // is the `Event.Type` literal union. Narrow for the anchor only (FDRS-454).
+    type: row.type
+  };
+}
+function productJson(row) {
+  return {
+    id: row.id,
+    object: "product",
+    active: Boolean(row.active),
+    created: row.created,
+    default_price: null,
+    description: row.description,
+    images: [],
+    livemode: false,
+    marketing_features: [],
+    metadata: parseJson(row.metadata_json, {}),
+    name: row.name,
+    package_dimensions: null,
+    shippable: null,
+    tax_code: null,
+    type: "service",
+    unit_label: null,
+    updated: row.updated,
+    url: null
+  };
+}
+function priceJson(row) {
+  const recurring = row.recurring_interval ? {
+    // Twin row `recurring_interval` is a free `string`; upstream
+    // `Price.Recurring.interval` is a literal union. Narrow for the type
+    // anchor only (FDRS-454), runtime unchanged.
+    interval: row.recurring_interval,
+    interval_count: row.recurring_interval_count ?? 1,
+    meter: null,
+    usage_type: "licensed"
+  } : null;
+  return {
+    id: row.id,
+    object: "price",
+    active: Boolean(row.active),
+    billing_scheme: "per_unit",
+    created: row.created,
+    currency: row.currency,
+    custom_unit_amount: null,
+    livemode: false,
+    lookup_key: row.lookup_key,
+    metadata: parseJson(row.metadata_json, {}),
+    nickname: row.nickname,
+    product: row.product_id,
+    recurring,
+    tax_behavior: "unspecified",
+    tiers_mode: null,
+    transform_quantity: null,
+    type: recurring ? "recurring" : "one_time",
+    unit_amount: row.unit_amount,
+    unit_amount_decimal: row.unit_amount === null ? null : String(row.unit_amount)
+  };
+}
+function subscriptionJson(row, itemPrices) {
+  const items = parseJson(row.items_json, []);
+  const firstPrice = items[0] ? itemPrices.get(items[0].price) : void 0;
+  const itemsData = items.map((item) => {
+    const price = itemPrices.get(item.price);
+    return {
+      id: item.id,
+      object: "subscription_item",
+      created: row.created,
+      metadata: {},
+      // Anchor bridge: every stored item price resolves (referential check at
+      // create time); the Map lookup type keeps `undefined` in the signature.
+      price: price ? priceJson(price) : void 0,
+      quantity: item.quantity,
+      subscription: row.id
+    };
+  });
+  return {
+    id: row.id,
+    object: "subscription",
+    billing_cycle_anchor: row.created,
+    cancel_at: null,
+    cancel_at_period_end: Boolean(row.cancel_at_period_end),
+    canceled_at: row.canceled_at,
+    collection_method: "charge_automatically",
+    created: row.created,
+    currency: firstPrice?.currency ?? "usd",
+    customer: row.customer_id,
+    days_until_due: null,
+    default_payment_method: null,
+    description: null,
+    ended_at: row.ended_at,
+    items: {
+      object: "list",
+      data: itemsData,
+      has_more: false,
+      url: `/v1/subscription_items?subscription=${row.id}`
+    },
+    latest_invoice: null,
+    livemode: false,
+    metadata: parseJson(row.metadata_json, {}),
+    start_date: row.created,
+    status: row.status,
+    trial_end: null,
+    trial_start: null
+  };
+}
+function serializedList(data, hasMore, _limit, url) {
+  const envelope = {
+    object: "list",
+    data,
+    has_more: hasMore,
+    url
+  };
+  return envelope;
+}
+function balanceJson(available, pending) {
+  return {
+    object: "balance",
+    // The twin's per-currency balance entries are spec-faithful {amount, currency}
+    // shapes; bridge the domain layer's opaque arrays to the upstream entry type.
+    available,
+    pending,
+    livemode: false
+  };
+}
+function parseJson(value, fallback) {
+  if (!value)
+    return fallback;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+
+// ../packages/twin-stripe/dist/src/domain/stripe-domain.js
+var StripeDomain = class {
+  db;
+  paymentIntents;
+  charges;
+  balance;
+  events;
+  refunds;
+  customers;
+  paymentMethods;
+  billing;
+  constructor(db) {
+    this.db = db;
+    ensureStripeTables(db);
+    this.paymentIntents = new PaymentIntentsDomain(db);
+    this.charges = new ChargesDomain(db);
+    this.balance = new BalanceDomain(db);
+    this.events = new EventsDomain(db);
+    this.refunds = new RefundsDomain(db);
+    this.customers = new CustomersDomain(db);
+    this.paymentMethods = new PaymentMethodsDomain(db);
+    this.billing = new BillingDomain(db);
+  }
+  /** Reset Stripe-domain state. Used by `/admin/reset`. */
+  reset() {
+    resetStripeTables(this.db);
+  }
+  // ---------- PI flows ----------
+  createPaymentIntent(accountId2, input) {
+    const isCard = Array.isArray(input.payment_method_types) && input.payment_method_types.length === 1 && input.payment_method_types[0] === "card";
+    let resolved = {
+      paymentMethodId: null,
+      customerId: null
+    };
+    if (isCard) {
+      const customerId = input.customer ? this.customers.requireLive(accountId2, input.customer).id : null;
+      let paymentMethodId = null;
+      if (input.payment_method) {
+        const pm = this.paymentMethods.requireById(accountId2, input.payment_method);
+        assertPMUsable(pm, customerId);
+        paymentMethodId = pm.id;
+      }
+      resolved = { paymentMethodId, customerId };
+      if (input.confirm && !resolved.paymentMethodId) {
+        throw missingPaymentMethod();
+      }
+    }
+    const pi = this.paymentIntents.create(accountId2, input, resolved);
+    this.events.create(accountId2, { type: "payment_intent.created", object: paymentIntentJson(pi) });
+    if (pi.status === "requires_action") {
+      this.events.create(accountId2, {
+        type: "payment_intent.requires_action",
+        object: paymentIntentJson(pi)
+      });
+    }
+    if (isCard && input.confirm) {
+      const confirmed = this.confirmPaymentIntent(accountId2, pi.id);
+      return {
+        body: confirmed.body,
+        delta: { before: null, after: confirmed.delta?.after ?? rowToRecord(pi) }
+      };
+    }
+    return {
+      body: paymentIntentJson(pi),
+      delta: { before: null, after: rowToRecord(pi) }
+    };
+  }
+  retrievePaymentIntent(accountId2, id) {
+    return paymentIntentJson(this.paymentIntents.requireById(accountId2, id));
+  }
+  listPaymentIntents(accountId2, input) {
+    const { rows, hasMore, limit } = this.paymentIntents.list(accountId2, input);
+    return serializedList(rows.map(paymentIntentJson), hasMore, limit, "/v1/payment_intents");
+  }
+  confirmPaymentIntent(accountId2, id, opts = {}) {
+    const before = this.paymentIntents.requireById(accountId2, id);
+    if (!piTypes(before).includes("card")) {
+      const pi = this.paymentIntents.confirm(accountId2, id);
+      return {
+        body: paymentIntentJson(pi),
+        delta: { before: rowToRecord(before), after: rowToRecord(pi) }
+      };
+    }
+    if (before.status !== "requires_confirmation" && before.status !== "requires_payment_method") {
+      throw piUnexpectedState(before.status);
+    }
+    const pmId = (opts.payment_method || void 0) ?? before.payment_method_id;
+    if (!pmId) {
+      throw missingPaymentMethod();
+    }
+    const pm = this.paymentMethods.requireById(accountId2, pmId);
+    assertPMUsable(pm, before.customer_id);
+    const decline = declineForFingerprint(pm.card_fingerprint);
+    const tx = this.db.transaction(() => {
+      const inFlight = this.paymentIntents.confirmCardLeg1(accountId2, id, before.status, pm.id);
+      const detailsJson = JSON.stringify(cardChargeDetails(pm));
+      if (decline) {
+        const failedCharge = this.charges.createForPI(accountId2, {
+          payment_intent_id: id,
+          amount: inFlight.amount,
+          currency: inFlight.currency,
+          payment_method_id: pm.id,
+          payment_method_details_json: detailsJson,
+          customer_id: inFlight.customer_id,
+          status: "failed",
+          failure_code: decline.code,
+          failure_decline_code: decline.decline_code,
+          failure_message: decline.message
+        });
+        const lastPaymentError = {
+          type: "card_error",
+          code: decline.code,
+          decline_code: decline.decline_code,
+          message: decline.message,
+          payment_method: paymentMethodJson(pm)
+        };
+        const pi2 = this.paymentIntents.finalizeCardDecline(accountId2, id, failedCharge.id, JSON.stringify(lastPaymentError));
+        this.events.create(accountId2, {
+          type: "payment_intent.payment_failed",
+          object: paymentIntentJson(pi2)
+        });
+        this.events.create(accountId2, {
+          type: "charge.failed",
+          object: chargeJson(failedCharge)
+        });
+        return { declined: decline, pi: pi2 };
+      }
+      const balanceTx = this.balance.create(accountId2, {
+        type: "charge",
+        amount: inFlight.amount,
+        fee: 0,
+        currency: inFlight.currency,
+        source_id: id,
+        source_type: "payment_intent"
+      });
+      const charge = this.charges.createForPI(accountId2, {
+        payment_intent_id: id,
+        amount: inFlight.amount,
+        currency: inFlight.currency,
+        balance_transaction_id: balanceTx.id,
+        payment_method_id: pm.id,
+        payment_method_details_json: detailsJson,
+        customer_id: inFlight.customer_id
+      });
+      const pi = this.paymentIntents.finalizeCardSuccess(accountId2, id, charge.id);
+      this.events.create(accountId2, {
+        type: "payment_intent.succeeded",
+        object: paymentIntentJson(pi)
+      });
+      this.events.create(accountId2, {
+        type: "charge.succeeded",
+        object: chargeJson(charge)
+      });
+      return { declined: null, pi };
+    });
+    const result = tx();
+    if (result.declined) {
+      throw new TwinError("card_error", result.declined.code, result.declined.message, {
+        statusCode: 402,
+        decline_code: result.declined.decline_code,
+        payment_intent: paymentIntentJson(result.pi),
+        state_mutation: true,
+        state_delta: { before: rowToRecord(before), after: rowToRecord(result.pi) }
+      });
+    }
+    return {
+      body: paymentIntentJson(result.pi),
+      delta: { before: rowToRecord(before), after: rowToRecord(result.pi) }
+    };
+  }
+  /**
+   * POST /v1/payment_intents/:id (F-731). The ruled retry-with-new-PM step:
+   * metadata merges per-key, and attaching a PM moves the card PI back to
+   * requires_confirmation. PM/customer resolution happens here so unknown
+   * ids 404 with Stripe's resource_missing before any state gate fires.
+   */
+  updatePaymentIntent(accountId2, id, input) {
+    const before = this.paymentIntents.requireById(accountId2, id);
+    const resolved = {};
+    if (input.customer !== void 0) {
+      resolved.customerId = input.customer ? this.customers.requireLive(accountId2, input.customer).id : null;
+    }
+    const effectiveCustomerId = resolved.customerId !== void 0 ? resolved.customerId : before.customer_id;
+    if (input.payment_method !== void 0) {
+      if (input.payment_method) {
+        const pm = this.paymentMethods.requireById(accountId2, input.payment_method);
+        assertPMUsable(pm, effectiveCustomerId);
+        resolved.paymentMethodId = pm.id;
+      } else {
+        resolved.paymentMethodId = null;
+      }
+    } else if (input.customer !== void 0 && before.payment_method_id) {
+      assertPMUsable(this.paymentMethods.requireById(accountId2, before.payment_method_id), effectiveCustomerId);
+    }
+    const pi = this.paymentIntents.update(accountId2, id, input, resolved);
+    return {
+      body: paymentIntentJson(pi),
+      delta: { before: rowToRecord(before), after: rowToRecord(pi) }
+    };
+  }
+  cancelPaymentIntent(accountId2, id) {
+    const before = this.paymentIntents.requireById(accountId2, id);
+    if (before.status === "canceled") {
+      return {
+        body: paymentIntentJson(before),
+        delta: { before: rowToRecord(before), after: rowToRecord(before) }
+      };
+    }
+    const pi = this.paymentIntents.cancel(accountId2, id);
+    this.events.create(accountId2, { type: "payment_intent.canceled", object: paymentIntentJson(pi) });
+    return {
+      body: paymentIntentJson(pi),
+      delta: { before: rowToRecord(before), after: rowToRecord(pi) }
+    };
+  }
+  /**
+   * Drive a PI through requires_action → processing → succeeded.
+   * Emits payment_intent.processing, payment_intent.succeeded,
+   * charge.succeeded events. Mints exactly one charge + one
+   * balance_transaction. CAS guarantees only one parallel caller wins.
+   *
+   * F2: the entire flow runs inside a single better-sqlite3 transaction.
+   * If anything throws between Leg 1 and the final event emit, the
+   * transaction rolls back — no orphan charges/balance txns and no PI
+   * stuck in `processing`. better-sqlite3 transactions are synchronous
+   * and atomic, and the CAS works inside the transaction the same way it
+   * does outside it.
+   */
+  simulateCryptoDeposit(accountId2, id) {
+    const before = this.paymentIntents.requireById(accountId2, id);
+    const tx = this.db.transaction(() => {
+      let pi = this.paymentIntents.simulateCryptoDepositLeg1(accountId2, id);
+      this.events.create(accountId2, {
+        type: "payment_intent.processing",
+        object: paymentIntentJson(pi)
+      });
+      const balanceTx = this.balance.create(accountId2, {
+        type: "charge",
+        amount: pi.amount,
+        fee: 0,
+        currency: pi.currency,
+        source_id: pi.id,
+        source_type: "payment_intent"
+      });
+      const charge = this.charges.createForPI(accountId2, {
+        payment_intent_id: pi.id,
+        amount: pi.amount,
+        currency: pi.currency,
+        balance_transaction_id: balanceTx.id
+      });
+      pi = this.paymentIntents.simulateCryptoDepositLeg2(accountId2, id, charge.id);
+      const finalCharge = this.charges.requireById(accountId2, charge.id);
+      this.events.create(accountId2, {
+        type: "payment_intent.succeeded",
+        object: paymentIntentJson(pi)
+      });
+      this.events.create(accountId2, {
+        type: "charge.succeeded",
+        object: chargeJson(finalCharge)
+      });
+      return { body: paymentIntentJson(pi), after: pi };
+    });
+    const result = tx();
+    return {
+      body: result.body,
+      delta: { before: rowToRecord(before), after: rowToRecord(result.after) }
+    };
+  }
+  // ---------- Refunds ----------
+  /**
+   * Create a refund. Returns the serialized API shape plus a canonical
+   * `state_delta` so the route can hand both to `respond()`.
+   *
+   * F-733: the whole flow — refund INSERT + charges.amount_refunded UPDATE
+   * (inside `refunds.create()`, nested as a savepoint), the negative
+   * refund-type balance transaction, the ledger link backfill, and the
+   * charge.refunded / refund.created events — commits in one better-sqlite3
+   * transaction, mirroring the settle flows.
+   */
+  createRefund(accountId2, input) {
+    const tx = this.db.transaction(() => {
+      const { row: row2, charge } = this.refunds.create(accountId2, input);
+      const balanceTx = this.balance.create(accountId2, {
+        type: "refund",
+        amount: -row2.amount,
+        fee: 0,
+        currency: row2.currency,
+        source_id: row2.id,
+        source_type: "refund"
+      });
+      const linked = this.refunds.linkBalanceTransaction(accountId2, row2.id, balanceTx.id);
+      this.events.create(accountId2, { type: "charge.refunded", object: chargeJson(charge) });
+      this.events.create(accountId2, { type: "refund.created", object: refundJson(linked) });
+      return linked;
+    });
+    const row = tx();
+    return {
+      body: refundJson(row),
+      delta: { before: null, after: rowToRecord(row) }
+    };
+  }
+  retrieveRefund(accountId2, id) {
+    return refundJson(this.refunds.requireById(accountId2, id));
+  }
+  listRefunds(accountId2, input) {
+    const { rows, hasMore, limit } = this.refunds.list(accountId2, input);
+    return serializedList(rows.map(refundJson), hasMore, limit, "/v1/refunds");
+  }
+  // ---------- Customers ----------
+  createCustomer(accountId2, input) {
+    const row = this.customers.create(accountId2, input);
+    this.events.create(accountId2, { type: "customer.created", object: customerJson(row) });
+    return {
+      body: customerJson(row),
+      delta: { before: null, after: rowToRecord(row) }
+    };
+  }
+  /** Deleted customers serve the `{deleted: true}` stub, like real Stripe. */
+  retrieveCustomer(accountId2, id) {
+    const row = this.customers.requireById(accountId2, id);
+    return row.deleted ? deletedCustomerJson(row) : customerJson(row);
+  }
+  updateCustomer(accountId2, id, input) {
+    const before = this.customers.requireLive(accountId2, id);
+    const row = this.customers.update(accountId2, id, input);
+    this.events.create(accountId2, { type: "customer.updated", object: customerJson(row) });
+    return {
+      body: customerJson(row),
+      delta: { before: rowToRecord(before), after: rowToRecord(row) }
+    };
+  }
+  deleteCustomer(accountId2, id) {
+    const before = this.customers.requireById(accountId2, id);
+    const attached = this.paymentMethods.allAttachedToCustomer(accountId2, id);
+    const { row, alreadyDeleted } = this.customers.delete(accountId2, id);
+    if (!alreadyDeleted) {
+      this.events.create(accountId2, { type: "customer.deleted", object: deletedCustomerJson(row) });
+      for (const pm of attached) {
+        this.events.create(accountId2, {
+          type: "payment_method.detached",
+          object: paymentMethodJson(this.paymentMethods.requireById(accountId2, pm.id))
+        });
+      }
+    }
+    return {
+      body: deletedCustomerJson(row),
+      delta: { before: rowToRecord(before), after: rowToRecord(row) }
+    };
+  }
+  listCustomers(accountId2, input) {
+    const { rows, hasMore, limit } = this.customers.list(accountId2, input);
+    return serializedList(rows.map(customerJson), hasMore, limit, "/v1/customers");
+  }
+  listCustomerPaymentMethods(accountId2, customerId, input) {
+    this.customers.requireLive(accountId2, customerId);
+    const { rows, hasMore, limit } = this.paymentMethods.listForCustomer(accountId2, customerId, input);
+    return serializedList(rows.map(paymentMethodJson), hasMore, limit, `/v1/customers/${customerId}/payment_methods`);
+  }
+  // ---------- Payment methods ----------
+  createPaymentMethod(accountId2, input) {
+    const row = this.paymentMethods.create(accountId2, input);
+    return {
+      body: paymentMethodJson(row),
+      delta: { before: null, after: rowToRecord(row) }
+    };
+  }
+  retrievePaymentMethod(accountId2, id) {
+    return paymentMethodJson(this.paymentMethods.requireById(accountId2, id));
+  }
+  attachPaymentMethod(accountId2, id, customerId) {
+    this.customers.requireLive(accountId2, customerId);
+    const before = this.paymentMethods.requireById(accountId2, id);
+    const row = this.paymentMethods.attach(accountId2, id, customerId);
+    this.events.create(accountId2, {
+      type: "payment_method.attached",
+      object: paymentMethodJson(row)
+    });
+    return {
+      body: paymentMethodJson(row),
+      delta: { before: rowToRecord(before), after: rowToRecord(row) }
+    };
+  }
+  detachPaymentMethod(accountId2, id) {
+    const before = this.paymentMethods.requireById(accountId2, id);
+    const row = this.paymentMethods.detach(accountId2, id);
+    this.events.create(accountId2, {
+      type: "payment_method.detached",
+      object: paymentMethodJson(row)
+    });
+    return {
+      body: paymentMethodJson(row),
+      delta: { before: rowToRecord(before), after: rowToRecord(row) }
+    };
+  }
+  // ---------- Charges ----------
+  retrieveCharge(accountId2, id) {
+    return chargeJson(this.charges.requireById(accountId2, id));
+  }
+  listCharges(accountId2, input) {
+    const { rows, hasMore, limit } = this.charges.list(accountId2, input);
+    return serializedList(rows.map(chargeJson), hasMore, limit, "/v1/charges");
+  }
+  // ---------- Balance ----------
+  retrieveBalance(accountId2) {
+    const { available, pending } = this.balance.current(accountId2);
+    return balanceJson(available, pending);
+  }
+  listBalanceTransactions(accountId2, input) {
+    const { rows, hasMore, limit } = this.balance.list(accountId2, input);
+    return serializedList(rows.map(balanceTransactionJson), hasMore, limit, "/v1/balance_transactions");
+  }
+  // ---------- Events ----------
+  retrieveEvent(accountId2, id) {
+    return eventJson(this.events.requireById(accountId2, id));
+  }
+  listEvents(accountId2, input) {
+    const { rows, hasMore, limit } = this.events.list(accountId2, input);
+    return serializedList(rows.map(eventJson), hasMore, limit, "/v1/events");
+  }
+  // ---------- Billing (F-734, shape tier) ----------
+  //
+  // Warm surfaces per the F-729 ruling: stored rows served in Stripe shape,
+  // deliberately WITHOUT the semantic billing machine — creating a product,
+  // price, or subscription emits no events and mints no invoices; the
+  // recorder deltas stay truthful to the single-row writes.
+  createProduct(accountId2, input) {
+    const row = this.billing.createProduct(accountId2, input);
+    return { body: productJson(row), delta: { before: null, after: rowToRecord(row) } };
+  }
+  retrieveProduct(accountId2, id) {
+    return productJson(this.billing.requireProduct(accountId2, id));
+  }
+  listProducts(accountId2, input) {
+    const { rows, hasMore, limit } = this.billing.listProducts(accountId2, input);
+    return serializedList(rows.map(productJson), hasMore, limit, "/v1/products");
+  }
+  createPrice(accountId2, input) {
+    const row = this.billing.createPrice(accountId2, input);
+    return { body: priceJson(row), delta: { before: null, after: rowToRecord(row) } };
+  }
+  retrievePrice(accountId2, id) {
+    return priceJson(this.billing.requirePrice(accountId2, id));
+  }
+  listPrices(accountId2, input) {
+    const { rows, hasMore, limit } = this.billing.listPrices(accountId2, input);
+    return serializedList(rows.map(priceJson), hasMore, limit, "/v1/prices");
+  }
+  createSubscription(accountId2, input) {
+    if (input.customer)
+      this.customers.requireLive(accountId2, input.customer);
+    const row = this.billing.createSubscription(accountId2, input);
+    return {
+      body: this.subscriptionBody(accountId2, row),
+      delta: { before: null, after: rowToRecord(row) }
+    };
+  }
+  retrieveSubscription(accountId2, id) {
+    return this.subscriptionBody(accountId2, this.billing.requireSubscription(accountId2, id));
+  }
+  updateSubscription(accountId2, id, input) {
+    const before = this.billing.requireSubscription(accountId2, id);
+    const row = this.billing.updateSubscription(accountId2, id, input);
+    return {
+      body: this.subscriptionBody(accountId2, row),
+      delta: { before: rowToRecord(before), after: rowToRecord(row) }
+    };
+  }
+  cancelSubscription(accountId2, id) {
+    const before = this.billing.requireSubscription(accountId2, id);
+    const row = this.billing.cancelSubscription(accountId2, id);
+    return {
+      body: this.subscriptionBody(accountId2, row),
+      delta: { before: rowToRecord(before), after: rowToRecord(row) }
+    };
+  }
+  listSubscriptions(accountId2, input) {
+    const { rows, hasMore, limit } = this.billing.listSubscriptions(accountId2, input);
+    return serializedList(rows.map((row) => this.subscriptionBody(accountId2, row)), hasMore, limit, "/v1/subscriptions");
+  }
+  /** Resolve item price rows so the serializer can expand SubscriptionItem.price. */
+  subscriptionBody(accountId2, row) {
+    const items = JSON.parse(row.items_json);
+    const prices = /* @__PURE__ */ new Map();
+    for (const item of items) {
+      if (!prices.has(item.price)) {
+        prices.set(item.price, this.billing.requirePrice(accountId2, item.price));
+      }
+    }
+    return subscriptionJson(row, prices);
+  }
+  // Invoices are reads-only (F-729 ruling point 2: create/finalize/pay stay
+  // unlisted-cold) and nothing in the twin mints one, so the list is always
+  // empty and retrieve always 404s — loud, Stripe-shaped, documented.
+  retrieveInvoice(accountId2, id) {
+    throw noSuch("invoice", id);
+  }
+  listInvoices(accountId2, input) {
+    const limit = Math.min(100, Math.max(1, Math.floor(input.limit ?? 10)));
+    return serializedList([], false, limit, "/v1/invoices");
+  }
+  // ---------- State export (for _pome/state) ----------
+  /**
+   * Account-scoped state export. Used by `/_pome/state` to surface only
+   * the calling session's data. Two sessions hitting `_pome/state` see
+   * disjoint views of the same DB.
+   *
+   * Ordering is `created DESC, rowid DESC`: `created` has unix-second
+   * resolution, so rows minted within the same second tied and flipped
+   * order run-to-run (the F-683 export-race class). The insertion-order
+   * tiebreak keeps the export deterministic — same seed + same ops =>
+   * same state (test/state-export.test.ts).
+   */
+  exportState(accountId2) {
+    const pis = this.db.prepare("SELECT * FROM payment_intents WHERE account_id = ? ORDER BY created DESC, rowid DESC").all(accountId2);
+    const charges = this.db.prepare("SELECT * FROM charges WHERE account_id = ? ORDER BY created DESC, rowid DESC").all(accountId2);
+    const balanceTxs = this.db.prepare("SELECT * FROM balance_transactions WHERE account_id = ? ORDER BY created DESC, rowid DESC").all(accountId2);
+    const events = this.db.prepare("SELECT * FROM events WHERE account_id = ? ORDER BY created DESC, rowid DESC").all(accountId2);
+    const refunds = this.db.prepare("SELECT * FROM refunds WHERE account_id = ? ORDER BY created DESC, rowid DESC").all(accountId2);
+    const customers = this.db.prepare("SELECT * FROM customers WHERE account_id = ? ORDER BY created DESC, rowid DESC").all(accountId2);
+    const paymentMethods = this.db.prepare("SELECT * FROM payment_methods WHERE account_id = ? ORDER BY created DESC, rowid DESC").all(accountId2);
+    const products = this.db.prepare("SELECT * FROM products WHERE account_id = ? ORDER BY created DESC, rowid DESC").all(accountId2);
+    const prices = this.db.prepare("SELECT * FROM prices WHERE account_id = ? ORDER BY created DESC, rowid DESC").all(accountId2);
+    const subscriptions = this.db.prepare("SELECT * FROM subscriptions WHERE account_id = ? ORDER BY created DESC, rowid DESC").all(accountId2);
+    return {
+      payment_intents: pis.map(paymentIntentJson),
+      charges: charges.map(chargeJson),
+      balance_transactions: balanceTxs.map(balanceTransactionJson),
+      events: events.map(eventJson),
+      refunds: refunds.map(refundJson),
+      customers: customers.map((row) => row.deleted ? deletedCustomerJson(row) : customerJson(row)),
+      payment_methods: paymentMethods.map(paymentMethodJson),
+      products: products.map(productJson),
+      prices: prices.map(priceJson),
+      subscriptions: subscriptions.map((row) => this.subscriptionBody(accountId2, row))
+    };
+  }
+};
+function rowToRecord(row) {
+  return { ...row };
+}
+function missingPaymentMethod() {
+  return new TwinError("invalid_request_error", "payment_intent_unexpected_state", "You cannot confirm this PaymentIntent because it's missing a payment method. Update the PaymentIntent with a payment_method and then confirm it again.", { statusCode: 400 });
+}
+function assertPMUsable(pm, customerId) {
+  if (pm.detached) {
+    throw new TwinError("invalid_request_error", "payment_method_previously_detached", "A payment method that has been previously detached from a customer may not be used again.", { param: "payment_method", statusCode: 400 });
+  }
+  if (pm.customer_id && pm.customer_id !== customerId) {
+    throw new TwinError("invalid_request_error", "payment_method_customer_mismatch", "The payment method you provided is attached to a customer. You may only use it with that customer via the `customer` parameter.", { param: "payment_method", statusCode: 400 });
+  }
+}
+function cardChargeDetails(pm) {
+  return { type: "card", card: cardJson(pm) };
+}
+var CACHEABLE_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
+var HANDLER_RESULT_KEY = "twinStripeHandlerResult";
+function setHandlerResult(c, result) {
+  c.set(HANDLER_RESULT_KEY, result);
+}
+function getHandlerResult(c) {
+  return c.get(HANDLER_RESULT_KEY) ?? null;
+}
+function hashRequest(method, path, body) {
+  return createHash("sha256").update(method).update("\0").update(path).update("\0").update(body).digest("hex");
+}
+function getAccountId(c) {
+  const session = c.get("session");
+  if (session)
+    return session.account_id;
+  const sid = c.req.param("sid");
+  return sid ? `acct_${sid}` : "_anon";
+}
+function idempotencyMiddleware(db, recorder, runId = "local") {
+  const select = db.prepare(`SELECT key, account_id, method, path, request_hash, response_status, response_body_json, created_at
+       FROM idempotency_keys
+      WHERE key = ? AND account_id = ? AND method = ? AND path = ?`);
+  const insert = db.prepare(`INSERT INTO idempotency_keys
+       (key, account_id, method, path, request_hash, response_status, response_body_json, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(key, account_id, method, path) DO NOTHING`);
+  const pending = /* @__PURE__ */ new Map();
+  return async (c, next) => {
+    const method = c.req.method.toUpperCase();
+    if (!CACHEABLE_METHODS.has(method)) {
+      await next();
+      return;
+    }
+    const headerKey = c.req.header("Idempotency-Key") ?? c.req.header("idempotency-key");
+    if (!headerKey) {
+      await next();
+      return;
+    }
+    const startedAt = Date.now();
+    const account_id = getAccountId(c);
+    const path = new URL(c.req.url).pathname;
+    const rawBody = await c.req.raw.clone().text().catch(() => "");
+    const requestHash = hashRequest(method, path, rawBody);
+    const pendingKey = [headerKey, account_id, method, path].join("\0");
+    const existing = select.get(headerKey, account_id, method, path);
+    if (existing) {
+      if (existing.request_hash !== requestHash) {
+        const env = stripeError("idempotency_error", "idempotency_key_in_use", `Keys for idempotent requests can only be used with the same parameters they were first used with. Try using a key other than '${headerKey}'.`, { statusCode: 400 });
+        return c.json(env.body, env.status);
+      }
+      let cachedBody;
+      try {
+        cachedBody = JSON.parse(existing.response_body_json);
+      } catch {
+        cachedBody = null;
+      }
+      recordDedupeEvent(c, recorder, runId, startedAt, rawBody, {
+        status: existing.response_status,
+        body: cachedBody
+      });
+      return c.json(cachedBody, existing.response_status);
+    }
+    const inFlight = pending.get(pendingKey);
+    if (inFlight) {
+      if (inFlight.requestHash !== requestHash) {
+        const env = stripeError("idempotency_error", "idempotency_key_in_use", `Keys for idempotent requests can only be used with the same parameters they were first used with. Try using a key other than '${headerKey}'.`, { statusCode: 400 });
+        return c.json(env.body, env.status);
+      }
+      const cached = await inFlight.promise;
+      if (cached.status < 400) {
+        const cachedBody = parseCachedBody(cached.bodyText);
+        recordDedupeEvent(c, recorder, runId, startedAt, rawBody, {
+          status: cached.status,
+          body: cachedBody
+        });
+        return c.json(cachedBody, cached.status);
+      }
+      await next();
+      return;
+    }
+    let resolvePending;
+    let rejectPending;
+    const promise = new Promise((resolve, reject) => {
+      resolvePending = resolve;
+      rejectPending = reject;
+    });
+    pending.set(pendingKey, { requestHash, promise });
+    try {
+      await next();
+    } catch (error) {
+      rejectPending(error);
+      pending.delete(pendingKey);
+      throw error;
+    }
+    try {
+      const handled = getHandlerResult(c);
+      const status = handled ? handled.status : c.res.status;
+      if (status >= 400) {
+        resolvePending({ status, bodyText: "null" });
+        return;
+      }
+      let bodyText = "";
+      if (handled) {
+        bodyText = JSON.stringify(handled.body);
+      } else {
+        const cloned = c.res.clone();
+        try {
+          bodyText = await cloned.text();
+        } catch {
+          bodyText = "";
+        }
+      }
+      try {
+        JSON.parse(bodyText);
+      } catch {
+        bodyText = "null";
+      }
+      insert.run(headerKey, account_id, method, path, requestHash, status, bodyText, nowIso());
+      resolvePending({ status, bodyText });
+    } catch (error) {
+      rejectPending(error);
+      throw error;
+    } finally {
+      pending.delete(pendingKey);
+    }
+  };
+}
+function recordDedupeEvent(c, recorder, runId, startedAt, rawBody, cached) {
+  if (!recorder)
+    return;
+  const reqId = requestId();
+  const stepId = c.req.header("x-pome-scenario-step-id") ?? null;
+  recorder.record({
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    run_id: runId,
+    twin: "stripe",
+    request_id: reqId,
+    correlation_id: c.req.header("x-pome-correlation-id") ?? reqId,
+    task_step_id: stepId,
+    scenario_step_id: stepId,
+    step_id: null,
+    tool_call_id: null,
+    method: c.req.method,
+    path: new URL(c.req.url).pathname,
+    request_body: rawBody === "" ? null : rawBody,
+    // F-1125 — the replay's own headers, which is where `Idempotency-Key`
+    // lives. Recording the dedupe outcome while hiding the key that caused it
+    // would leave the reason unreadable on the one row that is about it.
+    request_headers: recordedRequestHeaders(c),
+    tool: null,
+    status: cached.status,
+    response_body: cached.body,
+    latency_ms: Date.now() - startedAt,
+    fidelity: "semantic",
+    state_mutation: false,
+    state_delta: null,
+    idempotency_dedupe: true,
+    error: null
+  });
+}
+function parseCachedBody(bodyText) {
+  try {
+    return JSON.parse(bodyText);
+  } catch {
+    return null;
+  }
+}
+function accountId(c) {
+  const session = c.get("session");
+  if (!session) {
+    throw new TwinError("api_error", "internal_error", "Missing session context (auth middleware did not run).", { statusCode: 500 });
+  }
+  return session.account_id;
+}
+function ok(body, mutation = false, stateDelta) {
+  return { status: 200, body, mutation, stateDelta };
+}
+function created(body, stateDelta) {
+  return { status: 200, body, mutation: true, stateDelta };
+}
+async function handle(c, recorder, runId, fn) {
+  const started = Date.now();
+  let requestBody = null;
+  try {
+    if (c.req.method !== "GET" && c.req.method !== "HEAD") {
+      try {
+        requestBody = await c.req.raw.clone().text();
+      } catch {
+        requestBody = null;
+      }
+    }
+    const result = await fn();
+    return respond(c, recorder, runId, started, requestBody, result.status, result.body, result.mutation, "semantic", result.stateDelta ?? null);
+  } catch (error) {
+    if (error instanceof TwinError) {
+      return respond(c, recorder, runId, started, requestBody, error.status, error.toEnvelope(), error.state_mutation ?? false, error.fidelity ?? "semantic", error.state_delta ?? null);
+    }
+    if (error instanceof z.ZodError) {
+      const first = error.issues[0];
+      const envelope2 = stripeError("invalid_request_error", "parameter_invalid", first?.message ?? "Invalid request parameters.", { param: first?.path?.join(".") });
+      return respond(c, recorder, runId, started, requestBody, envelope2.status, envelope2.body, false, "semantic", null);
+    }
+    if (error instanceof SyntaxError) {
+      const envelope2 = stripeError("invalid_request_error", "invalid_json", "Could not parse request body as JSON.");
+      return respond(c, recorder, runId, started, requestBody, envelope2.status, envelope2.body, false, "semantic", null);
+    }
+    const envelope = stripeError("api_error", "internal_error", error instanceof Error ? error.message : "Internal Server Error", { statusCode: 500 });
+    return respond(c, recorder, runId, started, requestBody, envelope.status, envelope.body, false, "semantic", null);
+  }
+}
+function respond(c, recorder, runId, started, requestBody, status, responseBody, stateMutation, fidelity = "semantic", stateDelta = null) {
+  const reqId = requestId();
+  setHandlerResult(c, { status, body: responseBody });
+  const override = c.get(FAILURE_INJECTION_OVERRIDE_KEY) ?? null;
+  const finalStatus = override ? override.status : status;
+  const finalBody = override ? override.body : responseBody;
+  const stepId = c.req.header("x-pome-scenario-step-id") ?? null;
+  recorder?.record({
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    run_id: runId,
+    twin: "stripe",
+    request_id: reqId,
+    correlation_id: c.req.header("x-pome-correlation-id") ?? reqId,
+    task_step_id: stepId,
+    scenario_step_id: stepId,
+    step_id: null,
+    tool_call_id: null,
+    method: c.req.method,
+    path: new URL(c.req.url).pathname,
+    request_body: requestBody,
+    // F-1125 — one shared implementation with the engine's own emit(), so
+    // "which headers get recorded" has a single answer across every site.
+    request_headers: recordedRequestHeaders(c),
+    // Stripe's REST routes are not declared as twin actions: no criterion asks
+    // whether a stripe TOOL was called, and stamping a name here that no check
+    // can bind would be an unverifiable claim. MCP dispatch still stamps its
+    // own name through the engine.
+    tool: null,
+    status: finalStatus,
+    response_body: finalBody,
+    latency_ms: Date.now() - started,
+    fidelity,
+    state_mutation: stateMutation,
+    state_delta: stateDelta,
+    error: finalStatus >= 400 ? errorMessage(finalBody) : null
+  });
+  return c.json(finalBody, finalStatus);
+}
+function errorMessage(body) {
+  if (body && typeof body === "object" && "error" in body) {
+    const err = body.error;
+    if (err && typeof err.message === "string")
+      return err.message;
+  }
+  return "request failed";
+}
+function parseListQuery(c) {
+  const limit = c.req.query("limit");
+  const numericLimit = limit !== void 0 ? Number(limit) : void 0;
+  const created2 = createdRangeFromQuery(c);
+  return {
+    limit: Number.isFinite(numericLimit) ? numericLimit : void 0,
+    starting_after: c.req.query("starting_after"),
+    ending_before: c.req.query("ending_before"),
+    ...created2
+  };
+}
+async function readBodyForm(c) {
+  const contentType = c.req.header("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    try {
+      return await c.req.json();
+    } catch {
+      return {};
+    }
+  }
+  if (contentType.includes("application/x-www-form-urlencoded") || contentType.includes("multipart/form-data")) {
+    try {
+      const form = await c.req.parseBody({ all: true });
+      return formToObject(form);
+    } catch {
+      return {};
+    }
+  }
+  try {
+    return await c.req.json();
+  } catch {
+    try {
+      const form = await c.req.parseBody({ all: true });
+      return formToObject(form);
+    } catch {
+      return {};
+    }
+  }
+}
+function formToObject(form) {
+  const out = {};
+  for (const [rawKey, value] of Object.entries(form)) {
+    const path = parseBracketPath(rawKey);
+    setDeep(out, path, value);
+  }
+  return out;
+}
+var POLLUTION_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function parseBracketPath(key) {
+  const parts = [];
+  const regex = /([^\[\]]+)|\[([^\[\]]*)\]/g;
+  let match;
+  while ((match = regex.exec(key)) !== null) {
+    const piece = match[1] ?? match[2] ?? "";
+    if (/^\d+$/.test(piece))
+      parts.push(Number(piece));
+    else
+      parts.push(piece);
+  }
+  return parts;
+}
+function setDeep(target, path, value) {
+  for (const key of path) {
+    if (typeof key === "string" && POLLUTION_KEYS.has(key)) {
+      return;
+    }
+  }
+  let cursor = target;
+  for (let i = 0; i < path.length; i++) {
+    const key = path[i];
+    const isLast = i === path.length - 1;
+    if (isLast) {
+      cursor[key] = value;
+    } else {
+      const nextKey = path[i + 1];
+      if (cursor[key] === void 0) {
+        cursor[key] = typeof nextKey === "number" ? [] : {};
+      }
+      cursor = cursor[key];
+    }
+  }
+}
+function createdRangeFromQuery(c) {
+  const out = {};
+  const flat = c.req.query("created");
+  if (flat !== void 0 && /^\d+$/.test(flat)) {
+    out.created_gte = Number(flat);
+    out.created_lte = Number(flat);
+  }
+  const gt = c.req.query("created[gt]");
+  const gte = c.req.query("created[gte]");
+  const lt = c.req.query("created[lt]");
+  const lte = c.req.query("created[lte]");
+  if (gt && /^\d+$/.test(gt))
+    out.created_gt = Number(gt);
+  if (gte && /^\d+$/.test(gte))
+    out.created_gte = Number(gte);
+  if (lt && /^\d+$/.test(lt))
+    out.created_lt = Number(lt);
+  if (lte && /^\d+$/.test(lte))
+    out.created_lte = Number(lte);
+  return out;
+}
+var formBool = z.union([z.boolean(), z.enum(["true", "false"]).transform((v) => v === "true")]).optional();
+var createPISchema = z.object({
+  amount: z.coerce.number().int().positive(),
+  currency: z.string().min(1),
+  payment_method_types: z.array(z.string()).min(1),
+  payment_method_options: z.object({
+    crypto: z.object({
+      mode: z.literal("deposit"),
+      deposit_options: z.object({
+        networks: z.array(z.string()).min(1).optional()
+      }).optional()
+    })
+  }).optional(),
+  payment_method: z.string().optional(),
+  customer: z.string().optional(),
+  confirm: formBool,
+  metadata: z.record(z.string(), z.string()).optional(),
+  capture_method: z.string().optional(),
+  confirmation_method: z.string().optional()
+});
+var confirmPISchema = z.object({
+  payment_method: z.string().optional()
+});
+var updatePISchema = z.object({
+  amount: z.coerce.number().int().optional(),
+  metadata: z.record(z.string(), z.string().nullable()).optional(),
+  payment_method: z.string().optional(),
+  customer: z.string().optional()
+});
+function registerPaymentIntentRoutes(router, domain, recorder, runId) {
+  router.post("/v1/payment_intents", (c) => handle(c, recorder, runId, async () => {
+    const body = await readBodyForm(c);
+    const input = createPISchema.parse(body);
+    const { body: piBody, delta } = domain.createPaymentIntent(accountId(c), input);
+    return created(piBody, delta);
+  }));
+  router.get("/v1/payment_intents/:id", (c) => handle(c, recorder, runId, () => ok(domain.retrievePaymentIntent(accountId(c), c.req.param("id")))));
+  router.get("/v1/payment_intents", (c) => handle(c, recorder, runId, () => {
+    const list = parseListQuery(c);
+    return ok(domain.listPaymentIntents(accountId(c), list));
+  }));
+  router.post("/v1/payment_intents/:id/confirm", (c) => handle(c, recorder, runId, async () => {
+    const input = confirmPISchema.parse(await readBodyForm(c));
+    const { body, delta } = domain.confirmPaymentIntent(accountId(c), c.req.param("id"), input);
+    return ok(body, true, delta);
+  }));
+  router.post("/v1/payment_intents/:id", (c) => handle(c, recorder, runId, async () => {
+    const input = updatePISchema.parse(await readBodyForm(c));
+    const { body, delta } = domain.updatePaymentIntent(accountId(c), c.req.param("id"), input);
+    return ok(body, true, delta);
+  }));
+  router.post("/v1/payment_intents/:id/cancel", (c) => handle(c, recorder, runId, () => {
+    const { body, delta } = domain.cancelPaymentIntent(accountId(c), c.req.param("id"));
+    return ok(body, true, delta);
+  }));
+  router.post("/v1/test_helpers/payment_intents/:id/simulate_crypto_deposit", (c) => handle(c, recorder, runId, () => {
+    const { body, delta } = domain.simulateCryptoDeposit(accountId(c), c.req.param("id"));
+    return ok(body, true, delta);
+  }));
+}
+
+// ../packages/twin-stripe/dist/src/routes/charges.js
+function registerChargesRoutes(router, domain, recorder, runId) {
+  router.get("/v1/charges/:id", (c) => handle(c, recorder, runId, () => ok(domain.retrieveCharge(accountId(c), c.req.param("id")))));
+  router.get("/v1/charges", (c) => handle(c, recorder, runId, () => {
+    const list = parseListQuery(c);
+    return ok(domain.listCharges(accountId(c), {
+      ...list,
+      payment_intent: c.req.query("payment_intent"),
+      customer: c.req.query("customer")
+    }));
+  }));
+}
+
+// ../packages/twin-stripe/dist/src/routes/balance.js
+function registerBalanceRoutes(router, domain, recorder, runId) {
+  router.get("/v1/balance", (c) => handle(c, recorder, runId, () => ok(domain.retrieveBalance(accountId(c)))));
+  router.get("/v1/balance_transactions", (c) => handle(c, recorder, runId, () => {
+    const list = parseListQuery(c);
+    return ok(domain.listBalanceTransactions(accountId(c), {
+      ...list,
+      type: c.req.query("type")
+    }));
+  }));
+}
+
+// ../packages/twin-stripe/dist/src/routes/events.js
+function registerEventsRoutes(router, domain, recorder, runId) {
+  router.get("/v1/events/:id", (c) => handle(c, recorder, runId, () => ok(domain.retrieveEvent(accountId(c), c.req.param("id")))));
+  router.get("/v1/events", (c) => handle(c, recorder, runId, () => {
+    const list = parseListQuery(c);
+    return ok(domain.listEvents(accountId(c), {
+      ...list,
+      type: c.req.query("type")
+    }));
+  }));
+}
+
+// ../packages/twin-stripe/dist/src/routes/refunds.js
+function registerRefundsRoutes(router, domain, recorder, runId) {
+  router.post("/v1/refunds", (c) => handle(c, recorder, runId, async () => {
+    const body = await readJson(c);
+    const { body: response, delta } = domain.createRefund(accountId(c), {
+      charge: typeof body.charge === "string" ? body.charge : "",
+      amount: typeof body.amount === "number" ? body.amount : void 0,
+      reason: typeof body.reason === "string" ? body.reason : null,
+      idempotency_key: c.req.header("Idempotency-Key") ?? c.req.header("idempotency-key") ?? null
+    });
+    return created(response, delta);
+  }));
+  router.get("/v1/refunds/:id", (c) => handle(c, recorder, runId, () => ok(domain.retrieveRefund(accountId(c), c.req.param("id")))));
+  router.get("/v1/refunds", (c) => handle(c, recorder, runId, () => {
+    const list = parseListQuery(c);
+    return ok(domain.listRefunds(accountId(c), {
+      ...list,
+      charge: c.req.query("charge"),
+      payment_intent: c.req.query("payment_intent")
+    }));
+  }));
+}
+async function readJson(c) {
+  const contentType = c.req.header("content-type") ?? "";
+  if (contentType.includes("application/x-www-form-urlencoded")) {
+    try {
+      const parsed = await c.req.parseBody();
+      return coerceFormBody(parsed);
+    } catch {
+      return {};
+    }
+  }
+  try {
+    const body = await c.req.json();
+    return body && typeof body === "object" ? body : {};
+  } catch {
+    return {};
+  }
+}
+function coerceFormBody(form) {
+  const out = {};
+  for (const [k, v] of Object.entries(form)) {
+    if (typeof v === "string" && /^-?\d+$/.test(v) && k === "amount") {
+      out[k] = Number(v);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+var customerFieldsSchema = z.object({
+  name: z.string().nullish(),
+  email: z.string().nullish(),
+  description: z.string().nullish(),
+  phone: z.string().nullish(),
+  metadata: z.record(z.string(), z.string().nullable()).optional()
+});
+function registerCustomersRoutes(router, domain, recorder, runId) {
+  router.post("/v1/customers", (c) => handle(c, recorder, runId, async () => {
+    const input = customerFieldsSchema.parse(await readBodyForm(c));
+    const { body, delta } = domain.createCustomer(accountId(c), input);
+    return created(body, delta);
+  }));
+  router.get("/v1/customers/:id/payment_methods", (c) => handle(c, recorder, runId, () => {
+    const list = parseListQuery(c);
+    return ok(domain.listCustomerPaymentMethods(accountId(c), c.req.param("id"), {
+      ...list,
+      type: c.req.query("type")
+    }));
+  }));
+  router.get("/v1/customers/:id", (c) => handle(c, recorder, runId, () => ok(domain.retrieveCustomer(accountId(c), c.req.param("id")))));
+  router.post("/v1/customers/:id", (c) => handle(c, recorder, runId, async () => {
+    const input = customerFieldsSchema.parse(await readBodyForm(c));
+    const { body, delta } = domain.updateCustomer(accountId(c), c.req.param("id"), input);
+    return ok(body, true, delta);
+  }));
+  router.delete("/v1/customers/:id", (c) => handle(c, recorder, runId, () => {
+    const { body, delta } = domain.deleteCustomer(accountId(c), c.req.param("id"));
+    return ok(body, true, delta);
+  }));
+  router.get("/v1/customers", (c) => handle(c, recorder, runId, () => {
+    const list = parseListQuery(c);
+    return ok(domain.listCustomers(accountId(c), { ...list, email: c.req.query("email") }));
+  }));
+}
+
+// ../packages/twin-stripe/dist/src/routes/payment-methods.js
+function registerPaymentMethodsRoutes(router, domain, recorder, runId) {
+  router.post("/v1/payment_methods", (c) => handle(c, recorder, runId, async () => {
+    const body = await readBodyForm(c);
+    const { body: response, delta } = domain.createPaymentMethod(accountId(c), body);
+    return created(response, delta);
+  }));
+  router.get("/v1/payment_methods/:id", (c) => handle(c, recorder, runId, () => ok(domain.retrievePaymentMethod(accountId(c), c.req.param("id")))));
+  router.post("/v1/payment_methods/:id/attach", (c) => handle(c, recorder, runId, async () => {
+    const body = await readBodyForm(c);
+    const customer = typeof body.customer === "string" ? body.customer : "";
+    if (!customer) {
+      throw new TwinError("invalid_request_error", "parameter_missing", "Missing required param: customer.", { param: "customer", statusCode: 400 });
+    }
+    const { body: response, delta } = domain.attachPaymentMethod(accountId(c), c.req.param("id"), customer);
+    return ok(response, true, delta);
+  }));
+  router.post("/v1/payment_methods/:id/detach", (c) => handle(c, recorder, runId, () => {
+    const { body, delta } = domain.detachPaymentMethod(accountId(c), c.req.param("id"));
+    return ok(body, true, delta);
+  }));
+}
+var formBool2 = z.union([z.boolean(), z.enum(["true", "false"]).transform((v) => v === "true")]).optional();
+var metadataSchema = z.record(z.string(), z.string().nullable()).optional();
+var productFieldsSchema = z.object({
+  name: z.string().min(1).optional(),
+  description: z.string().nullish(),
+  active: formBool2,
+  metadata: metadataSchema
+});
+var createPriceSchema = z.object({
+  currency: z.string().min(1).optional(),
+  product: z.string().min(1).optional(),
+  unit_amount: z.coerce.number().int().nonnegative().optional(),
+  recurring: z.object({
+    interval: z.string().min(1),
+    interval_count: z.coerce.number().int().positive().optional()
+  }).optional(),
+  nickname: z.string().nullish(),
+  lookup_key: z.string().nullish(),
+  active: formBool2,
+  metadata: metadataSchema
+});
+var createSubscriptionSchema = z.object({
+  customer: z.string().min(1).optional(),
+  items: z.array(z.object({
+    price: z.string().min(1).optional(),
+    quantity: z.coerce.number().int().positive().optional()
+  })).optional(),
+  cancel_at_period_end: formBool2,
+  metadata: metadataSchema
+});
+var updateSubscriptionSchema = z.object({
+  cancel_at_period_end: formBool2,
+  metadata: metadataSchema
+});
+function registerBillingRoutes(router, domain, recorder, runId) {
+  router.post("/v1/products", (c) => handle(c, recorder, runId, async () => {
+    const input = productFieldsSchema.parse(await readBodyForm(c));
+    const { body, delta } = domain.createProduct(accountId(c), input);
+    return created(body, delta);
+  }));
+  router.get("/v1/products/:id", (c) => handle(c, recorder, runId, () => ok(domain.retrieveProduct(accountId(c), c.req.param("id")))));
+  router.get("/v1/products", (c) => handle(c, recorder, runId, () => {
+    const list = parseListQuery(c);
+    return ok(domain.listProducts(accountId(c), { ...list, active: queryBool(c.req.query("active")) }));
+  }));
+  router.post("/v1/prices", (c) => handle(c, recorder, runId, async () => {
+    const input = createPriceSchema.parse(await readBodyForm(c));
+    const { body, delta } = domain.createPrice(accountId(c), input);
+    return created(body, delta);
+  }));
+  router.get("/v1/prices/:id", (c) => handle(c, recorder, runId, () => ok(domain.retrievePrice(accountId(c), c.req.param("id")))));
+  router.get("/v1/prices", (c) => handle(c, recorder, runId, () => {
+    const list = parseListQuery(c);
+    return ok(domain.listPrices(accountId(c), {
+      ...list,
+      product: c.req.query("product"),
+      active: queryBool(c.req.query("active"))
+    }));
+  }));
+  router.post("/v1/subscriptions", (c) => handle(c, recorder, runId, async () => {
+    const input = createSubscriptionSchema.parse(await readBodyForm(c));
+    const { body, delta } = domain.createSubscription(accountId(c), input);
+    return created(body, delta);
+  }));
+  router.get("/v1/subscriptions/:id", (c) => handle(c, recorder, runId, () => ok(domain.retrieveSubscription(accountId(c), c.req.param("id")))));
+  router.post("/v1/subscriptions/:id", (c) => handle(c, recorder, runId, async () => {
+    const input = updateSubscriptionSchema.parse(await readBodyForm(c));
+    const { body, delta } = domain.updateSubscription(accountId(c), c.req.param("id"), input);
+    return ok(body, true, delta);
+  }));
+  router.delete("/v1/subscriptions/:id", (c) => handle(c, recorder, runId, () => {
+    const { body, delta } = domain.cancelSubscription(accountId(c), c.req.param("id"));
+    return ok(body, true, delta);
+  }));
+  router.get("/v1/subscriptions", (c) => handle(c, recorder, runId, () => {
+    const list = parseListQuery(c);
+    return ok(domain.listSubscriptions(accountId(c), {
+      ...list,
+      customer: c.req.query("customer"),
+      status: c.req.query("status")
+    }));
+  }));
+  router.get("/v1/invoices/:id", (c) => handle(c, recorder, runId, () => ok(domain.retrieveInvoice(accountId(c), c.req.param("id")))));
+  router.get("/v1/invoices", (c) => handle(c, recorder, runId, () => ok(domain.listInvoices(accountId(c), parseListQuery(c)))));
+}
+function queryBool(value) {
+  if (value === "true")
+    return true;
+  if (value === "false")
+    return false;
+  return void 0;
+}
+
+// ../packages/twin-stripe/dist/src/routes/index.js
+function registerStripeRoutes(router, domain, recorder, runId) {
+  registerPaymentIntentRoutes(router, domain, recorder, runId);
+  registerChargesRoutes(router, domain, recorder, runId);
+  registerRefundsRoutes(router, domain, recorder, runId);
+  registerCustomersRoutes(router, domain, recorder, runId);
+  registerPaymentMethodsRoutes(router, domain, recorder, runId);
+  registerBillingRoutes(router, domain, recorder, runId);
+  registerBalanceRoutes(router, domain, recorder, runId);
+  registerEventsRoutes(router, domain, recorder, runId);
+  router.all("/v1/*", (c) => {
+    const envelope = unsupported();
+    return respond(c, recorder, runId, Date.now(), null, envelope.status, envelope.body, false, "unsupported");
+  });
+}
+var DEFAULT_SID = "default";
+var DEFAULT_API_KEY = "sk_test_pome_default";
+var PI_STATUSES = [
+  "requires_payment_method",
+  "requires_confirmation",
+  "requires_action",
+  "processing",
+  "requires_capture",
+  "canceled",
+  "succeeded"
+];
+var CHARGE_STATUSES = ["pending", "succeeded", "failed"];
+var REFUND_STATUSES = ["succeeded", "pending", "failed", "canceled"];
+var BALANCE_TX_STATUSES = ["pending", "available"];
+var paymentIntentSeedSchema = z.object({
+  id: z.string().min(1),
+  account_id: z.string().min(1),
+  amount: z.number().int(),
+  currency: z.string().min(1),
+  status: z.enum(PI_STATUSES),
+  payment_method_types: z.array(z.string()).default(["crypto"]),
+  next_action: z.unknown().nullable().optional(),
+  latest_charge_id: z.string().nullable().optional(),
+  capture_method: z.string().default("automatic"),
+  confirmation_method: z.string().default("automatic"),
+  idempotency_key: z.string().nullable().optional(),
+  metadata: z.record(z.string(), z.string()).default({}),
+  crypto_deposit: z.unknown().nullable().optional(),
+  client_secret: z.string().min(1),
+  created: z.number().int(),
+  updated: z.number().int(),
+  canceled_at: z.number().int().nullable().optional(),
+  captured_at: z.number().int().nullable().optional()
+});
+var chargeSeedSchema = z.object({
+  id: z.string().min(1),
+  account_id: z.string().min(1),
+  payment_intent_id: z.string().min(1),
+  amount: z.number().int(),
+  amount_captured: z.number().int().default(0),
+  amount_refunded: z.number().int().default(0),
+  status: z.enum(CHARGE_STATUSES),
+  balance_transaction_id: z.string().nullable().optional(),
+  captured: z.boolean().default(true),
+  currency: z.string().min(1),
+  created: z.number().int()
+});
+var refundSeedSchema = z.object({
+  id: z.string().min(1),
+  account_id: z.string().min(1),
+  charge_id: z.string().min(1),
+  payment_intent_id: z.string().min(1),
+  amount: z.number().int(),
+  currency: z.string().min(1),
+  status: z.enum(REFUND_STATUSES),
+  reason: z.string().nullable().optional(),
+  balance_transaction_id: z.string().nullable().optional(),
+  idempotency_key: z.string().nullable().optional(),
+  created: z.number().int()
+});
+var balanceTransactionSeedSchema = z.object({
+  id: z.string().min(1),
+  account_id: z.string().min(1),
+  type: z.string().min(1),
+  amount: z.number().int(),
+  fee: z.number().int().default(0),
+  net: z.number().int(),
+  currency: z.string().min(1),
+  source_id: z.string().nullable().optional(),
+  source_type: z.string().nullable().optional(),
+  available_on: z.number().int(),
+  status: z.enum(BALANCE_TX_STATUSES).default("available"),
+  created: z.number().int()
+});
+var seedSchema = z.object({
+  api_keys: z.array(z.object({
+    key: z.string().min(1),
+    sid: z.string().min(1),
+    account_id: z.string().min(1).optional()
+  })).default([]),
+  failure_injection: z.array(failureInjectionRuleSchema).default([]),
+  payment_intents: z.array(paymentIntentSeedSchema).default([]),
+  charges: z.array(chargeSeedSchema).default([]),
+  refunds: z.array(refundSeedSchema).default([]),
+  balance_transactions: z.array(balanceTransactionSeedSchema).default([])
+});
+function parseSeed(input) {
+  return seedSchema.parse(input);
+}
+function loadSeedFromEnv(env = process.env) {
+  const raw = env.POME_SEED_JSON;
+  if (raw === void 0 || raw === "") {
+    return defaultSeed();
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`POME_SEED_JSON is not valid JSON: ${err.message}`);
+  }
+  const unwrapped = unwrapStripeSeed(parsed);
+  return parseSeed(unwrapped);
+}
+function unwrapStripeSeed(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const stripeKey = value.stripe;
+    if (stripeKey && typeof stripeKey === "object" && !Array.isArray(stripeKey)) {
+      const inner = stripeKey.seed;
+      if (inner !== void 0) {
+        return inner;
+      }
+    }
+  }
+  return value;
+}
+function defaultSeed() {
+  return {
+    api_keys: [
+      { key: DEFAULT_API_KEY, sid: DEFAULT_SID, account_id: `acct_${DEFAULT_SID}` }
+    ],
+    failure_injection: [],
+    payment_intents: [],
+    charges: [],
+    refunds: [],
+    balance_transactions: []
+  };
+}
+function applySeed(db, seed, failureInjection) {
+  ensureStripeTables(db);
+  for (const entry of seed.api_keys ?? []) {
+    mintApiKey(db, {
+      sid: entry.sid,
+      account_id: entry.account_id,
+      key: entry.key
+    });
+  }
+  for (const row of seed.payment_intents ?? []) {
+    insertSeedPaymentIntent(db, row);
+  }
+  for (const row of seed.charges ?? []) {
+    insertSeedCharge(db, row);
+  }
+  for (const row of seed.balance_transactions ?? []) {
+    insertSeedBalanceTransaction(db, row);
+  }
+  for (const row of seed.refunds ?? []) {
+    insertSeedRefund(db, row);
+  }
+  if (failureInjection) {
+    failureInjection.setRules(seed.failure_injection ?? []);
+  }
+}
+function insertSeedPaymentIntent(db, row) {
+  db.prepare(`INSERT INTO payment_intents (
+      id, account_id, amount, currency, status,
+      payment_method_types_json, next_action_json,
+      latest_charge_id, capture_method, confirmation_method,
+      idempotency_key, metadata_json, crypto_deposit_json,
+      client_secret, created, updated, canceled_at, captured_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.id, row.account_id, row.amount, row.currency, row.status, JSON.stringify(row.payment_method_types), row.next_action === void 0 || row.next_action === null ? null : JSON.stringify(row.next_action), row.latest_charge_id ?? null, row.capture_method, row.confirmation_method, row.idempotency_key ?? null, JSON.stringify(row.metadata), row.crypto_deposit === void 0 || row.crypto_deposit === null ? null : JSON.stringify(row.crypto_deposit), row.client_secret, row.created, row.updated, row.canceled_at ?? null, row.captured_at ?? null);
+}
+function insertSeedCharge(db, row) {
+  db.prepare(`INSERT INTO charges (
+      id, account_id, payment_intent_id, amount, amount_captured, amount_refunded,
+      status, balance_transaction_id, captured, currency, created
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.id, row.account_id, row.payment_intent_id, row.amount, row.amount_captured, row.amount_refunded, row.status, row.balance_transaction_id ?? null, row.captured ? 1 : 0, row.currency, row.created);
+}
+function insertSeedRefund(db, row) {
+  db.prepare(`INSERT INTO refunds (
+      id, account_id, charge_id, payment_intent_id, amount, currency,
+      status, reason, balance_transaction_id, idempotency_key, created
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.id, row.account_id, row.charge_id, row.payment_intent_id, row.amount, row.currency, row.status, row.reason ?? null, row.balance_transaction_id ?? null, row.idempotency_key ?? null, row.created);
+}
+function insertSeedBalanceTransaction(db, row) {
+  db.prepare(`INSERT INTO balance_transactions (
+      id, account_id, type, amount, fee, net, currency, source_id, source_type,
+      available_on, status, created
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.id, row.account_id, row.type, row.amount, row.fee, row.net, row.currency, row.source_id ?? null, row.source_type ?? null, row.available_on, row.status, row.created);
+}
+
+// ../packages/twin-stripe/dist/src/x402.js
+function parsePriceToBaseUnits(price) {
+  const trimmed = price.trim();
+  const match = trimmed.match(/^\$?\s*(\d+(?:\.\d+)?)\s*([A-Za-z]+)?$/);
+  if (!match) {
+    throw new Error(`paymentMiddleware: cannot parse price "${price}"`);
+  }
+  const numStr = match[1];
+  const asset = (match[2] ?? "USDC").toUpperCase();
+  const decimals = 6;
+  const [whole, frac = ""] = numStr.split(".");
+  const fracPadded = (frac + "0".repeat(decimals)).slice(0, decimals);
+  const combined = `${whole}${fracPadded}`.replace(/^0+(?=\d)/, "");
+  return {
+    amount: combined === "" ? "0" : combined,
+    asset,
+    decimals
+  };
+}
+var TwinFacilitatorClient = class {
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  get fetch_() {
+    return this.opts.fetch ?? globalThis.fetch;
+  }
+  url(path) {
+    let base = this.opts.twinBaseUrl;
+    while (base.endsWith("/")) {
+      base = base.slice(0, -1);
+    }
+    return `${base}/s/${encodeURIComponent(this.opts.sid)}${path}`;
+  }
+  headers(extra = {}) {
+    return {
+      Authorization: `Bearer ${this.opts.apiKey}`,
+      "Content-Type": "application/json",
+      ...extra
+    };
+  }
+  /**
+   * Create a crypto-mode PaymentIntent on the twin and pull the deposit
+   * address out of `next_action.crypto_display_details.deposit_addresses.<network>.address`.
+   *
+   * Network parsing: `eip155:84532` → `base`. (We accept either form; v1
+   * supports `base` only.)
+   */
+  async createCryptoPaymentIntent(args) {
+    const networkSlug = networkToSlug(args.network);
+    const body = {
+      amount: args.amount,
+      currency: args.currency,
+      payment_method_types: ["crypto"],
+      payment_method_options: {
+        crypto: {
+          mode: "deposit",
+          deposit_options: { networks: [networkSlug] }
+        }
+      },
+      metadata: args.metadata ?? {}
+    };
+    const res = await this.fetch_(this.url("/v1/payment_intents"), {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const text = await safeReadText(res);
+      throw new Error(`TwinFacilitatorClient.createCryptoPaymentIntent: twin returned ${res.status}: ${text}`);
+    }
+    const pi = await res.json();
+    const id = String(pi.id ?? "");
+    const status = String(pi.status ?? "");
+    const depositAddress = extractDepositAddress(pi, networkSlug);
+    if (!id || !depositAddress) {
+      throw new Error(`TwinFacilitatorClient.createCryptoPaymentIntent: malformed PI from twin: ${JSON.stringify(pi).slice(0, 256)}`);
+    }
+    return { id, depositAddress, status };
+  }
+  async retrievePaymentIntent(id) {
+    const res = await this.fetch_(this.url(`/v1/payment_intents/${encodeURIComponent(id)}`), {
+      method: "GET",
+      headers: this.headers()
+    });
+    if (!res.ok) {
+      const text = await safeReadText(res);
+      throw new Error(`retrievePaymentIntent ${id}: ${res.status} ${text}`);
+    }
+    return await res.json();
+  }
+  /** Settle a crypto-mode PI by calling the test helper. */
+  async simulateCryptoDeposit(piId) {
+    const res = await this.fetch_(this.url(`/v1/test_helpers/payment_intents/${encodeURIComponent(piId)}/simulate_crypto_deposit`), {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify({})
+    });
+    if (!res.ok) {
+      const text = await safeReadText(res);
+      throw new Error(`simulateCryptoDeposit ${piId}: ${res.status} ${text}`);
+    }
+    return await res.json();
+  }
+};
+function networkToSlug(network) {
+  if (/^eip155:/i.test(network))
+    return "base";
+  return network.toLowerCase();
+}
+function extractDepositAddress(pi, networkSlug) {
+  const next = pi.next_action ?? null;
+  const display = next?.crypto_display_details ?? null;
+  const addrs = display?.deposit_addresses ?? null;
+  if (!addrs)
+    return void 0;
+  const entry = addrs[networkSlug] ?? addrs["base"] ?? null;
+  if (!entry)
+    return void 0;
+  return typeof entry === "string" ? entry : entry.address;
+}
+async function safeReadText(res) {
+  try {
+    return await res.text();
+  } catch {
+    return "<unreadable>";
+  }
+}
+function decodeXPayment(header) {
+  const json = base64decodeToString(header);
+  const obj = JSON.parse(json);
+  if (!obj || typeof obj !== "object") {
+    throw new Error("X-PAYMENT: not a JSON object");
+  }
+  const auth = obj?.payload?.authorization;
+  if (!auth || typeof auth.to !== "string" || typeof auth.value !== "string") {
+    throw new Error("X-PAYMENT: missing authorization.to or authorization.value");
+  }
+  return obj;
+}
+function base64decodeToString(b64) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(b64, "base64").toString("utf8");
+  }
+  return atob(b64);
+}
+function base64encodeFromString(s) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(s, "utf8").toString("base64");
+  }
+  return btoa(s);
+}
+var ChallengeCache = class {
+  ttlMs;
+  byPayTo = /* @__PURE__ */ new Map();
+  byPaymentHeader = /* @__PURE__ */ new Map();
+  constructor(ttlMs) {
+    this.ttlMs = ttlMs;
+  }
+  rememberChallenge(c) {
+    this.byPayTo.set(c.payTo.toLowerCase(), c);
+  }
+  lookupByPayTo(payTo) {
+    const hit = this.byPayTo.get(payTo.toLowerCase());
+    if (!hit)
+      return void 0;
+    if (Date.now() - hit.createdAt > this.ttlMs) {
+      this.byPayTo.delete(payTo.toLowerCase());
+      return void 0;
+    }
+    return hit;
+  }
+  rememberSettled(headerB64, result) {
+    this.byPaymentHeader.set(headerB64, { piId: result.piId, status: result.status, result: result.result });
+  }
+  lookupSettled(headerB64) {
+    return this.byPaymentHeader.get(headerB64);
+  }
+  /** Test-only: clear in-memory state. */
+  clear() {
+    this.byPayTo.clear();
+    this.byPaymentHeader.clear();
+  }
+};
+function paymentMiddleware(routes, twinOpts) {
+  const facilitator = new TwinFacilitatorClient(resolveStaticTwinOptions(twinOpts));
+  const cache = new ChallengeCache(twinOpts.challengeTtlMs ?? 5 * 6e4);
+  for (const [key, cfg] of Object.entries(routes)) {
+    if (!/^[A-Z]+\s+\//.test(key)) {
+      throw new Error(`paymentMiddleware: route keys must look like "GET /paid"; got "${key}"`);
+    }
+    if (!cfg.accepts || cfg.accepts.length === 0) {
+      throw new Error(`paymentMiddleware: route "${key}" must declare at least one accepts entry`);
+    }
+    for (const a of cfg.accepts) {
+      if (a.scheme !== "exact") {
+        throw new Error(`paymentMiddleware: only scheme "exact" is supported in v1, got "${a.scheme}"`);
+      }
+    }
+  }
+  const handler = async (c, next) => {
+    const method = c.req.method.toUpperCase();
+    const url = new URL(c.req.url);
+    const routeKey = resolveRouteKey(method, url.pathname, routes);
+    const config = routeKey ? routes[routeKey] : void 0;
+    if (!config || !routeKey) {
+      return next();
+    }
+    const requestFacilitator = new TwinFacilitatorClient(await resolveTwinOptions(c, twinOpts));
+    const headerB64 = c.req.header("X-PAYMENT") ?? c.req.header("x-payment");
+    if (!headerB64) {
+      const body = await build402Body(c, config, requestFacilitator, cache, routeKey);
+      return c.json(body, 402);
+    }
+    let payload;
+    try {
+      payload = decodeXPayment(headerB64);
+    } catch (err) {
+      return c.json({
+        x402Version: 1,
+        error: `X-PAYMENT: malformed (${err.message})`,
+        accepts: await buildAcceptsList(c, config, requestFacilitator, cache, routeKey)
+      }, 402);
+    }
+    const seen = cache.lookupSettled(headerB64);
+    if (seen) {
+      return next();
+    }
+    const auth = payload.payload.authorization;
+    const challenge = cache.lookupByPayTo(auth.to);
+    if (!challenge) {
+      return c.json({
+        x402Version: 1,
+        error: `X-PAYMENT.authorization.to=${auth.to} does not match any active challenge`,
+        accepts: await buildAcceptsList(c, config, requestFacilitator, cache, routeKey)
+      }, 402);
+    }
+    if (auth.value !== challenge.amount) {
+      return c.json({
+        x402Version: 1,
+        error: `X-PAYMENT.authorization.value=${auth.value} does not match required ${challenge.amount}`,
+        accepts: await buildAcceptsList(c, config, requestFacilitator, cache, routeKey)
+      }, 402);
+    }
+    if (challenge.network !== payload.network) {
+      return c.json({
+        x402Version: 1,
+        error: `X-PAYMENT.network=${payload.network} does not match challenge.network=${challenge.network}`,
+        accepts: await buildAcceptsList(c, config, requestFacilitator, cache, routeKey)
+      }, 402);
+    }
+    try {
+      let pi;
+      try {
+        pi = await requestFacilitator.simulateCryptoDeposit(challenge.paymentIntentId);
+      } catch (err) {
+        pi = await requestFacilitator.retrievePaymentIntent(challenge.paymentIntentId);
+        if (pi.status !== "succeeded") {
+          throw err;
+        }
+      }
+      if (pi.status !== "succeeded") {
+        return c.json({
+          x402Version: 1,
+          error: `settlement: PI ${challenge.paymentIntentId} did not advance to succeeded (status=${pi.status})`,
+          accepts: await buildAcceptsList(c, config, requestFacilitator, cache, routeKey, twinOpts)
+        }, 402);
+      }
+      cache.rememberSettled(headerB64, {
+        piId: challenge.paymentIntentId,
+        status: 200,
+        result: pi
+      });
+    } catch (err) {
+      return c.json({
+        x402Version: 1,
+        error: `settlement: ${err.message}`,
+        accepts: await buildAcceptsList(c, config, requestFacilitator, cache, routeKey)
+      }, 402);
+    }
+    const respHeader = base64encodeFromString(JSON.stringify({
+      success: true,
+      transaction: challenge.paymentIntentId,
+      network: challenge.network,
+      payer: auth.from
+    }));
+    c.header("X-PAYMENT-RESPONSE", respHeader);
+    await next();
+  };
+  return Object.assign(handler, {
+    facilitator,
+    _resetCache: () => cache.clear()
+  });
+}
+function resolveRouteKey(method, pathname, routes) {
+  const direct = `${method} ${pathname}`;
+  if (routes[direct])
+    return direct;
+  const sessionless = pathname.replace(/^\/s\/[^/]+/, "") || "/";
+  const stripped = `${method} ${sessionless}`;
+  return routes[stripped] ? stripped : void 0;
+}
+function resolveStaticTwinOptions(opts) {
+  return {
+    ...opts,
+    apiKey: typeof opts.apiKey === "function" ? "sk_test_pome_default" : opts.apiKey,
+    sid: typeof opts.sid === "function" ? "default" : opts.sid
+  };
+}
+async function resolveTwinOptions(c, opts) {
+  return {
+    ...opts,
+    apiKey: await resolveContextValue(c, opts.apiKey),
+    sid: await resolveContextValue(c, opts.sid)
+  };
+}
+async function resolveContextValue(c, value) {
+  if (typeof value === "function") {
+    return value(c);
+  }
+  return value;
+}
+async function build402Body(c, config, facilitator, cache, routeKey, twinOpts) {
+  const accepts = await buildAcceptsList(c, config, facilitator, cache, routeKey);
+  return {
+    x402Version: 1,
+    accepts,
+    error: "payment required"
+  };
+}
+async function buildAcceptsList(c, config, facilitator, cache, routeKey, twinOpts) {
+  const out = [];
+  for (let i = 0; i < config.accepts.length; i++) {
+    const a = config.accepts[i];
+    const parsed = parsePriceToBaseUnits(a.price);
+    const explicitPayTo = await resolveExplicitPayTo(a.payTo, c);
+    let payTo;
+    let piId;
+    if (explicitPayTo) {
+      const created2 = await facilitator.createCryptoPaymentIntent({
+        amount: Number(parsed.amount),
+        // PI currency is always USD per Stripe x402 docs (the on-chain leg
+        // is USDC but Stripe captures the PI in USD). parsed.asset is the
+        // wire asset name (USDC) and stays in the x402 accepts entry below.
+        currency: "usd",
+        network: a.network,
+        metadata: { x402_route: routeKey, x402_explicit_payTo: explicitPayTo }
+      });
+      payTo = explicitPayTo;
+      piId = created2.id;
+    } else {
+      const cached = findReusable(cache, routeKey, i, parsed.amount);
+      if (cached) {
+        payTo = cached.payTo;
+        piId = cached.paymentIntentId;
+      } else {
+        const created2 = await facilitator.createCryptoPaymentIntent({
+          amount: Number(parsed.amount),
+          // PI currency is always USD per Stripe x402 docs (the on-chain leg
+          // is USDC but Stripe captures the PI in USD). parsed.asset is the
+          // wire asset name (USDC) and stays in the x402 accepts entry below.
+          currency: "usd",
+          network: a.network,
+          metadata: { x402_route: routeKey }
+        });
+        payTo = created2.depositAddress;
+        piId = created2.id;
+      }
+    }
+    const entry = {
+      scheme: "exact",
+      network: a.network,
+      maxAmountRequired: parsed.amount,
+      resource: a.resource ?? c.req.url,
+      description: a.description ?? config.description ?? "",
+      mimeType: a.mimeType ?? config.mimeType ?? "application/json",
+      payTo,
+      maxTimeoutSeconds: a.maxTimeoutSeconds ?? 60,
+      asset: a.asset ?? parsed.asset,
+      outputSchema: null,
+      extra: a.extra
+    };
+    out.push(entry);
+    cache.rememberChallenge({
+      routeKey,
+      acceptsIndex: i,
+      payTo,
+      amount: parsed.amount,
+      asset: entry.asset,
+      network: a.network,
+      paymentIntentId: piId,
+      createdAt: Date.now()
+    });
+  }
+  return out;
+}
+function findReusable(cache, routeKey, acceptsIndex, amount) {
+  for (const c of cache.byPayTo.values()) {
+    if (c.routeKey === routeKey && c.acceptsIndex === acceptsIndex && c.amount === amount && Date.now() - c.createdAt < cache.ttlMs) {
+      return c;
+    }
+  }
+  return void 0;
+}
+async function resolveExplicitPayTo(payTo, c) {
+  if (!payTo)
+    return void 0;
+  if (typeof payTo === "string")
+    return payTo;
+  return await payTo(c);
+}
+
+// ../packages/twin-stripe/dist/src/session.js
+function recordGatedExchange(recorder, runId) {
+  return async (c, next) => {
+    const started = Date.now();
+    await next();
+    let responseBody = null;
+    try {
+      responseBody = await c.res.clone().json();
+    } catch {
+      responseBody = null;
+    }
+    const status = c.res.status;
+    recorder.record({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      run_id: runId,
+      twin: "stripe",
+      request_id: `req_${crypto.randomUUID()}`,
+      correlation_id: c.req.header("x-pome-correlation-id") ?? `req_${crypto.randomUUID()}`,
+      task_step_id: c.req.header("x-pome-scenario-step-id") ?? null,
+      scenario_step_id: c.req.header("x-pome-scenario-step-id") ?? null,
+      step_id: null,
+      tool_call_id: null,
+      method: c.req.method,
+      path: new URL(c.req.url).pathname,
+      request_body: null,
+      request_headers: recordedRequestHeaders(c),
+      // No MCP counterpart — x402 is a wire protocol, not a twin action.
+      tool: null,
+      status,
+      response_body: responseBody,
+      latency_ms: Date.now() - started,
+      fidelity: "semantic",
+      state_mutation: false,
+      state_delta: null,
+      error: status >= 400 ? x402Error(responseBody) : null
+    });
+  };
+}
+function x402Error(body) {
+  if (body && typeof body === "object" && "error" in body) {
+    const message = body.error;
+    if (typeof message === "string")
+      return message;
+  }
+  return "payment required";
+}
+function registerX402Routes(session, opts) {
+  session.use("/x402/*", recordGatedExchange(opts.recorder, opts.runId));
+  session.use(paymentMiddleware({
+    "GET /x402/protected-resource": {
+      accepts: [
+        {
+          scheme: "exact",
+          price: "$0.01",
+          network: "eip155:84532",
+          description: "Unlock the hosted Stripe x402 protected resource"
+        }
+      ],
+      description: "Hosted Stripe x402 protected resource",
+      mimeType: "application/json"
+    }
+  }, {
+    twinBaseUrl: opts.twinBaseUrl,
+    sid: (c) => {
+      const sess = c.get("session");
+      return sess?.sid ?? "default";
+    },
+    apiKey: (c) => {
+      const header = c.req.header("authorization") ?? c.req.header("Authorization") ?? "";
+      return header.replace(/^bearer\s+/i, "");
+    }
+  }));
+  session.get("/x402/protected-resource", (c) => c.json({
+    ok: true,
+    resource: "stripe-x402-protected-resource",
+    message: "Payment verified by the Stripe twin."
+  }));
+}
+var piPMTypes = z.array(z.enum(["crypto", "card"])).length(1);
+var cryptoOptions = z.object({
+  mode: z.literal("deposit"),
+  deposit_options: z.object({
+    networks: z.array(z.string()).min(1).optional()
+  }).optional()
+});
+var limitShape = {
+  limit: z.coerce.number().int().min(1).max(100).optional()
+};
+var createdRange = {
+  created: z.union([
+    z.coerce.number().int(),
+    z.object({
+      gt: z.coerce.number().int().optional(),
+      gte: z.coerce.number().int().optional(),
+      lt: z.coerce.number().int().optional(),
+      lte: z.coerce.number().int().optional()
+    })
+  ]).optional()
+};
+function flattenCreated(input) {
+  if (input.created === void 0)
+    return {};
+  if (typeof input.created === "number") {
+    return { created_gte: input.created, created_lte: input.created };
+  }
+  return {
+    created_gt: input.created.gt,
+    created_gte: input.created.gte,
+    created_lt: input.created.lt,
+    created_lte: input.created.lte
+  };
+}
+var toolDefinitions = [
+  {
+    name: "create_payment_intent",
+    description: "Create a PaymentIntent: crypto-deposit (the x402 entry point) or card (optionally with payment_method / customer / confirm).",
+    schema: z.object({
+      amount: z.coerce.number().int().positive(),
+      currency: z.string().min(1),
+      payment_method_types: piPMTypes,
+      payment_method_options: z.object({
+        crypto: cryptoOptions
+      }).optional(),
+      payment_method: z.string().optional(),
+      customer: z.string().optional(),
+      confirm: z.boolean().optional(),
+      metadata: z.record(z.string(), z.string()).optional(),
+      capture_method: z.string().optional(),
+      confirmation_method: z.string().optional()
+    })
+  },
+  {
+    name: "retrieve_payment_intent",
+    description: "Retrieve a PaymentIntent by id.",
+    schema: z.object({ id: z.string().min(1) })
+  },
+  {
+    name: "list_payment_intents",
+    description: "List PaymentIntents with optional filters.",
+    schema: z.object({ ...limitShape, ...createdRange })
+  },
+  {
+    name: "confirm_payment_intent",
+    description: "Confirm a PaymentIntent. Card PIs attempt the charge synchronously (magic test PMs decline); crypto-deposit PIs are idempotent here.",
+    schema: z.object({ id: z.string().min(1), payment_method: z.string().optional() })
+  },
+  {
+    name: "update_payment_intent",
+    description: "Update a non-terminal PaymentIntent (amount, metadata, payment_method, customer). The card retry step: attach a new PM after a decline, then confirm again.",
+    schema: z.object({
+      id: z.string().min(1),
+      amount: z.coerce.number().int().optional(),
+      metadata: z.record(z.string(), z.string().nullable()).optional(),
+      payment_method: z.string().optional(),
+      customer: z.string().optional()
+    })
+  },
+  {
+    name: "cancel_payment_intent",
+    description: "Cancel a PaymentIntent. Refused once succeeded.",
+    schema: z.object({ id: z.string().min(1) })
+  },
+  {
+    name: "simulate_crypto_deposit",
+    description: "Test helper: drive a crypto-deposit PI from requires_action through processing to succeeded.",
+    schema: z.object({ id: z.string().min(1) })
+  },
+  {
+    name: "retrieve_charge",
+    description: "Retrieve a Charge by id.",
+    schema: z.object({ id: z.string().min(1) })
+  },
+  {
+    name: "list_charges",
+    description: "List charges with optional payment_intent / customer / created filters.",
+    schema: z.object({
+      ...limitShape,
+      ...createdRange,
+      payment_intent: z.string().optional(),
+      customer: z.string().optional()
+    })
+  },
+  {
+    name: "create_refund",
+    description: "Refund a charge, fully or partially. Stripe refuses a refund on a charge that is already fully refunded, or one that would exceed the remaining refundable amount.",
+    schema: z.object({
+      charge: z.string().min(1),
+      amount: z.coerce.number().int().positive().optional(),
+      reason: z.string().optional()
+    })
+  },
+  {
+    name: "retrieve_refund",
+    description: "Retrieve a Refund by id.",
+    schema: z.object({ id: z.string().min(1) })
+  },
+  {
+    name: "list_refunds",
+    description: "List refunds, optionally filtered by charge or payment_intent.",
+    schema: z.object({
+      ...limitShape,
+      ...createdRange,
+      charge: z.string().optional(),
+      payment_intent: z.string().optional()
+    })
+  },
+  {
+    name: "create_customer",
+    description: "Create a customer. All fields optional, like real Stripe.",
+    schema: z.object({
+      name: z.string().optional(),
+      email: z.string().optional(),
+      description: z.string().optional(),
+      phone: z.string().optional(),
+      metadata: z.record(z.string(), z.string()).optional()
+    })
+  },
+  {
+    name: "retrieve_customer",
+    description: "Retrieve a Customer by id. Deleted customers return the {deleted: true} stub.",
+    schema: z.object({ id: z.string().min(1) })
+  },
+  {
+    name: "update_customer",
+    description: "Update a customer's fields. Metadata merges per-key; a null or empty value unsets the key.",
+    schema: z.object({
+      id: z.string().min(1),
+      name: z.string().optional(),
+      email: z.string().optional(),
+      description: z.string().optional(),
+      phone: z.string().optional(),
+      // Nullable values mirror the REST surface: null (or "") unsets the key.
+      metadata: z.record(z.string(), z.string().nullable()).optional()
+    })
+  },
+  {
+    name: "delete_customer",
+    description: "Delete a customer (soft delete; its payment methods are detached).",
+    schema: z.object({ id: z.string().min(1) })
+  },
+  {
+    name: "list_customers",
+    description: "List customers with optional email / created filters.",
+    schema: z.object({
+      ...limitShape,
+      ...createdRange,
+      email: z.string().optional()
+    })
+  },
+  {
+    name: "list_customer_payment_methods",
+    description: "List the payment methods attached to a customer.",
+    schema: z.object({
+      customer: z.string().min(1),
+      type: z.string().optional(),
+      ...limitShape
+    })
+  },
+  {
+    name: "create_payment_method",
+    description: "Create a card payment method from test card details (e.g. number 4242424242424242).",
+    schema: z.object({
+      type: z.literal("card"),
+      card: z.object({
+        number: z.string().min(1),
+        exp_month: z.coerce.number().int(),
+        exp_year: z.coerce.number().int(),
+        cvc: z.string().optional()
+      })
+    })
+  },
+  {
+    name: "retrieve_payment_method",
+    description: "Retrieve a PaymentMethod by id.",
+    schema: z.object({ id: z.string().min(1) })
+  },
+  {
+    name: "attach_payment_method",
+    description: "Attach a payment method to a customer. One customer per PM; a detached PM cannot be reattached.",
+    schema: z.object({ id: z.string().min(1), customer: z.string().min(1) })
+  },
+  {
+    name: "detach_payment_method",
+    description: "Detach a payment method from its customer.",
+    schema: z.object({ id: z.string().min(1) })
+  },
+  {
+    name: "retrieve_balance",
+    description: "Retrieve the current balance (available + pending per currency).",
+    schema: z.object({}).optional()
+  },
+  {
+    name: "list_balance_transactions",
+    description: "List balance transactions (charges, refunds, fees).",
+    schema: z.object({
+      ...limitShape,
+      ...createdRange,
+      type: z.string().optional()
+    })
+  },
+  {
+    name: "retrieve_event",
+    description: "Retrieve an event by id.",
+    schema: z.object({ id: z.string().min(1) })
+  },
+  {
+    name: "list_events",
+    description: "List events. Filter by type and created.",
+    schema: z.object({
+      ...limitShape,
+      ...createdRange,
+      type: z.string().optional()
+    })
+  }
+];
+function listTools() {
+  return toolDefinitions.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    input_schema: schemaToJson(tool.schema)
+  }));
+}
+function isMutatingTool(name) {
+  return [
+    "create_payment_intent",
+    "confirm_payment_intent",
+    "update_payment_intent",
+    "cancel_payment_intent",
+    "simulate_crypto_deposit",
+    "create_refund",
+    "create_customer",
+    "update_customer",
+    "delete_customer",
+    "create_payment_method",
+    "attach_payment_method",
+    "detach_payment_method"
+  ].includes(name);
+}
+function executeTool(domain, accountId2, name, input) {
+  const definition = toolDefinitions.find((tool) => tool.name === name);
+  if (!definition) {
+    throw new TwinError("invalid_request_error", "tool_unknown", `No such MCP tool: '${name}'.`, { param: "tool", statusCode: 400 });
+  }
+  const parsed = definition.schema.parse(input ?? {});
+  switch (name) {
+    case "create_payment_intent":
+      return domain.createPaymentIntent(accountId2, parsed).body;
+    case "retrieve_payment_intent":
+      return domain.retrievePaymentIntent(accountId2, parsed.id);
+    case "list_payment_intents": {
+      const flat = flattenCreated(parsed);
+      return domain.listPaymentIntents(accountId2, { ...parsed, ...flat });
+    }
+    case "confirm_payment_intent":
+      return domain.confirmPaymentIntent(accountId2, parsed.id, {
+        payment_method: parsed.payment_method
+      }).body;
+    case "update_payment_intent": {
+      const { id, ...fields } = parsed;
+      return domain.updatePaymentIntent(accountId2, id, fields).body;
+    }
+    case "cancel_payment_intent":
+      return domain.cancelPaymentIntent(accountId2, parsed.id).body;
+    case "simulate_crypto_deposit":
+      return domain.simulateCryptoDeposit(accountId2, parsed.id).body;
+    case "retrieve_charge":
+      return domain.retrieveCharge(accountId2, parsed.id);
+    case "list_charges": {
+      const flat = flattenCreated(parsed);
+      return domain.listCharges(accountId2, { ...parsed, ...flat });
+    }
+    case "create_refund":
+      return domain.createRefund(accountId2, parsed).body;
+    case "retrieve_refund":
+      return domain.retrieveRefund(accountId2, parsed.id);
+    case "list_refunds": {
+      const flat = flattenCreated(parsed);
+      return domain.listRefunds(accountId2, { ...parsed, ...flat });
+    }
+    case "create_customer":
+      return domain.createCustomer(accountId2, parsed).body;
+    case "retrieve_customer":
+      return domain.retrieveCustomer(accountId2, parsed.id);
+    case "update_customer": {
+      const { id, ...fields } = parsed;
+      return domain.updateCustomer(accountId2, id, fields).body;
+    }
+    case "delete_customer":
+      return domain.deleteCustomer(accountId2, parsed.id).body;
+    case "list_customers": {
+      const flat = flattenCreated(parsed);
+      return domain.listCustomers(accountId2, { ...parsed, ...flat });
+    }
+    case "list_customer_payment_methods": {
+      const { customer, ...rest } = parsed;
+      return domain.listCustomerPaymentMethods(accountId2, customer, rest);
+    }
+    case "create_payment_method":
+      return domain.createPaymentMethod(accountId2, parsed).body;
+    case "retrieve_payment_method":
+      return domain.retrievePaymentMethod(accountId2, parsed.id);
+    case "attach_payment_method":
+      return domain.attachPaymentMethod(accountId2, parsed.id, parsed.customer).body;
+    case "detach_payment_method":
+      return domain.detachPaymentMethod(accountId2, parsed.id).body;
+    case "retrieve_balance":
+      return domain.retrieveBalance(accountId2);
+    case "list_balance_transactions": {
+      const flat = flattenCreated(parsed);
+      return domain.listBalanceTransactions(accountId2, { ...parsed, ...flat });
+    }
+    case "retrieve_event":
+      return domain.retrieveEvent(accountId2, parsed.id);
+    case "list_events": {
+      const flat = flattenCreated(parsed);
+      return domain.listEvents(accountId2, { ...parsed, ...flat });
+    }
+  }
+}
+function schemaToJson(schema) {
+  const candidate = z.toJSONSchema;
+  if (typeof candidate === "function") {
+    try {
+      return candidate(schema);
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+
+// ../packages/twin-stripe/dist/src/twin.js
+var stripeSeedSchema = z.preprocess((value) => value === null || value === void 0 ? defaultSeed() : value, seedSchema);
+function tthwSeconds(startedAtMs, nowMs = Date.now) {
+  const ms = Math.max(0, nowMs() - startedAtMs);
+  return Number((ms / 1e3).toFixed(3));
+}
+function accountIdFrom(session) {
+  return typeof session?.account_id === "string" ? session.account_id : "acct_default";
+}
+function zodIssues(err) {
+  if (err instanceof ZodError)
+    return err.issues;
+  if (err instanceof Error && err.name === "ZodError" && Array.isArray(err.issues)) {
+    return err.issues;
+  }
+  return void 0;
+}
+function stripeErrorEnvelope(err) {
+  if (err instanceof UnknownToolError) {
+    return stripeError("invalid_request_error", "tool_unknown", `No such MCP tool: '${err.tool}'.`, {
+      param: "tool",
+      statusCode: 400
+    });
+  }
+  if (err instanceof TwinError) {
+    return { status: err.status, body: err.toEnvelope() };
+  }
+  const issues = zodIssues(err);
+  if (issues) {
+    const first = issues[0];
+    return stripeError("invalid_request_error", "parameter_invalid", first?.message ?? "Invalid request parameters.", {
+      param: first?.path?.join(".")
+    });
+  }
+  if (err instanceof SyntaxError) {
+    return stripeError("invalid_request_error", "invalid_json", "Could not parse request body as JSON.");
+  }
+  return stripeError("api_error", "internal_error", err instanceof Error ? err.message : "Internal Server Error", { statusCode: 500 });
+}
+var toolListing = new Map(listTools().map((tool) => [tool.name, tool]));
+function createStripeTwinDefinition(opts) {
+  const { db } = opts;
+  const startedAtMs = opts.startedAtMs ?? Date.now();
+  const failureInjection = createFailureInjectionStore();
+  return defineTwin({
+    id: "stripe",
+    version: process.env.POME_TWIN_VERSION ?? "0.1.0",
+    implementation: "stripe_clone",
+    packageName: "@pome-sh/twin-stripe",
+    fidelity: { default: "semantic" },
+    // Pre-port: `payload === null ? defaultSeed() : parseSeed(payload)` —
+    // an absent/unparseable seed body applies the default world.
+    seed: z.preprocess((value) => value === null || value === void 0 ? defaultSeed() : value, stripeSeedSchema),
+    domain: ({ db: injected, seed }) => {
+      if (injected && injected !== db) {
+        throw new Error("twin-stripe: the db passed to createApp/serve must be the db the definition was created with");
+      }
+      const domain = new StripeDomain(db);
+      if (seed !== void 0)
+        applySeed(db, seed, failureInjection);
+      return domain;
+    },
+    // Session-wide middleware (the pre-port `session.use("*")` position):
+    // mounted by the engine BEFORE its MCP routes, so failure injection and
+    // idempotency cover /mcp, /mcp/call, /mcp/tools/:name exactly as the
+    // pre-port chassis did (F-684 review pin: an Idempotency-Key'd MCP
+    // create must replay, and injected rules on MCP paths must fire).
+    middleware: (app, ctx) => {
+      app.use("*", failureInjectionMiddleware(failureInjection, {
+        recorder: ctx.recorder,
+        runId: ctx.runId,
+        twin: "stripe"
+      }));
+      app.use("*", idempotencyMiddleware(db, ctx.recorder, ctx.runId));
+    },
+    // Frozen pre-port body parsing on the engine-owned surfaces (F-684
+    // review pin). Two pre-port readers existed: /admin/seed was strict
+    // JSON with a null fallback (null → default seed via the schema
+    // preprocess below), while the MCP dispatch surfaces used
+    // routes/index.ts's form-or-JSON reader ({} fallback).
+    bodyReader: async (c) => {
+      if (new URL(c.req.url).pathname.endsWith("/admin/seed")) {
+        try {
+          return await c.req.json();
+        } catch {
+          return null;
+        }
+      }
+      const contentType = c.req.header("content-type") ?? "";
+      if (contentType.includes("application/x-www-form-urlencoded")) {
+        try {
+          return await c.req.parseBody();
+        } catch {
+          return {};
+        }
+      }
+      try {
+        return await c.req.json();
+      } catch {
+        return {};
+      }
+    },
+    routes: (app, ctx) => {
+      opts.extendRoutes?.(app, ctx);
+      registerStripeRoutes(app, ctx.domain, ctx.recorder, ctx.runId);
+      if (opts.twinBaseUrl) {
+        registerX402Routes(app, {
+          twinBaseUrl: opts.twinBaseUrl,
+          recorder: ctx.recorder,
+          runId: ctx.runId
+        });
+      }
+    },
+    // Account-scoped state export (F1): two sessions sharing a DB see
+    // disjoint `/_pome/state` views.
+    state: ({ domain, session }) => session ? domain.exportState(accountIdFrom(session)) : { payment_intents: [], charges: [], balance_transactions: [], events: [] },
+    admin: {
+      reset: () => {
+        resetDatabase(db);
+        applySeed(db, defaultSeed(), failureInjection);
+        return { ok: true, message: "Stripe twin state reset to default seed." };
+      },
+      seed: ({ seed }) => {
+        resetDatabase(db);
+        applySeed(db, seed, failureInjection);
+        return {
+          ok: true,
+          api_keys: (seed.api_keys ?? []).length,
+          failure_injection: (seed.failure_injection ?? []).length
+        };
+      },
+      // Frozen tape shape: stripe's pre-port recorder never saw admin
+      // traffic — /admin/reset|seed emit no events (F-684 review pin).
+      recorded: false,
+      // Frozen stripe admin-gate 403 body.
+      forbidden: () => forbidden("Forbidden")
+    },
+    tools: toolDefinitions.map((def) => ({
+      name: def.name,
+      description: def.description,
+      schema: def.schema,
+      mutation: isMutatingTool(def.name),
+      inputSchema: toolListing.get(def.name)?.input_schema,
+      handler: (domain, args, ctx) => executeTool(domain, accountIdFrom(ctx.session), def.name, args)
+    })),
+    // Frozen healthz extras: fidelity + tthw_seconds on top of the contract
+    // core {ok, twin, implementation, tools, runtime}.
+    healthz: () => ({ fidelity: "semantic", tthw_seconds: tthwSeconds(startedAtMs) }),
+    // Frozen per-session health shape: implementation/fidelity/tthw/runtime
+    // plus recorder counters (bounded store: real dropped count, D-ENG-10).
+    pomeHealth: ({ recorder }) => ({
+      implementation: "stripe_clone",
+      fidelity: "semantic",
+      tthw_seconds: tthwSeconds(startedAtMs),
+      runtime: twinBuildInfo("@pome-sh/twin-stripe"),
+      recorder: { events: recorder.count(), dropped: recorder.dropped() }
+    }),
+    // Frozen per-twin difference: stripe has NO per-session /healthz (501).
+    sessionHealthz: false,
+    // F3 SDK-compat root mount: stripe-node/stripe-python URLs (/v1/*) hit
+    // the same session router; the bearer alone resolves the sid.
+    mountSessionAtRoot: true,
+    unsupported: () => unsupported(),
+    errorEnvelope: stripeErrorEnvelope,
+    auth: {
+      // F-712 pins: liberal bearer parsing ON (raw token + case-insensitive
+      // "bearer"); sid mismatch → 403; api_keys table lookup ahead of
+      // provider-shaped verify + JWT; no path sid required (root mount);
+      // expired-vs-invalid classified by the engine and rendered through
+      // the frozen unauthorized envelope.
+      providerToken: { provider: "stripe", prefixes: ["sk_test_pome_"] },
+      providerSession: (sid) => ({ account_id: `acct_${sid}`, via: "api_key" }),
+      allowRawBearer: true,
+      requirePathSid: false,
+      resolveCredential: (token) => {
+        if (!looksLikeApiKey(token))
+          return void 0;
+        const row = resolveSidFromKey(db, token);
+        return row ? { sid: row.sid, account_id: row.account_id, via: "api_key" } : void 0;
+      },
+      unauthorized: (kind, info) => {
+        const message = kind === "expired" ? "Token expired" : info?.token && looksLikeApiKey(info.token) ? "Invalid API Key provided." : "Bad credentials";
+        const envelope = unauthorized(message);
+        return { status: envelope.status, body: envelope.body };
+      },
+      sidMismatch: () => {
+        const envelope = forbidden("Session id mismatch.");
+        return { status: envelope.status, body: envelope.body };
+      },
+      sessionExtras: (claims) => ({
+        account_id: typeof claims.account_id === "string" ? claims.account_id : `acct_${claims.sid}`,
+        via: "jwt"
+      })
+    }
+  });
+}
+function createTwinStripeApp(opts = {}) {
+  const db = opts.db ?? openTwinStripeDatabase(":memory:");
+  const definition = createStripeTwinDefinition({
+    db,
+    twinBaseUrl: opts.twinBaseUrl,
+    startedAtMs: opts.startedAtMs,
+    extendRoutes: opts.extendRoutes
+  });
+  const seed = opts.noSeed ? void 0 : opts.seed ?? (opts.db ? void 0 : defaultSeed());
+  return createApp(definition, {
+    db,
+    recorder: opts.recorder,
+    runId: opts.runId ?? "local",
+    seed
+  });
+}
+
+export { DEFAULT_API_KEY, DEFAULT_SID, StripeDomain, applySeed, createStripeTwinDefinition, createTwinStripeApp, defaultSeed, executeTool, isMutatingTool, listTools, loadSeedFromEnv, migrate, mintApiKey, openTwinStripeDatabase, parseSeed, paymentMiddleware, registerStripeRoutes, registerX402Routes, resetDatabase, resolveSidFromKey, revokeApiKey, seedSchema, toolDefinitions, tthwSeconds };