@volter/twin-stripe 2.0.38 → 3.0.1

package/dist/src/{stripe-params.js → engine/params.js}

@@ -9,13 +9,10 @@
 // Where the evidence stops: the check knows only the served version's parameters (the spec's, surface.version). A
 // request pinning an earlier version with Stripe-Version is not checked, since the pack holds no earlier spec, beyond
 // the values of the payment_method_types it still takes (PAYMENT_METHOD_TYPES below); nested parameters are not checked.
-import { readParams, vendorError } from '@volter/world-core';
-import surface from './generated/surface.gen.json' with { type: 'json' };
-import { manifest } from "./manifest.js";
-import { SERVED_VERSION } from "./stripe-version.js";
-const OPS = new Map(surface.operations.map((o) => [o.id, o]));
+import surface from '../generated/surface.gen.json' with { type: 'json' };
+export const OPS = new Map(surface.operations.map((o) => [o.id, o]));
 /** Parameters Stripe documents outside its published spec, each with the page that documents it. */
-const DOCUMENTED = {
+export const DOCUMENTED = {
     // a top-up into the Issuing balance (docs.stripe.com/issuing/funding/balance: "destination_balance=issuing")
     PostTopups: ['destination_balance'],
 };
@@ -45,8 +42,8 @@ const DOCUMENTED = {
 export const METHOD_TYPES_REMOVED_IN = '2026-08-26.preview';
 /** Whether a pinned version is at or after the removal: versions order by their date (YYYY-MM-DD). */
 export const methodTypesRemoved = (pinned) => pinned.slice(0, 10) >= METHOD_TYPES_REMOVED_IN.slice(0, 10);
-const REMOVED_TYPES = new Set(['PostPaymentIntents', 'PostPaymentIntentsIntent', 'PostPaymentIntentsIntentConfirm', 'PostSetupIntents', 'PostSetupIntentsIntent']);
-const TYPED = new Set([...REMOVED_TYPES, 'PostCheckoutSessions']);
+export const REMOVED_TYPES = new Set(['PostPaymentIntents', 'PostPaymentIntentsIntent', 'PostPaymentIntentsIntentConfirm', 'PostSetupIntents', 'PostSetupIntentsIntent']);
+export const TYPED = new Set([...REMOVED_TYPES, 'PostCheckoutSessions']);
 /** The payment method types there are: the PaymentMethod object's `type` in the served spec. */
 export const PAYMENT_METHOD_TYPES = surface.resources.find((r) => r.name === 'payment_method')?.fields.find((f) => f.name === 'type')?.enum ?? [];
 /** The payment method types a Checkout Session takes: the vendored spec's (2026-09-30.endive) PostCheckoutSessions
@@ -55,59 +52,9 @@ export const PAYMENT_METHOD_TYPES = surface.resources.find((r) => r.name === 'pa
  *  interac_present) and no `custom`. The surface keeps no request enums, so it is copied here. */
 export const CHECKOUT_METHOD_TYPES = ['acss_debit', 'affirm', 'afterpay_clearpay', 'alipay', 'alma', 'amazon_pay', 'au_becs_debit', 'bacs_debit', 'bancontact', 'billie', 'bizum', 'blik', 'boleto', 'card', 'cashapp', 'crypto', 'customer_balance', 'eps', 'fpx', 'giropay', 'grabpay', 'ideal', 'kakao_pay', 'klarna', 'konbini', 'kr_card', 'link', 'mb_way', 'mobilepay', 'multibanco', 'naver_pay', 'nz_bank_account', 'oxxo', 'p24', 'pay_by_bank', 'payco', 'paynow', 'paypal', 'paypay', 'payto', 'pix', 'promptpay', 'revolut_pay', 'samsung_pay', 'satispay', 'scalapay', 'sepa_debit', 'sequra', 'sofort', 'sunbit', 'swish', 'twint', 'upi', 'us_bank_account', 'wechat_pay', 'zip'];
 /** The create page each intent's refusal links to. */
-const TYPES_DOC = {
+export const TYPES_DOC = {
     payment_intents: 'https://stripe.com/docs/api/payment_intents/create#create_payment_intent-payment_method_types',
     setup_intents: 'https://stripe.com/docs/api/setup_intents/create#create_setup_intent-payment_method_types',
 };
 /** An enum's values as Stripe lists them in a refusal: "a, b, or c". */
-const oneOf = (values) => (values.length > 1 ? `${values.slice(0, -1).join(', ')}, or ${values.at(-1)}` : values.join(''));
-/** An earlier version's payment_method_types refused: the first value that names no payment method type the
- *  operation takes, in the intent's words or (a Checkout Session) the enum's. */
-function unknownMethodType(opId, given) {
-    const values = Array.isArray(given) ? given : given && typeof given === 'object' ? Object.values(given) : [given];
-    const checkout = opId === 'PostCheckoutSessions';
-    const known = checkout ? CHECKOUT_METHOD_TYPES : PAYMENT_METHOD_TYPES;
-    const i = values.findIndex((v) => !known.includes(String(v)));
-    if (i < 0)
-        return undefined;
-    if (checkout) {
-        const param = `payment_method_types[${i}]`;
-        return vendorError(manifest, { status: 400, param, message: `Invalid ${param}: must be one of ${oneOf(known)}` });
-    }
-    const doc = TYPES_DOC[opId.startsWith('PostSetupIntents') ? 'setup_intents' : 'payment_intents'];
-    return vendorError(manifest, { status: 400, param: 'payment_method_types', message: `The payment method type "${String(values[i])}" is invalid. See ${doc} for the full list of supported payment method types.` });
-}
-/** payment_method_types refused where the caller's version removed it. */
-const noLongerSupported = (version) => vendorError(manifest, { status: 400, code: 'payment_method_types_no_longer_supported', param: 'payment_method_types', message: `payment_method_types is no longer supported in API version ${version}. Use allowed_payment_method_types, or dynamic payment methods, instead.` });
-/** Stripe's refusal of a request whose top-level parameters the operation does not take, or undefined. */
-export async function refuseParameters(call) {
-    const op = OPS.get(call.operation.id);
-    if (!op)
-        return undefined;
-    const pinned = call.request.headers.get('stripe-version');
-    if (pinned && pinned < SERVED_VERSION) {
-        if (!TYPED.has(op.id))
-            return undefined;
-        const earlier = await readParams(manifest, call.request.clone(), call.operation);
-        if (earlier.payment_method_types === undefined)
-            return undefined;
-        if (REMOVED_TYPES.has(op.id) && methodTypesRemoved(pinned))
-            return noLongerSupported(pinned);
-        return unknownMethodType(op.id, earlier.payment_method_types);
-    }
-    const method = call.request.method.toUpperCase();
-    const known = new Set([...(op.query ?? []), ...(op.body ?? [])].map((p) => p.name).concat(DOCUMENTED[op.id] ?? []));
-    const params = await readParams(manifest, call.request.clone(), call.operation);
-    if (REMOVED_TYPES.has(op.id) && params.payment_method_types !== undefined)
-        return noLongerSupported(pinned ?? SERVED_VERSION);
-    for (const name of Object.keys(params)) {
-        if (!known.has(name))
-            return vendorError(manifest, { status: 400, code: 'parameter_unknown', param: name, message: `Received unknown parameter: ${name}` });
-    }
-    const required = method === 'GET' || method === 'DELETE' ? (op.query ?? []) : (op.body ?? []);
-    for (const p of required) {
-        if (p.required && params[p.name] === undefined)
-            return vendorError(manifest, { status: 400, code: 'parameter_missing', param: p.name, message: `Missing required param: ${p.name}.` });
-    }
-    return undefined;
-}
+export const oneOf = (values) => (values.length > 1 ? `${values.slice(0, -1).join(', ')}, or ${values.at(-1)}` : values.join(''));

package/dist/src/engine/payment-intents.d.ts

@@ -0,0 +1,10 @@
+import type { Row } from './common.js';
+export declare const PI = "payment_intent";
+/** Bookkeeping: the intents whose caller named the methods (payment_method_types, allowed_payment_method_types) on
+ *  create. The twin's default list (['card']) stands for Stripe's choice and restricts nothing, so only a named list
+ *  refuses a confirm with a method of another type. Kept apart from the intent: a `_` subject is never pushed
+ *  (world-core isTwinBookkeeping). */
+export declare const TYPES_GIVEN = "_payment_intent_types_given";
+/** What every charge an intent makes carries of it: its transfer_group, which "identifies the resulting payment as part
+ *  of a group" (docs.stripe.com/api/payment_intents/object), its description and its metadata. */
+export declare function intentCarries(pi: Row): Row;

package/dist/src/engine/payment-intents.js

@@ -0,0 +1,27 @@
+export const PI = 'payment_intent';
+/** Bookkeeping: the intents whose caller named the methods (payment_method_types, allowed_payment_method_types) on
+ *  create. The twin's default list (['card']) stands for Stripe's choice and restricts nothing, so only a named list
+ *  refuses a confirm with a method of another type. Kept apart from the intent: a `_` subject is never pushed
+ *  (world-core isTwinBookkeeping). */
+export const TYPES_GIVEN = '_payment_intent_types_given';
+// ── THE MONEY MODEL, continued: a succeeded intent has a Charge ──
+//
+// Real Stripe always materializes a Charge when a PaymentIntent succeeds and points the intent's
+// `latest_charge` at it: the charge is what a refund lands on, so an intent that succeeds without
+// one cannot answer "refund this payment" at all. Idempotent against a repeated confirm: an intent
+// that already names a successful charge keeps it (a second one would double the money collected); a
+// declined attempt's failed charge is history, and the payment that succeeds makes its own. The id is
+// returned so the caller folds `latest_charge` into the same intent write (one write, one event). The
+// charge is written as the event Stripe sends for it, `charge.succeeded` ("Occurs whenever a charge is
+// successful", docs.stripe.com/api/events/types); Stripe has no `charge.created`.
+/** What every charge an intent makes carries of it: its transfer_group, which "identifies the resulting payment as part
+ *  of a group" (docs.stripe.com/api/payment_intents/object), its description and its metadata. */
+export function intentCarries(pi) {
+    return {
+        ...(typeof pi.transfer_group === 'string' ? { transfer_group: pi.transfer_group } : {}),
+        ...(typeof pi.description === 'string' ? { description: pi.description } : {}),
+        // "When a PaymentIntent creates a Charge, the metadata copies to the Charge in a one-time snapshot"
+        // (docs.stripe.com/metadata, "Copy metadata to another object")
+        ...(pi.metadata && typeof pi.metadata === 'object' ? { metadata: { ...pi.metadata } } : {}),
+    };
+}

package/dist/src/engine/payment-methods.d.ts

@@ -0,0 +1,16 @@
+import type { Row } from './common.js';
+export declare const PM = "payment_method";
+export declare const noBilling: {
+    address: null;
+    email: null;
+    name: null;
+    phone: null;
+};
+export declare const TEST_PM_CARDS: Record<string, {
+    brand: string;
+    number: string;
+}>;
+/** Attach a payment method to a customer (both known to exist or be attachable): a stored one moves to the
+ *  customer; a test name mints a new PaymentMethod on the customer carrying that card's outcome. */
+/** The card a test name (pm_card_*, tok_*) stands for, never stored as a PaymentMethod (docs.stripe.com/testing#cards). */
+export declare function testCardOf(ref: string): Row | undefined;

package/dist/src/engine/payment-methods.js

@@ -0,0 +1,22 @@
+// PaymentMethod semantics: a PaymentMethod is created detached, attached to a customer, and
+// detached again. The list is the derived core's.
+import { paymentMethodSubObject } from "./stripe.js";
+import { AFTER_SUCCESS_CARDS } from "./after-payment.js";
+export const PM = 'payment_method';
+export const noBilling = { address: null, email: null, name: null, phone: null };
+export const TEST_PM_CARDS = {
+    ...AFTER_SUCCESS_CARDS,
+    pm_card_mastercard: { brand: 'mastercard', number: '5555555555554444' },
+    pm_card_amex: { brand: 'amex', number: '378282246310005' },
+    pm_card_discover: { brand: 'discover', number: '6011111111111117' },
+};
+/** Attach a payment method to a customer (both known to exist or be attachable): a stored one moves to the
+ *  customer; a test name mints a new PaymentMethod on the customer carrying that card's outcome. */
+/** The card a test name (pm_card_*, tok_*) stands for, never stored as a PaymentMethod (docs.stripe.com/testing#cards). */
+export function testCardOf(ref) {
+    const name = ref.replace(/^tok_/, 'pm_card_');
+    if (!name.startsWith('pm_card_'))
+        return undefined;
+    const test = TEST_PM_CARDS[name] ?? { brand: 'visa', number: '4242424242424242' };
+    return { ...paymentMethodSubObject('card', { card: { number: test.number } }).card, brand: test.brand };
+}

package/dist/src/engine/radar.d.ts

@@ -0,0 +1,2 @@
+export declare const VL = "radar.value_list";
+export declare const VLI = "radar.value_list_item";

package/dist/src/engine/radar.js

@@ -0,0 +1,5 @@
+// Radar semantics: reviews of payments Radar held (approving closes one, the machine in
+// ../manifest.ts) and the value lists custom rules reference, with their items. Review list and
+// retrieve, value-list list and retrieve, and value-list-item retrieve are the derived core's.
+export const VL = 'radar.value_list';
+export const VLI = 'radar.value_list_item';

package/dist/src/engine/refunds.d.ts

@@ -0,0 +1 @@
+export declare const REFUND_REASONS: Set<string>;

package/dist/src/engine/refunds.js

@@ -0,0 +1,3 @@
+// The published refund reasons; expired_uncaptured_charge is Stripe's own, not a request reason.
+// source: spec:/paths/~1v1~1refunds/post/requestBody/content/application~1x-www-form-urlencoded/schema/properties/reason "String indicating the reason for the refund."
+export const REFUND_REASONS = new Set(['duplicate', 'fraudulent', 'requested_by_customer']);

package/dist/src/engine/renewals.d.ts

@@ -0,0 +1,36 @@
+import type { Row } from './common.js';
+export declare const SUB = "subscription";
+export declare const INV = "invoice";
+export declare const HOUR = 3600;
+/** The statuses a subscription renews in. */
+export declare const RENEWING: string[];
+export declare const itemsOf: (sub: Row) => Row[];
+/** An item's quantity as it bills: 1 when none is set, and 0 when 0 is (a quantity of 0 bills nothing). */
+export declare function itemQuantity(it: Row): number;
+/** The subscription's discounts with a `once` coupon's spent: "When a subscription uses a coupon with `duration=once`, the
+ *  coupon is considered used after the invoice finalizes and is removed from the subscription's `discounts` array"
+ *  (docs.stripe.com/billing/subscriptions/coupons#coupon-duration). */
+export declare function unspentDiscounts(discounts: unknown): Row[];
+/** The coupon ids an invoice's discounts name. */
+export declare const couponsOf: (discounts: unknown) => Set<string>;
+/** A subscription's discounts after `invoice` finalizes: less the `once` coupons it took. */
+export declare function keptAfter(discounts: Row[], invoice: Row): Row[];
+/** A Checkout session's one-time line items as lines of its subscription's first invoice, numbered after its `after` lines. */
+export declare function oneTimeLines(invoiceId: string, sub: Row, items: Row[], after: number, at: number, currency: string): {
+    id: string;
+    object: string;
+    type: string;
+    amount: number;
+    currency: string;
+    quantity: number;
+    proration: boolean;
+    price: Row | null;
+    subscription: unknown;
+    subscription_item: null;
+    invoice_item: null;
+    period: {
+        start: number;
+        end: number;
+    };
+    description: string | null;
+}[];

package/dist/src/engine/renewals.js

@@ -0,0 +1,65 @@
+// A subscription's invoices over time: the first one Checkout pays, and each renewal. Time's moves are made
+// as the twin's trial end already made them: caught up to the customer's clock (the World's, or its test
+// clock) whenever the twin is asked anything (./front.ts), each checked against the machines in
+// ../manifest.ts.
+//
+// - Checkout's subscription session pays the first invoice with the card the customer entered, which becomes the
+//   subscription's default payment method (docs.stripe.com/payments/checkout/how-checkout-works); nothing is due
+//   on a trial's.
+// - At each period's end Stripe drafts a `subscription_cycle` invoice for the next period and advances the
+//   period; a trial's end is the first such renewal, and the subscription is active from then
+//   (docs.stripe.com/billing/subscriptions/overview#how-payments-work-subscriptions,
+//   docs.stripe.com/billing/subscriptions/trials).
+// - About an hour after, Stripe finalizes the draft and charges the subscription's default payment method,
+//   else the customer's (docs.stripe.com/invoicing/integration/workflow-transitions#finalized,
+//   docs.stripe.com/api/subscriptions/object#subscription_object-default_payment_method).
+// - A declined renewal leaves the invoice open with its attempt counted and the subscription past_due
+//   (docs.stripe.com/billing/subscriptions/overview#payment-status); paying the invoice later, through the API
+//   (docs.stripe.com/api/invoices/pay) or on the customer portal (docs.stripe.com/customer-management), makes it
+//   active again.
+//
+// Where the documentation stops and the twin decides: Stripe retries a failed renewal on its Smart Retries
+// schedule and may then cancel or mark the subscription unpaid; the twin makes no retry (next_payment_attempt
+// is null) and leaves it past_due until the invoice is paid. A paused subscription (pause_collection) is not renewed.
+// - One set to cancel at its period's end is canceled when the period ends, with no renewal
+//   (docs.stripe.com/billing/subscriptions/cancel#cancel-at-end-of-cycle).
+import { priceAmount } from "./stripe.js";
+export const SUB = 'subscription';
+export const INV = 'invoice';
+export const HOUR = 3600;
+/** The statuses a subscription renews in. */
+export const RENEWING = ['trialing', 'active', 'past_due'];
+export const itemsOf = (sub) => (sub.items?.data) ?? [];
+/** An item's quantity as it bills: 1 when none is set, and 0 when 0 is (a quantity of 0 bills nothing). */
+export function itemQuantity(it) {
+    return it.quantity === undefined || it.quantity === null ? 1 : Math.max(0, Math.trunc(Number(it.quantity) || 0));
+}
+/** The subscription's discounts with a `once` coupon's spent: "When a subscription uses a coupon with `duration=once`, the
+ *  coupon is considered used after the invoice finalizes and is removed from the subscription's `discounts` array"
+ *  (docs.stripe.com/billing/subscriptions/coupons#coupon-duration). */
+export function unspentDiscounts(discounts) {
+    return (discounts ?? []).filter((d) => !(d && typeof d === 'object' && d.coupon?.duration === 'once'));
+}
+/** The coupon ids an invoice's discounts name. */
+export const couponsOf = (discounts) => new Set((discounts ?? []).map((d) => {
+    const c = d && typeof d === 'object' ? d.coupon : undefined;
+    return typeof c === 'string' ? c : c && typeof c === 'object' ? String(c.id ?? '') : '';
+}).filter(Boolean));
+/** A subscription's discounts after `invoice` finalizes: less the `once` coupons it took. */
+export function keptAfter(discounts, invoice) {
+    const taken = couponsOf(invoice.discounts);
+    return discounts.filter((d) => !(unspentDiscounts([d]).length === 0 && [...couponsOf([d])].some((c) => taken.has(c))));
+}
+/** A Checkout session's one-time line items as lines of its subscription's first invoice, numbered after its `after` lines. */
+export function oneTimeLines(invoiceId, sub, items, after, at, currency) {
+    return items.map((it, i) => {
+        const price = it.price && typeof it.price === 'object' ? it.price : null;
+        const quantity = itemQuantity(it);
+        return {
+            id: `il_twin_${invoiceId}_${after + i + 1}`, object: 'line_item', type: 'subscription',
+            amount: priceAmount(price ?? undefined, quantity), currency, quantity, proration: false,
+            price, subscription: sub.id, subscription_item: null, invoice_item: null,
+            period: { start: at, end: at }, description: typeof it.description === 'string' ? it.description : null,
+        };
+    });
+}

package/dist/src/{stripe-twin.d.ts → engine/stripe.d.ts}

@@ -1,18 +1,10 @@
-export type StripeRequest = {
-    method: string;
-    path: string;
-    body?: string;
-    occurredAt?: string;
-    root?: string;
-    readOnly?: boolean;
-    idempotencyKey?: string;
-    apiVersion?: string;
-    stripeAccount?: string;
-};
+import { type TwinResource } from '@volter/world-core';
 export type StripeResponse = {
     status: number;
     body: unknown;
 };
+/** Stripe's error body: an invalid_request_error with the message, and the code when there is one. */
+export declare function err(message: string, status?: number, code?: string): StripeResponse;
 export declare const TWIN_API_VERSION: string;
 export declare function isValidApiVersion(v: string): boolean;
 export declare function validateMoney(params: Record<string, unknown>): StripeResponse | null;
@@ -23,14 +15,13 @@ type DeclineOutcome = {
 };
 export declare const TEST_TOKEN_DECLINES: Record<string, DeclineOutcome | null>;
 /** A stored subject by stored type and id, in the pack's view (tombstones included): how the
- *  semantics hand these helpers the tree they read (semantics/shared.ts `finder`). */
+ *  semantics hand these helpers the tree they read (./common.ts `finder`). */
 export type FindStored = (storedType: string, id: string) => Record<string, unknown> | undefined;
 export declare function declineFor(find: FindStored, ...paramSets: Array<Record<string, unknown>>): DeclineOutcome | null | undefined;
 export declare function requiresAuthentication(...paramSets: Array<Record<string, unknown>>): boolean;
 export declare function threeDsNextAction(): Record<string, unknown>;
 export declare function requiresMicrodeposits(...paramSets: Array<Record<string, unknown>>): boolean;
 export declare function microdepositsNextAction(): Record<string, unknown>;
-export declare function verifyMicrodeposits(params: Record<string, unknown>, _existing: Record<string, unknown>): StripeResponse | null;
 /** A card error's body: `charge` "For card errors, the ID of the failed charge", and `payment_intent` "The PaymentIntent
  *  object for errors returned on a request involving a PaymentIntent" (docs.stripe.com/api/errors). */
 export declare function cardError(outcome: DeclineOutcome, attach?: {
@@ -38,21 +29,17 @@ export declare function cardError(outcome: DeclineOutcome, attach?: {
     payment_intent?: Record<string, unknown>;
 }): StripeResponse;
 export declare function nowUnix(occurredAt?: string): number;
-export declare function mintClientSecret(id: string): string;
+/** An intent's client secret: its id, `_secret_`, and a secret the World holds for it (ctx.secret, passed in), so no one
+ *  derives it from the intent's id; Stripe.js confirms an intent with it and the publishable key. */
+export declare function mintClientSecret(id: string, secret: string): string;
 export declare const OBJECT_NAME: Record<string, string>;
-export declare function view(type: string, r: Record<string, unknown>): Record<string, unknown>;
+/** A stored row as Stripe answers it: its `object`, its own fields (the vendor's `type` among them, which the tree's
+ *  shadows: world-core ownFields) without the twin's `_` bookkeeping, and its id. */
+export declare function view(type: string, r: TwinResource): Record<string, unknown>;
 export declare function paginate(items: Array<Record<string, unknown>>, params: Record<string, unknown>): {
     page: Array<Record<string, unknown>>;
     hasMore: boolean;
 };
-/** What follows every stored Stripe write: the webhook for the state change and the stored Event
- *  the Events API lists. The derived pack's write hook (manifest.ts) is this same function. */
-export declare function afterStripeWrite(type: string, op: string, out: Record<string, unknown>, root?: string, occurredAt?: string, apiVersion?: string, stripeAccount?: string): Promise<void>;
-/** The id the World's next event takes: its place in the World's events, so it is deterministic and never repeats
- *  within a World (a Balance has no id of its own, so nothing about the object can tell two events apart). The number
- *  is taken synchronously — the count of stored events, or the last number taken, whichever is higher. */
-export declare function nextStripeEventId(root?: string): string;
-export declare function persistStripeEvent(eventType: string, resource: Record<string, unknown>, root?: string, occurredAt?: string, apiVersion?: string, account?: string, id?: string): Promise<void>;
 export declare function asBool(v: unknown): boolean;
 export declare function searchOver(items: Array<Record<string, unknown>>, params: Record<string, unknown>, path: string): StripeResponse;
 export declare function subscriptionHasPrice(sub: Record<string, unknown>, priceId: string): boolean;
@@ -63,10 +50,6 @@ export declare function subscriptionCouponParam(params: Record<string, unknown>)
 export declare function buildDiscount(coupon: Record<string, unknown>, customer: string, at: number, on?: {
     subscription?: string;
 }): Record<string, unknown>;
-export declare function subscriptionItemPairs(sub: Record<string, unknown>): Array<{
-    price: string;
-    quantity: number;
-}>;
 export declare function subscriptionItemEntries(value: unknown): Array<Record<string, unknown>>;
 type BillingInterval = 'day' | 'week' | 'month' | 'year';
 export declare function resolveSubscriptionBillingInterval(entries: Array<Record<string, unknown>>, find: FindStored): {
@@ -93,10 +76,8 @@ export declare function resolveTrial(params: Record<string, unknown>, at: number
     start: number;
     end: number;
 } | undefined;
-export declare function stashVendorType(_type: string, fields: Record<string, unknown>): Record<string, unknown>;
-export declare function embedIssuingAuthorizationCard(body: Record<string, unknown>, root?: string): Record<string, unknown>;
 export declare function emptySpendingControls(): Record<string, unknown>;
-export declare function normalizeSpendingControls(raw: unknown, currency: string | null): {
+export declare function normalizeSpendingControls(raw: unknown, currency: string | null, previous?: Record<string, unknown>): {
     controls?: Record<string, unknown>;
     error?: StripeResponse;
 };
@@ -137,19 +118,5 @@ export declare function resolveLineItem(entry: Record<string, unknown>, index: n
 };
 export declare function lineItemEntries(params: Record<string, unknown>): Array<Record<string, unknown>>;
 export declare function chargeDefaults(chargeId: string, amount: number, captured: boolean, occurredAt?: string): Record<string, unknown>;
-/**
- * Public entry: honors the Idempotency-Key (replay → stored response, no re-write)
- * then delegates to the router. Only POSTs are idempotent (matches Stripe; GET/DELETE
- * pass straight through). A read-only twin never stores (it cannot write).
- */
-/** Stripe's API as one call: the request goes through the pack's own dispatch (the derived dispatch over
- *  its semantics, its derived core and the hand-written routes below), so a caller that holds no
- *  HTTP server reaches exactly what an SDK does. `occurredAt` pins the World instant. */
-export declare function handleStripeTwinRequest(req: StripeRequest): Promise<StripeResponse>;
-/**
- * The twin's doors: what stands in for an act Stripe's API does not have, each under `/_twin/`. The
- * platform's own account settings (its payout schedule) change on Stripe's Dashboard, which has no API:
- * POST /_twin/account stands in for that page. Answers nothing for any other path.
- */
-export declare function handleStripeDoor(req: StripeRequest, params: Record<string, unknown>): Promise<StripeResponse | undefined>;
+export declare function planView(price: Record<string, unknown>): Record<string, unknown>;
 export {};