@volter/twin-stripe 2.0.37 → 3.0.0

package/src/semantics/transfers.ts

@@ -1,37 +1,12 @@
-// Transfer and application-fee semantics: money the platform moves to a connected account and
-// claws back (reversals), and the platform's fee on a connected charge and its refunds. A
-// reversal or fee refund never exceeds what is left, and lands on its parent's totals and list.
-// A transfer goes only to an account whose transfers capability is active, comes out of the
-// platform's available balance, and lands in the destination's (docs.stripe.com/connect/separate-
-// charges-and-transfers); a reversal moves it back.
-// A transfer tied to a charge (`source_transaction`, "Transfer availability" in the same guide) "returns success
-// regardless of your available balance if the related charge hasn't settled yet", but "the funds don't become
-// available in the destination account until the funds from the associated charge are available"; a charge whose funds
-// are already available by the World's clock is no exception, and the transfer is held to the available balance as any
-// other. "The amount of the transfer must not exceed the amount of the source charge", several transfers may share one
-// charge while "the sum of the transfers doesn't exceed the source charge", and the charge's balance currency must
-// match. "If the source charge has a `transfer_group` value, Stripe assigns the same value to the transfer's
-// `transfer_group`. If it doesn't, then Stripe generates a string in the format `group_` plus the associated
-// PaymentIntent ID ... It assigns that string as the `transfer_group` for both the charge and the transfer."
-// Where the documentation stops and the twin decides: the sum from one charge counts each transfer less what was
-// reversed of it; a transfer_group the request names is kept only when the charge has none and no PaymentIntent to
-// name one after; an uncaptured charge (an authorization, docs silent) is refused as a source_transaction until it is
-// captured; the refusals' wording is the twin's.
-// Transfer list, retrieve and update and application-fee list and retrieve are the derived core's.
-import type { Semantics, SemanticsContext } from '@volter/world-core';
-import { validateMoney } from '../stripe-twin.ts';
-import { refusePayout, settleTransfer, settleTransferReversal } from './ledger.ts';
-import { at, created, fail, list, newest, send, type Row } from './shared.ts';
-
-const transferMissing = (ctx: SemanticsContext, id: string): Response => fail(ctx, `No such transfer: '${id}'`, 404, 'resource_missing');
-const emptyList = (url: string): Row => ({ object: 'list', data: [], has_more: false, total_count: 0, url });
-
-/** A transfer to an account whose transfers capability is not active. */
-function transfersInactive(ctx: SemanticsContext): Response {
-  return ctx.refuse({ status: 400, code: 'insufficient_capabilities_for_transfer', param: 'destination', message: 'Your destination account needs to have at least one of the following capabilities enabled: transfers, crypto_transfers, legacy_payments' });
-}
-
-const create: Semantics = async (ctx) => {
+// Stripe's transfers operations (docs/contributing/architecture.md, "What an author writes"): each handler over the
+// handler contract's context, computing with the engine (../engine/).
+import type { HandlerContext } from '@volter/world-core';
+import type { Row } from '../engine/common.ts';
+import { nowUnix, validateMoney } from '../engine/stripe.ts';
+import { emptyList } from '../engine/transfers.ts';
+import { at, created, fail, giveBack, list, newest, refusePayout, send, settledSourceRefused, settleTransfer, settleTransferReversal, transferMissing, transfersInactive } from './shared.ts';
+
+export async function PostTransfers(ctx: HandlerContext): Promise<Response> {
   const bad = validateMoney(ctx.params);
   if (bad) return send(ctx, bad);
   const destination = typeof ctx.params.destination === 'string' ? ctx.params.destination : '';
@@ -55,9 +30,9 @@ const create: Semantics = async (ctx) => {
     if (already + amount > Number(charge.amount ?? 0)) return fail(ctx, `The transfers from source_transaction ${sourceId} would exceed its amount (${String(charge.amount)}).`, 400, 'invalid_request_error');
     const bt = typeof charge.balance_transaction === 'string' ? ctx.get('balance_transaction', charge.balance_transaction) : undefined;
     // a charge that has settled waives nothing: the transfer comes out of what is available
-    const settledRefusal = bt && Number(bt.available_on) <= Number(ctx.now()) ? settledSourceRefused(ctx, amount, currency) : undefined;
+    const settledRefusal = bt && Number(bt.available_on) <= Number(nowUnix(ctx.occurredAt)) ? settledSourceRefused(ctx, amount, currency) : undefined;
     if (settledRefusal) return settledRefusal;
-    availableOn = Math.max(Number(ctx.now()), Number(bt?.available_on) || 0);
+    availableOn = Math.max(Number(nowUnix(ctx.occurredAt)), Number(bt?.available_on) || 0);
     group = typeof charge.transfer_group === 'string' ? charge.transfer_group : typeof charge.payment_intent === 'string' ? `group_${charge.payment_intent}` : undefined;
     // the generated group is the charge's too
     if (group && charge.transfer_group !== group) await ctx.write('charge', sourceId, { transfer_group: group }, 'charge.transfer_group_assigned');
@@ -75,100 +50,5 @@ const create: Semantics = async (ctx) => {
       destination_payment: `py_${id.replace(/^tr_/, '')}`,
     }),
   );
-};
-
-/** A transfer from a charge whose funds have settled: "With a source_transaction, the transfer request returns success
- *  regardless of your available balance if the related charge hasn't settled yet" (docs.stripe.com/connect/separate-
- *  charges-and-transfers), so a settled one comes out of the available balance. */
-function settledSourceRefused(ctx: SemanticsContext, amount: number, currency: string): Response | undefined {
-  return refusePayout(ctx, amount, currency, undefined);
-}
-
-/** An application fee refunded to its whole through its own refunds endpoint: the fee machine's move, or its refusal. */
-function feeFullyRefunded(ctx: SemanticsContext, resource: string, flag: string, id: string): Response | undefined {
-  const refused = ctx.legal(resource, flag, ctx.call.operation.id, 'false', 'true', id);
-  return refused ? ctx.refuse(refused) : undefined;
 }
 
-/** Take `amount` (the remainder by default) back out of a parent's total, as a child row appended to its list. */
-async function giveBack(ctx: SemanticsContext, o: {
-  parent: Row; parentResource: string; child: string; childFields: (amount: number) => Row; childDefaults: Row;
-  doneField: string; flag: string; listUrl: string; op: string; tooLarge: (remaining: number) => string;
-  /** what the money movement itself writes, once the child exists */
-  settle?: (child: Row, amount: number) => Promise<void>;
-}): Promise<Response> {
-  const id = String(o.parent.id);
-  const total = Number(o.parent.amount ?? 0);
-  const already = Number(o.parent[o.doneField] ?? 0);
-  const remaining = total - already;
-  const amount = ctx.params.amount !== undefined ? Math.trunc(Number(ctx.params.amount) || 0) : remaining;
-  if (amount <= 0 || amount > remaining) return fail(ctx, o.tooLarge(remaining), 400, 'amount_too_large');
-  const done = already + amount;
-  // a fee refunded in full is `refunded`: the application fee machine's move (a transfer's `reversed` is no state)
-  const feeRefusal = o.parentResource === 'application_fee' && done >= total && o.parent[o.flag] !== true ? feeFullyRefunded(ctx, o.parentResource, o.flag, id) : undefined;
-  if (feeRefusal) return feeRefusal;
-  // the `metadata` a reversal or a fee refund is created with is its own ("Set of key-value pairs that you can attach to
-  // an object", docs.stripe.com/api/transfer_reversals/create, docs.stripe.com/api/fee_refunds/create)
-  const metadata = ctx.params.metadata && typeof ctx.params.metadata === 'object' ? { metadata: ctx.params.metadata } : {};
-  const child = await created(ctx, o.child, { ...o.childFields(amount), ...metadata }, o.childDefaults);
-  if (o.settle) await o.settle(child, amount);
-  const existing = (o.parent[o.flag === 'reversed' ? 'reversals' : 'refunds'] as Row) ?? { object: 'list', data: [], has_more: false, total_count: 0 };
-  const data = [...((existing.data as unknown[]) ?? []), child];
-  await ctx.write(o.parentResource, id, {
-    [o.doneField]: done, [o.flag]: done >= total,
-    [o.flag === 'reversed' ? 'reversals' : 'refunds']: { ...existing, data, total_count: data.length, url: o.listUrl },
-  }, o.op);
-  return ctx.reply(child);
-}
-
-const reverse: Semantics = async (ctx) => {
-  const id = at(ctx, 'id');
-  const tr = ctx.get('transfer', id);
-  if (!tr) return transferMissing(ctx, id);
-  return giveBack(ctx, {
-    parent: tr, parentResource: 'transfer', child: 'transfer_reversal',
-    childFields: (amount) => ({ amount, currency: tr.currency ?? 'usd', transfer: id }),
-    childDefaults: { balance_transaction: null, destination_payment_refund: null, source_refund: null, metadata: {} },
-    doneField: 'amount_reversed', flag: 'reversed', listUrl: `/v1/transfers/${id}/reversals`, op: 'transfer.reversed',
-    tooLarge: (remaining) => `Transfer ${id} can only be reversed up to ${remaining}.`,
-    settle: async (child, amount) => {
-      const bt = await settleTransferReversal(ctx, String(child.id), amount, String(tr.currency ?? 'usd'), String(tr.destination));
-      await ctx.write('transfer_reversal', String(child.id), { balance_transaction: bt }, 'transfer_reversal.updated');
-    },
-  });
-};
-
-const reversals: Semantics = async (ctx) => {
-  const id = at(ctx, 'id');
-  if (!ctx.get('transfer', id)) return transferMissing(ctx, id);
-  return list(ctx, 'transfer_reversal', newest(ctx, 'transfer_reversal').filter((r) => r.transfer === id));
-};
-
-const feeMissing = (ctx: SemanticsContext, id: string): Response => fail(ctx, `No such application fee: '${id}'`, 404, 'resource_missing');
-
-const refundFee: Semantics = async (ctx) => {
-  const id = at(ctx, 'id');
-  const fee = ctx.get('application_fee', id);
-  if (!fee) return feeMissing(ctx, id);
-  return giveBack(ctx, {
-    parent: fee, parentResource: 'application_fee', child: 'fee_refund',
-    childFields: (amount) => ({ amount, currency: fee.currency ?? 'usd', fee: id }),
-    childDefaults: { balance_transaction: null, metadata: {} },
-    doneField: 'amount_refunded', flag: 'refunded', listUrl: `/v1/application_fees/${id}/refunds`, op: 'application_fee.refunded',
-    tooLarge: (remaining) => `Application fee ${id} can only be refunded up to ${remaining}.`,
-  });
-};
-
-const feeRefunds: Semantics = async (ctx) => {
-  const id = at(ctx, 'id');
-  if (!ctx.get('application_fee', id)) return feeMissing(ctx, id);
-  return list(ctx, 'fee_refund', newest(ctx, 'fee_refund').filter((r) => r.fee === id));
-};
-
-export const transfers: Record<string, Semantics> = {
-  PostTransfers: create,
-  PostTransfersIdReversals: reverse,
-  GetTransfersIdReversals: reversals,
-  PostApplicationFeesIdRefunds: refundFee,
-  GetApplicationFeesIdRefunds: feeRefunds,
-};

package/src/server.ts

@@ -0,0 +1,8 @@
+// FETCH-FIRST (runtime contract R12b): a fixed file, the kernel's serve seam around the pack's fetch (./fetch.ts).
+import { serveHttp, type PackFetchOptions } from '@volter/world-core';
+import { createStripeFetch } from './fetch.ts';
+
+export async function createStripeTwinServer(options: PackFetchOptions & { port?: number } = {}): Promise<{ port: number; stop: () => void }> {
+  const server = await serveHttp({ port: options.port ?? 0, idleTimeout: 60, fetch: createStripeFetch(options) });
+  return { port: server.port ?? options.port ?? 0, stop: () => server.stop(true) };
+}

package/client/dashboard-api.ts

@@ -1,286 +0,0 @@
-// The Stripe Dashboard's reads and writes, through Stripe's own API on this origin (docs/contributing/
-// architecture.md, "Screens": a workspace reads and writes only through the pack's operations). The calls
-// the Dashboard makes for the pages it shows: the balance, payments (PaymentIntents and the Charges they
-// made), refunds, customers and their saved payment methods, subscriptions, invoices, products and prices,
-// and events for a detail page's timeline. The writes a person makes here: refund a payment
-// (POST /v1/refunds), cancel a subscription (DELETE /v1/subscriptions/{id}, or schedule it with
-// cancel_at_period_end), create a customer or a product. Bodies are form-encoded as Stripe's API takes them;
-// an `error` envelope, never the HTTP status alone, is what refuses.
-
-type Json = any;
-export type StripeObject = Record<string, any>;
-
-export function wireBaseFrom(hasBaseElement: boolean, baseURI: string): string {
-  return hasBaseElement ? new URL('.', baseURI).pathname.replace(/\/$/, '') : '';
-}
-// Served at the origin root the base is ''; served under a path prefix (an embedder's earlier <base>) every
-// call resolves inside that prefix.
-export const API_BASE = typeof document === 'undefined' ? '' : wireBaseFrom(document.querySelector('base[href]') !== null, document.baseURI);
-
-export class StripeApiError extends Error {
-  constructor(message: string, readonly code?: string) { super(message); }
-}
-
-async function call(method: string, path: string, body?: Record<string, string | number | boolean | undefined>): Promise<Json> {
-  const init: RequestInit = { method, headers: { accept: 'application/json' } };
-  if (body) {
-    const form = Object.entries(body).filter(([, v]) => v !== undefined && v !== '').map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join('&');
-    init.body = form;
-    (init.headers as Record<string, string>)['content-type'] = 'application/x-www-form-urlencoded';
-  }
-  const res = await fetch(`${API_BASE}${path}`, init);
-  const json = await res.json().catch(() => ({ error: { message: `${res.status} ${res.statusText}` } }));
-  if (json && json.error) throw new StripeApiError(String(json.error.message ?? 'Request failed'), json.error.code);
-  return json;
-}
-
-export const retrieve = (path: string): Promise<StripeObject> => call('GET', path);
-/** A list endpoint's `data`, newest first as Stripe returns it (one page of up to 100). */
-export async function list(path: string): Promise<StripeObject[]> {
-  const sep = path.includes('?') ? '&' : '?';
-  const body = await call('GET', `${path}${sep}limit=100`);
-  return Array.isArray(body?.data) ? body.data : [];
-}
-const optional = <T>(p: Promise<T>, fallback: T): Promise<T> => p.catch(() => fallback);
-
-// ── what a payment row is ────────────────────────────────────────────────────
-/** One row of the Payments list: a PaymentIntent (or a Charge made without one) with what the Dashboard
- *  shows beside it — its charge, refunds, card and customer. */
-export type Payment = {
-  id: string;
-  amount: number;
-  currency: string;
-  status: PaymentStatus;
-  description?: string;
-  created: number;
-  customer?: StripeObject;
-  charge?: StripeObject;
-  intent?: StripeObject;
-  paymentMethod?: StripeObject;
-  amountRefunded: number;
-  refundedAt?: number;
-  declineReason?: string;
-  declineMessage?: string;
-};
-export type PaymentStatus = 'succeeded' | 'refunded' | 'partially_refunded' | 'failed' | 'incomplete' | 'uncaptured' | 'canceled' | 'disputed' | 'processing';
-
-export function paymentStatusOf(intent: StripeObject | undefined, charge: StripeObject | undefined): PaymentStatus {
-  if (charge?.disputed) return 'disputed';
-  if (charge?.refunded) return 'refunded';
-  if (charge && Number(charge.amount_refunded) > 0) return 'partially_refunded';
-  if (charge?.status === 'failed') return 'failed';
-  if (intent) {
-    if (intent.status === 'succeeded') return 'succeeded';
-    if (intent.status === 'canceled') return 'canceled';
-    if (intent.status === 'requires_capture') return 'uncaptured';
-    if (intent.status === 'processing') return 'processing';
-    if (intent.last_payment_error) return 'failed';
-    return 'incomplete';
-  }
-  return charge?.status === 'succeeded' ? 'succeeded' : charge?.status === 'pending' ? 'processing' : 'failed';
-}
-
-const DECLINE_REASONS: Record<string, string> = {
-  generic_decline: 'Generic decline', insufficient_funds: 'Insufficient funds', lost_card: 'Lost card', stolen_card: 'Stolen card',
-  expired_card: 'Expired card', incorrect_cvc: 'Incorrect CVC', processing_error: 'Processing error', card_declined: 'Card declined',
-};
-export const declineReasonText = (code: string | undefined): string | undefined => (code ? DECLINE_REASONS[code] ?? code.replace(/_/g, ' ') : undefined);
-
-type Directory = { customers: Map<string, StripeObject>; paymentMethods: Map<string, StripeObject> };
-
-async function paymentMethodsById(ids: Iterable<string>): Promise<Map<string, StripeObject>> {
-  const unique = [...new Set([...ids].filter((id) => typeof id === 'string' && id.startsWith('pm_')))];
-  const found = await Promise.all(unique.map((id) => optional(retrieve(`/v1/payment_methods/${id}`), undefined as StripeObject | undefined)));
-  return new Map(found.filter((pm): pm is StripeObject => Boolean(pm?.id)).map((pm) => [pm.id, pm]));
-}
-
-function paymentOf(intent: StripeObject | undefined, charge: StripeObject | undefined, refunds: StripeObject[], dir: Directory): Payment {
-  const base = intent ?? charge!;
-  const customerId = typeof base.customer === 'string' ? base.customer : base.customer?.id;
-  const pmId = typeof base.payment_method === 'string' ? base.payment_method : charge?.payment_method;
-  const error = intent?.last_payment_error;
-  const refundsOf = refunds.filter((r) => (intent && r.payment_intent === intent.id) || (charge && r.charge === charge.id));
-  return {
-    id: String(base.id),
-    amount: Number(base.amount) || 0,
-    currency: String(base.currency ?? 'usd'),
-    status: paymentStatusOf(intent, charge),
-    description: base.description ?? charge?.description ?? undefined,
-    created: Number(base.created) || 0,
-    customer: customerId ? dir.customers.get(customerId) ?? { id: customerId } : undefined,
-    charge, intent,
-    paymentMethod: pmId ? dir.paymentMethods.get(pmId) : undefined,
-    amountRefunded: Number(charge?.amount_refunded) || refundsOf.reduce((n, r) => n + (r.status === 'failed' ? 0 : Number(r.amount) || 0), 0),
-    refundedAt: refundsOf.length ? Math.max(...refundsOf.map((r) => Number(r.created) || 0)) : undefined,
-    declineReason: declineReasonText(error?.decline_code ?? error?.code ?? charge?.failure_code),
-    declineMessage: error?.message ?? charge?.failure_message ?? undefined,
-  };
-}
-
-/** The Payments list: every PaymentIntent, and every Charge made without one. */
-export async function loadPayments(): Promise<Payment[]> {
-  const [intents, charges, refunds, customers] = await Promise.all([
-    list('/v1/payment_intents'), list('/v1/charges'), optional(list('/v1/refunds'), []), list('/v1/customers'),
-  ]);
-  const chargeById = new Map(charges.map((c) => [c.id, c]));
-  const pmIds = [...intents.map((i) => i.payment_method), ...charges.map((c) => c.payment_method)];
-  const dir: Directory = { customers: new Map(customers.map((c) => [c.id, c])), paymentMethods: await paymentMethodsById(pmIds) };
-  const rows = intents.map((pi) => {
-    const charge = (typeof pi.latest_charge === 'string' ? chargeById.get(pi.latest_charge) : pi.latest_charge) ?? charges.find((c) => c.payment_intent === pi.id);
-    return paymentOf(pi, charge, refunds, dir);
-  });
-  for (const ch of charges) if (!ch.payment_intent) rows.push(paymentOf(undefined, ch, refunds, dir));
-  return rows.sort((a, b) => b.created - a.created);
-}
-
-export type PaymentDetail = Payment & { refunds: StripeObject[]; events: StripeObject[]; invoice?: StripeObject };
-
-/** One payment's page: the intent (or charge), its charge, refunds, card, customer and the events about it. */
-export async function loadPayment(id: string): Promise<PaymentDetail> {
-  let intent: StripeObject | undefined;
-  let charge: StripeObject | undefined;
-  if (id.startsWith('ch_') || id.startsWith('py_')) {
-    charge = await retrieve(`/v1/charges/${id}`);
-    if (typeof charge.payment_intent === 'string') intent = await optional(retrieve(`/v1/payment_intents/${charge.payment_intent}`), undefined);
-  } else {
-    intent = await retrieve(`/v1/payment_intents/${id}`);
-    const chargeId = typeof intent.latest_charge === 'string' ? intent.latest_charge : intent.latest_charge?.id;
-    if (chargeId) charge = await optional(retrieve(`/v1/charges/${chargeId}`), undefined);
-  }
-  const base = intent ?? charge!;
-  const customerId = typeof base.customer === 'string' ? base.customer : undefined;
-  const pmId = typeof base.payment_method === 'string' ? base.payment_method : charge?.payment_method;
-  const refundPath = intent ? `/v1/refunds?payment_intent=${intent.id}` : `/v1/refunds?charge=${charge!.id}`;
-  const [customer, pms, refunds, events, invoice] = await Promise.all([
-    customerId ? optional(retrieve(`/v1/customers/${customerId}`), { id: customerId }) : Promise.resolve(undefined),
-    paymentMethodsById(pmId ? [pmId] : []),
-    optional(list(refundPath), []),
-    optional(list('/v1/events'), []),
-    typeof base.invoice === 'string' ? optional(retrieve(`/v1/invoices/${base.invoice}`), undefined) : Promise.resolve(undefined),
-  ]);
-  const dir: Directory = { customers: new Map(customer ? [[customer.id, customer]] : []), paymentMethods: pms };
-  const related = new Set<string>([base.id, charge?.id, intent?.id, ...refunds.map((r) => r.id)].filter(Boolean) as string[]);
-  return {
-    ...paymentOf(intent, charge, refunds, dir),
-    refunds,
-    events: events.filter((e) => related.has(e?.data?.object?.id)).sort((a, b) => b.created - a.created),
-    invoice,
-  };
-}
-
-// ── customers ────────────────────────────────────────────────────────────────
-export type CustomerRow = StripeObject & { defaultCard?: StripeObject; totalSpend: number; payments: number; refunds: number; currency: string };
-
-export async function loadCustomers(): Promise<CustomerRow[]> {
-  const [customers, charges, intents] = await Promise.all([list('/v1/customers'), list('/v1/charges'), list('/v1/payment_intents')]);
-  const pmIds = customers.map((c) => c.invoice_settings?.default_payment_method).filter((x) => typeof x === 'string');
-  const pms = await paymentMethodsById(pmIds);
-  return customers.map((c) => {
-    const mine = charges.filter((ch) => ch.customer === c.id && ch.status === 'succeeded');
-    const pmId = c.invoice_settings?.default_payment_method;
-    return {
-      ...c,
-      defaultCard: typeof pmId === 'string' ? pms.get(pmId) : undefined,
-      totalSpend: mine.reduce((n, ch) => n + (Number(ch.amount_captured ?? ch.amount) || 0) - (Number(ch.amount_refunded) || 0), 0),
-      payments: intents.filter((i) => i.customer === c.id && i.status === 'succeeded').length || mine.length,
-      refunds: mine.reduce((n, ch) => n + (Number(ch.amount_refunded) || 0), 0),
-      currency: String(mine[0]?.currency ?? c.currency ?? 'usd'),
-    };
-  });
-}
-
-export type CustomerDetail = {
-  customer: StripeObject;
-  paymentMethods: StripeObject[];
-  subscriptions: StripeObject[];
-  invoices: StripeObject[];
-  payments: Payment[];
-  products: Map<string, StripeObject>;
-  events: StripeObject[];
-};
-
-export async function loadCustomer(id: string): Promise<CustomerDetail> {
-  const customer = await retrieve(`/v1/customers/${id}`);
-  const [paymentMethods, subscriptions, invoices, payments, products, events] = await Promise.all([
-    optional(list(`/v1/customers/${id}/payment_methods`), []),
-    optional(list(`/v1/subscriptions?customer=${id}&status=all`), []),
-    optional(list(`/v1/invoices?customer=${id}`), []),
-    loadPayments().then((all) => all.filter((p) => p.customer?.id === id)),
-    optional(list('/v1/products'), []),
-    optional(list('/v1/events'), []),
-  ]);
-  const mine = new Set([id, ...subscriptions.map((s) => s.id), ...invoices.map((i) => i.id), ...payments.map((p) => p.id)]);
-  return {
-    customer, paymentMethods, subscriptions, invoices, payments,
-    products: new Map(products.map((p) => [p.id, p])),
-    events: events.filter((e) => mine.has(e?.data?.object?.id)).sort((a, b) => b.created - a.created),
-  };
-}
-
-// ── billing ──────────────────────────────────────────────────────────────────
-export type Billing = { subscriptions: StripeObject[]; customers: Map<string, StripeObject>; products: Map<string, StripeObject> };
-
-export async function loadSubscriptions(): Promise<Billing> {
-  const [subscriptions, customers, products] = await Promise.all([list('/v1/subscriptions?status=all'), list('/v1/customers'), list('/v1/products')]);
-  return { subscriptions, customers: new Map(customers.map((c) => [c.id, c])), products: new Map(products.map((p) => [p.id, p])) };
-}
-
-export type SubscriptionDetail = { subscription: StripeObject; customer?: StripeObject; invoices: StripeObject[]; products: Map<string, StripeObject>; events: StripeObject[]; paymentMethod?: StripeObject };
-
-export async function loadSubscription(id: string): Promise<SubscriptionDetail> {
-  const subscription = await retrieve(`/v1/subscriptions/${id}`);
-  const customerId = typeof subscription.customer === 'string' ? subscription.customer : subscription.customer?.id;
-  const [customer, invoices, products, events] = await Promise.all([
-    customerId ? optional(retrieve(`/v1/customers/${customerId}`), undefined) : Promise.resolve(undefined),
-    optional(list(`/v1/invoices?subscription=${id}`), []),
-    optional(list('/v1/products'), []),
-    optional(list('/v1/events'), []),
-  ]);
-  const pmId = subscription.default_payment_method ?? customer?.invoice_settings?.default_payment_method;
-  const pms = await paymentMethodsById(typeof pmId === 'string' ? [pmId] : []);
-  return {
-    subscription, customer, invoices, products: new Map(products.map((p) => [p.id, p])),
-    events: events.filter((e) => e?.data?.object?.id === id).sort((a, b) => b.created - a.created),
-    paymentMethod: typeof pmId === 'string' ? pms.get(pmId) : undefined,
-  };
-}
-
-export async function loadInvoices(): Promise<{ invoices: StripeObject[]; customers: Map<string, StripeObject> }> {
-  const [invoices, customers] = await Promise.all([list('/v1/invoices'), list('/v1/customers')]);
-  return { invoices, customers: new Map(customers.map((c) => [c.id, c])) };
-}
-
-export async function loadProducts(): Promise<{ products: StripeObject[]; prices: StripeObject[] }> {
-  const [products, prices] = await Promise.all([list('/v1/products'), list('/v1/prices')]);
-  return { products, prices };
-}
-
-export type HomeData = { balance: StripeObject; payments: Payment[]; customers: StripeObject[]; subscriptions: StripeObject[]; invoices: StripeObject[] };
-export async function loadHome(): Promise<HomeData> {
-  const [balance, payments, customers, subscriptions, invoices] = await Promise.all([
-    retrieve('/v1/balance'), loadPayments(), list('/v1/customers'), optional(list('/v1/subscriptions?status=all'), []), optional(list('/v1/invoices'), []),
-  ]);
-  return { balance, payments, customers, subscriptions, invoices };
-}
-
-export async function loadBalances(): Promise<{ balance: StripeObject; transactions: StripeObject[]; payouts: StripeObject[] }> {
-  const [balance, transactions, payouts] = await Promise.all([retrieve('/v1/balance'), optional(list('/v1/balance_transactions'), []), optional(list('/v1/payouts'), [])]);
-  return { balance, transactions, payouts };
-}
-
-export async function loadDevelopers(): Promise<{ events: StripeObject[]; webhooks: StripeObject[]; account?: StripeObject }> {
-  const [events, webhooks, account] = await Promise.all([optional(list('/v1/events'), []), optional(list('/v1/webhook_endpoints'), []), optional(retrieve('/v1/account'), undefined)]);
-  return { events, webhooks, account };
-}
-
-// ── writes ───────────────────────────────────────────────────────────────────
-/** Refund a payment in full (no amount) or in part. */
-export function createRefund(payment: { intent?: StripeObject; charge?: StripeObject }, amount: number | undefined, reason: string | undefined): Promise<StripeObject> {
-  const target = payment.intent ? { payment_intent: String(payment.intent.id) } : { charge: String(payment.charge?.id) };
-  return call('POST', '/v1/refunds', { ...target, amount, reason });
-}
-/** Cancel now (DELETE) or at the end of the current period (cancel_at_period_end). */
-export function cancelSubscription(id: string, when: 'now' | 'period_end'): Promise<StripeObject> {
-  return when === 'now' ? call('DELETE', `/v1/subscriptions/${id}`) : call('POST', `/v1/subscriptions/${id}`, { cancel_at_period_end: true });
-}
-export const createObject = (collection: string, fields: Record<string, string>): Promise<StripeObject> => call('POST', `/v1/${collection}`, fields);