npm - @volter/twin-stripe - Versions diffs - 0.1.2 → 2.0.1 - Mend

@volter/twin-stripe 0.1.2 → 2.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (229) hide show

package/README.md +96 -27
package/client/dashboard-api.ts +286 -0
package/client/stripe-mirror.css +272 -159
package/client/stripe-mirror.tsx +1384 -541
package/dist/client/dashboard-api.d.ts +107 -0
package/dist/client/dashboard-api.js +238 -0
package/dist/client/dashboard-api.ts +286 -0
package/dist/client/stripe-mirror.bundle.js +236 -0
package/dist/client/stripe-mirror.css +275 -0
package/dist/client/stripe-mirror.d.ts +134 -0
package/dist/client/stripe-mirror.js +823 -0
package/dist/client/stripe-mirror.tsx +1534 -0
package/dist/src/cli.d.ts +2 -0
package/dist/src/cli.js +39 -0
package/dist/src/generated/events.gen.json +1 -0
package/dist/src/generated/surface.gen.json +1 -0
package/dist/src/generated/ui.gen.json +1 -0
package/dist/src/index.d.ts +14 -0
package/dist/src/index.js +75 -0
package/dist/src/manifest.d.ts +2 -0
package/dist/src/manifest.js +1070 -0
package/dist/src/screens/checkout.d.ts +31 -0
package/dist/src/screens/checkout.js +255 -0
package/dist/src/screens/connect-oauth.d.ts +27 -0
package/dist/src/screens/connect-oauth.js +414 -0
package/dist/src/screens/connect-settings.d.ts +22 -0
package/dist/src/screens/connect-settings.js +103 -0
package/dist/src/screens/consent-skin.d.ts +4 -0
package/dist/src/screens/consent-skin.js +18 -0
package/dist/src/screens/financial-connections.d.ts +5 -0
package/dist/src/screens/financial-connections.js +90 -0
package/dist/src/screens/identity.d.ts +5 -0
package/dist/src/screens/identity.js +86 -0
package/dist/src/screens/industries.d.ts +1 -0
package/dist/src/screens/industries.js +267 -0
package/dist/src/screens/onboarding.d.ts +13 -0
package/dist/src/screens/onboarding.js +225 -0
package/dist/src/screens/portal.d.ts +5 -0
package/dist/src/screens/portal.js +216 -0
package/dist/src/screens/public-details.d.ts +5 -0
package/dist/src/screens/public-details.js +90 -0
package/dist/src/semantics/after-payment.d.ts +22 -0
package/dist/src/semantics/after-payment.js +99 -0
package/dist/src/semantics/apps-secrets.d.ts +2 -0
package/dist/src/semantics/apps-secrets.js +54 -0
package/dist/src/semantics/balance.d.ts +11 -0
package/dist/src/semantics/balance.js +195 -0
package/dist/src/semantics/billing.d.ts +2 -0
package/dist/src/semantics/billing.js +220 -0
package/dist/src/semantics/charges.d.ts +28 -0
package/dist/src/semantics/charges.js +209 -0
package/dist/src/semantics/checkout.d.ts +15 -0
package/dist/src/semantics/checkout.js +316 -0
package/dist/src/semantics/connect.d.ts +5 -0
package/dist/src/semantics/connect.js +493 -0
package/dist/src/semantics/coupons.d.ts +6 -0
package/dist/src/semantics/coupons.js +92 -0
package/dist/src/semantics/credit-notes.d.ts +2 -0
package/dist/src/semantics/credit-notes.js +172 -0
package/dist/src/semantics/customers.d.ts +6 -0
package/dist/src/semantics/customers.js +429 -0
package/dist/src/semantics/disputes.d.ts +2 -0
package/dist/src/semantics/disputes.js +51 -0
package/dist/src/semantics/entitlements.d.ts +2 -0
package/dist/src/semantics/entitlements.js +95 -0
package/dist/src/semantics/ephemeral-keys.d.ts +2 -0
package/dist/src/semantics/ephemeral-keys.js +34 -0
package/dist/src/semantics/files.d.ts +2 -0
package/dist/src/semantics/files.js +125 -0
package/dist/src/semantics/invoices.d.ts +18 -0
package/dist/src/semantics/invoices.js +545 -0
package/dist/src/semantics/issuing.d.ts +13 -0
package/dist/src/semantics/issuing.js +575 -0
package/dist/src/semantics/ledger.d.ts +59 -0
package/dist/src/semantics/ledger.js +200 -0
package/dist/src/semantics/payment-intents.d.ts +18 -0
package/dist/src/semantics/payment-intents.js +404 -0
package/dist/src/semantics/payment-links.d.ts +2 -0
package/dist/src/semantics/payment-links.js +133 -0
package/dist/src/semantics/payment-methods.d.ts +20 -0
package/dist/src/semantics/payment-methods.js +140 -0
package/dist/src/semantics/plans.d.ts +5 -0
package/dist/src/semantics/plans.js +121 -0
package/dist/src/semantics/platform.d.ts +9 -0
package/dist/src/semantics/platform.js +206 -0
package/dist/src/semantics/products.d.ts +2 -0
package/dist/src/semantics/products.js +140 -0
package/dist/src/semantics/radar.d.ts +2 -0
package/dist/src/semantics/radar.js +83 -0
package/dist/src/semantics/refunds.d.ts +9 -0
package/dist/src/semantics/refunds.js +195 -0
package/dist/src/semantics/renewals.d.ts +47 -0
package/dist/src/semantics/renewals.js +251 -0
package/dist/src/semantics/setup-intents.d.ts +2 -0
package/dist/src/semantics/setup-intents.js +84 -0
package/dist/src/semantics/shared.d.ts +82 -0
package/dist/src/semantics/shared.js +203 -0
package/dist/src/semantics/subscription-schedules.d.ts +2 -0
package/dist/src/semantics/subscription-schedules.js +119 -0
package/dist/src/semantics/subscriptions.d.ts +11 -0
package/dist/src/semantics/subscriptions.js +605 -0
package/dist/src/semantics/tax.d.ts +2 -0
package/dist/src/semantics/tax.js +197 -0
package/dist/src/semantics/terminal.d.ts +5 -0
package/dist/src/semantics/terminal.js +182 -0
package/dist/src/semantics/test-cards.d.ts +4 -0
package/dist/src/semantics/test-cards.js +7 -0
package/dist/src/semantics/test-clocks.d.ts +6 -0
package/dist/src/semantics/test-clocks.js +73 -0
package/dist/src/semantics/tokens.d.ts +4 -0
package/dist/src/semantics/tokens.js +44 -0
package/dist/src/semantics/transfers.d.ts +2 -0
package/dist/src/semantics/transfers.js +154 -0
package/dist/src/semantics/treasury.d.ts +2 -0
package/dist/src/semantics/treasury.js +377 -0
package/dist/src/semantics/webhook-endpoints.d.ts +3 -0
package/dist/src/semantics/webhook-endpoints.js +85 -0
package/dist/src/stripe-budget.d.ts +55 -0
package/dist/src/stripe-budget.js +155 -0
package/dist/src/stripe-capabilities.d.ts +3 -0
package/dist/src/stripe-capabilities.js +5695 -0
package/dist/src/stripe-conformance.d.ts +43 -0
package/dist/src/stripe-conformance.js +105 -0
package/dist/src/stripe-connector.d.ts +161 -0
package/dist/src/stripe-connector.js +414 -0
package/dist/src/stripe-emit.d.ts +2 -0
package/dist/src/stripe-emit.js +145 -0
package/dist/src/stripe-events.d.ts +93 -0
package/dist/src/stripe-events.js +392 -0
package/dist/src/stripe-js.d.ts +4 -0
package/dist/src/stripe-js.js +70 -0
package/dist/src/stripe-mirror-ui.d.ts +15 -0
package/dist/src/stripe-mirror-ui.js +87 -0
package/dist/src/stripe-params.d.ts +3 -0
package/dist/src/stripe-params.js +43 -0
package/dist/src/stripe-perform-harness.d.ts +9 -0
package/dist/src/stripe-perform-harness.js +26 -0
package/dist/src/stripe-server.d.ts +33 -0
package/dist/src/stripe-server.js +393 -0
package/dist/src/stripe-shared.d.ts +109 -0
package/dist/src/stripe-shared.js +276 -0
package/dist/src/stripe-twin.d.ts +155 -0
package/dist/src/stripe-twin.js +1232 -0
package/dist/src/stripe-ui-conformance.d.ts +5 -0
package/dist/src/stripe-ui-conformance.js +79 -0
package/dist/src/stripe-ui-structure.d.ts +3 -0
package/dist/src/stripe-ui-structure.js +168 -0
package/dist/src/stripe-version.d.ts +12 -0
package/dist/src/stripe-version.js +287 -0
package/dist/test-fixtures/stripe-known-deviations.json +110 -0
package/dist/test-fixtures/stripe-openapi-operations.SOURCE.md +14 -0
package/dist/test-fixtures/stripe-openapi-operations.json +4717 -0
package/dist/test-fixtures/stripe-schemas.SOURCE.md +35 -0
package/dist/test-fixtures/stripe-schemas.json +3813 -0
package/package.json +18 -10
package/src/cli.ts +7 -7
package/src/generated/events.gen.json +1 -0
package/src/generated/surface.gen.json +1 -0
package/src/generated/ui.gen.json +1 -0
package/src/index.ts +34 -10
package/src/manifest.ts +1102 -0
package/src/screens/checkout.tsx +267 -0
package/src/screens/connect-oauth.tsx +400 -0
package/src/screens/connect-settings.tsx +121 -0
package/src/screens/consent-skin.ts +20 -0
package/src/screens/financial-connections.tsx +101 -0
package/src/screens/identity.tsx +96 -0
package/src/screens/industries.ts +267 -0
package/src/screens/onboarding.tsx +243 -0
package/src/screens/portal.tsx +220 -0
package/src/screens/public-details.tsx +105 -0
package/src/semantics/after-payment.ts +118 -0
package/src/semantics/apps-secrets.ts +58 -0
package/src/semantics/balance.ts +209 -0
package/src/semantics/billing.ts +216 -0
package/src/semantics/charges.ts +220 -0
package/src/semantics/checkout.ts +310 -0
package/src/semantics/connect.ts +487 -0
package/src/semantics/coupons.ts +97 -0
package/src/semantics/credit-notes.ts +168 -0
package/src/semantics/customers.ts +432 -0
package/src/semantics/disputes.ts +62 -0
package/src/semantics/entitlements.ts +94 -0
package/src/semantics/ephemeral-keys.ts +34 -0
package/src/semantics/files.ts +143 -0
package/src/semantics/invoices.ts +545 -0
package/src/semantics/issuing.ts +590 -0
package/src/semantics/ledger.ts +253 -0
package/src/semantics/payment-intents.ts +420 -0
package/src/semantics/payment-links.ts +148 -0
package/src/semantics/payment-methods.ts +145 -0
package/src/semantics/plans.ts +131 -0
package/src/semantics/platform.ts +220 -0
package/src/semantics/products.ts +154 -0
package/src/semantics/radar.ts +85 -0
package/src/semantics/refunds.ts +218 -0
package/src/semantics/renewals.ts +274 -0
package/src/semantics/setup-intents.ts +87 -0
package/src/semantics/shared.ts +226 -0
package/src/semantics/subscription-schedules.ts +129 -0
package/src/semantics/subscriptions.ts +610 -0
package/src/semantics/tax.ts +220 -0
package/src/semantics/terminal.ts +195 -0
package/src/semantics/test-cards.ts +7 -0
package/src/semantics/test-clocks.ts +77 -0
package/src/semantics/tokens.ts +52 -0
package/src/semantics/transfers.ts +174 -0
package/src/semantics/treasury.ts +383 -0
package/src/semantics/webhook-endpoints.ts +87 -0
package/src/stripe-budget.ts +4 -4
package/src/stripe-capabilities.ts +2258 -380
package/src/stripe-conformance.ts +19 -7
package/src/stripe-connector.ts +68 -40
package/src/stripe-emit.ts +15 -8
package/src/stripe-events.ts +102 -40
package/src/stripe-js.ts +70 -0
package/src/stripe-mirror-ui.ts +28 -298
package/src/stripe-params.ts +44 -0
package/src/stripe-perform-harness.ts +29 -0
package/src/stripe-server.ts +318 -38
package/src/stripe-shared.ts +297 -0
package/src/stripe-twin.ts +434 -5325
package/src/stripe-ui-conformance.ts +70 -107
package/src/stripe-ui-structure.ts +124 -348
package/src/stripe-version.ts +281 -0
package/test-fixtures/stripe-known-deviations.json +8 -8
package/test-fixtures/stripe-openapi-operations.json +1188 -2855
package/test-fixtures/stripe-schemas.json +85 -12
package/src/stripe-form.ts +0 -35

package/src/stripe-capabilities.ts CHANGED Viewed

@@ -6,13 +6,16 @@
 // regression. Grow this toward Stripe's *full* surface every cycle — a missing entry is a
 // hidden gap, and a high % against a thin list is a misleading metric (the bug this fixes).
 import { mkdtempSync, rmSync } from 'node:fs';
-import { emitTwinEvent } from '@volter/twin';
+import { createServer } from 'node:http';
+import type { AddressInfo } from 'node:net';
+import { applyTwinWrite, emitTwinEvent } from '@volter/world-core';
 import { stripeEmitter } from './stripe-emit.ts';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { createElement } from 'react';
 import { renderToStaticMarkup } from 'react-dom/server';
-import { checkCapabilities, type CapabilityReport, type CapabilitySpec, verifyBoundary, isInfrastructureError, harnessError } from '@volter/twin-tooling';
+import { FORMAT_SCRIPT } from '@volter/world-ui';
+import { checkCapabilities, type CapabilityReport, type CapabilitySpec, verifyBoundary, isInfrastructureError, harnessError } from '@volter/world-tooling';
 import { ListPane, SECTIONS, PaymentErrorBanner, ConnectAccountPanel, BalanceSummary, type Section } from '../client/stripe-mirror.tsx';
 import type { StripeRow } from './stripe-mirror-ui.ts';
 import {
@@ -27,6 +30,13 @@ import {
 import { fullSyncStripe } from './stripe-connector.ts';
 import { buildStripeMirrorClient, createStripeMirrorServer, formatStripeAmount } from './stripe-mirror-ui.ts';
 import { handleStripeTwinRequest, type StripeResponse } from './stripe-twin.ts';
+import { createStripeTwinFetch } from './stripe-server.ts';
+import { SERVED_VERSION } from './stripe-version.ts';
+import { pack } from './index.ts';
+import { stripeIdentityFlow } from './screens/identity.tsx';
+import { stripeFinancialConnectionsFlow } from './screens/financial-connections.tsx';
+import { currentlyDue, stripeOnboardingFlow } from './screens/onboarding.tsx';
+import { stripePortalFlow } from './screens/portal.tsx';
 // ── UI verify: the built mirror bundle must contain the screen's load-bearing markers ──
 let bundle: Promise<string> | null = null;
@@ -45,17 +55,17 @@ type ServerFetch = (path: string) => Promise<Body>;
 type ServerClient = { get: ServerFetch; post: (path: string, body?: string) => Promise<Body> };
 function uiDataCoupled(opts: {
   markers: string[];
-  seed: (h: (s: Step) => Promise<StripeResponse>) => Promise<void>;
+  seed: (h: (s: Step) => Promise<StripeResponse>, root: string) => Promise<void>;
   check: (client: ServerClient) => Promise<boolean>;
 }): () => Promise<boolean> {
   return async () => {
     const js = await mirrorBundle();
     if (!opts.markers.every((m) => js.includes(m))) return false;
     const root = mkdtempSync(join(tmpdir(), 'stp-ui-'));
-    const server = createStripeMirrorServer({ root, port: 0 });
+    const server = await createStripeMirrorServer({ root, port: 0 });
     try {
       const h = (s: Step) => handleStripeTwinRequest({ method: s.m, path: s.p, body: s.b, root });
-      await opts.seed(h);
+      await opts.seed(h, root);
       const base = `http://127.0.0.1:${server.port}`;
       const get: ServerFetch = (path) => fetch(`${base}${path}`).then((r) => r.json() as Promise<Body>);
       const post = (path: string, body?: string) => fetch(`${base}${path}`, { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: body ?? '' }).then((r) => r.json() as Promise<Body>);
@@ -95,17 +105,129 @@ type Step = { m: string; p: string; b?: string };
 type Body = Record<string, unknown>;
 /** Run a sequence of real Stripe requests against an isolated root; return all responses. */
-async function withRoot(steps: (h: (s: Step) => Promise<StripeResponse>) => Promise<boolean>): Promise<boolean> {
+async function withRoot(steps: (h: (s: Step) => Promise<StripeResponse>, root: string) => Promise<boolean>): Promise<boolean> {
   const root = mkdtempSync(join(tmpdir(), 'stp-cap-'));
   const h = (s: Step) => handleStripeTwinRequest({ method: s.m, path: s.p, body: s.b, root });
   try {
-    return await verifyBoundary('stripe.withRoot', () => steps(h));
+    return await verifyBoundary('stripe.withRoot', () => steps(h, root));
   } finally {
     rmSync(root, { recursive: true, force: true });
   }
 }
+/** Funds the Issuing balance with a top-up made a week before `at` (default now): a top-up "can take up to 5 business
+ *  days to become available. While they're pending, they won't be added to your Issuing balance"
+ *  (docs.stripe.com/issuing/funding/balance), so the next request at `at` finds it settled. */
+async function fundIssuing(root: string, amount: number, at?: string): Promise<StripeResponse> {
+  const t = at ? Date.parse(at) : Date.now();
+  return handleStripeTwinRequest({ method: 'POST', path: '/v1/topups', body: `amount=${amount}&currency=usd&destination_balance=issuing`, root, occurredAt: new Date(t - 7 * 86_400_000).toISOString() });
+}
 const ok = (r: StripeResponse) => r.status >= 200 && r.status < 300;
+/** A seller the platform can pay: a Custom account onboarded through the API (its business profile, the owner's
+ *  acceptance of the terms, the individual's name, a bank account), and funds in the platform's balance to send it.
+ *  Answers the account id. The name is owed at once for an individual with transfers (e0e3b88c6: what Stripe's
+ *  requirements endpoint lists for the business type and capabilities), so without it transfers stay inactive. */
+async function onboardedSeller(h: (s: Step) => Promise<StripeResponse>): Promise<string> {
+  const a = await h({ m: 'POST', p: '/v1/accounts', b: 'type=custom&country=US&capabilities[transfers][requested]=true&business_profile[mcc]=5462&business_profile[url]=https://seller.test&tos_acceptance[date]=1767225600&tos_acceptance[ip]=203.0.113.9&individual[first_name]=Sam&individual[last_name]=Seller' });
+  await h({ m: 'POST', p: `/v1/accounts/${id(a)}/external_accounts`, b: 'external_account[object]=bank_account&external_account[country]=US&external_account[currency]=usd&external_account[routing_number]=110000000&external_account[account_number]=000123456789' });
+  await h({ m: 'POST', p: '/v1/charges', b: 'amount=100000&currency=usd&source=tok_bypassPending' });
+  return id(a);
+}
+/** A local webhook receiver, as an application runs one: a node:http server on 127.0.0.1 that keeps each event POSTed
+ *  to it by path (`/platform`, `/connect`, …). */
+async function webhookReceiver(): Promise<{ url: (path: string) => string; got: (path: string) => StripeEvent[]; close: () => void }> {
+  const got = new Map<string, StripeEvent[]>();
+  const server = createServer((req, res) => {
+    let body = '';
+    req.on('data', (d) => { body += String(d); });
+    req.on('end', () => { got.set(String(req.url), [...(got.get(String(req.url)) ?? []), JSON.parse(body) as StripeEvent]); res.end('ok'); });
+  });
+  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const port = (server.address() as AddressInfo).port;
+  return { url: (path) => `http://127.0.0.1:${port}${path}`, got: (path) => got.get(path) ?? [], close: () => server.close() };
+}
+/** A request to the twin's fetch at a World instant, as an account (the Stripe-Account header) when one is named. */
+function fetcher(f: (r: Request) => Promise<Response>): (m: string, p: string, b?: string, acct?: string) => Promise<Body> {
+  return async (m, p, b, acct) => (await (await f(new Request(`http://stripe.test${p}`, {
+    method: m, headers: { authorization: 'Bearer sk_test_twin', 'content-type': 'application/x-www-form-urlencoded', ...(acct ? { 'stripe-account': acct } : {}) }, ...(b !== undefined ? { body: b } : {}),
+  }))).json()) as Body;
+}
+// ── Connect OAuth (screens/connect-oauth.tsx, screens/connect-settings.tsx) ──
+/** Cal.com's callback, the redirect URI its Stripe app registers. */
+const OAUTH_CALLBACK = 'http://localhost:3000/api/integrations/stripepayment/callback';
+/** An authorize query as Cal.com's Stripe app builds it (qs-stringify: nested stripe_user[...] keys), with `extra` added. */
+const authorizeQuery = (extra = '', redirect: string | null = OAUTH_CALLBACK): string =>
+  `client_id=ca_twin_self&scope=read_write&response_type=code${redirect === null ? '' : `&redirect_uri=${encodeURIComponent(redirect)}`}&state=st8${extra}`;
+type OAuthWorld = {
+  f: (r: Request) => Promise<Response>;
+  root: string;
+  api: (m: string, p: string, b?: string, acct?: string) => Promise<{ status: number; body: Body }>;
+  at: (iso: string) => void;
+  settings: (enabled: boolean, uris: string) => Promise<Response>;
+  authorize: (query: string, decision?: 'skip' | 'deny') => Promise<Response>;
+  endpoint: (path: 'token' | 'deauthorize', body: string, auth?: string) => Promise<{ status: number; body: Body }>;
+  /** Connect a new account through the page (skip) and exchange its code: the redirect, the code and the token answer. */
+  connect: (extra?: string) => Promise<{ location: URL; code: string; token: Body }>;
+};
+/** A fresh World with a Connect platform whose OAuth is on and whose callback is registered (unless `configure` is false). */
+async function withOAuth(run: (w: OAuthWorld) => Promise<boolean>, configure = true): Promise<boolean> {
+  const root = mkdtempSync(join(tmpdir(), 'stp-oauth-'));
+  let now = '2026-03-01T00:00:00.000Z';
+  const f = createStripeTwinFetch({ root, clock: () => now });
+  const form = { 'content-type': 'application/x-www-form-urlencoded' };
+  const w: OAuthWorld = {
+    f,
+    root,
+    api: async (m, p, b, acct) => {
+      const r = await f(new Request(`http://stripe.test${p}`, { method: m, headers: { authorization: 'Bearer sk_test_platform', ...form, ...(acct ? { 'stripe-account': acct } : {}) }, ...(b !== undefined ? { body: b } : {}) }));
+      return { status: r.status, body: (await r.json()) as Body };
+    },
+    at: (iso) => { now = iso; },
+    settings: (enabled, uris) => f(new Request('https://dashboard.stripe.com/settings/connect/onboarding-options/oauth', { method: 'POST', headers: form, body: new URLSearchParams({ ...(enabled ? { oauth_enabled: 'on' } : {}), redirect_uris: uris }).toString() })),
+    authorize: (query, decision) => f(new Request(`https://connect.stripe.com/oauth/authorize?${query}`, decision ? { method: 'POST', headers: form, body: `decision=${decision}` } : {})),
+    endpoint: async (path, body, auth = 'Bearer sk_test_platform') => {
+      const r = await f(new Request(`https://connect.stripe.com/oauth/${path}`, { method: 'POST', headers: { ...form, ...(auth ? { authorization: auth } : {}) }, body }));
+      return { status: r.status, body: (await r.json()) as Body };
+    },
+    connect: async (extra = '') => {
+      const location = new URL((await w.authorize(authorizeQuery(extra), 'skip')).headers.get('location') ?? 'about:blank');
+      const code = location.searchParams.get('code') ?? '';
+      const token = (await w.endpoint('token', `grant_type=authorization_code&code=${code}`)).body;
+      return { location, code, token };
+    },
+  };
+  try {
+    if (configure) await w.settings(true, OAUTH_CALLBACK);
+    return await verifyBoundary('stripe.withOAuth', () => run(w));
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+}
+/** A dispute as Stripe opens one: a charge whose test card the bank disputes (docs.stripe.com/testing#disputes). */
+async function disputed(h: (s: Step) => Promise<StripeResponse>, amount = 1000): Promise<StripeResponse> {
+  await h({ m: 'POST', p: '/v1/charges', b: `amount=${amount}&currency=usd&source=tok_createDispute` });
+  const first = (((await h({ m: 'GET', p: '/v1/disputes' })).body as Body).data as Body[])[0]!;
+  return h({ m: 'GET', p: `/v1/disputes/${String(first.id)}` });
+}
+/** A field on a hosted page under the page's own formatting script: typing (one character at a time), deleting, or a
+ *  paste or autofill of a whole value, each answering the field's value after the script has run. */
+function expiryField(script: string): { type: (s: string) => string; back: () => string; fill: (s: string) => string } {
+  const listeners: Array<(e: { inputType: string }) => void> = [];
+  const el = { value: '', addEventListener: (_: string, f: (e: { inputType: string }) => void) => { listeners.push(f); } };
+  new Function('document', script)({ querySelectorAll: () => [el] });
+  const fire = (inputType: string) => { for (const f of listeners) f({ inputType }); return el.value; };
+  return {
+    type: (s) => { for (const c of s) { el.value += c; fire('insertText'); } return el.value; },
+    back: () => { el.value = el.value.slice(0, -1); return fire('deleteContentBackward'); },
+    fill: (s) => { el.value = s; return fire('insertFromPaste'); },
+  };
+}
+/** A person's submission on one of Stripe's hosted pages (verify.stripe.com, the bank-linking flow Stripe.js opens). */
+async function hostedSubmit(root: string, flow: (scope: { root?: string }) => (request: Request) => Promise<Response | undefined>, url: string, form: Record<string, string>): Promise<Response | undefined> {
+  return flow({ root })(new Request(url, { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: new URLSearchParams(form).toString() }));
+}
 const id = (r: StripeResponse) => (r.body as Body)?.id as string;
 const field = (r: StripeResponse, k: string) => (r.body as Body)?.[k];
@@ -119,7 +241,6 @@ const listOk = (path: string) => () =>
 // ── shorthands (mirror the linear manifest) ──
 const done = (id: string, area: string, title: string, dimension: CapabilitySpec['dimension'], tier: CapabilitySpec['tier'], verify: CapabilitySpec['verify']): CapabilitySpec => ({ id, area, title, dimension, tier, expected: 'done', verify });
 const todo = (id: string, area: string, title: string, dimension: CapabilitySpec['dimension'], tier: CapabilitySpec['tier']): CapabilitySpec => ({ id, area, title, dimension, tier, expected: 'todo' });
-const outOfScope = (id: string, area: string, title: string, dimension: CapabilitySpec['dimension'], tier: CapabilitySpec['tier'], reason: string): CapabilitySpec => ({ id, area, title, dimension, tier, expected: 'todo', outOfScope: reason });
 // The real Stripe surface (the target). Entries with verify() + expected:'done' are what we
 // currently claim are working against THIS twin; everything else (the majority) is a gap.
@@ -189,8 +310,10 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
     }),
   ),
   // Cash balance: GET /v1/customers/:id/cash_balance returns the cash_balance summary
-  // (available currency→amount map, derived from the cash-balance ledger). Funding via
-  // .../cash_balance_transactions accrues into `available`; POST updates reconciliation_mode.
+  // (available currency→amount map, derived from the cash-balance ledger). Funding via the test helper
+  // POST /v1/test_helpers/customers/:id/fund_cash_balance ("Create an incoming testmode bank transfer",
+  // docs.stripe.com/api/cash_balance/fund_cash_balance) accrues into `available`; POST updates reconciliation_mode.
+  // (The twin-invented POST .../cash_balance_transactions left with 5decb1d77: Stripe's API has no such write.)
   // An unknown customer 404s; an invalid reconciliation_mode 400s. (Only this feature produces
   // the available map keyed by the funded currency.)
   done('stripe.customers.cash_balance', 'customers', 'Customer cash balance', 'api', 'niche', () =>
@@ -198,9 +321,9 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       const cust = await h({ m: 'POST', p: '/v1/customers', b: 'email=cash@twin.test' });
       const empty = await h({ m: 'GET', p: `/v1/customers/${id(cust)}/cash_balance` });
       if (!ok(empty) || field(empty, 'object') !== 'cash_balance' || field(empty, 'available') !== null) return false;
-      const fund = await h({ m: 'POST', p: `/v1/customers/${id(cust)}/cash_balance_transactions`, b: 'amount=5000&currency=usd' });
+      const fund = await h({ m: 'POST', p: `/v1/test_helpers/customers/${id(cust)}/fund_cash_balance`, b: 'amount=5000&currency=usd' });
       if (!ok(fund) || field(fund, 'type') !== 'funded' || field(fund, 'ending_balance') !== 5000) return false;
-      const more = await h({ m: 'POST', p: `/v1/customers/${id(cust)}/cash_balance_transactions`, b: 'amount=2500&currency=usd' });
+      const more = await h({ m: 'POST', p: `/v1/test_helpers/customers/${id(cust)}/fund_cash_balance`, b: 'amount=2500&currency=usd' });
       if (field(more, 'ending_balance') !== 7500) return false;
       const bal = await h({ m: 'GET', p: `/v1/customers/${id(cust)}/cash_balance` });
       if ((field(bal, 'available') as Body)?.usd !== 7500) return false;
@@ -269,7 +392,11 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       const beforeN = ((before.body as Body).data as Body[]).length;
       const afterN = ((after.body as Body).data as Body[]).length;
       const again = await h({ m: 'DELETE', p: `/v1/customers/${id(c)}` });
-      return gone.status === 404 && afterN === beforeN - 1 && again.status === 404;
+      // a deleted customer still RETRIEVES, as the stub: "If it's for a deleted Customer, a subset of the customer's
+      // information is returned, including a `deleted` property that's set to true" (docs.stripe.com/api/customers/retrieve;
+      // 8154bb647). It leaves the list, and a second delete finds nothing to delete.
+      return gone.status === 200 && field(gone, 'deleted') === true && field(gone, 'id') === id(c) && field(gone, 'email') === undefined
+        && afterN === beforeN - 1 && again.status === 404;
     }),
   ),
@@ -298,16 +425,25 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
     }),
   ),
   // Manual capture: a manual-capture PI confirmed lands in requires_capture (funds authorized,
-  // amount_capturable=amount), then /capture → succeeded (amount_received set, capturable cleared).
-  // Capturing an already-captured PI is the vendor 400 payment_intent_unexpected_state; unknown id 404.
+  // amount_capturable=amount) with its authorization a charge, succeeded and uncaptured (charge.succeeded), then
+  // /capture → succeeded (amount_received set, capturable cleared) capturing that same charge (charge.captured,
+  // "Occurs whenever a previously uncaptured charge is captured"). Capturing an already-captured PI is the vendor 400
+  // payment_intent_unexpected_state; unknown id 404.
   done('stripe.payment_intents.capture', 'payment_intents', 'PaymentIntent manual capture (capture_method=manual + /capture)', 'api', 'core', () =>
     withRoot(async (h) => {
       const pi = await h({ m: 'POST', p: '/v1/payment_intents', b: 'amount=2000&currency=usd&capture_method=manual' });
       if (!ok(pi)) return false;
       const conf = await h({ m: 'POST', p: `/v1/payment_intents/${id(pi)}/confirm`, b: 'payment_method=pm_card_visa' });
       if (!ok(conf) || field(conf, 'status') !== 'requires_capture' || field(conf, 'amount_capturable') !== 2000) return false;
+      const held = await h({ m: 'GET', p: `/v1/charges/${String(field(conf, 'latest_charge'))}` });
+      if (field(held, 'status') !== 'succeeded' || field(held, 'captured') !== false || field(held, 'amount_captured') !== 0 || field(held, 'balance_transaction') !== null) return false;
       const cap = await h({ m: 'POST', p: `/v1/payment_intents/${id(pi)}/capture` });
       if (!ok(cap) || field(cap, 'status') !== 'succeeded' || field(cap, 'amount_received') !== 2000 || field(cap, 'amount_capturable') !== 0) return false;
+      const taken = await h({ m: 'GET', p: `/v1/charges/${String(field(cap, 'latest_charge'))}` });
+      if (id(taken) !== id(held) || field(taken, 'captured') !== true || field(taken, 'amount_captured') !== 2000 || typeof field(taken, 'balance_transaction') !== 'string') return false;
+      const events = (((await h({ m: 'GET', p: '/v1/events?limit=100' })).body as Body).data as Body[]) ?? [];
+      const on = (type: string) => events.filter((e) => e.type === type && ((e.data as Body).object as Body).id === id(held)).map((e) => (e.data as Body).object as Body);
+      if (on('charge.succeeded').length !== 1 || on('charge.succeeded')[0]!.captured !== false || on('charge.captured').length !== 1 || on('charge.captured')[0]!.captured !== true) return false;
       // re-read persists; double-capture is the vendor unexpected-state 400; unknown id 404
       const g = await h({ m: 'GET', p: `/v1/payment_intents/${id(pi)}` });
       const again = await h({ m: 'POST', p: `/v1/payment_intents/${id(pi)}/capture` });
@@ -317,6 +453,51 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
         missing.status === 404;
     }),
   ),
+  // A declined confirm records the attempt as a failed charge the intent's latest_charge names, written as the event
+  // Stripe sends, charge.failed ("Occurs whenever a failed charge attempt occurs", docs.stripe.com/api/events/types), and
+  // carrying what every charge of the intent carries: its transfer_group and description. Dub reads the payout invoice a
+  // failed payment belongs to from transfer_group.
+  done('stripe.payment_intents.declined_charge', 'payment_intents', 'A declined confirm\'s failed charge fires charge.failed with the intent\'s transfer_group and description', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const pi = await h({ m: 'POST', p: '/v1/payment_intents', b: 'amount=2000&currency=usd&transfer_group=inv_77&description=Payout%20invoice%2077' });
+      const dec = await h({ m: 'POST', p: `/v1/payment_intents/${id(pi)}/confirm`, b: 'payment_method=pm_card_chargeDeclined' });
+      const chargeId = ((dec.body as Body).error as Body | undefined)?.charge;
+      const after = await h({ m: 'GET', p: `/v1/payment_intents/${id(pi)}` });
+      const charge = await h({ m: 'GET', p: `/v1/charges/${String(chargeId)}` });
+      const events = (((await h({ m: 'GET', p: '/v1/events?type=charge.failed' })).body as Body).data as Body[]) ?? [];
+      const object = (events[0]?.data as Body | undefined)?.object as Body | undefined;
+      return dec.status === 402 && field(after, 'latest_charge') === chargeId && field(charge, 'status') === 'failed'
+        && field(charge, 'transfer_group') === 'inv_77' && field(charge, 'description') === 'Payout invoice 77'
+        && events.length === 1 && object?.id === chargeId && object?.transfer_group === 'inv_77' && object?.description === 'Payout invoice 77';
+    }),
+  ),
+  // Cancelling a manual-capture intent releases its authorization: "For PaymentIntents with a `status` of
+  // `requires_capture`, the remaining `amount_capturable` is automatically refunded" (docs.stripe.com/api/payment_intents/cancel).
+  // Since basil the cancellation makes no Refund ("`refunded` will no longer be `true` for payment cancellation flows",
+  // the basil changelog), no money moves, and capturing the charge is refused, the intent being canceled.
+  done('stripe.payment_intents.cancel_authorization', 'payment_intents', 'Cancelling a requires_capture intent releases its uncaptured charge (no Refund, no balance moved); capturing it is refused', 'api', 'common', () =>
+    withRoot(async (h) => {
+      // the whole balance, available and pending
+      const avail = async (): Promise<number> => {
+        const b = (await h({ m: 'GET', p: '/v1/balance' })).body as Body;
+        return [...((b.available as Body[]) ?? []), ...((b.pending as Body[]) ?? [])].reduce((n, x) => n + (Number(x.amount) || 0), 0);
+      };
+      const pi = await h({ m: 'POST', p: '/v1/payment_intents', b: 'amount=2000&currency=usd&capture_method=manual&payment_method=pm_card_visa&confirm=true' });
+      const chargeId = String(field(pi, 'latest_charge'));
+      const before = await avail();
+      const cancel = await h({ m: 'POST', p: `/v1/payment_intents/${id(pi)}/cancel` });
+      const ch = await h({ m: 'GET', p: `/v1/charges/${chargeId}` });
+      const refunds = ((field(ch, 'refunds') as Body)?.data as Body[]) ?? [];
+      const capture = await h({ m: 'POST', p: `/v1/charges/${chargeId}/capture` });
+      const after = await avail();
+      // since basil a cancellation makes no Refund: amount_captured 0, amount_refunded and refunded untouched
+      return field(cancel, 'status') === 'canceled' && field(cancel, 'amount_capturable') === 0
+        && field(ch, 'captured') === false && field(ch, 'refunded') === false && field(ch, 'amount_refunded') === 0 && field(ch, 'amount_captured') === 0
+        && refunds.length === 0
+        && capture.status === 400 && ((capture.body as Body).error as Body)?.code === 'payment_intent_unexpected_state'
+        && before === 0 && after === 0;
+    }),
+  ),
   // Cancel: a non-terminal PI cancels → status canceled (+ cancellation_reason). Canceling a
   // succeeded PI is the vendor 400 payment_intent_unexpected_state; an unknown id is 404.
   done('stripe.payment_intents.cancel', 'payment_intents', 'PaymentIntent cancel', 'api', 'core', () =>
@@ -402,7 +583,7 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       return ok(g) && id(g) === id(ch) && field(l, 'object') === 'list';
     }),
   ),
-  done('stripe.charges.test_declines', 'charges', 'Test-card declines → 402 typed card_error (no charge persisted)', 'api', 'core', () =>
+  done('stripe.charges.test_declines', 'charges', 'Test-card declines → 402 typed card_error naming the failed charge', 'api', 'core', () =>
     withRoot(async (h) => {
       const dec = await h({ m: 'POST', p: '/v1/charges', b: 'amount=1000&currency=usd&source[number]=4000000000000002' });
       const ins = await h({ m: 'POST', p: '/v1/charges', b: 'amount=1000&currency=usd&source[number]=4000000000009995' });
@@ -411,6 +592,26 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       return dec.status === 402 && decErr?.code === 'card_declined' && ins.status === 402 && insErr?.decline_code === 'insufficient_funds';
     }),
   ),
+  // POST /v1/charges writes the event Stripe sends for the charge (docs.stripe.com/api/events/types; Stripe has no
+  // charge.created): charge.succeeded, "Occurs whenever a charge is successful", for one made and for an authorization
+  // (capture=false), charge.failed, "Occurs whenever a failed charge attempt occurs", for a declined attempt, and
+  // charge.captured, "Occurs whenever a previously uncaptured charge is captured", when the authorization is captured.
+  done('stripe.charges.events', 'charges', 'Charges fire charge.succeeded (made or authorized), charge.failed (declined) and charge.captured', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const made = await h({ m: 'POST', p: '/v1/charges', b: 'amount=2000&currency=usd&source=tok_visa' });
+      const auth = await h({ m: 'POST', p: '/v1/charges', b: 'amount=3000&currency=usd&source=tok_visa&capture=false' });
+      const dec = await h({ m: 'POST', p: '/v1/charges', b: 'amount=1000&currency=usd&source=tok_chargeDeclined' });
+      const declined = ((dec.body as Body).error as Body | undefined)?.charge;
+      await h({ m: 'POST', p: `/v1/charges/${id(auth)}/capture` });
+      const events = (((await h({ m: 'GET', p: '/v1/events?limit=100' })).body as Body).data as Body[]) ?? [];
+      const of = (type: string) => events.filter((e) => e.type === type).map((e) => (e.data as Body).object as Body);
+      const succeeded = of('charge.succeeded');
+      return dec.status === 402 && typeof declined === 'string'
+        && succeeded.some((c) => c.id === id(made) && c.captured === true) && succeeded.some((c) => c.id === id(auth) && c.captured === false)
+        && of('charge.failed').some((c) => c.id === declined && c.status === 'failed')
+        && of('charge.captured').some((c) => c.id === id(auth) && c.captured === true && c.amount_captured === 3000);
+    }),
+  ),
   // Charge capture: a charge created with capture=false is an uncaptured auth (captured:false,
   // amount_captured:0); /capture captures it (captured:true, amount_captured set). Re-capture
   // is the vendor 400 charge_already_captured; an immediately-captured charge (default) cannot
@@ -422,6 +623,12 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       const cap = await h({ m: 'POST', p: `/v1/charges/${id(auth)}/capture` });
       if (!ok(cap) || field(cap, 'captured') !== true || field(cap, 'amount_captured') !== 3000) return false;
       const again = await h({ m: 'POST', p: `/v1/charges/${id(auth)}/capture` });
+      // A PARTIAL capture releases the remainder with no Refund (the basil change): amount_refunded stays 0
+      const part = await h({ m: 'POST', p: '/v1/charges', b: 'amount=3000&currency=usd&capture=false' });
+      const capPart = await h({ m: 'POST', p: `/v1/charges/${id(part)}/capture`, b: 'amount=1200' });
+      if (!ok(capPart) || field(capPart, 'amount_captured') !== 1200 || field(capPart, 'amount_refunded') !== 0 || field(capPart, 'refunded') !== false) return false;
+      const released = ((field(capPart, 'refunds') as Body)?.data as Body[]) ?? [];
+      if (released.length !== 0) return false;
       const def = await h({ m: 'POST', p: '/v1/charges', b: 'amount=1000&currency=usd' });
       const capDef = await h({ m: 'POST', p: `/v1/charges/${id(def)}/capture` });
       const missing = await h({ m: 'POST', p: '/v1/charges/ch_nope/capture' });
@@ -464,30 +671,112 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   // ── Refunds ─────────────────────────────────────────────────────────────────────
   done('stripe.refunds.crud', 'refunds', 'Refunds: create + retrieve + list', 'api', 'core', () =>
     withRoot(async (h) => {
-      const r = await h({ m: 'POST', p: '/v1/refunds', b: 'charge=ch_twin&amount=500' });
+      const c = await h({ m: 'POST', p: '/v1/charges', b: 'amount=2000&currency=usd' });
+      const r = await h({ m: 'POST', p: '/v1/refunds', b: `charge=${id(c)}&amount=500` });
       if (!ok(r) || field(r, 'object') !== 'refund') return false;
       const g = await h({ m: 'GET', p: `/v1/refunds/${id(r)}` });
       const l = await h({ m: 'GET', p: '/v1/refunds' });
       return ok(g) && id(g) === id(r) && field(l, 'object') === 'list';
     }),
   ),
+  // The money model's central claim: a refund is VISIBLE FROM THE CHARGE it came out of.
+  // amount_refunded accumulates, `refunded` flips only at the full amount, and the charge's
+  // own refunds sub-list carries the refund objects. A twin that answers a succeeded refund
+  // while the charge still reads amount_refunded 0 hands a reconciler the wrong ledger with
+  // no error to tell them — which is why the over-refund refusal is part of the same claim.
+  done('stripe.refunds.visible_on_charge', 'refunds', 'A refund lands on its charge: amount_refunded / refunded / refunds list, and an over-refund is refused', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const c = await h({ m: 'POST', p: '/v1/charges', b: 'amount=2000&currency=usd' });
+      const r1 = await h({ m: 'POST', p: '/v1/refunds', b: `charge=${id(c)}&amount=500` });
+      if (!ok(r1)) return false;
+      // `refunds` is includable on a charge, "not returned by default" (docs.stripe.com/api/charges/object; 4388f04e9):
+      // the plain read leaves it out, and the read that expands it carries the refund
+      const plain = await h({ m: 'GET', p: `/v1/charges/${id(c)}` });
+      if (field(plain, 'refunds') !== undefined) return false;
+      const partial = await h({ m: 'GET', p: `/v1/charges/${id(c)}?expand[]=refunds` });
+      if (field(partial, 'amount_refunded') !== 500 || field(partial, 'refunded') !== false) return false;
+      const listed = (field(partial, 'refunds') as Body)?.data as Body[] | undefined;
+      if (!Array.isArray(listed) || listed.length !== 1 || listed[0]?.id !== id(r1)) return false;
+      // more than the charge has left to give is refused, not silently accepted
+      const tooMuch = await h({ m: 'POST', p: '/v1/refunds', b: `charge=${id(c)}&amount=1600` });
+      if (tooMuch.status !== 400) return false;
+      // an omitted amount refunds the whole remainder, and THEN the charge is fully refunded
+      // (taken through the charge's OWN refund endpoint — Stripe serves both spellings)
+      const r2 = await h({ m: 'POST', p: `/v1/charges/${id(c)}/refunds` });
+      if (!ok(r2) || field(r2, 'amount') !== 1500) return false;
+      const full = await h({ m: 'GET', p: `/v1/charges/${id(c)}` });
+      // and the charge's own refunds sub-route answers the same two refunds
+      const sub = await h({ m: 'GET', p: `/v1/charges/${id(c)}/refunds` });
+      const none = await h({ m: 'POST', p: '/v1/refunds', b: 'amount=100' });
+      const nosuch = await h({ m: 'POST', p: '/v1/refunds', b: 'charge=ch_nope&amount=100' });
+      return field(full, 'amount_refunded') === 2000 && field(full, 'refunded') === true
+        && ((field(sub, 'data') as Body[])?.length === 2)
+        && none.status === 400 && nosuch.status === 404;
+    }),
+  ),
+  // A refund reached through its PaymentIntent lands on the SAME charge: a succeeded intent
+  // has a latest_charge (real Stripe always mints one), and that is what the refund hits.
+  done('stripe.refunds.by_payment_intent', 'refunds', 'Refund by payment_intent resolves the intent’s charge', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const pi = await h({ m: 'POST', p: '/v1/payment_intents', b: 'amount=3000&currency=usd' });
+      const con = await h({ m: 'POST', p: `/v1/payment_intents/${id(pi)}/confirm`, b: 'payment_method=pm_card_visa' });
+      const charge = field(con, 'latest_charge') as string | undefined;
+      if (!charge) return false;
+      const r = await h({ m: 'POST', p: '/v1/refunds', b: `payment_intent=${id(pi)}&amount=1200` });
+      if (!ok(r) || field(r, 'charge') !== charge || field(r, 'payment_intent') !== id(pi)) return false;
+      const ch = await h({ m: 'GET', p: `/v1/charges/${charge}` });
+      const missing = await h({ m: 'POST', p: '/v1/refunds', b: 'payment_intent=pi_nope&amount=1' });
+      return field(ch, 'amount_refunded') === 1200 && missing.status === 404;
+    }),
+  ),
   // Refund update: POST /v1/refunds/:id persists metadata; retrieve round-trips it. Unknown id 404.
+  // An uncaptured charge holds an authorization, not money. A PaymentIntent's "remains uncaptured and can't be refunded
+  // directly. You must cancel the PaymentIntent" (docs.stripe.com/refunds), so its refund is refused, through the intent
+  // or the charge; a capture=false charge's refund releases it (refunded in full, no balance moved) and its capture is
+  // then refused ("unless the charge is already refunded", docs.stripe.com/api/charges/capture).
+  done('stripe.refunds.uncaptured', 'refunds', 'Refunding an uncaptured charge: refused for a PaymentIntent\'s (cancel it), a release for a capture=false charge; no balance moved, capture refused after', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const whole = async (): Promise<number> => {
+        const b = (await h({ m: 'GET', p: '/v1/balance' })).body as Body;
+        return [...((b.available as Body[]) ?? []), ...((b.pending as Body[]) ?? [])].reduce((n, x) => n + (Number(x.amount) || 0), 0);
+      };
+      const pi = await h({ m: 'POST', p: '/v1/payment_intents', b: 'amount=2000&currency=usd&capture_method=manual&payment_method=pm_card_visa&confirm=true' });
+      const viaIntent = await h({ m: 'POST', p: '/v1/refunds', b: `payment_intent=${id(pi)}` });
+      const viaCharge = await h({ m: 'POST', p: '/v1/refunds', b: `charge=${String(field(pi, 'latest_charge'))}` });
+      const still = await h({ m: 'GET', p: `/v1/charges/${String(field(pi, 'latest_charge'))}` });
+      if (viaIntent.status !== 400 || viaCharge.status !== 400 || field(still, 'refunded') !== false || field(still, 'amount_refunded') !== 0) return false;
+      const auth = await h({ m: 'POST', p: '/v1/charges', b: 'amount=3000&currency=usd&source=tok_visa&capture=false' });
+      const refund = await h({ m: 'POST', p: '/v1/refunds', b: `charge=${id(auth)}` });
+      const released = await h({ m: 'GET', p: `/v1/charges/${id(auth)}` });
+      const capture = await h({ m: 'POST', p: `/v1/charges/${id(auth)}/capture` });
+      return ok(refund) && field(refund, 'amount') === 3000 && field(refund, 'balance_transaction') === null
+        && field(released, 'refunded') === true && field(released, 'captured') === false && field(released, 'amount_refunded') === 3000
+        && capture.status === 400 && ((capture.body as Body).error as Body)?.code === 'charge_already_refunded' && await whole() === 0;
+    }),
+  ),
   done('stripe.refunds.update', 'refunds', 'Refund update (metadata)', 'api', 'common', () =>
     withRoot(async (h) => {
-      const r = await h({ m: 'POST', p: '/v1/refunds', b: 'charge=ch_twin&amount=500' });
+      const c = await h({ m: 'POST', p: '/v1/charges', b: 'amount=2000&currency=usd' });
+      const r = await h({ m: 'POST', p: '/v1/refunds', b: `charge=${id(c)}&amount=500` });
       const u = await h({ m: 'POST', p: `/v1/refunds/${id(r)}`, b: 'metadata[reason]=duplicate' });
       if (!ok(u) || ((field(u, 'metadata') as Body)?.reason) !== 'duplicate') return false;
       const g = await h({ m: 'GET', p: `/v1/refunds/${id(r)}` });
       const missing = await h({ m: 'POST', p: '/v1/refunds/re_nope', b: 'metadata[x]=1' });
-      return ok(g) && ((field(g, 'metadata') as Body)?.reason) === 'duplicate' && missing.status === 404;
+      // the same refund, read and written THROUGH its charge (Stripe's charge-scoped routes)
+      const viaCharge = await h({ m: 'GET', p: `/v1/charges/${id(c)}/refunds/${id(r)}` });
+      const editedViaCharge = await h({ m: 'POST', p: `/v1/charges/${id(c)}/refunds/${id(r)}`, b: 'metadata[note]=via-charge' });
+      const wrongCharge = await h({ m: 'GET', p: `/v1/charges/${id(c)}/refunds/re_nope` });
+      return ok(g) && ((field(g, 'metadata') as Body)?.reason) === 'duplicate' && missing.status === 404
+        && ok(viaCharge) && id(viaCharge) === id(r) && wrongCharge.status === 404
+        && ((field(editedViaCharge, 'metadata') as Body)?.note) === 'via-charge';
     }),
   ),
   // (refunds.cancel upgraded to done() in the AUDIT GROWTH block below.)
   // ── Disputes ────────────────────────────────────────────────────────────────────
-  done('stripe.disputes.crud', 'disputes', 'Disputes: create + retrieve + list', 'api', 'common', () =>
+  done('stripe.disputes.crud', 'disputes', 'Disputes: a disputed charge opens one; retrieve + list', 'api', 'common', () =>
     withRoot(async (h) => {
-      const d = await h({ m: 'POST', p: '/v1/disputes', b: 'charge=ch_twin&amount=1000&currency=usd' });
+      const d = await disputed(h);
       if (!ok(d) || field(d, 'object') !== 'dispute') return false;
       const g = await h({ m: 'GET', p: `/v1/disputes/${id(d)}` });
       const l = await h({ m: 'GET', p: '/v1/disputes' });
@@ -496,13 +785,27 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   ),
   done('stripe.disputes.evidence', 'disputes', 'Dispute evidence submission (update) + close', 'api', 'common', () =>
     withRoot(async (h) => {
-      const d = await h({ m: 'POST', p: '/v1/disputes', b: 'charge=ch_twin&amount=1000&currency=usd' });
+      const d = await disputed(h);
       const ev = await h({ m: 'POST', p: `/v1/disputes/${id(d)}`, b: 'evidence[uncategorized_text]=we shipped it' });
       const cl = await h({ m: 'POST', p: `/v1/disputes/${id(d)}/close` });
       return ok(ev) && ok(cl) && field(cl, 'status') === 'lost';
     }),
   ),
+  // The dispute test cards open a dispute through Checkout as through the API, and test-mode evidence decides it:
+  // `winning_evidence` wins (the amount comes back), `losing_evidence` loses (docs.stripe.com/testing#disputes, #evidence).
+  done('stripe.disputes.test_outcomes', 'disputes', 'Dispute test cards through Checkout; winning_evidence / losing_evidence decide the dispute', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const cs = await h({ m: 'POST', p: '/v1/checkout/sessions', b: 'mode=payment&success_url=https://x.test&line_items[0][price_data][currency]=usd&line_items[0][price_data][unit_amount]=6500&line_items[0][quantity]=1' });
+      await h({ m: 'POST', p: `/c/pay/${id(cs)}`, b: 'email=pay%40twin.test&cardNumber=4000000000002685&cardExpiry=12%2F34&cardCvc=123&billingName=Twin&billingCountry=US&billingPostalCode=94105' });
+      const opened = ((await h({ m: 'GET', p: '/v1/disputes' })).body as Body).data as Body[];
+      const won = await h({ m: 'POST', p: `/v1/disputes/${String(opened[0]?.id)}`, b: 'evidence[uncategorized_text]=winning_evidence' });
+      const lostOne = await disputed(h);
+      const lost = await h({ m: 'POST', p: `/v1/disputes/${id(lostOne)}`, b: 'evidence[uncategorized_text]=losing_evidence' });
+      return opened[0]?.reason === 'product_not_received' && field(won, 'status') === 'won' && field(lost, 'status') === 'lost';
+    }),
+  ),
   // ── Balance / BalanceTransactions / Payouts ───────────────────────────────────────
   done('stripe.balance.retrieve', 'balance', 'Balance retrieve (available/pending)', 'api', 'core', () =>
     withRoot(async (h) => {
@@ -510,17 +813,37 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       return ok(r) && field(r, 'object') === 'balance';
     }),
   ),
-  done('stripe.balance_transactions.crud', 'balance', 'BalanceTransactions: create + retrieve + list', 'api', 'core', () =>
+  done('stripe.balance_transactions.crud', 'balance', 'BalanceTransactions: a charge\'s ledger entry; retrieve + list', 'api', 'core', () =>
     withRoot(async (h) => {
-      const t = await h({ m: 'POST', p: '/v1/balance_transactions', b: 'amount=1000&currency=usd' });
-      if (!ok(t)) return false;
+      await h({ m: 'POST', p: '/v1/charges', b: 'amount=1000&currency=usd&source=tok_visa' });
+      const t = { status: 200, body: (((await h({ m: 'GET', p: '/v1/balance_transactions' })).body as Body).data as Body[])[0]! } as StripeResponse;
+      if (!t.body || field(t, 'amount') !== 1000) return false;
       const g = await h({ m: 'GET', p: `/v1/balance_transactions/${id(t)}` });
       const l = await h({ m: 'GET', p: '/v1/balance_transactions' });
       return ok(g) && id(g) === id(t) && field(l, 'object') === 'list';
     }),
   ),
+  // Every money movement writes its balance transaction (semantics/ledger.ts): a captured charge credits its
+  // amount less Stripe's standard fee, pending until available_on; a refund and a payout debit at once; a
+  // platform payout beyond the available balance is balance_insufficient.
+  done('stripe.balance_transactions.from_money_movement', 'balance', 'BalanceTransactions written by charges, refunds and payouts; the balance their sum; payouts held to it', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const ch = await h({ m: 'POST', p: '/v1/charges', b: 'amount=10000&currency=usd&source=tok_visa' });
+      const btId = field(ch, 'balance_transaction') as string;
+      const bt = await h({ m: 'GET', p: `/v1/balance_transactions/${btId}` });
+      if (!(ok(bt) && field(bt, 'type') === 'charge' && field(bt, 'fee') === 320 && field(bt, 'net') === 9680 && field(bt, 'status') === 'pending')) return false;
+      // pending funds cannot be paid out; funds that settle at once can
+      if ((await h({ m: 'POST', p: '/v1/payouts', b: 'amount=5000&currency=usd' })).status !== 400) return false;
+      await h({ m: 'POST', p: '/v1/charges', b: 'amount=10000&currency=usd&source=tok_bypassPending' });
+      const po = await h({ m: 'POST', p: '/v1/payouts', b: 'amount=5000&currency=usd' });
+      const bal = await h({ m: 'GET', p: '/v1/balance' });
+      const available = ((bal.body as { available: Array<{ amount: number }> }).available[0]!).amount;
+      return ok(po) && available === 9680 - 5000;
+    }),
+  ),
   done('stripe.payouts.crud', 'payouts', 'Payouts: create + retrieve + list + cancel', 'api', 'core', () =>
     withRoot(async (h) => {
+      await h({ m: 'POST', p: '/v1/charges', b: 'amount=2000&currency=usd&source=tok_bypassPending' });
       const p = await h({ m: 'POST', p: '/v1/payouts', b: 'amount=1000&currency=usd' });
       if (!ok(p) || field(p, 'object') !== 'payout') return false;
       const g = await h({ m: 'GET', p: `/v1/payouts/${id(p)}` });
@@ -528,22 +851,39 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       return ok(g) && id(g) === id(p) && ok(c);
     }),
   ),
-  // Payout reverse: POST /v1/payouts/:id/reverse materializes the reversal as a NEW payout
-  // (carrying original_payout) and marks the original canceled + reversed_by. Reversing twice
-  // 400s; unknown id 404. (Only this feature sets original_payout / reversed_by.)
-  done('stripe.payouts.reverse', 'payouts', 'Payout reverse', 'api', 'niche', () =>
-    withRoot(async (h) => {
-      const p = await h({ m: 'POST', p: '/v1/payouts', b: 'amount=4000&currency=usd' });
-      if (!ok(p)) return false;
-      const rev = await h({ m: 'POST', p: `/v1/payouts/${id(p)}/reverse` });
-      if (!ok(rev) || field(rev, 'original_payout') !== id(p) || field(rev, 'amount') !== 4000) return false;
-      const orig = await h({ m: 'GET', p: `/v1/payouts/${id(p)}` });
-      if (field(orig, 'status') !== 'canceled' || field(orig, 'reversed_by') !== id(rev)) return false;
-      const twice = await h({ m: 'POST', p: `/v1/payouts/${id(p)}/reverse` });
+  // Payout reverse: a connected account's payout, once paid, is reversed as a NEW payout carrying original_payout;
+  // the original stays paid and names it (reversed_by). A pending payout is canceled instead (400), a platform payout
+  // cannot be reversed (400), reversing twice 400s, and an unknown id 404s.
+  done('stripe.payouts.reverse', 'payouts', 'Payout reverse (a connected account\'s paid payout)', 'api', 'niche', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'stp-rev-'));
+    try {
+      // at noon: accounts are paid out automatically at midnight UTC on their schedule's days (5ab14297c), so a charge
+      // made at the stroke of midnight is swept into that same instant's automatic payout and nothing is left to send
+      const h = (s: Step & { acct?: string; day?: number }) => handleStripeTwinRequest({ method: s.m, path: s.p, body: s.b, root, occurredAt: `2026-06-${String(s.day ?? 1).padStart(2, '0')}T12:00:00Z`, ...(s.acct ? { stripeAccount: s.acct } : {}) });
+      const seller = await onboardedSeller(h);
+      await h({ m: 'POST', p: '/v1/transfers', b: `amount=5000&currency=usd&destination=${seller}` });
+      const p = await h({ m: 'POST', p: '/v1/payouts', b: 'amount=4000&currency=usd', acct: seller });
+      if (!ok(p) || (await h({ m: 'POST', p: `/v1/payouts/${id(p)}/reverse`, acct: seller })).status !== 400) return false;
+      // the platform's own payout, made the same day, before its automatic payout sweeps what is left (5ab14297c)
+      const plat = await h({ m: 'POST', p: '/v1/payouts', b: 'amount=1000&currency=usd' });
+      if (!ok(plat)) return false;
+      const rev = await h({ m: 'POST', p: `/v1/payouts/${id(p)}/reverse`, acct: seller, day: 5 });
+      // the reversal is a payout the other way, "a negative amount" as the reverse page's example answers it
+      // (docs.stripe.com/api/payouts/reverse; 8848ebfaa)
+      if (!ok(rev) || field(rev, 'original_payout') !== id(p) || field(rev, 'amount') !== -4000) return false;
+      const orig = await h({ m: 'GET', p: `/v1/payouts/${id(p)}`, acct: seller, day: 5 });
+      if (field(orig, 'status') !== 'paid' || field(orig, 'reversed_by') !== id(rev)) return false;
+      const platRev = await h({ m: 'POST', p: `/v1/payouts/${id(plat)}/reverse`, day: 5 });
+      const twice = await h({ m: 'POST', p: `/v1/payouts/${id(p)}/reverse`, acct: seller, day: 5 });
       const nope = await h({ m: 'POST', p: '/v1/payouts/po_nope/reverse' });
-      return twice.status === 400 && nope.status === 404;
-    }),
-  ),
+      return platRev.status === 400 && twice.status === 400 && nope.status === 404;
+    } catch (err) {
+      if (isInfrastructureError(err)) throw harnessError('stripe.payouts.reverse', err);
+      return false;
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  }),
   // Payout schedule: the automatic-payout cadence lives in account.settings.payouts.schedule.
   // GET /v1/account returns the platform account with a default daily schedule; POST updates
   // it to e.g. weekly+anchor (anchors normalized — weekly_anchor set, monthly_anchor null) and
@@ -555,7 +895,7 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       if (!ok(acct)) return false;
       const sched0 = ((field(acct, 'settings') as Body)?.payouts as Body)?.schedule as Body;
       if (!sched0 || sched0.interval !== 'daily') return false;
-      const upd = await h({ m: 'POST', p: '/v1/account', b: 'settings[payouts][schedule][interval]=weekly&settings[payouts][schedule][weekly_anchor]=friday' });
+      const upd = await h({ m: 'POST', p: '/_twin/account', b: 'settings[payouts][schedule][interval]=weekly&settings[payouts][schedule][weekly_anchor]=friday' });
       const sched1 = ((field(upd, 'settings') as Body)?.payouts as Body)?.schedule as Body;
       if (!ok(upd) || sched1.interval !== 'weekly' || sched1.weekly_anchor !== 'friday' || sched1.monthly_anchor !== null) return false;
       // persists across a re-read.
@@ -569,6 +909,211 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
     }),
   ),
+  // Automatic payouts: on its schedule an account is paid out what has become available, and the ledger lists the
+  // entries each automatic payout paid (docs.stripe.com/payouts#payout-schedule,
+  // docs.stripe.com/api/balance_transactions/list#balance_transaction_list-payout).
+  done('stripe.payouts.automatic', 'payouts', 'Automatic payouts on the account\'s schedule, with the entries each paid out', 'api', 'core', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'stp-auto-'));
+    try {
+      const h = (s: Step & { day?: number }) => handleStripeTwinRequest({ method: s.m, path: s.p, body: s.b, root, occurredAt: `2026-06-${String(s.day ?? 1).padStart(2, '0')}T12:00:00Z` });
+      const ch = await h({ m: 'POST', p: '/v1/charges', b: 'amount=2000&currency=usd&source=tok_visa' });
+      const early = await h({ m: 'GET', p: '/v1/payouts', day: 2 });
+      const later = await h({ m: 'GET', p: '/v1/payouts?created[gte]=1780272000', day: 6 });
+      const po = (((later.body as Body).data as Body[]) ?? [])[0];
+      const entries = await h({ m: 'GET', p: `/v1/balance_transactions?payout=${String(po?.id)}`, day: 6 });
+      const sources = (((entries.body as Body).data as Body[]) ?? []).map((t) => t.source);
+      return ((early.body as Body).data as Body[]).length === 0 && po?.automatic === true && po.amount === 2000 - 88
+        && sources.includes(id(ch)) && sources.includes(po.id);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  }),
+  // Time's events (stripe-server.ts, the drain door): funds coming due send their account balance.available, a payout's
+  // arrival sends payout.paid, each once, a connected account's scoped to it (docs.stripe.com/api/events/types;
+  // docs.stripe.com/connect/webhooks). Dub pays a partner's connected account out on balance.available and completes
+  // the partner's payouts on payout.paid. The webhooks are read where an application reads them, a local receiver behind
+  // a platform endpoint and a `connect` one; the stored events are listed as each account (the Stripe-Account header).
+  done('stripe.events.time_drain', 'webhooks', 'Events World time produces (balance.available, payout.paid) sent through the drain door, once each, scoped to their account', 'api', 'common', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'stp-drain-'));
+    const rx = await webhookReceiver();
+    try {
+      let now = '2026-06-01T12:00:00.000Z';
+      const h = fetcher(createStripeTwinFetch({ root, clock: () => now }));
+      await h('POST', '/v1/webhook_endpoints', `url=${rx.url('/platform')}&enabled_events[]=balance.available&enabled_events[]=payout.paid`);
+      await h('POST', '/v1/webhook_endpoints', `url=${rx.url('/connect')}&enabled_events[]=balance.available&enabled_events[]=payout.paid&connect=true`);
+      const seller = String((await h('POST', '/v1/accounts', 'type=custom&country=US&capabilities[transfers][requested]=true&business_profile[mcc]=5462&business_profile[url]=https://seller.test&tos_acceptance[date]=1767225600&tos_acceptance[ip]=203.0.113.9&individual[first_name]=Sam&individual[last_name]=Seller&settings[payouts][schedule][interval]=manual')).id);
+      await h('POST', `/v1/accounts/${seller}/external_accounts`, 'external_account[object]=bank_account&external_account[country]=US&external_account[currency]=usd&external_account[routing_number]=110000000&external_account[account_number]=000123456789');
+      await h('POST', '/_twin/account', 'settings[payouts][schedule][interval]=manual');
+      const pi = await h('POST', '/v1/payment_intents', 'amount=2592&currency=usd&payment_method=pm_card_visa&confirm=true');
+      await h('POST', '/v1/transfers', `amount=2400&currency=usd&destination=${seller}&source_transaction=${String(pi.latest_charge)}`);
+      const sent = async (): Promise<string[]> => ((await h('POST', '/_twin/drain')).delivered as Body[]).map((d) => `${String(d.type)}@${String(d.account ?? 'platform')}`);
+      const early = await sent();
+      now = '2026-06-04T12:00:00.000Z';
+      const due = await sent();
+      const again = await sent();
+      const po = await h('POST', '/v1/payouts', 'amount=2400&currency=usd', seller);
+      now = '2026-06-07T12:00:00.000Z';
+      const arrived = await sent();
+      // the connected account's webhooks reach only the connect endpoint, naming it; the platform's only the other
+      const theirs = rx.got('/connect');
+      const ours = rx.got('/platform');
+      const balance = theirs.find((e) => e.type === 'balance.available');
+      const paid = theirs.find((e) => e.type === 'payout.paid');
+      const hook = balance?.account === seller && ((balance.data.object as Body).available as Body[])?.[0]?.amount === 2400
+        && paid?.account === seller && (paid.data.object as Body).id === po.id && theirs.length === 2
+        && ours.length === 1 && ours[0]!.type === 'balance.available' && !('account' in ours[0]!);
+      const listed = (acct?: string) => h('GET', '/v1/events?limit=50', undefined, acct).then((l) => ((l.data as Body[]) ?? []).map((e) => `${String(e.type)}@${String(e.account ?? 'platform')}`));
+      const sellerEvents = await listed(seller);
+      const platformEvents = await listed();
+      return early.length === 0 && due.includes(`balance.available@${seller}`) && due.includes('balance.available@platform') && again.length === 0
+        && po.status === 'pending' && arrived.includes(`payout.paid@${seller}`) && hook
+        && sellerEvents.includes(`balance.available@${seller}`) && sellerEvents.includes(`payout.paid@${seller}`)
+        && platformEvents.includes('balance.available@platform') && !platformEvents.some((e) => e.endsWith(`@${seller}`));
+    } finally {
+      rx.close();
+      rmSync(root, { recursive: true, force: true });
+    }
+  }),
+  // Test mode's clock, as Stripe documents it (docs.stripe.com/testing#available-balance; semantics/ledger.ts): a card
+  // that bypasses the pending balance (4000000000000077, 4000003720000278, their pm_card_/tok_ names) puts its funds in
+  // the available balance at once, a PaymentMethod saved from it too when a later charge names it by id, and a
+  // source_transaction transfer from that charge is available on the connected account at once ("takes on the pending
+  // status of the associated charge", docs.stripe.com/connect/separate-charges-and-transfers); the drain in that same
+  // instant sends each account balance.available. Every other card keeps the delay (4242 pending), and a test payout
+  // keeps live timing ("Test payouts simulate a live payout", docs.stripe.com/payouts#test-payouts): paid at its
+  // arrival_date, not before. Dub's partner payout reaches Completed this way without World time for the funds. A US
+  // bank account debit settles at once too ("Test transactions settle instantly and are added to your available test
+  // balance", docs.stripe.com/testing), and every credit available at once is sent as balance.available.
+  done('stripe.balance.test_mode_bypass_pending', 'balance', 'Test-mode funds timing: bypass cards (raw, by test name, saved as a PaymentMethod) and bank debits available at once with balance.available sent, source_transaction transfers inheriting it; 4242 and test payouts keep their timing', 'api', 'common', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'stp-bypass-'));
+    const rx = await webhookReceiver();
+    try {
+      let now = '2026-06-01T12:00:00.000Z';
+      const h = fetcher(createStripeTwinFetch({ root, clock: () => now }));
+      await h('POST', '/v1/webhook_endpoints', `url=${rx.url('/connect')}&enabled_events[]=balance.available&enabled_events[]=payout.paid&connect=true`);
+      const seller = String((await h('POST', '/v1/accounts', 'type=custom&country=US&capabilities[transfers][requested]=true&business_profile[mcc]=5462&business_profile[url]=https://seller.test&tos_acceptance[date]=1767225600&tos_acceptance[ip]=203.0.113.9&business_type=individual&individual[first_name]=Jordan&individual[last_name]=Lee&settings[payouts][schedule][interval]=manual')).id);
+      await h('POST', `/v1/accounts/${seller}/external_accounts`, 'external_account[object]=bank_account&external_account[country]=US&external_account[currency]=usd&external_account[routing_number]=110000000&external_account[account_number]=000123456789');
+      await h('POST', '/_twin/account', 'settings[payouts][schedule][interval]=manual');
+      const btOf = async (charge: unknown) => h('GET', `/v1/balance_transactions/${String((await h('GET', `/v1/charges/${String(charge)}`)).balance_transaction)}`);
+      const amounts = async (acct?: string) => {
+        const b = await h('GET', '/v1/balance', undefined, acct);
+        return { available: ((b.available as Body[])[0]?.amount as number) ?? 0, pending: ((b.pending as Body[])[0]?.amount as number) ?? 0 };
+      };
+      // 4242: the delay stands in test mode
+      const visa = await h('POST', '/v1/payment_intents', 'amount=1000&currency=usd&payment_method=pm_card_visa&confirm=true');
+      if ((await btOf(visa.latest_charge)).status !== 'pending') return false;
+      const before = await amounts();
+      // a card saved from 4000000000000077, charged later by its id
+      const customer = String((await h('POST', '/v1/customers', 'email=maya@acme.test')).id);
+      const pm = String((await h('POST', '/v1/payment_methods', 'type=card&card[number]=4000000000000077&card[exp_month]=4&card[exp_year]=2030&card[cvc]=314')).id);
+      await h('POST', `/v1/payment_methods/${pm}/attach`, `customer=${customer}`);
+      const pi = await h('POST', '/v1/payment_intents', `amount=2592&currency=usd&customer=${customer}&payment_method=${pm}&confirm=true&off_session=true&expand[]=latest_charge.balance_transaction`);
+      const charge = String((pi.latest_charge as Body | undefined)?.id);
+      const bt = await btOf(charge);
+      const after = await amounts();
+      // the entry reads available however it is read: its own retrieve, the balance, an expansion
+      const embedded = ((pi.latest_charge as Body | undefined)?.balance_transaction as Body | undefined)?.status;
+      const platformAtOnce = bt.status === 'available' && embedded === 'available' && after.available - before.available === Number(bt.net) && after.pending === before.pending;
+      // its source_transaction transfer is available on the connected account at once, and is sent as such
+      await h('POST', '/v1/transfers', `amount=2400&currency=usd&destination=${seller}&source_transaction=${charge}`);
+      const theirs = await amounts(seller);
+      const sent = async (): Promise<string[]> => ((await h('POST', '/_twin/drain')).delivered as Body[]).map((d) => `${String(d.type)}@${String(d.account ?? 'platform')}`);
+      const drained = await sent();
+      const again = await sent();
+      const hook = rx.got('/connect').find((e) => e.type === 'balance.available');
+      const announced = drained.includes(`balance.available@${seller}`) && drained.includes('balance.available@platform') && again.length === 0
+        && hook?.account === seller && ((hook.data.object as Body).available as Body[])?.[0]?.amount === 2400;
+      // a test payout to Stripe's succeeding test bank account keeps live timing: pending until its arrival_date
+      const po = await h('POST', '/v1/payouts', 'amount=2400&currency=usd', seller);
+      if (!(platformAtOnce && theirs.available === 2400 && theirs.pending === 0 && announced && typeof po.id === 'string')) return false;
+      const early = await sent();
+      now = new Date(Number(po.arrival_date) * 1000 + 1000).toISOString();
+      const arrived = await sent();
+      const paid = (await h('GET', `/v1/payouts/${String(po.id)}`, undefined, seller)).status;
+      // the international bypass card, raw and by test name
+      const intl = await h('POST', '/v1/charges', 'amount=500&currency=usd&card[number]=4000003720000278&card[exp_month]=4&card[exp_year]=2030');
+      const named = String((await h('POST', `/v1/payment_methods/pm_card_bypassPendingInternational/attach`, `customer=${customer}`)).id);
+      const byName = await h('POST', '/v1/payment_intents', `amount=500&currency=usd&customer=${customer}&payment_method=${named}&confirm=true&off_session=true`);
+      const intlAtOnce = (await btOf(intl.id)).status === 'available' && (await btOf(byName.latest_charge)).status === 'available';
+      // a US bank account debit settles into the available balance at once ("Test transactions settle instantly")
+      const ach = await h('POST', '/v1/payment_intents', 'amount=700&currency=usd&payment_method=pm_usBankAccount_success&confirm=true');
+      const achCharge = (await h('GET', `/v1/payment_intents/${String(ach.id)}`)).latest_charge;
+      // and a stored us_bank_account PaymentMethod's, as an application saves one
+      const bank = String((await h('POST', '/v1/payment_methods', 'type=us_bank_account&us_bank_account[account_number]=000123456789&us_bank_account[routing_number]=110000000&us_bank_account[account_holder_type]=individual&billing_details[name]=Maya')).id);
+      const stored = await h('POST', '/v1/payment_intents', `amount=800&currency=usd&payment_method=${bank}&confirm=true`);
+      const storedCharge = (await h('GET', `/v1/payment_intents/${String(stored.id)}`)).latest_charge;
+      const achAtOnce = typeof achCharge === 'string' && (await btOf(achCharge)).status === 'available'
+        && typeof storedCharge === 'string' && (await btOf(storedCharge)).status === 'available';
+      // a plain transfer's credit is sent as the connected account's balance.available too
+      await h('POST', '/v1/transfers', `amount=100&currency=usd&destination=${seller}`);
+      const plain = (await sent()).includes(`balance.available@${seller}`);
+      // a card made from payment_method_data carries what follows its success (a dispute, docs.stripe.com/testing#disputes)
+      const fromData = await h('POST', '/v1/payment_intents', 'amount=300&currency=usd&payment_method_data[type]=card&payment_method_data[card][number]=4000000000000259&payment_method_data[card][exp_month]=4&payment_method_data[card][exp_year]=2030&confirm=true');
+      const disputed = (await h('GET', `/v1/charges/${String(fromData.latest_charge)}`)).disputed === true;
+      // a 4242 charge, three days on and before any drain records its move, reads available however it is read, an
+      // expansion included
+      const later = await h('POST', '/v1/payment_intents', 'amount=400&currency=usd&payment_method=pm_card_visa&confirm=true');
+      now = new Date(Date.parse(now) + 3 * 86_400_000).toISOString();
+      const laterRead = await h('GET', `/v1/charges/${String(later.latest_charge)}?expand[]=balance_transaction`);
+      const visaAvailable = (laterRead.balance_transaction as Body | undefined)?.status === 'available';
+      return po.status === 'pending' && Number(po.arrival_date) > Number(po.created) && !early.includes(`payout.paid@${seller}`)
+        && arrived.includes(`payout.paid@${seller}`) && paid === 'paid' && intlAtOnce && achAtOnce && plain && visaAvailable && disputed;
+    } finally {
+      rx.close();
+      rmSync(root, { recursive: true, force: true });
+    }
+  }),
+  // One event, one id: the webhook a consumer receives and the event the Events API stores carry the same id, and no two
+  // events share one — Dub's queue deduplicates by event.id, and a Balance has no id of its own to tell two accounts'
+  // balance.available apart. Two partners' funds coming due in one drain are two events, each retrievable by its id as
+  // its account (the Stripe-Account header).
+  done('stripe.events.ids', 'webhooks', 'Event ids: unique per event (two accounts\' balance.available in one drain), and a webhook\'s id is the stored event\'s', 'api', 'common', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'stp-evid-'));
+    const rx = await webhookReceiver();
+    try {
+      let now = '2026-06-01T12:00:00.000Z';
+      const h = fetcher(createStripeTwinFetch({ root, clock: () => now }));
+      await h('POST', '/v1/webhook_endpoints', `url=${rx.url('/platform')}&enabled_events[]=*`);
+      await h('POST', '/v1/webhook_endpoints', `url=${rx.url('/connect')}&enabled_events[]=balance.available&connect=true`);
+      await h('POST', '/_twin/account', 'settings[payouts][schedule][interval]=manual');
+      const partner = async (): Promise<string> => {
+        const a = String((await h('POST', '/v1/accounts', 'type=custom&country=US&capabilities[transfers][requested]=true&business_profile[mcc]=5462&business_profile[url]=https://seller.test&tos_acceptance[date]=1767225600&tos_acceptance[ip]=203.0.113.9&individual[first_name]=Sam&individual[last_name]=Seller&settings[payouts][schedule][interval]=manual')).id);
+        await h('POST', `/v1/accounts/${a}/external_accounts`, 'external_account[object]=bank_account&external_account[country]=US&external_account[currency]=usd&external_account[routing_number]=110000000&external_account[account_number]=000123456789');
+        const pi = await h('POST', '/v1/payment_intents', 'amount=2000&currency=usd&payment_method=pm_card_visa&confirm=true');
+        await h('POST', '/v1/transfers', `amount=1500&currency=usd&destination=${a}&source_transaction=${String(pi.latest_charge)}`);
+        return a;
+      };
+      const [first, second] = [await partner(), await partner()];
+      const customer = await h('POST', '/v1/customers', 'email=ids@twin.test');
+      // two writes at once: each event takes its own number, though both are delivered before either answers
+      const [c1, c2] = await Promise.all([h('POST', '/v1/customers', 'email=ids1@twin.test'), h('POST', '/v1/customers', 'email=ids2@twin.test')]);
+      now = '2026-06-04T12:00:00.000Z';
+      await h('POST', '/_twin/drain');
+      const due = rx.got('/connect').filter((e) => e.type === 'balance.available');
+      const of = (acct: string) => due.find((e) => e.account === acct);
+      const [a, b] = [of(first), of(second)];
+      if (!a || !b || a.id === b.id || due.length !== 2) return false;
+      const [ga, gb] = [await h('GET', `/v1/events/${a.id}`, undefined, first), await h('GET', `/v1/events/${b.id}`, undefined, second)];
+      const hook = rx.got('/platform').find((e) => e.type === 'customer.created');
+      const stored = await h('GET', `/v1/events/${String(hook?.id)}`);
+      const ids = rx.got('/platform').concat(rx.got('/connect')).map((e) => e.id);
+      return ga.id === a.id && ga.account === first && ga.type === 'balance.available' && gb.id === b.id && gb.account === second
+        && stored.id === hook?.id && ((stored.data as Body)?.object as Body)?.id === customer.id && new Set(ids).size === ids.length
+        && await (async () => {
+          const both = rx.got('/platform').filter((e) => e.type === 'customer.created' && [c1.id, c2.id].includes(((e.data as Body)?.object as Body)?.id));
+          const looked = await Promise.all(both.map((e) => h('GET', `/v1/events/${String(e.id)}`)));
+          return both.length === 2 && both[0]!.id !== both[1]!.id
+            && looked.every((g, i) => ((g.data as Body)?.object as Body)?.id === ((both[i]!.data as Body)?.object as Body)?.id);
+        })();
+    } finally {
+      rx.close();
+      rmSync(root, { recursive: true, force: true });
+    }
+  }),
   // ── Products / Prices ─────────────────────────────────────────────────────────────
   done('stripe.products.crud', 'catalog', 'Products: create + retrieve + update + list', 'api', 'core', () =>
     withRoot(async (h) => {
@@ -592,6 +1137,53 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       return ok(g) && field(l, 'object') === 'list' && bad.status >= 400;
     }),
   ),
+  // Plans: the Prices API "replaces the Plans API and is backwards compatible" (docs.stripe.com/api/plans/create), so a
+  // plan made with the id its creator chose ("You can optionally override this ID") is a recurring price under that id:
+  // read as a price, found by a lookup_key set on the price, and listed, updated and deleted as a plan. "Only one of
+  // `amount` and `amount_decimal` can be set"; plan writes send plan.created / plan.updated / plan.deleted carrying the
+  // plan; and "Existing subscribers aren't affected" by a deletion (docs.stripe.com/api/plans/delete).
+  done('stripe.plans.crud', 'catalog', 'Plans: create (with a chosen id) + retrieve + list + update + delete, each plan the recurring price it is', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const prod = await h({ m: 'POST', p: '/v1/products', b: 'name=Business' });
+      const plan = await h({ m: 'POST', p: '/v1/plans', b: `id=price_business_monthly&amount=9000&currency=usd&interval=month&product=${id(prod)}` });
+      if (!ok(plan) || field(plan, 'object') !== 'plan' || id(plan) !== 'price_business_monthly' || field(plan, 'amount') !== 9000) return false;
+      const asPrice = await h({ m: 'GET', p: '/v1/prices/price_business_monthly' });
+      const keyed = await h({ m: 'POST', p: '/v1/prices/price_business_monthly', b: 'lookup_key=business_monthly' });
+      const found = await h({ m: 'GET', p: '/v1/prices?lookup_keys[]=business_monthly' });
+      const again = await h({ m: 'POST', p: '/v1/plans', b: `id=price_business_monthly&amount=1&currency=usd&interval=month&product=${id(prod)}` });
+      const renamed = await h({ m: 'POST', p: '/v1/plans/price_business_monthly', b: 'nickname=Business%20monthly' });
+      const listed = await h({ m: 'GET', p: '/v1/plans' });
+      // a subscriber on the plan is not affected by its deletion: the price its item names stays, inactive
+      const cust = await h({ m: 'POST', p: '/v1/customers', b: 'email=plan@twin.test' });
+      const sub = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(cust)}&items[0][price]=price_business_monthly&payment_behavior=default_incomplete` });
+      const gone = await h({ m: 'DELETE', p: '/v1/plans/price_business_monthly' });
+      const after = await h({ m: 'GET', p: '/v1/plans/price_business_monthly' });
+      const twice = await h({ m: 'DELETE', p: '/v1/plans/price_business_monthly' });
+      const kept = await h({ m: 'GET', p: '/v1/prices/price_business_monthly' });
+      const subAfter = await h({ m: 'GET', p: `/v1/subscriptions/${id(sub)}` });
+      const item = ((field(subAfter, 'items') as Body)?.data as Body[] | undefined)?.[0];
+      // amount_decimal is kept as the decimal given, and only one of amount and amount_decimal may be set
+      const decimal = await h({ m: 'POST', p: '/v1/plans', b: `amount_decimal=1250.5&currency=usd&interval=month&product=${id(prod)}` });
+      const both = await h({ m: 'POST', p: '/v1/plans', b: `amount=100&amount_decimal=100&currency=usd&interval=month&product=${id(prod)}` });
+      // a decimal plan bills the decimal times the quantity, rounded after multiplying (docs.stripe.com/products-prices/manage-prices): 1250.5 × 3 = 3751.5 → 3752
+      const onDecimal = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(cust)}&items[0][price]=${id(decimal)}&items[0][quantity]=3&payment_behavior=default_incomplete` });
+      const decimalInvoice = await h({ m: 'GET', p: `/v1/invoices/${String(field(onDecimal, 'latest_invoice'))}` });
+      // plan writes send plan events carrying the plan
+      const events = (((await h({ m: 'GET', p: '/v1/events?limit=100' })).body as Body).data as Body[]) ?? [];
+      const planEvent = (type: string) => events.find((e) => e.type === type && ((e.data as Body).object as Body).id === 'price_business_monthly');
+      const sent = ['plan.created', 'plan.updated', 'plan.deleted'].every((t) => ((planEvent(t)?.data as Body | undefined)?.object as Body | undefined)?.object === 'plan')
+        && (((planEvent('plan.created')?.data as Body).object as Body).amount === 9000);
+      const data = (field(found, 'data') ?? []) as Array<{ id?: string }>;
+      return ok(asPrice) && field(asPrice, 'object') === 'price' && field(asPrice, 'unit_amount') === 9000
+        && ok(keyed) && data.length === 1 && data[0]!.id === 'price_business_monthly'
+        && again.status === 400
+        && field(renamed, 'nickname') === 'Business monthly'
+        && field(listed, 'object') === 'list' && ok(gone) && field(gone, 'deleted') === true && after.status === 404 && twice.status === 404
+        && ok(kept) && field(kept, 'active') === false && (item?.price as Body | undefined)?.id === 'price_business_monthly'
+        && ok(decimal) && field(decimal, 'amount_decimal') === '1250.5' && field(decimal, 'amount') === null
+        && both.status === 400 && sent && field(decimalInvoice, 'total') === 3752;
+    }),
+  ),
   // Tiered pricing: a billing_scheme=tiered price requires tiers_mode (graduated|volume) +
   // tiers[] (each up_to + unit_amount/flat_amount); the twin normalizes the tiers, forces
   // unit_amount null, and round-trips them. currency_options pass through (a per-currency
@@ -671,8 +1263,11 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   done('stripe.promotion_codes.create', 'discounts', 'PromotionCode create + activate/deactivate', 'api', 'common', () =>
     withRoot(async (h) => {
       const coupon = await h({ m: 'POST', p: '/v1/coupons', b: 'percent_off=10&duration=once' });
-      const pc = await h({ m: 'POST', p: '/v1/promotion_codes', b: `coupon=${id(coupon)}&code=SAVE10` });
-      if (!ok(pc) || field(pc, 'object') !== 'promotion_code' || field(pc, 'code') !== 'SAVE10' || field(pc, 'active') !== true || field(pc, 'coupon') !== id(coupon)) return false;
+      const pc = await h({ m: 'POST', p: '/v1/promotion_codes', b: `promotion[type]=coupon&promotion[coupon]=${id(coupon)}&code=SAVE10` });
+      // what it promotes is `promotion: {type: 'coupon', coupon}` in the served version, with no top-level coupon
+      // (2025-09-30.clover, docs.stripe.com/changelog/clover/2025-09-30/polymorphic-coupon; stripe-version.ts renders it)
+      if (!ok(pc) || field(pc, 'object') !== 'promotion_code' || field(pc, 'code') !== 'SAVE10' || field(pc, 'active') !== true) return false;
+      if ((field(pc, 'promotion') as Body)?.type !== 'coupon' || (field(pc, 'promotion') as Body)?.coupon !== id(coupon) || field(pc, 'coupon') !== undefined) return false;
       const g = await h({ m: 'GET', p: `/v1/promotion_codes/${id(pc)}` });
       const off = await h({ m: 'POST', p: `/v1/promotion_codes/${id(pc)}`, b: 'active=false' });
       const on = await h({ m: 'POST', p: `/v1/promotion_codes/${id(pc)}`, b: 'active=true' });
@@ -680,7 +1275,7 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       if (!ok(g) || id(g) !== id(pc) || !ok(off) || field(off, 'active') !== false || !ok(on) || field(on, 'active') !== true) return false;
       if (((lst.body as Body).data as Body[]).length !== 1) return false;
       const noCoupon = await h({ m: 'POST', p: '/v1/promotion_codes', b: 'code=X' });
-      const badCoupon = await h({ m: 'POST', p: '/v1/promotion_codes', b: 'coupon=coupon_nope&code=Y' });
+      const badCoupon = await h({ m: 'POST', p: '/v1/promotion_codes', b: 'promotion[type]=coupon&promotion[coupon]=coupon_nope&code=Y' });
       return noCoupon.status === 400 && badCoupon.status === 400 && ((badCoupon.body as Body).error as Body)?.code === 'resource_missing';
     }),
   ),
@@ -707,7 +1302,7 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       if (!card || card.last4 !== '4242') return false;
       // last4 FIDELITY (not just presence): a raw test PAN must surface its TRUE last4 —
       // the '4242' check above can't prove that, since '4242' equals the synthesized
-      // fallback. parseStripeForm coerces an all-digit card[number] to a JS number (like
+      // fallback. The form reader coerces an all-digit card[number] to a JS number (like
       // any numeric-looking form field), so cover BOTH wire shapes: the numeric-coerced
       // bare PAN and a string PAN (spaces keep it a string through the form parser).
       const pmNum = await h({ m: 'POST', p: '/v1/payment_methods', b: 'type=card&card[number]=5555555555554444&card[exp_month]=4&card[exp_year]=2030&card[cvc]=314' });
@@ -785,13 +1380,54 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       const cust = await h({ m: 'POST', p: '/v1/customers', b: 'email=sub@twin.test' });
       const prod = await h({ m: 'POST', p: '/v1/products', b: 'name=Plan' });
       const price = await h({ m: 'POST', p: '/v1/prices', b: `unit_amount=1500&currency=usd&recurring[interval]=month&product=${id(prod)}` });
-      const sub = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(cust)}&items[0][price]=${id(price)}` });
+      // the customer's card pays the first invoice, so the subscription starts active
+      const card = await h({ m: 'POST', p: '/v1/payment_methods/pm_card_visa/attach', b: `customer=${id(cust)}` });
+      const sub = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(cust)}&items[0][price]=${id(price)}&default_payment_method=${id(card)}` });
       if (!ok(sub) || field(sub, 'status') !== 'active') return false;
       const g = await h({ m: 'GET', p: `/v1/subscriptions/${id(sub)}` });
       const cancel = await h({ m: 'DELETE', p: `/v1/subscriptions/${id(sub)}` });
       return ok(g) && ok(cancel) && field(cancel, 'status') === 'canceled';
     }),
   ),
+  // An update's `items` changes the subscription's items (docs.stripe.com/api/subscriptions/update): an entry with an
+  // `id` swaps that item's price ("`quantity` is set to 1 unless a `quantity` parameter is provided") or its quantity, or
+  // with `deleted` removes it; one without adds an item, from a price or from `price_data`, which generates a Price
+  // inline, archived (active=false; docs.stripe.com/products-prices/manage-prices). A refused entry refuses the whole
+  // update, leaving the items as they were. Dub's trial switch to Advanced replaced the price of its one item.
+  done('stripe.subscriptions.update_items', 'subscriptions', 'Subscription update items: swap a price, change a quantity, add (price or price_data), delete; all or nothing', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const cust = await h({ m: 'POST', p: '/v1/customers', b: 'email=items@twin.test' });
+      const prod = await h({ m: 'POST', p: '/v1/products', b: 'name=Pro' });
+      const pro = await h({ m: 'POST', p: '/v1/prices', b: `unit_amount=1000&currency=usd&recurring[interval]=month&product=${id(prod)}` });
+      const advanced = await h({ m: 'POST', p: '/v1/prices', b: `unit_amount=3000&currency=usd&recurring[interval]=month&product=${id(prod)}` });
+      const sub = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(cust)}&items[0][price]=${id(pro)}&items[0][quantity]=3&payment_behavior=default_incomplete` });
+      const items = (r: StripeResponse): Body[] => ((field(r, 'items') as Body)?.data as Body[]) ?? [];
+      const si = String(items(sub)[0]?.id);
+      const upd = (b: string) => h({ m: 'POST', p: `/v1/subscriptions/${id(sub)}`, b });
+      const swapped = await upd(`items[0][id]=${si}&items[0][price]=${id(advanced)}`);
+      const s0 = items(swapped);
+      if (s0.length !== 1 || s0[0]?.id !== si || (s0[0]?.price as Body)?.id !== id(advanced) || s0[0]?.quantity !== 1) return false;
+      const more = items(await upd(`items[0][id]=${si}&items[0][quantity]=5`));
+      if (more.length !== 1 || more[0]?.quantity !== 5 || (more[0]?.price as Body)?.id !== id(advanced)) return false;
+      // naming the item's own price is no change of price: the quantity stays
+      const same = items(await upd(`items[0][id]=${si}&items[0][price]=${id(advanced)}`));
+      if (same[0]?.quantity !== 5) return false;
+      const added = items(await upd(`items[0][price_data][currency]=usd&items[0][price_data][product]=${id(prod)}&items[0][price_data][unit_amount]=250&items[0][price_data][recurring][interval]=month`));
+      const inline = added.find((i) => i.id !== si)?.price as Body | undefined;
+      if (added.length !== 2 || inline?.unit_amount !== 250 || inline?.active !== false || inline?.product !== id(prod)) return false;
+      // one bad entry refuses the update: the delete beside it is not applied
+      const refused = await upd(`items[0][id]=${si}&items[0][deleted]=true&items[1][price]=price_nope`);
+      const kept = items(await h({ m: 'GET', p: `/v1/subscriptions/${id(sub)}` }));
+      if (refused.status !== 400 || kept.length !== 2 || !kept.some((i) => i.id === si)) return false;
+      const removed = items(await upd(`items[0][id]=${si}&items[0][deleted]=true`));
+      const listed = await h({ m: 'GET', p: `/v1/subscription_items?subscription=${id(sub)}` });
+      // a price_data amount that is not a whole number of cents is kept as the decimal, never truncated
+      const decimal = items(await upd(`items[0][price_data][currency]=usd&items[0][price_data][product]=${id(prod)}&items[0][price_data][unit_amount_decimal]=12.5&items[0][price_data][recurring][interval]=month`));
+      const decimalPrice = decimal.map((i) => i.price as Body).find((p) => p?.unit_amount_decimal === '12.5');
+      return removed.length === 1 && removed[0]?.id !== si && ((listed.body as Body).data as Body[]).length === 1
+        && decimalPrice !== undefined && decimalPrice.unit_amount === null;
+    }),
+  ),
   done('stripe.subscriptions.list', 'subscriptions', 'Subscription list + filter by customer', 'api', 'core', () =>
     withRoot(async (h) => {
       const r = await h({ m: 'GET', p: '/v1/subscriptions' });
@@ -810,13 +1446,218 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       const sub = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(cust)}&items[0][price]=${id(price)}&trial_period_days=14` });
       if (!ok(sub) || field(sub, 'status') !== 'trialing' || typeof field(sub, 'trial_end') !== 'number') return false;
       // upcoming invoice WITH a proration_date splits the period (credit + charge proration lines).
-      const up = await h({ m: 'GET', p: `/v1/invoices/upcoming?subscription=${id(sub)}&proration_date=100` });
-      if (!ok(up) || field(up, 'object') !== 'invoice' || field(up, 'id') !== null) return false;
+      const up = await h({ m: 'POST', p: '/v1/invoices/create_preview', b: `subscription=${id(sub)}&subscription_details[proration_date]=100` });
+      // a preview's id is prefixed `upcoming_in` ("For preview invoices created using the create preview endpoint, this id
+      // will be prefixed with `upcoming_in`", served spec invoice.id), and a line's proration flag is on its parent's
+      // details in the served version (basil, docs.stripe.com/changelog/basil; stripe-version.ts line_item, 24e757f60)
+      if (!ok(up) || field(up, 'object') !== 'invoice' || !String(field(up, 'id')).startsWith('upcoming_in_')) return false;
       const lines = (field(up, 'lines') as Body).data as Body[];
-      const prorations = lines.filter((l) => l.proration === true);
+      const prorationOf = (l: Body): unknown => ((l.parent as Body | undefined)?.subscription_item_details as Body | undefined)?.proration ?? ((l.parent as Body | undefined)?.invoice_item_details as Body | undefined)?.proration;
+      if (lines.some((l) => 'proration' in l)) return false;
+      const prorations = lines.filter((l) => prorationOf(l) === true);
       return prorations.length === 2 && prorations.some((l) => Number(l.amount) < 0) && prorations.some((l) => Number(l.amount) > 0);
     }),
   ),
+  // Renewal over time: at the period's end a subscription_cycle invoice is drafted and, an hour on, charged to the
+  // default payment method; a card that declines when charged leaves it open and the subscription past_due, and
+  // paying it makes the subscription active (docs.stripe.com/billing/subscriptions/overview#payment-status).
+  done('stripe.subscriptions.renewal', 'subscriptions', 'Subscriptions renew at each period end; a declined renewal is past_due until its invoice is paid', 'api', 'core', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'stp-renew-'));
+    try {
+      // February's reads come two hours into the renewed period: its invoice is drafted at the period's end and charged
+      // "an hour on" (above; cab4389eb stamps each catch-up write at that moment), so a read at the period's very end
+      // sees the draft, not the paid invoice this claim is about
+      const h = (s: Step & { month?: number }) => handleStripeTwinRequest({ method: s.m, path: s.p, body: s.b, root, occurredAt: `2026-${String(s.month ?? 1).padStart(2, '0')}-10T${(s.month ?? 1) > 1 ? '02' : '00'}:00:00Z` });
+      const prod = await h({ m: 'POST', p: '/v1/products', b: 'name=Box' });
+      const price = await h({ m: 'POST', p: '/v1/prices', b: `unit_amount=3500&currency=usd&recurring[interval]=month&product=${id(prod)}` });
+      const payer = await h({ m: 'POST', p: '/v1/customers', b: 'email=renews@twin.test&payment_method=pm_card_visa&invoice_settings[default_payment_method]=pm_card_visa' });
+      const good = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(payer)}&items[0][price]=${id(price)}&default_payment_method=pm_card_visa` });
+      const failing = await h({ m: 'POST', p: '/v1/customers', b: 'email=declines@twin.test' });
+      const bad = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(failing)}&items[0][price]=${id(price)}&default_payment_method=pm_card_chargeCustomerFail&trial_period_days=7` });
+      const renewed = await h({ m: 'GET', p: `/v1/invoices?subscription=${id(good)}`, month: 2 });
+      const cycle = ((renewed.body as Body).data as Body[]).find((i) => i.billing_reason === 'subscription_cycle');
+      const pastDue = await h({ m: 'GET', p: `/v1/subscriptions/${id(bad)}`, month: 2 });
+      const open = (((await h({ m: 'GET', p: `/v1/invoices?subscription=${id(bad)}&status=open`, month: 2 })).body as Body).data as Body[])[0];
+      const paid = await h({ m: 'POST', p: `/v1/invoices/${String(open?.id)}/pay`, b: 'payment_method=pm_card_visa', month: 2 });
+      const back = await h({ m: 'GET', p: `/v1/subscriptions/${id(bad)}`, month: 2 });
+      // made when Stripe would have made it, not when the February request caught it up
+      const stamped = cycle?.created === cycle?.period_start && (cycle?.status_transitions as Body | undefined)?.paid_at === Number(cycle?.period_start) + 3600;
+      return stamped && cycle?.status === 'paid' && cycle.amount_paid === 3500 && field(pastDue, 'status') === 'past_due'
+        && open?.attempt_count === 1 && field(paid, 'status') === 'paid' && field(back, 'status') === 'active';
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  }),
+  // A `once` coupon discounts one invoice: the one the subscription finalizes next after it was applied, which records it,
+  // and is then removed from the subscription's discounts (docs.stripe.com/billing/subscriptions/coupons#coupon-duration),
+  // however that invoice is finalized: by time, or through the Invoices API.
+  done('stripe.subscriptions.once_coupon', 'subscriptions', 'A once coupon discounts the next invoice finalized after it is applied, then is removed from the subscription', 'api', 'common', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'stp-once-'));
+    try {
+      const h = (s: Step & { at?: string }) => handleStripeTwinRequest({ method: s.m, path: s.p, body: s.b, root, occurredAt: s.at ?? '2026-03-01T00:00:00Z' });
+      const prod = await h({ m: 'POST', p: '/v1/products', b: 'name=Box' });
+      const price = await h({ m: 'POST', p: '/v1/prices', b: `unit_amount=9000&currency=usd&recurring[interval]=month&product=${id(prod)}` });
+      const cust = await h({ m: 'POST', p: '/v1/customers', b: 'email=once%40twin.test&payment_method=pm_card_visa&invoice_settings[default_payment_method]=pm_card_visa' });
+      const coupon = await h({ m: 'POST', p: '/v1/coupons', b: 'id=HALF&percent_off=50&duration=once' });
+      const invoices = async (sub: StripeResponse, at: string) => ((((await h({ m: 'GET', p: `/v1/invoices?subscription=${id(sub)}`, at })).body as Body).data as Body[]) ?? []);
+      const discounts = (r: StripeResponse) => ((field(r, 'discounts') as unknown[] | undefined) ?? []).length;
+      // added after April's renewal was drafted (00:00) and before it is collected (01:00): April is full, May is halved
+      const late = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(cust)}&items[0][price]=${id(price)}` });
+      await h({ m: 'GET', p: `/v1/subscriptions/${id(late)}`, at: '2026-04-01T00:10:00Z' });
+      await h({ m: 'POST', p: `/v1/subscriptions/${id(late)}`, b: `discounts[0][coupon]=${id(coupon)}`, at: '2026-04-01T00:20:00Z' });
+      const april = (await invoices(late, '2026-04-01T02:00:00Z')).find((i) => i.period_start === Date.parse('2026-04-01T00:00:00Z') / 1000);
+      const stillThere = await h({ m: 'GET', p: `/v1/subscriptions/${id(late)}`, at: '2026-04-01T02:00:00Z' });
+      const may = (await invoices(late, '2026-05-01T02:00:00Z')).find((i) => i.period_start === Date.parse('2026-05-01T00:00:00Z') / 1000);
+      const gone = await h({ m: 'GET', p: `/v1/subscriptions/${id(late)}`, at: '2026-05-01T02:00:00Z' });
+      if (april?.total !== 9000 || discounts(stillThere) !== 1 || may?.total !== 4500 || discounts(gone) !== 0) return false;
+      // the renewal's draft finalized and paid through the Invoices API spends it too: June is full again
+      const other = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(cust)}&items[0][price]=${id(price)}` });
+      await h({ m: 'POST', p: `/v1/subscriptions/${id(other)}`, b: `discounts[0][coupon]=${id(coupon)}`, at: '2026-03-15T00:00:00Z' });
+      const draft = (await invoices(other, '2026-04-01T00:10:00Z')).find((i) => i.status === 'draft');
+      await h({ m: 'POST', p: `/v1/invoices/${String(draft?.id)}/finalize`, at: '2026-04-01T00:20:00Z' });
+      const afterFinalize = await h({ m: 'GET', p: `/v1/subscriptions/${id(other)}`, at: '2026-04-01T00:30:00Z' });
+      const mayOther = (await invoices(other, '2026-05-01T02:00:00Z')).find((i) => i.period_start === Date.parse('2026-05-01T00:00:00Z') / 1000);
+      return draft?.total === 4500 && discounts(afterFinalize) === 0 && mayOther?.total === 9000;
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  }),
+  // Ending a trial early: `trial_end=now` on a trialing subscription starts a paid period now, invoices it and charges it
+  // at once (active; a decline leaves it past_due, error_if_incomplete refuses with 402 and changes nothing); a future
+  // timestamp moves the trial's end and the period with it; a past one is refused (semantics/subscriptions.ts
+  // applyTrialEnd; docs.stripe.com/api/subscriptions/update#update_subscription-trial_end,
+  // docs.stripe.com/billing/subscriptions/upgrade-downgrade#immediate-payment). Read in basil's shape, as Dub reads it.
+  done('stripe.subscriptions.trial_end_now', 'subscriptions', 'Subscription update trial_end: `now` ends the trial and charges a new period at once; a timestamp moves it; a past one is refused', 'api', 'core', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'stp-trialend-'));
+    try {
+      const h = (s: Step & { day?: number }) => handleStripeTwinRequest({ method: s.m, path: s.p, body: s.b, root, occurredAt: `2026-03-${String(s.day ?? 1).padStart(2, '0')}T00:00:00Z` });
+      const day = (d: number) => Date.parse(`2026-03-${String(d).padStart(2, '0')}T00:00:00Z`) / 1000;
+      const prod = await h({ m: 'POST', p: '/v1/products', b: 'name=Business' });
+      const price = await h({ m: 'POST', p: '/v1/prices', b: `unit_amount=9000&currency=usd&recurring[interval]=month&product=${id(prod)}` });
+      const trialing = async (email: string, pm: string) => {
+        const c = await h({ m: 'POST', p: '/v1/customers', b: `email=${email}&payment_method=${pm}&invoice_settings[default_payment_method]=${pm}` });
+        return h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(c)}&items[0][price]=${id(price)}&trial_period_days=14` });
+      };
+      const period = (r: StripeResponse) => ((field(r, 'items') as Body | undefined)?.data as Body[] | undefined)?.[0] ?? {};
+      const sub = await trialing('trial%40twin.test', 'pm_card_visa');
+      // a trial's end is its billing anchor
+      if (field(sub, 'billing_cycle_anchor') !== field(sub, 'trial_end')) return false;
+      // refused before anything changes: a past timestamp, a value that is no timestamp
+      const past = await h({ m: 'POST', p: `/v1/subscriptions/${id(sub)}`, b: 'trial_end=1700000000', day: 3 });
+      const junk = await h({ m: 'POST', p: `/v1/subscriptions/${id(sub)}`, b: 'trial_end=tomorrow', day: 3 });
+      const pastError = (past.body as { error?: Body }).error;
+      if (past.status !== 400 || pastError?.param !== 'trial_end' || pastError?.message !== 'Invalid timestamp: must be an integer Unix timestamp in the future.' || junk.status !== 400) return false;
+      // a future timestamp moves the trial's end, the period's end and the billing anchor
+      const moved = await h({ m: 'POST', p: `/v1/subscriptions/${id(sub)}`, b: `trial_end=${day(20)}`, day: 3 });
+      if (field(moved, 'status') !== 'trialing' || field(moved, 'trial_end') !== day(20) || period(moved).current_period_end !== day(20) || field(moved, 'billing_cycle_anchor') !== day(20)) return false;
+      // `now`: the trial ends, a month's period starts now and its invoice is paid by the default payment method
+      const ended = await h({ m: 'POST', p: `/v1/subscriptions/${id(sub)}`, b: 'trial_end=now&cancel_at_period_end=false', day: 5 });
+      const inv = await h({ m: 'GET', p: `/v1/invoices/${String(field(ended, 'latest_invoice'))}`, day: 5 });
+      const invoices = (((await h({ m: 'GET', p: `/v1/invoices?customer=${String(field(sub, 'customer'))}`, day: 5 })).body as Body).data as Body[]) ?? [];
+      const events = ((((await h({ m: 'GET', p: '/v1/events?limit=100', day: 5 })).body as Body).data as Body[]) ?? []).filter((e) => e.created === day(5)).map((e) => e.type);
+      const endedOk = ok(ended) && field(ended, 'status') === 'active' && field(ended, 'trial_end') === day(5) && field(ended, 'billing_cycle_anchor') === day(5)
+        && period(ended).current_period_start === day(5) && period(ended).current_period_end === Date.parse('2026-04-05T00:00:00Z') / 1000;
+      const invoiceOk = field(inv, 'status') === 'paid' && field(inv, 'billing_reason') === 'subscription_update' && field(inv, 'amount_paid') === 9000
+        && field(inv, 'period_start') === day(5) && invoices.some((i) => i.id === id(inv));
+      if (!endedOk || !invoiceOk || !['customer.subscription.updated', 'invoice.created', 'invoice.paid'].every((t) => events.includes(t))) return false;
+      // a cancel scheduled during the trial follows the new period; a `once` coupon added during the trial, or with the
+      // update itself, takes the invoice ending it and is then spent
+      const once = await h({ m: 'POST', p: '/v1/coupons', b: 'id=HALFOFF&percent_off=50&duration=once', day: 2 });
+      const leaving = await trialing('leaving%40twin.test', 'pm_card_visa');
+      await h({ m: 'POST', p: `/v1/subscriptions/${id(leaving)}`, b: `cancel_at_period_end=true&discounts[0][coupon]=${id(once)}`, day: 2 });
+      const early = await h({ m: 'POST', p: `/v1/subscriptions/${id(leaving)}`, b: 'trial_end=now', day: 5 });
+      const halved = await h({ m: 'GET', p: `/v1/invoices/${String(field(early, 'latest_invoice'))}`, day: 5 });
+      const sameCall = await trialing('same%40twin.test', 'pm_card_visa');
+      const withCoupon = await h({ m: 'POST', p: `/v1/subscriptions/${id(sameCall)}`, b: `trial_end=now&discounts[0][coupon]=${id(once)}`, day: 5 });
+      const halvedToo = await h({ m: 'GET', p: `/v1/invoices/${String(field(withCoupon, 'latest_invoice'))}`, day: 5 });
+      const spent = (r: StripeResponse) => ((field(r, 'discounts') as Body[] | undefined) ?? []).length === 0;
+      if (field(early, 'cancel_at') !== period(early).current_period_end || field(early, 'cancel_at_period_end') !== true || field(halved, 'total') !== 4500
+        || !spent(early) || field(halvedToo, 'total') !== 4500 || !spent(withCoupon)) return false;
+      // what the update leaves bills: a quantity of 0 bills nothing (paid, active, with no card); an unknown item is refused as such
+      const nobody = await h({ m: 'POST', p: '/v1/customers', b: 'email=nobody%40twin.test' });
+      const idle = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(nobody)}&items[0][price]=${id(price)}&trial_period_days=14` });
+      const zero = await h({ m: 'POST', p: `/v1/subscriptions/${id(idle)}`, b: `trial_end=now&payment_behavior=error_if_incomplete&items[0][id]=${String(period(idle).id)}&items[0][quantity]=0`, day: 5 });
+      const zeroInvoice = await h({ m: 'GET', p: `/v1/invoices/${String(field(zero, 'latest_invoice'))}`, day: 5 });
+      if (field(zero, 'status') !== 'active' || field(zeroInvoice, 'total') !== 0 || field(zeroInvoice, 'status') !== 'paid') return false;
+      const idle2 = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(nobody)}&items[0][price]=${id(price)}&trial_period_days=14` });
+      const decimal = await h({ m: 'POST', p: `/v1/subscriptions/${id(idle2)}`, b: `trial_end=now&payment_behavior=error_if_incomplete&items[0][id]=${String(period(idle2).id)}&items[0][deleted]=true&items[1][price_data][currency]=usd&items[1][price_data][product]=${id(prod)}&items[1][price_data][unit_amount_decimal]=5000&items[1][price_data][recurring][interval]=month`, day: 5 });
+      const unknown = await h({ m: 'POST', p: `/v1/subscriptions/${id(idle2)}`, b: 'trial_end=now&payment_behavior=error_if_incomplete&items[0][id]=si_nope&items[0][quantity]=2', day: 5 });
+      const idleAfter = await h({ m: 'GET', p: `/v1/subscriptions/${id(idle2)}`, day: 5 });
+      if (decimal.status !== 400 || !String(((unknown.body as { error?: Body }).error)?.message).includes("No such subscription_item: 'si_nope'")
+        || field(idleAfter, 'status') !== 'trialing' || period(idleAfter).id !== period(idle2).id) return false;
+      // a trial made through the API opens its $0 invoice at once, which takes and spends a once coupon, as Checkout's does
+      const withOnce = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(nobody)}&items[0][price]=${id(price)}&trial_period_days=14&discounts[0][coupon]=${id(once)}` });
+      const trialInvoice = await h({ m: 'GET', p: `/v1/invoices/${String(field(withOnce, 'latest_invoice'))}` });
+      if (field(trialInvoice, 'total') !== 0 || field(trialInvoice, 'status') !== 'paid' || field(trialInvoice, 'billing_reason') !== 'subscription_create'
+        || ((field(trialInvoice, 'discounts') as unknown[] | undefined) ?? []).length !== 1 || !spent(withOnce)) return false;
+      // and the subscription names it from its own create: the customer.subscription.created event carries it
+      const createdEvent = ((((await h({ m: 'GET', p: '/v1/events?type=customer.subscription.created&limit=100' })).body as Body).data as Body[]) ?? [])
+        .find((e) => ((e.data as Body).object as Body).id === id(withOnce));
+      if (((createdEvent?.data as Body | undefined)?.object as Body | undefined)?.latest_invoice !== field(withOnce, 'latest_invoice')) return false;
+      // a card that declines when charged: the change stands, the invoice is open and the subscription past_due
+      const declining = await trialing('declines%40twin.test', 'pm_card_chargeCustomerFail');
+      const invoicesOf = async (s: StripeResponse) => ((((await h({ m: 'GET', p: `/v1/invoices?customer=${String(field(s, 'customer'))}`, day: 5 })).body as Body).data as Body[]) ?? []).length;
+      const before = await invoicesOf(declining);
+      const strict = await h({ m: 'POST', p: `/v1/subscriptions/${id(declining)}`, b: 'trial_end=now&payment_behavior=error_if_incomplete', day: 5 });
+      const still = await h({ m: 'GET', p: `/v1/subscriptions/${id(declining)}`, day: 5 });
+      if (await invoicesOf(declining) !== before) return false;
+      // error_if_incomplete judges the period as the update leaves it: $0 items swapped for a paid price with no payment
+      // method to charge is refused as the create refuses it (semantics/subscriptions.ts firstPaymentRefused)
+      const freeProd = await h({ m: 'POST', p: '/v1/prices', b: `unit_amount=0&currency=usd&recurring[interval]=month&product=${id(prod)}` });
+      const bare = await h({ m: 'POST', p: '/v1/customers', b: 'email=bare%40twin.test' });
+      const free = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(bare)}&items[0][price]=${id(freeProd)}&trial_period_days=14` });
+      const freeItem = String(period(free).id);
+      const upgrade = await h({ m: 'POST', p: `/v1/subscriptions/${id(free)}`, b: `trial_end=now&payment_behavior=error_if_incomplete&items[0][id]=${freeItem}&items[0][price]=${id(price)}`, day: 5 });
+      const unchanged = await h({ m: 'GET', p: `/v1/subscriptions/${id(free)}`, day: 5 });
+      if (upgrade.status !== 400 || field(unchanged, 'status') !== 'trialing' || (period(unchanged).price as Body | undefined)?.id !== id(freeProd)) return false;
+      // default_incomplete: the period is invoiced and left open, no payment attempted
+      const quiet = await trialing('quiet%40twin.test', 'pm_card_visa');
+      const deferred = await h({ m: 'POST', p: `/v1/subscriptions/${id(quiet)}`, b: 'trial_end=now&payment_behavior=default_incomplete', day: 5 });
+      const unpaid = await h({ m: 'GET', p: `/v1/invoices/${String(field(deferred, 'latest_invoice'))}`, day: 5 });
+      if (field(deferred, 'status') !== 'past_due' || field(unpaid, 'status') !== 'open' || field(unpaid, 'attempted') !== false || field(unpaid, 'amount_paid') !== 0) return false;
+      const lenient = await h({ m: 'POST', p: `/v1/subscriptions/${id(declining)}`, b: 'trial_end=now', day: 5 });
+      const open = await h({ m: 'GET', p: `/v1/invoices/${String(field(lenient, 'latest_invoice'))}`, day: 5 });
+      return strict.status === 402 && field(still, 'status') === 'trialing' && field(still, 'latest_invoice') === field(declining, 'latest_invoice')
+        && field(lenient, 'status') === 'past_due' && field(open, 'status') === 'open' && field(open, 'amount_remaining') === 9000;
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  }),
+  // Automatic reconciliation: a bank transfer arriving in the customer's cash balance pays their open invoice that takes
+  // transfers (docs.stripe.com/payments/customer-balance/reconciliation).
+  done('stripe.customers.cash_balance_reconciliation', 'customers', 'Cash balance funding pays an open bank-transfer invoice (automatic reconciliation)', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const cust = await h({ m: 'POST', p: '/v1/customers', b: 'name=Cowork&email=ap@cowork.test' });
+      const inv = await h({ m: 'POST', p: '/v1/invoices', b: `customer=${id(cust)}&collection_method=send_invoice&days_until_due=30&payment_settings[payment_method_types][0]=customer_balance` });
+      await h({ m: 'POST', p: '/v1/invoiceitems', b: `customer=${id(cust)}&invoice=${id(inv)}&amount=24000&currency=usd` });
+      await h({ m: 'POST', p: `/v1/invoices/${id(inv)}/finalize` });
+      await h({ m: 'POST', p: `/v1/test_helpers/customers/${id(cust)}/fund_cash_balance`, b: 'amount=24000&currency=usd' });
+      const paid = await h({ m: 'GET', p: `/v1/invoices/${id(inv)}` });
+      const bal = await h({ m: 'GET', p: `/v1/customers/${id(cust)}/cash_balance` });
+      return field(paid, 'status') === 'paid' && field(paid, 'amount_paid') === 24000 && ((field(bal, 'available') as Body | null)?.usd ?? 0) === 0;
+    }),
+  ),
+  // A subscription set to cancel at its period's end is canceled when the period ends, with no renewal invoice
+  // (docs.stripe.com/billing/subscriptions/cancel#cancel-at-end-of-cycle).
+  done('stripe.subscriptions.cancel_at_period_end', 'subscriptions', 'cancel_at_period_end cancels the subscription when its period ends', 'api', 'common', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'stp-cape-'));
+    try {
+      // February's reads come two hours into the renewed period: its invoice is drafted at the period's end and charged
+      // "an hour on" (above; cab4389eb stamps each catch-up write at that moment), so a read at the period's very end
+      // sees the draft, not the paid invoice this claim is about
+      const h = (s: Step & { month?: number }) => handleStripeTwinRequest({ method: s.m, path: s.p, body: s.b, root, occurredAt: `2026-${String(s.month ?? 1).padStart(2, '0')}-10T${(s.month ?? 1) > 1 ? '02' : '00'}:00:00Z` });
+      const prod = await h({ m: 'POST', p: '/v1/products', b: 'name=Box' });
+      const price = await h({ m: 'POST', p: '/v1/prices', b: `unit_amount=3500&currency=usd&recurring[interval]=month&product=${id(prod)}` });
+      const cust = await h({ m: 'POST', p: '/v1/customers', b: 'email=leaving@twin.test' });
+      const sub = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(cust)}&items[0][price]=${id(price)}&default_payment_method=pm_card_visa` });
+      const set = await h({ m: 'POST', p: `/v1/subscriptions/${id(sub)}`, b: 'cancel_at_period_end=true' });
+      const after = await h({ m: 'GET', p: `/v1/subscriptions/${id(sub)}`, month: 3 });
+      const invoices = ((await h({ m: 'GET', p: `/v1/invoices?subscription=${id(sub)}`, month: 3 })).body as Body).data as Body[];
+      return typeof field(set, 'cancel_at') === 'number' && field(after, 'status') === 'canceled' && typeof field(after, 'ended_at') === 'number' && invoices.length === 1;
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  }),
   // Pause/resume: set pause_collection[behavior]=void → the sub records pause_collection (and
   // the customer.subscription.paused event fires); clearing it (pause_collection="") resumes
   // (pause_collection null). cancel_at_period_end toggles a scheduled cancel and reactivation.
@@ -861,29 +1702,30 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
         ok(rel) && field(rel, 'status') === 'released' && relAgain.status === 400 && noTarget.status === 400;
     }),
   ),
-  // Metered/usage billing: a Billing Meter defines event_name + aggregation; usage is reported
-  // via meter_events (and the legacy subscription_items usage_records). The twin requires
-  // display_name/event_name/default_aggregation[formula], lists/retrieves meters, deactivate
-  // transitions active→inactive, and usage record summaries total the reported quantity.
-  done('stripe.billing.metered_usage', 'subscriptions', 'Usage / metered billing (meters + usage records)', 'api', 'common', () =>
+  // Metered/usage billing: a Billing Meter defines event_name + aggregation; usage is reported as meter events and read
+  // back as the meter's event summaries (GET /v1/billing/meters/:id/event_summaries, docs.stripe.com/api/billing/meter-event-summary).
+  // The twin requires display_name/event_name/default_aggregation, lists/retrieves meters, deactivate transitions
+  // active→inactive, and a summary totals the customer's reported values. The legacy per-item usage records this claim
+  // used to drive "left the API with basil" and were removed from the twin (5decb1d77; docs.stripe.com/changelog/basil).
+  done('stripe.billing.metered_usage', 'subscriptions', 'Usage / metered billing (meters + meter events and their summaries)', 'api', 'common', () =>
     withRoot(async (h) => {
-      const meter = await h({ m: 'POST', p: '/v1/billing/meters', b: 'display_name=API calls&event_name=api_request&default_aggregation[formula]=sum&value_settings[event_payload_key]=value' });
+      const cust = await h({ m: 'POST', p: '/v1/customers', b: 'email=metered@twin.test' });
+      const meter = await h({ m: 'POST', p: '/v1/billing/meters', b: 'display_name=API calls&event_name=api_request&default_aggregation[formula]=sum&value_settings[event_payload_key]=value&customer_mapping[event_payload_key]=stripe_customer_id&customer_mapping[type]=by_id' });
       if (!ok(meter) || field(meter, 'object') !== 'billing.meter' || field(meter, 'status') !== 'active' || field(meter, 'event_name') !== 'api_request') return false;
       const noAgg = await h({ m: 'POST', p: '/v1/billing/meters', b: 'display_name=X&event_name=y' });
       if (noAgg.status !== 400) return false;
-      const evt = await h({ m: 'POST', p: '/v1/billing/meter_events', b: 'event_name=api_request&payload[value]=10&payload[stripe_customer_id]=cus_x' });
+      // two events (7 + 3) so the summary proves real aggregation (a single-value / canned impl would not total 10)
+      const evt = await h({ m: 'POST', p: '/v1/billing/meter_events', b: `event_name=api_request&payload[value]=7&payload[stripe_customer_id]=${id(cust)}` });
       if (!ok(evt) || field(evt, 'object') !== 'billing.meter_event' || field(evt, 'event_name') !== 'api_request') return false;
+      const evt2 = await h({ m: 'POST', p: '/v1/billing/meter_events', b: `event_name=api_request&payload[value]=3&payload[stripe_customer_id]=${id(cust)}` });
+      // a window on whole days, as Stripe asks (its bounds are refused off minute boundaries), around the events just sent
+      const now = Math.floor(Date.now() / 86_400_000) * 86_400;
+      const summ = await h({ m: 'GET', p: `/v1/billing/meters/${id(meter)}/event_summaries?customer=${id(cust)}&start_time=${now - 86_400}&end_time=${now + 86_400}` });
+      const sd = (summ.body as Body).data as Body[];
       const g = await h({ m: 'GET', p: `/v1/billing/meters/${id(meter)}` });
       const deact = await h({ m: 'POST', p: `/v1/billing/meters/${id(meter)}/deactivate` });
-      // legacy per-item usage records SUM in the summary — post two (7 + 3) so the assertion
-      // proves real aggregation (a single-value / canned impl would not total to 10).
-      const ur = await h({ m: 'POST', p: '/v1/subscription_items/si_twin/usage_records', b: 'quantity=7' });
-      const ur2 = await h({ m: 'POST', p: '/v1/subscription_items/si_twin/usage_records', b: 'quantity=3' });
-      const noQty = await h({ m: 'POST', p: '/v1/subscription_items/si_twin/usage_records' });
-      const summ = await h({ m: 'GET', p: '/v1/subscription_items/si_twin/usage_record_summaries' });
-      const sd = (summ.body as Body).data as Body[];
-      return ok(g) && ok(deact) && field(deact, 'status') === 'inactive' && ok(ur) && ok(ur2) && noQty.status === 400 &&
-        sd.length === 1 && sd[0]!.total_usage === 10;
+      return ok(evt2) && ok(summ) && sd.length === 1 && sd[0]!.object === 'billing.meter_event_summary' && sd[0]!.aggregated_value === 10
+        && ok(g) && ok(deact) && field(deact, 'status') === 'inactive';
     }),
   ),
   // Subscription discounts: a `coupon` on create attaches a discount (validated to exist),
@@ -894,12 +1736,12 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
     withRoot(async (h) => {
       const cust = await h({ m: 'POST', p: '/v1/customers', b: 'email=disc@twin.test' });
       const coupon = await h({ m: 'POST', p: '/v1/coupons', b: 'percent_off=25&duration=forever' });
-      const sub = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(cust)}&coupon=${id(coupon)}` });
+      const sub = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(cust)}&discounts[0][coupon]=${id(coupon)}` });
       if (!ok(sub)) return false;
       const discs = (field(sub, 'discounts') as Body[]) ?? [];
       if (discs.length !== 1 || discs[0]!.object !== 'discount' || (discs[0]!.coupon as Body)?.id !== id(coupon)) return false;
       // unknown coupon on a fresh sub 400s.
-      const bad = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(cust)}&coupon=coupon_nope` });
+      const bad = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(cust)}&discounts[0][coupon]=coupon_nope` });
       if (bad.status !== 400) return false;
       // remove the discount.
       const del = await h({ m: 'DELETE', p: `/v1/subscriptions/${id(sub)}/discount` });
@@ -945,12 +1787,36 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       return ok(payGood) && field(payGood, 'status') === 'paid';
     }),
   ),
-  done('stripe.invoiceitems.crud', 'invoices', 'InvoiceItems: create + list', 'api', 'core', () =>
+  done('stripe.invoiceitems.crud', 'invoices', 'InvoiceItems: create + retrieve + update + list + delete', 'api', 'core', () =>
     withRoot(async (h) => {
       const cust = await h({ m: 'POST', p: '/v1/customers', b: 'email=ii@twin.test' });
       const ii = await h({ m: 'POST', p: '/v1/invoiceitems', b: `customer=${id(cust)}&amount=400&currency=usd` });
       const l = await h({ m: 'GET', p: '/v1/invoiceitems' });
-      return ok(ii) && field(ii, 'object') === 'invoiceitem' && field(l, 'object') === 'list';
+      if (!ok(ii) || field(ii, 'object') !== 'invoiceitem' || field(l, 'object') !== 'list') return false;
+      // an item is reachable by the id its own create handed back
+      const g = await h({ m: 'GET', p: `/v1/invoiceitems/${id(ii)}` });
+      const miss = await h({ m: 'GET', p: '/v1/invoiceitems/ii_nope' });
+      if (!ok(g) || id(g) !== id(ii) || miss.status !== 404) return false;
+      // The earlier pending 400 is swept onto the invoice at creation, when the create asks: pending_invoice_items_behavior
+      // "Defaults to `exclude` if the parameter is omitted" (docs.stripe.com/api/invoices/create; e0e3b88c6).
+      // An item on a DRAFT invoice moves the invoice's total when it changes, and again when
+      // it is deleted — an invoice billing for a line that no longer says that is money in
+      // two places at once.
+      const inv = await h({ m: 'POST', p: '/v1/invoices', b: `customer=${id(cust)}&pending_invoice_items_behavior=include` });
+      const on = await h({ m: 'POST', p: '/v1/invoiceitems', b: `customer=${id(cust)}&invoice=${id(inv)}&amount=900&currency=usd` });
+      const u = await h({ m: 'POST', p: `/v1/invoiceitems/${id(on)}`, b: 'amount=1500' });
+      const afterUpdate = await h({ m: 'GET', p: `/v1/invoices/${id(inv)}` });
+      if (!ok(u) || field(afterUpdate, 'amount_due') !== 1900) return false;
+      const del = await h({ m: 'DELETE', p: `/v1/invoiceitems/${id(on)}` });
+      const afterDelete = await h({ m: 'GET', p: `/v1/invoices/${id(inv)}` });
+      const gone = await h({ m: 'GET', p: `/v1/invoiceitems/${id(on)}` });
+      // and once the invoice is finalized its items are no longer deletable, like Stripe
+      const inv2 = await h({ m: 'POST', p: '/v1/invoices', b: `customer=${id(cust)}` });
+      const locked = await h({ m: 'POST', p: '/v1/invoiceitems', b: `customer=${id(cust)}&invoice=${id(inv2)}&amount=700&currency=usd` });
+      await h({ m: 'POST', p: `/v1/invoices/${id(inv2)}/finalize` });
+      const refused = await h({ m: 'DELETE', p: `/v1/invoiceitems/${id(locked)}` });
+      return ok(del) && field(del, 'deleted') === true && field(afterDelete, 'amount_due') === 400
+        && gone.status === 404 && refused.status === 400;
     }),
   ),
   // Invoice send / mark_uncollectible / pay-out-of-band: send auto-finalizes a draft (→ open);
@@ -961,11 +1827,15 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
     withRoot(async (h) => {
       const cust = await h({ m: 'POST', p: '/v1/customers', b: 'email=send@twin.test' });
       await h({ m: 'POST', p: '/v1/invoiceitems', b: `customer=${id(cust)}&amount=4000&currency=usd` });
-      const inv = await h({ m: 'POST', p: '/v1/invoices', b: `customer=${id(cust)}` });
+      // the pending item is taken only when the create asks ("Defaults to `exclude`", docs.stripe.com/api/invoices/create)
+      const inv = await h({ m: 'POST', p: '/v1/invoices', b: `customer=${id(cust)}&pending_invoice_items_behavior=include` });
+      if (field(inv, 'amount_due') !== 4000) return false;
       const sent = await h({ m: 'POST', p: `/v1/invoices/${id(inv)}/send` });
       if (!ok(sent) || field(sent, 'status') !== 'open') return false;
       const oob = await h({ m: 'POST', p: `/v1/invoices/${id(inv)}/pay`, b: 'paid_out_of_band=true' });
-      if (!ok(oob) || field(oob, 'status') !== 'paid' || field(oob, 'paid_out_of_band') !== true) return false;
+      // out of band is `amount_paid_off_stripe` in the served version ("Amount ... paid on the invoice outside of
+      // Stripe", served spec invoice); basil answers no `paid_out_of_band` (docs.stripe.com/changelog/basil; 24e757f60)
+      if (!ok(oob) || field(oob, 'status') !== 'paid' || field(oob, 'amount_paid_off_stripe') !== 4000 || field(oob, 'amount_paid') !== 4000 || 'paid_out_of_band' in (oob.body as Body)) return false;
       // a second invoice can be marked uncollectible
       const inv2 = await h({ m: 'POST', p: '/v1/invoices', b: `customer=${id(cust)}` });
       await h({ m: 'POST', p: `/v1/invoices/${id(inv2)}/finalize` });
@@ -984,14 +1854,17 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       const prod = await h({ m: 'POST', p: '/v1/products', b: 'name=Plan' });
       const price = await h({ m: 'POST', p: `/v1/prices`, b: `unit_amount=3000&currency=usd&recurring[interval]=month&product=${id(prod)}` });
       const coupon = await h({ m: 'POST', p: '/v1/coupons', b: 'percent_off=10&duration=forever' });
-      const sub = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(cust)}&items[0][price]=${id(price)}&coupon=${id(coupon)}` });
-      const up = await h({ m: 'GET', p: `/v1/invoices/upcoming?subscription=${id(sub)}` });
-      if (!ok(up) || field(up, 'object') !== 'invoice' || field(up, 'id') !== null) return false;
+      const sub = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(cust)}&items[0][price]=${id(price)}&discounts[0][coupon]=${id(coupon)}` });
+      const up = await h({ m: 'POST', p: '/v1/invoices/create_preview', b: `subscription=${id(sub)}` });
+      // not persisted, and named as a preview: "For preview invoices created using the create preview endpoint, this id
+      // will be prefixed with `upcoming_in`" (served spec, invoice.id; b75e48888)
+      if (!ok(up) || field(up, 'object') !== 'invoice' || !String(field(up, 'id')).startsWith('upcoming_in_')) return false;
+      if ((await h({ m: 'GET', p: `/v1/invoices/${String(field(up, 'id'))}` })).status !== 404) return false;
       // subtotal 3000, 10% off → total 2700.
       if (field(up, 'subtotal') !== 3000 || field(up, 'total') !== 2700) return false;
       const lines = (field(up, 'lines') as Body).data as Body[];
       if (lines.length !== 1 || lines[0]!.amount !== 3000) return false;
-      const noCust = await h({ m: 'GET', p: '/v1/invoices/upcoming?customer=cus_nope' });
+      const noCust = await h({ m: 'POST', p: '/v1/invoices/create_preview', b: 'customer=cus_nope' });
       return noCust.status === 404;
     }),
   ),
@@ -1004,13 +1877,19 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
     withRoot(async (h) => {
       const cust = await h({ m: 'POST', p: '/v1/customers', b: 'email=cn@twin.test' });
       await h({ m: 'POST', p: '/v1/invoiceitems', b: `customer=${id(cust)}&amount=5000&currency=usd` });
-      const inv = await h({ m: 'POST', p: '/v1/invoices', b: `customer=${id(cust)}` });
+      // the pending item is taken only when the create asks ("Defaults to `exclude`", docs.stripe.com/api/invoices/create; e0e3b88c6)
+      const inv = await h({ m: 'POST', p: '/v1/invoices', b: `customer=${id(cust)}&pending_invoice_items_behavior=include` });
       await h({ m: 'POST', p: `/v1/invoices/${id(inv)}/finalize` });
       await h({ m: 'POST', p: `/v1/invoices/${id(inv)}/pay`, b: 'payment_method=pm_card_visa' });
+      // a paid invoice's credit says how it is paid back: "The sum of refunds, customer balance credits, and outside of
+      // Stripe credits must equal the post_payment_amount" (docs.stripe.com/api/credit_notes/create; 1159092c7), so the
+      // 2000 goes to the customer's balance (credit_amount), and a split that does not add up is refused
+      const unsplit = await h({ m: 'GET', p: `/v1/credit_notes/preview?invoice=${id(inv)}&amount=2000` });
+      if (unsplit.status !== 400) return false;
       // preview computes the object WITHOUT persisting it
-      const prev = await h({ m: 'GET', p: `/v1/credit_notes/preview?invoice=${id(inv)}&amount=2000` });
+      const prev = await h({ m: 'GET', p: `/v1/credit_notes/preview?invoice=${id(inv)}&amount=2000&credit_amount=2000` });
       if (!ok(prev) || field(prev, 'object') !== 'credit_note' || field(prev, 'amount') !== 2000) return false;
-      const cn = await h({ m: 'POST', p: '/v1/credit_notes', b: `invoice=${id(inv)}&amount=2000&reason=order_change` });
+      const cn = await h({ m: 'POST', p: '/v1/credit_notes', b: `invoice=${id(inv)}&amount=2000&credit_amount=2000&reason=order_change` });
       if (!ok(cn) || field(cn, 'object') !== 'credit_note' || field(cn, 'status') !== 'issued' || field(cn, 'type') !== 'post_payment' || field(cn, 'amount') !== 2000) return false;
       const g = await h({ m: 'GET', p: `/v1/credit_notes/${id(cn)}` });
       const lines = await h({ m: 'GET', p: `/v1/credit_notes/${id(cn)}/lines` });
@@ -1040,29 +1919,345 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       return ok(g) && ok(li) && field(li, 'object') === 'list' && ok(exp);
     }),
   ),
+  // A Checkout line item's description: "An arbitrary string attached to the object. Often useful for displaying to users.
+  // Defaults to product name." (spec/openapi.json.gz, the `item` schema). The session create's line_items take no
+  // description of their own (price, price_data, quantity, adjustable_quantity, metadata, tax_rates), so the name is the
+  // price's product's, or the product_data an inline price names. Dub's Checkout showed its Business plan as "Item".
+  done('stripe.checkout.line_item_description', 'checkout', 'Checkout line items are described by their product\'s name (a price\'s product, or price_data.product_data)', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const prod = await h({ m: 'POST', p: '/v1/products', b: 'name=Business' });
+      const price = await h({ m: 'POST', p: '/v1/prices', b: `unit_amount=9000&currency=usd&product=${id(prod)}` });
+      const cs = await h({ m: 'POST', p: '/v1/checkout/sessions', b: `mode=payment&success_url=https://x.test&line_items[0][price]=${id(price)}&line_items[0][quantity]=2&line_items[1][price_data][currency]=usd&line_items[1][price_data][unit_amount]=100&line_items[1][price_data][product_data][name]=Setup%20fee&line_items[1][quantity]=1` });
+      const items = (((await h({ m: 'GET', p: `/v1/checkout/sessions/${id(cs)}/line_items` })).body as Body).data as Body[]) ?? [];
+      return items.length === 2 && items[0]?.description === 'Business' && items[0]?.amount_total === 18000
+        && items[1]?.description === 'Setup fee' && items[1]?.amount_total === 100;
+    }),
+  ),
   // Completion copies the session's create-only subscription_data onto the created
   // subscription (metadata is how apps bind the checkout attempt → subscription; trial
   // becomes a real trialing window) — and the Session itself never echoes the param.
   done('stripe.checkout.subscription_data', 'checkout', 'Checkout completion copies subscription_data (metadata + trial) onto the created subscription', 'api', 'core', () =>
     withRoot(async (h) => {
       const cust = await h({ m: 'POST', p: '/v1/customers', b: 'email=subdata@twin.test' });
-      const cs = await h({ m: 'POST', p: '/v1/checkout/sessions', b: `mode=subscription&success_url=https://x.test&customer=${id(cust)}&line_items[0][price_data][currency]=usd&line_items[0][price_data][unit_amount]=999&line_items[0][quantity]=1&subscription_data[metadata][attemptId]=att_cap_1&subscription_data[trial_period_days]=7` });
+      // the inline price is a subscription's: a product and a recurring interval (docs.stripe.com/api/checkout/sessions/create,
+      // line_items.price_data), so the subscription has an item to carry its period (c3a378808 bills inline prices)
+      const cs = await h({ m: 'POST', p: '/v1/checkout/sessions', b: `mode=subscription&success_url=https://x.test&customer=${id(cust)}&line_items[0][price_data][currency]=usd&line_items[0][price_data][unit_amount]=999&line_items[0][price_data][product_data][name]=Plan&line_items[0][price_data][recurring][interval]=month&line_items[0][quantity]=1&subscription_data[metadata][attemptId]=att_cap_1&subscription_data[trial_period_days]=7` });
       if (!ok(cs) || field(cs, 'subscription_data') !== undefined || field(cs, '_subscription_data') !== undefined) return false;
-      const completed = await h({ m: 'POST', p: `/v1/checkout/sessions/${id(cs)}`, b: 'status=complete' });
+      await h({ m: 'POST', p: `/c/pay/${id(cs)}`, b: 'email=pay%40twin.test&cardNumber=4242424242424242&cardExpiry=12%2F34&cardCvc=123&billingName=Twin&billingCountry=US&billingPostalCode=94105' });
+      const completed = await h({ m: 'GET', p: `/v1/checkout/sessions/${id(cs)}` });
       if (!ok(completed) || !field(completed, 'subscription')) return false;
       const sub = await h({ m: 'GET', p: `/v1/subscriptions/${field(completed, 'subscription')}` });
       const md = field(sub, 'metadata') as Body | undefined;
+      // a subscription's billing period is its items' in the served version ("current_period_start and current_period_end
+      // ... moved to the subscription item", docs.stripe.com/changelog/basil/2025-03-31/deprecate-subscription-current-period-start-and-end; 24e757f60)
+      const item = (((field(sub, 'items') as Body | undefined)?.data as Body[] | undefined) ?? [])[0];
       return ok(sub) && md?.attemptId === 'att_cap_1' && field(sub, 'status') === 'trialing'
-        && typeof field(sub, 'trial_end') === 'number' && field(sub, 'trial_end') === field(sub, 'current_period_end');
-    }),
-  ),
+        && typeof field(sub, 'trial_end') === 'number' && field(sub, 'trial_end') === item?.current_period_end
+        && field(sub, 'current_period_end') === undefined;
+    }),
+  ),
+  // A subscription session's customer pays its first invoice on the page: the invoice is paid through a succeeded
+  // PaymentIntent and its charge, and the card is the subscription's default payment method
+  // (docs.stripe.com/payments/checkout/how-checkout-works).
+  done('stripe.checkout.subscription_first_invoice', 'checkout', 'Subscription Checkout pays the first invoice with the entered card, the subscription\'s default payment method', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const prod = await h({ m: 'POST', p: '/v1/products', b: 'name=Box' });
+      const price = await h({ m: 'POST', p: '/v1/prices', b: `unit_amount=3500&currency=usd&product=${id(prod)}&recurring[interval]=month` });
+      const cs = await h({ m: 'POST', p: '/v1/checkout/sessions', b: `mode=subscription&success_url=https://x.test&line_items[0][price]=${id(price)}&line_items[0][quantity]=1` });
+      await h({ m: 'POST', p: `/c/pay/${id(cs)}`, b: 'email=pay%40twin.test&cardNumber=4242424242424242&cardExpiry=12%2F34&cardCvc=123&billingName=Twin&billingCountry=US&billingPostalCode=94105' });
+      const done = await h({ m: 'GET', p: `/v1/checkout/sessions/${id(cs)}` });
+      const sub = await h({ m: 'GET', p: `/v1/subscriptions/${String(field(done, 'subscription'))}` });
+      const inv = await h({ m: 'GET', p: `/v1/invoices/${String(field(done, 'invoice'))}` });
+      // the invoice's PaymentIntent is its payment in the served version: basil answers no `invoice.payment_intent` and
+      // lists the invoice's payments (docs.stripe.com/changelog/basil/2025-03-31/add-support-for-multiple-partial-payments-on-invoices; 24e757f60)
+      const payments = (((await h({ m: 'GET', p: `/v1/invoice_payments?invoice=${String(field(done, 'invoice'))}` })).body as Body).data as Body[]) ?? [];
+      const pi = await h({ m: 'GET', p: `/v1/payment_intents/${String((payments[0]?.payment as Body | undefined)?.payment_intent)}` });
+      if (payments.length !== 1 || payments[0]!.status !== 'paid' || payments[0]!.amount_paid !== 3500) return false;
+      return field(sub, 'status') === 'active' && typeof field(sub, 'default_payment_method') === 'string'
+        && field(inv, 'status') === 'paid' && field(inv, 'billing_reason') === 'subscription_create' && field(inv, 'amount_paid') === 3500
+        && field(pi, 'status') === 'succeeded' && typeof field(pi, 'latest_charge') === 'string';
+    }),
+  ),
+  // Checkout attaches the card it saves to the customer and says so: payment_method.attached ("Occurs whenever a new payment
+  // method is attached to a customer", docs.stripe.com/api/events/types) for a subscription's card, which is also the
+  // subscription's default payment method (docs.stripe.com/payments/checkout/how-checkout-works), for a setup session's, and
+  // for a payment's only under payment_intent_data.setup_future_usage (docs.stripe.com/api/checkout/sessions/create
+  // #create_checkout_session-customer); the event comes before the subscription it pays for (the twin's order; Stripe's is
+  // not guaranteed, docs.stripe.com/webhooks#event-ordering). Rallly walk 4: its billing page read no saved card.
+  done('stripe.checkout.payment_method_attached', 'checkout', 'Checkout attaches the saved card to the customer and emits payment_method.attached (subscription, setup, and payment with setup_future_usage)', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const card = 'cardNumber=4242424242424242&cardExpiry=12%2F34&cardCvc=123&billingName=Twin&billingCountry=US&billingPostalCode=94105';
+      const attachedEvents = async () => (((await h({ m: 'GET', p: '/v1/events?type=payment_method.attached&limit=100' })).body as Body).data as Body[] | undefined) ?? [];
+      const cust = await h({ m: 'POST', p: '/v1/customers', b: 'email=saved@twin.test' });
+      const prod = await h({ m: 'POST', p: '/v1/products', b: 'name=Pro' });
+      const price = await h({ m: 'POST', p: '/v1/prices', b: `unit_amount=1200&currency=usd&product=${id(prod)}&recurring[interval]=month` });
+      const sub = await h({ m: 'POST', p: '/v1/checkout/sessions', b: `mode=subscription&success_url=https://x.test&customer=${id(cust)}&line_items[0][price]=${id(price)}&line_items[0][quantity]=1` });
+      await h({ m: 'POST', p: `/c/pay/${id(sub)}`, b: card });
+      const done = await h({ m: 'GET', p: `/v1/checkout/sessions/${id(sub)}` });
+      const subscription = await h({ m: 'GET', p: `/v1/subscriptions/${String(field(done, 'subscription'))}` });
+      const pmId = field(subscription, 'default_payment_method');
+      const pm = await h({ m: 'GET', p: `/v1/payment_methods/${String(pmId)}` });
+      const attached = await attachedEvents();
+      const all = (((await h({ m: 'GET', p: '/v1/events?limit=100' })).body as Body).data as Body[] | undefined) ?? [];
+      // the list is newest first: the attach is older than the subscription's creation and the session's completion
+      const at = (type: string) => all.findIndex((e) => e.type === type);
+      const subscriptionOk = field(done, 'status') === 'complete' && typeof pmId === 'string' && field(pm, 'customer') === id(cust)
+        && attached.length === 1 && ((attached[0]!.data as Body).object as Body).id === pmId && ((attached[0]!.data as Body).object as Body).customer === id(cust)
+        && at('payment_method.attached') > at('customer.subscription.created') && at('customer.subscription.created') > at('checkout.session.completed');
+      // a payment without setup_future_usage saves nothing on the customer; with it, the card is attached
+      const pay = (extra: string) => h({ m: 'POST', p: '/v1/checkout/sessions', b: `mode=payment&success_url=https://x.test&customer=${id(cust)}&line_items[0][price_data][currency]=usd&line_items[0][price_data][unit_amount]=2500&line_items[0][price_data][product_data][name]=Pot&line_items[0][quantity]=1${extra}` });
+      const once = await pay('');
+      await h({ m: 'POST', p: `/c/pay/${id(once)}`, b: card });
+      const oncePi = await h({ m: 'GET', p: `/v1/payment_intents/${String(field(await h({ m: 'GET', p: `/v1/checkout/sessions/${id(once)}` }), 'payment_intent'))}` });
+      const oncePm = await h({ m: 'GET', p: `/v1/payment_methods/${String(field(oncePi, 'payment_method'))}` });
+      const afterOnce = (await attachedEvents()).length;
+      const keep = await pay('&payment_intent_data[setup_future_usage]=off_session');
+      await h({ m: 'POST', p: `/c/pay/${id(keep)}`, b: card });
+      const keepPi = await h({ m: 'GET', p: `/v1/payment_intents/${String(field(await h({ m: 'GET', p: `/v1/checkout/sessions/${id(keep)}` }), 'payment_intent'))}` });
+      const keepPm = await h({ m: 'GET', p: `/v1/payment_methods/${String(field(keepPi, 'payment_method'))}` });
+      const afterKeep = await attachedEvents();
+      const paymentOk = ok(oncePm) && field(oncePm, 'customer') === null && afterOnce === 1 && field(keepPi, 'setup_future_usage') === 'off_session'
+        && field(keepPm, 'customer') === id(cust) && afterKeep.length === 2 && ((afterKeep[0]!.data as Body).object as Body).id === id(keepPm);
+      // a setup session saves the card: its SetupIntent names it, and it is attached
+      const setup = await h({ m: 'POST', p: '/v1/checkout/sessions', b: `mode=setup&currency=usd&success_url=https://x.test&customer=${id(cust)}` });
+      await h({ m: 'POST', p: `/c/pay/${id(setup)}`, b: card });
+      const si = await h({ m: 'GET', p: `/v1/setup_intents/${String(field(await h({ m: 'GET', p: `/v1/checkout/sessions/${id(setup)}` }), 'setup_intent'))}` });
+      const setupPm = await h({ m: 'GET', p: `/v1/payment_methods/${String(field(si, 'payment_method'))}` });
+      const afterSetup = await attachedEvents();
+      const setupOk = field(si, 'status') === 'succeeded' && field(setupPm, 'customer') === id(cust) && afterSetup.length === 3 && ((afterSetup[0]!.data as Body).object as Body).id === id(setupPm);
+      return subscriptionOk && paymentOk && setupOk;
+    }),
+  ),
+  // A session made for a customer with an email shows that email on the page, prefilled and not editable, and the session
+  // is the customer's email whatever is posted; a customer with none types one, which Checkout sets on the customer ("If the
+  // Customer already has a valid email set, the email will be prefilled and not editable in Checkout. If the Customer does
+  // not have a valid email, Checkout will set the email entered during the session on the Customer",
+  // docs.stripe.com/api/checkout/sessions/create#create_checkout_session-customer). Rallly walk 4: the field was empty.
+  done('stripe.checkout.customer_email', 'checkout', "Checkout for a session's customer shows the customer's email prefilled and not editable; a customer without one gets the typed email", 'ui', 'common', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'stp-cs-email-'));
+    try {
+      const f = createStripeTwinFetch({ root });
+      const api = async (method: string, path: string, body?: string) => (await f(new Request(`http://stripe.test${path}`, { method, headers: { 'content-type': 'application/x-www-form-urlencoded' }, ...(body ? { body } : {}) }))).json() as Promise<Body>;
+      const post = (url: string, email: string) => f(new Request(url, { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: new URLSearchParams({ email, cardNumber: '4242424242424242', cardExpiry: '12 / 34', cardCvc: '123', billingName: 'Twin', billingCountry: 'US', billingPostalCode: '94105' }).toString() }));
+      const session = (customer: string) => api('POST', '/v1/checkout/sessions', `mode=subscription&success_url=https://x.test&customer=${customer}&line_items[0][price_data][currency]=usd&line_items[0][price_data][unit_amount]=1200&line_items[0][price_data][product_data][name]=Pro&line_items[0][price_data][recurring][interval]=month&line_items[0][quantity]=1`);
+      const known = await api('POST', '/v1/customers', 'email=known@twin.test');
+      const cs = await session(String(known.id));
+      const html = await (await f(new Request(String(cs.url)))).text();
+      const input = /<input[^>]*id="email"[^>]*>/.exec(html)?.[0] ?? '';
+      const paid = await post(String(cs.url), 'other@twin.test');
+      const done = await api('GET', `/v1/checkout/sessions/${String(cs.id)}`);
+      const knownAfter = await api('GET', `/v1/customers/${String(known.id)}`);
+      const prefilled = input.includes('value="known@twin.test"') && /\sreadonly(=""|\s|\/|>)/i.test(input)
+        && paid.status === 303 && (done.customer_details as Body | undefined)?.email === 'known@twin.test' && knownAfter.email === 'known@twin.test';
+      // a customer with no email: the field is empty and editable, and the typed email becomes the customer's
+      const bare = await api('POST', '/v1/customers', 'name=Bare');
+      const cs2 = await session(String(bare.id));
+      const bareInput = /<input[^>]*id="email"[^>]*>/.exec(await (await f(new Request(String(cs2.url)))).text())?.[0] ?? '';
+      const paid2 = await post(String(cs2.url), 'typed@twin.test');
+      const bareAfter = await api('GET', `/v1/customers/${String(bare.id)}`);
+      const updated = ((await api('GET', '/v1/events?type=customer.updated')).data as Body[] | undefined) ?? [];
+      const typed = bareInput !== '' && !/readonly/i.test(bareInput) && paid2.status === 303 && bareAfter.email === 'typed@twin.test'
+        && updated.length === 1 && ((updated[0]!.data as Body).object as Body).id === bare.id && ((updated[0]!.data as Body).object as Body).email === 'typed@twin.test';
+      return prefilled && typed;
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  }),
+  // Checkout's expiry field takes the digits typed straight through, as Stripe's formats `1230` into `12 / 30`: the page
+  // marks the field for its formatter, and the posted digits pay and are the card's expiry (screens/checkout.tsx
+  // parseExpiry); two digits are still incomplete.
+  done('stripe.checkout.card_expiry_digits', 'checkout', 'Checkout card expiry accepts digits typed straight through (1230 is 12 / 30), formatted as typed', 'ui', 'common', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'stp-expiry-'));
+    try {
+      const f = createStripeTwinFetch({ root, clock: () => '2026-03-01T00:00:00Z' });
+      const api = async (method: string, path: string, body?: string) => (await f(new Request(`http://stripe.test${path}`, { method, headers: { 'content-type': 'application/x-www-form-urlencoded' }, ...(body ? { body } : {}) }))).json() as Promise<Body>;
+      const pay = (cs: Body, expiry: string) => f(new Request(String(cs.url), { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: new URLSearchParams({ email: 'pay@twin.test', cardNumber: '4242424242424242', cardExpiry: expiry, cardCvc: '123', billingName: 'Twin', billingCountry: 'US', billingPostalCode: '94105' }).toString() }));
+      const session = () => api('POST', '/v1/checkout/sessions', 'mode=payment&success_url=https://x.test&line_items[0][price_data][currency]=usd&line_items[0][price_data][unit_amount]=2500&line_items[0][price_data][product_data][name]=Pro&line_items[0][quantity]=1');
+      const cs = await session();
+      const html = await (await f(new Request(String(cs.url)))).text();
+      const script = /<script>([\s\S]*?)<\/script>/.exec(html)?.[1] ?? '';
+      const marked = /<input[^>]*id="cardExpiry"[^>]*data-format="card-expiry"/.test(html) && script === FORMAT_SCRIPT;
+      // the page's own script, run over a field as a person types, deletes, pastes or fills it
+      const typed = expiryField(script);
+      const formats = typed.type('1230') === '12 / 30' && expiryField(script).type('5') === '05 / ' && expiryField(script).type('1/3') === '01 / 3'
+        && expiryField(script).fill('12/2030') === '12 / 30' && expiryField(script).fill('122030') === '12 / 30'
+        && (typed.back(), typed.back()) === '12 / ' && typed.back() === '12' && typed.back() === '1';
+      const short = await pay(cs, '12');
+      const shortText = await short.text();
+      const paid = await pay(cs, '1230');
+      const done = await api('GET', `/v1/checkout/sessions/${String(cs.id)}`);
+      const pi = await api('GET', `/v1/payment_intents/${String(done.payment_intent)}`);
+      const card = (await api('GET', `/v1/payment_methods/${String(pi.payment_method)}`)).card as Body | undefined;
+      // a first digit above 1 is the month on its own: 530 is May 2030
+      const other = await session();
+      const may = await pay(other, '530');
+      const pmMay = (await api('GET', `/v1/payment_methods/${String((await api('GET', `/v1/payment_intents/${String((await api('GET', `/v1/checkout/sessions/${String(other.id)}`)).payment_intent)}`)).payment_method)}`)).card as Body | undefined;
+      return marked && formats && short.status === 402 && shortText.includes('expiration date is incomplete')
+        && paid.status === 303 && done.status === 'complete' && card?.exp_month === 12 && card?.exp_year === 2030
+        && may.status === 303 && pmMay?.exp_month === 5 && pmMay?.exp_year === 2030;
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  }),
+  // A subscription session with a trial shows the trial as Checkout does: "14 days free", "Then $90.00 per month", a
+  // "Start trial" button and, under it, when the trial's end charges; one without a trial says Subscribe and its amount
+  // (screens/checkout.tsx trialSummary). The amount and date come from the seeded price and the session's trial.
+  done('stripe.checkout.trial_display', 'checkout', 'Checkout shows a subscription\'s trial: N days free, then the price per interval from the trial\'s end, Start trial', 'ui', 'common', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'stp-trialpage-'));
+    try {
+      const f = createStripeTwinFetch({ root, clock: () => '2026-03-01T00:00:00Z' });
+      const api = async (method: string, path: string, body?: string) => (await f(new Request(`http://stripe.test${path}`, { method, headers: { 'content-type': 'application/x-www-form-urlencoded' }, ...(body ? { body } : {}) }))).json() as Promise<Body>;
+      const text = async (cs: Body) => (await (await f(new Request(String(cs.url)))).text()).replace(/<script[\s\S]*?<\/script>/g, '').replace(/<[^>]+>/g, '|');
+      const prod = await api('POST', '/v1/products', 'name=Business');
+      const price = await api('POST', '/v1/prices', `unit_amount=9000&currency=usd&recurring[interval]=month&product=${String(prod.id)}`);
+      const yearly = await api('POST', '/v1/prices', `unit_amount=90000&currency=usd&recurring[interval]=year&product=${String(prod.id)}`);
+      const line = (p: Body) => `mode=subscription&success_url=https://x.test&customer_email=t%40twin.test&line_items[0][price]=${String(p.id)}&line_items[0][quantity]=1`;
+      const trial = await text(await api('POST', '/v1/checkout/sessions', `${line(price)}&subscription_data[trial_period_days]=14`));
+      // a trial set by its end: 2026-03-08 is a week on
+      const byEnd = await text(await api('POST', '/v1/checkout/sessions', `${line(yearly)}&subscription_data[trial_end]=${Date.parse('2026-03-08T00:00:00Z') / 1000}`));
+      const plain = await text(await api('POST', '/v1/checkout/sessions', line(price)));
+      // after the trial a `once` coupon is spent (the trial's $0 invoice took it) and a one-time item is not billed again;
+      // a `forever` coupon still applies
+      const once = await api('POST', '/v1/coupons', 'id=ONCE50&percent_off=50&duration=once');
+      const forever = await api('POST', '/v1/coupons', 'id=EVER10&percent_off=10&duration=forever');
+      const setup = await api('POST', '/v1/prices', `unit_amount=2500&currency=usd&product=${String(prod.id)}`);
+      const spent = await text(await api('POST', '/v1/checkout/sessions', `${line(price)}&subscription_data[trial_period_days]=14&discounts[0][coupon]=${String(once.id)}&line_items[1][price]=${String(setup.id)}&line_items[1][quantity]=1`));
+      const kept = await text(await api('POST', '/v1/checkout/sessions', `${line(price)}&subscription_data[trial_period_days]=14&discounts[0][coupon]=${String(forever.id)}`));
+      // Checkout refuses a trial_end under 48 hours away
+      const soon = await f(new Request('http://stripe.test/v1/checkout/sessions', { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: `${line(price)}&subscription_data[trial_end]=${Date.parse('2026-03-02T12:00:00Z') / 1000}` }));
+      if (!spent.includes('|Then $90.00 per month|') || !kept.includes('|Then $81.00 per month|') || soon.status !== 400) return false;
+      // and the twin bills what the page says: the one-time price on the first invoice, then $90.00 a period
+      const paid = await api('POST', '/v1/checkout/sessions', `${line(price)}&subscription_data[trial_period_days]=14&line_items[1][price]=${String(setup.id)}&line_items[1][quantity]=1`);
+      await f(new Request(String(paid.url), { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: 'email=t%40twin.test&cardNumber=4242424242424242&cardExpiry=1230&cardCvc=123&billingName=T&billingCountry=US&billingPostalCode=94105' }));
+      const later = createStripeTwinFetch({ root, clock: () => '2026-03-20T00:00:00Z' });
+      const read = async (path: string) => (await later(new Request(`http://stripe.test${path}`))).json() as Promise<Body>;
+      const done = await read(`/v1/checkout/sessions/${String(paid.id)}`);
+      const first = await read(`/v1/invoices/${String(done.invoice)}`);
+      const bills = ((await read(`/v1/invoices?subscription=${String(done.subscription)}`)).data as Body[] | undefined) ?? [];
+      const cycle = bills.find((b) => b.billing_reason === 'subscription_cycle');
+      if (first.total !== 2500 || first.status !== 'paid' || cycle?.total !== 9000) return false;
+      // the same sale in inline price_data: the page and the invoices agree ($25 now, $90 a period)
+      const inlineLines = 'mode=subscription&success_url=https://x.test&customer_email=t%40twin.test&subscription_data[trial_period_days]=14'
+        + `&line_items[0][price_data][currency]=usd&line_items[0][price_data][unit_amount]=9000&line_items[0][price_data][recurring][interval]=month&line_items[0][price_data][product]=${String(prod.id)}&line_items[0][quantity]=1`
+        + '&line_items[1][price_data][currency]=usd&line_items[1][price_data][unit_amount]=2500&line_items[1][price_data][product_data][name]=Setup&line_items[1][quantity]=1';
+      const inlineCs = await api('POST', '/v1/checkout/sessions', inlineLines);
+      const inlinePage = await text(inlineCs);
+      await f(new Request(String(inlineCs.url), { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: 'email=t%40twin.test&cardNumber=4242424242424242&cardExpiry=1230&cardCvc=123&billingName=T&billingCountry=US&billingPostalCode=94105' }));
+      const inlineDone = await read(`/v1/checkout/sessions/${String(inlineCs.id)}`);
+      const inlineFirst = await read(`/v1/invoices/${String(inlineDone.invoice)}`);
+      const inlineBills = ((await read(`/v1/invoices?subscription=${String(inlineDone.subscription)}`)).data as Body[] | undefined) ?? [];
+      if (!inlinePage.includes('|Then $90.00 per month|') || inlineFirst.total !== 2500 || inlineBills.find((b) => b.billing_reason === 'subscription_cycle')?.total !== 9000) return false;
+      return trial.includes('|14 days free|') && trial.includes('|Then $90.00 per month|') && trial.includes('|Start trial|')
+        && trial.includes('After your trial ends, you will be charged $90.00 per month starting March 15, 2026. You can always cancel before then.')
+        && !trial.includes('|Subscribe|')
+        && byEnd.includes('|7 days free|') && byEnd.includes('|Then $900.00 per year|') && byEnd.includes('starting March 8, 2026')
+        && plain.includes('|Subscribe|') && plain.includes('|$90.00|') && !plain.includes('days free') && !plain.includes('Start trial');
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  }),
+  // A session's promotion code discounts it and the subscription it makes; an unknown code and an expired one are
+  // refused at create (docs.stripe.com/api/checkout/sessions/create#create_checkout_session-discounts).
+  done('stripe.checkout.promotion_codes', 'checkout', 'Checkout discounts[].promotion_code: applied, or refused when unknown or expired', 'api', 'common', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'stp-promo-'));
+    try {
+      const h = (s: Step & { day?: number }) => handleStripeTwinRequest({ method: s.m, path: s.p, body: s.b, root, occurredAt: `2026-05-${String(s.day ?? 1).padStart(2, '0')}T12:00:00Z` });
+      const prod = await h({ m: 'POST', p: '/v1/products', b: 'name=Box' });
+      const price = await h({ m: 'POST', p: '/v1/prices', b: `unit_amount=3500&currency=usd&recurring[interval]=month&product=${id(prod)}` });
+      const coupon = await h({ m: 'POST', p: '/v1/coupons', b: 'percent_off=50&duration=once' });
+      const code = await h({ m: 'POST', p: '/v1/promotion_codes', b: `promotion[type]=coupon&promotion[coupon]=${id(coupon)}&code=SPRING&expires_at=1780272000` });
+      const make = (day: number, pc: string) => h({ m: 'POST', p: '/v1/checkout/sessions', b: `mode=subscription&success_url=https://x.test&line_items[0][price]=${id(price)}&line_items[0][quantity]=1&discounts[0][promotion_code]=${pc}`, day });
+      const good = await make(2, id(code));
+      const unknown = await make(2, 'promo_nope');
+      const late = await make(30, id(code));
+      const lateOk = late.status === 200;
+      const june = await handleStripeTwinRequest({ method: 'POST', path: '/v1/checkout/sessions', body: `mode=subscription&success_url=https://x.test&line_items[0][price]=${id(price)}&line_items[0][quantity]=1&discounts[0][promotion_code]=${id(code)}`, root, occurredAt: '2026-06-02T12:00:00Z' });
+      return field(good, 'amount_total') === 1750 && unknown.status === 400 && lateOk && june.status === 400 && ((june.body as Body).error as Body)?.code === 'coupon_expired';
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  }),
+  // A payment session's payment_intent_data makes a destination charge: the payment transfers to the connected account
+  // less the platform's application fee (docs.stripe.com/connect/destination-charges).
+  done('stripe.checkout.destination_charge', 'checkout', 'Checkout payment_intent_data: destination charge with an application fee', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const seller = await onboardedSeller(h);
+      const cs = await h({ m: 'POST', p: '/v1/checkout/sessions', b: `mode=payment&success_url=https://x.test&line_items[0][price_data][currency]=usd&line_items[0][price_data][unit_amount]=5000&line_items[0][quantity]=1&payment_intent_data[application_fee_amount]=750&payment_intent_data[transfer_data][destination]=${seller}` });
+      await h({ m: 'POST', p: `/c/pay/${id(cs)}`, b: 'email=pay%40twin.test&cardNumber=4242424242424242&cardExpiry=12%2F34&cardCvc=123&billingName=Twin&billingCountry=US&billingPostalCode=94105' });
+      const done = await h({ m: 'GET', p: `/v1/checkout/sessions/${id(cs)}?expand[]=payment_intent.latest_charge` });
+      const charge = ((field(done, 'payment_intent') as Body)?.latest_charge ?? {}) as Body;
+      const transfer = await h({ m: 'GET', p: `/v1/transfers/${String(charge.transfer)}` });
+      return field(transfer, 'destination') === seller && field(transfer, 'amount') === 4250 && charge.application_fee_amount === 750;
+    }),
+  ),
+  // Refunding a destination charge with reverse_transfer and refund_application_fee reverses the transfer and refunds the
+  // application fee (docs.stripe.com/connect/destination-charges#issue-refunds).
+  done('stripe.refunds.reverse_transfer', 'payments', 'Refund reverse_transfer + refund_application_fee on a destination charge', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const seller = await onboardedSeller(h);
+      const pi = await h({ m: 'POST', p: '/v1/payment_intents', b: `amount=5000&currency=usd&payment_method=pm_card_visa&confirm=true&application_fee_amount=750&transfer_data[destination]=${seller}` });
+      const refund = await h({ m: 'POST', p: '/v1/refunds', b: `payment_intent=${id(pi)}&reverse_transfer=true&refund_application_fee=true` });
+      const fees = ((await h({ m: 'GET', p: '/v1/application_fees' })).body as Body).data as Body[];
+      const reversal = typeof field(refund, 'transfer_reversal') === 'string';
+      return ok(refund) && reversal && field(refund, 'reverse_transfer') === undefined && fees[0]?.refunded === true && fees[0]?.amount_refunded === 750;
+    }),
+  ),
+  // Hosted Express onboarding: an Account Link is a single-use entry point to the onboarding session
+  // (docs.stripe.com/connect/hosted-onboarding), which collects what a US account owes before card payments
+  // (docs.stripe.com/connect/required-verification-information: eighteen requirements for an individual), the business, its representative and the payout bank account, refuses a
+  // submit that leaves one out, and stores what it was given on the account (docs.stripe.com/connect/express-accounts).
+  done('stripe.connect.hosted_onboarding', 'connect', 'Hosted onboarding collects and stores the business, representative and bank account', 'api', 'common', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'stp-onb-'));
+    try {
+      const h = (s: Step) => handleStripeTwinRequest({ method: s.m, path: s.p, body: s.b, root });
+      const acct = await h({ m: 'POST', p: '/v1/accounts', b: 'type=express&country=US&business_type=individual&email=grower@twin.test' });
+      const owed = (((field(acct, 'requirements') as Body)?.currently_due as string[]) ?? []).length;
+      const link = await h({ m: 'POST', p: '/v1/account_links', b: `account=${id(acct)}&type=account_onboarding&refresh_url=https://x.test/r&return_url=https://x.test/d` });
+      // visiting the link consumes it and opens the onboarding session; a second visit is sent to refresh_url
+      const url = String(field(link, 'url'));
+      const visited = await stripeOnboardingFlow({ root })(new Request(url));
+      const session = visited?.headers.get('location') ?? '';
+      const again = await stripeOnboardingFlow({ root })(new Request(url));
+      // the page offers Stripe's supported industries (a creator or marketer finds Advertising Services) and every state
+      const shown = await (await stripeOnboardingFlow({ root })(new Request(session)))?.text() ?? '';
+      const offers = shown.includes('value="7311"') && shown.includes('Advertising Services') && shown.includes('value="5815"')
+        && shown.includes('value="WY"') && shown.includes('value="DC"') && !shown.includes('value="5967"')
+        && (shown.match(/<option /g) ?? []).length >= 256 + 51;
+      // no industry is chosen for the person, and a padded code is kept as the code
+      const unchosen = shown.includes('<select id="mcc" name="mcc"><option value="" selected="">Select your industry</option>');
+      // an account the platform gave an industry the page offers opens on it; one it does not offer, on no industry
+      const opened = async (mcc: string): Promise<string> => {
+        const a = await h({ m: 'POST', p: '/v1/accounts', b: `type=express&country=US&business_type=individual&business_profile[mcc]=${mcc}` });
+        const l = await h({ m: 'POST', p: '/v1/account_links', b: `account=${id(a)}&type=account_onboarding&refresh_url=https://x.test/r&return_url=https://x.test/d` });
+        const s = (await stripeOnboardingFlow({ root })(new Request(String(field(l, 'url')))))?.headers.get('location') ?? '';
+        return await (await stripeOnboardingFlow({ root })(new Request(s)))?.text() ?? '';
+      };
+      const prefilled = (await opened('7311')).includes('<option value="7311" selected="">') && (await opened('5912')).includes('<option value="" selected="">Select your industry</option>');
+      // an industry the page does not offer (a restricted code) leaves the MCC due
+      const unlisted = currentlyDue('individual', { mcc: '5967' }).includes('business_profile.mcc') && !currentlyDue('individual', { mcc: '7311' }).includes('business_profile.mcc');
+      const partial = await hostedSubmit(root, stripeOnboardingFlow, session, { business_type: 'individual', first_name: 'Ada' });
+      const full = await hostedSubmit(root, stripeOnboardingFlow, session, {
+        mcc: ' 5261 ', url: 'https://grower.test', statement_descriptor: 'GROWER TEST', line1: 'address_full_match', city: 'Portland', state: 'OR', postal_code: '97201',
+        first_name: 'Ada', last_name: 'Grower', email: 'grower@twin.test', phone: '0000000000', dob: '1901-01-01', ssn_last_4: '0000', routing_number: '110000000', account_number: '000123456789', tos: 'accepted',
+      });
+      const after = await h({ m: 'GET', p: `/v1/accounts/${id(acct)}` });
+      const banks = await h({ m: 'GET', p: `/v1/accounts/${id(acct)}/external_accounts` });
+      return owed === 18 && offers && unlisted && unchosen && prefilled && (field(after, 'business_profile') as Body)?.mcc === '5261' && ((field(after, 'requirements') as Body)?.currently_due as string[] | undefined)?.length === 0 && field(after, 'charges_enabled') === true
+        && session.startsWith('https://connect.stripe.com/setup/s/') && again?.headers.get('location') === 'https://x.test/r'
+        && partial?.status === 400 && full?.status === 302 && field(after, 'details_submitted') === true
+        && ((field(after, 'individual') as Body)?.last_name === 'Grower') && ((banks.body as Body).data as Body[])[0]?.last4 === '6789';
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  }),
   // Completing a session fires checkout.session.completed (data.object = the completed
   // Session) and stores it in the Events API — the event most billing flows fulfill from.
   done('stripe.checkout.completed_event', 'checkout', 'Checkout completion emits checkout.session.completed with the session payload', 'api', 'core', () =>
     withRoot(async (h) => {
       const cs = await h({ m: 'POST', p: '/v1/checkout/sessions', b: 'mode=payment&success_url=https://x.test&line_items[0][price_data][currency]=usd&line_items[0][price_data][unit_amount]=2500&line_items[0][quantity]=1' });
       if (!ok(cs)) return false;
-      const completed = await h({ m: 'POST', p: `/v1/checkout/sessions/${id(cs)}`, b: 'status=complete' });
+      await h({ m: 'POST', p: `/c/pay/${id(cs)}`, b: 'email=pay%40twin.test&cardNumber=4242424242424242&cardExpiry=12%2F34&cardCvc=123&billingName=Twin&billingCountry=US&billingPostalCode=94105' });
+      const completed = await h({ m: 'GET', p: `/v1/checkout/sessions/${id(cs)}` });
       if (!ok(completed) || field(completed, 'status') !== 'complete') return false;
       const ev = await h({ m: 'GET', p: '/v1/events?type=checkout.session.completed' });
       const rows = ((ev.body as Body)?.data ?? []) as Body[];
@@ -1071,6 +2266,105 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
         && payload?.id === id(cs) && payload?.status === 'complete' && payload?.payment_status === 'paid';
     }),
   ),
+  // Stripe.js (stripe-js.ts): the @stripe/stripe-js loader injects or accepts a script whose src matches
+  // `/^https:\/\/js\.stripe\.com\/v3\/?(\?.*)?$/` or `/^https:\/\/js\.stripe\.com\/(v3|[a-z]+)\/stripe\.js(\?.*)?$/`
+  // (@stripe/stripe-js 7.x dist/index.mjs) and reads `Stripe.version` (3 for v3, else the train's name). Each such path the
+  // pack's js.stripe.com host claims is served a script defining Stripe with that version, and redirectToCheckout sends
+  // the page to the session's hosted page, checkout.stripe.com/c/pay/{id}.
+  done('stripe.js.loader', 'checkout', 'Stripe.js served at /v3, /v3/, /v3/stripe.js and /<train>/stripe.js; redirectToCheckout opens the hosted Checkout page', 'api', 'common', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'stp-js-'));
+    try {
+      const f = createStripeTwinFetch({ root });
+      const host = pack.hosts?.find((x) => 'host' in x && x.host === 'js.stripe.com');
+      const claims = (p: string) => !!host?.pathPattern && new RegExp(host.pathPattern).test(p);
+      const load = async (p: string): Promise<{ version: unknown; opened: string[] } | undefined> => {
+        const res = await f(new Request(`https://js.stripe.com${p}`));
+        if (res.status !== 200 || !claims(p)) return undefined;
+        const opened: string[] = [];
+        const win: Record<string, unknown> = { location: { assign: (u: string) => opened.push(u) } };
+        new Function('window', await res.text())(win);
+        const Stripe = win.Stripe as ((key: string) => { redirectToCheckout: (o: { sessionId: string }) => unknown }) & { version: unknown };
+        void Stripe('pk_test_twin').redirectToCheckout({ sessionId: 'cs_test_1' });
+        return { version: Stripe.version, opened };
+      };
+      const [v3, v3slash, v3file, basil] = [await load('/v3'), await load('/v3/'), await load('/v3/stripe.js'), await load('/basil/stripe.js')];
+      const other = await f(new Request('https://js.stripe.com/v3/other.js'));
+      return [v3, v3slash, v3file].every((x) => x?.version === 3) && basil?.version === 'basil'
+        && [v3, v3slash, v3file, basil].every((x) => x?.opened.length === 1 && x.opened[0] === 'https://checkout.stripe.com/c/pay/cs_test_1')
+        && other.status === 404;
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  }),
+  // The name customers see: the operator saves the business name on the Dashboard's Public details page
+  // (dashboard.stripe.com/settings/public), which is the platform account's business_profile.name ("The customer-facing
+  // business name", docs.stripe.com/api/accounts/object), and Checkout and the customer portal show it ("You can change a
+  // Checkout page's name by modifying the Business name field", docs.stripe.com/payments/checkout/customization/appearance).
+  done('stripe.dashboard.public_details', 'checkout', 'Dashboard Public details: the business name saved there is the account\'s business_profile.name, shown on Checkout and the customer portal', 'ui', 'common', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'stp-public-'));
+    try {
+      const f = createStripeTwinFetch({ root });
+      const api = async (method: string, path: string, body?: string, account?: string) => (await f(new Request(`http://stripe.test${path}`, { method, headers: { 'content-type': 'application/x-www-form-urlencoded', ...(account ? { 'stripe-account': account } : {}) }, ...(body ? { body } : {}) }))).json() as Promise<Body>;
+      const page = async (url: string) => (await f(new Request(url))).text();
+      const save = (name: string) => f(new Request('https://dashboard.stripe.com/settings/public', { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: new URLSearchParams({ business_name: name }).toString() }));
+      const cs = await api('POST', '/v1/checkout/sessions', 'mode=payment&success_url=https://x.test&cancel_url=https://x.test/c&line_items[0][price_data][currency]=usd&line_items[0][price_data][unit_amount]=2500&line_items[0][price_data][product_data][name]=Pro&line_items[0][quantity]=1');
+      const before = await page(`https://checkout.stripe.com/c/pay/${String(cs.id)}`);
+      const empty = await save('  ');
+      const saved = await save('Dub');
+      const form = await page('https://dashboard.stripe.com/settings/public');
+      const account = await api('GET', '/v1/account');
+      const checkout = await page(`https://checkout.stripe.com/c/pay/${String(cs.id)}`);
+      const cust = await api('POST', '/v1/customers', 'email=public@twin.test');
+      const bps = await api('POST', '/v1/billing_portal/sessions', `customer=${String(cust.id)}&return_url=https://x.test/account`);
+      const portal = await page(String(bps.url));
+      // a second save changes the name in place and keeps the account's other public details
+      await save('Dub Technologies');
+      const again = await api('GET', '/v1/account');
+      // each save is the account's update, the first included
+      const updated = ((await api('GET', '/v1/events?type=account.updated')).data as Body[] | undefined) ?? [];
+      // a session's own branding_settings.display_name wins; a direct charge's page shows the connected account's name
+      const line = 'mode=payment&success_url=https://x.test&line_items[0][price_data][currency]=usd&line_items[0][price_data][unit_amount]=900&line_items[0][price_data][product_data][name]=Fern&line_items[0][quantity]=1';
+      const branded = await page(String((await api('POST', '/v1/checkout/sessions', `${line}&branding_settings[display_name]=Dub Links`)).url));
+      const grower = await api('POST', '/v1/accounts', 'type=standard&country=US&business_profile[name]=Grower Co');
+      const directSession = await api('POST', '/v1/checkout/sessions', line, String(grower.id));
+      const direct = await page(String(directSession.url));
+      // the name is the page's only use of the account a session was made on: paying it keeps its events where they were
+      // (the twin makes a hosted page's payment on the platform's books), all of them together
+      await f(new Request(String(directSession.url), { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: 'email=fern%40x.test&cardNumber=4242424242424242&cardExpiry=12%2F34&cardCvc=123&billingName=Fern&billingCountry=US&billingPostalCode=94105' }));
+      const completedHere = ((((await api('GET', '/v1/events?type=checkout.session.completed')).data as Body[] | undefined) ?? [])).filter((e) => ((e.data as Body)?.object as Body)?.id === directSession.id);
+      const completedThere = ((await api('GET', '/v1/events?type=checkout.session.completed', undefined, String(grower.id))).data as Body[] | undefined) ?? [];
+      const behalf = await page(String((await api('POST', '/v1/billing_portal/sessions', `customer=${String(cust.id)}&return_url=https://x.test/account&on_behalf_of=${String(grower.id)}`)).url));
+      const subBehalf = await page(String((await api('POST', '/v1/checkout/sessions', `mode=subscription&success_url=https://x.test&line_items[0][price_data][currency]=usd&line_items[0][price_data][unit_amount]=900&line_items[0][price_data][recurring][interval]=month&line_items[0][price_data][product_data][name]=Fern&line_items[0][quantity]=1&subscription_data[on_behalf_of]=${String(grower.id)}`)).url));
+      const onBehalf = await page(String((await api('POST', '/v1/checkout/sessions', `${line}&payment_intent_data[on_behalf_of]=${String(grower.id)}&payment_intent_data[transfer_data][destination]=${String(grower.id)}`)).url));
+      const portalAsGrower = await page(String((await api('POST', '/v1/billing_portal/sessions', `customer=${String(cust.id)}&return_url=https://x.test/account`, String(grower.id))).url));
+      // the page's trailing-slash address posts to itself and comes back to itself
+      const slashed = await page('https://dashboard.stripe.com/settings/public/');
+      const slashSave = await f(new Request('https://dashboard.stripe.com/settings/public/', { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: 'business_name=Dub+Technologies' }));
+      const landed = new URL(slashSave.headers.get('location') ?? '', 'https://dashboard.stripe.com/settings/public/').pathname;
+      // the /_twin/account door, written first, starts the platform's record from the same default and is an update too
+      const door = createStripeTwinFetch({ root: join(root, 'door') });
+      await door(new Request('http://stripe.test/_twin/account', { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: 'settings[payouts][schedule][interval]=manual&business_profile[support_email]=help@dub.test' }));
+      // and a save on the page keeps the public details it does not show, as the door keeps the name the page saved
+      await door(new Request('https://dashboard.stripe.com/settings/public', { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: 'business_name=Dub' }));
+      await door(new Request('http://stripe.test/_twin/account', { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: 'business_profile[url]=https://dub.test' }));
+      const doorAccount = await (await door(new Request('http://stripe.test/v1/account'))).json() as Body;
+      const doorEvents = (((await (await door(new Request('http://stripe.test/v1/events?type=account.updated'))).json()) as Body).data as Body[] | undefined) ?? [];
+      const long = await save('x'.repeat(5001));
+      return before.includes('Twin Inc.') && !before.includes('Dub') && empty.status === 400 && saved.status === 303 && long.status === 400
+        && updated.length === 2 && branded.includes('Pay Dub Links') && direct.includes('Pay Grower Co') && completedHere.length === 1 && !completedHere[0]!.account && completedThere.length === 0 && !direct.includes('Dub Technologies') && behalf.includes('Return to Grower Co')
+        && saved.headers.get('location') === '?saved=1' && form.includes('value="Dub"') && !form.includes('action=')
+        && onBehalf.includes('Pay Grower Co') && subBehalf.includes('<div class="pay-merchant">Grower Co</div>') && portalAsGrower.includes('Return to Grower Co')
+        && slashed.includes('name="business_name"') && slashSave.status === 303 && landed === '/settings/public/'
+        && doorAccount.created === 1767225600 && (doorAccount.capabilities as Body)?.card_payments === 'active' && doorEvents.length === 3
+        && (doorAccount.business_profile as Body)?.support_email === 'help@dub.test' && (doorAccount.business_profile as Body)?.name === 'Dub' && (doorAccount.business_profile as Body)?.url === 'https://dub.test'
+        && (((doorAccount.settings as Body)?.payouts as Body)?.schedule as Body)?.interval === 'manual'
+        && (account.business_profile as Body)?.name === 'Dub' && account.id === 'acct_twin_self' && account.charges_enabled === true
+        && checkout.includes('<div class="pay-merchant">Dub</div>') && checkout.includes('Pay Dub') && !checkout.includes('Twin Inc.')
+        && portal.includes('Return to Dub') && portal.includes('<div class="portal-merchant">Dub</div>') && (again.business_profile as Body)?.name === 'Dub Technologies';
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  }),
   done('stripe.billing_portal.session', 'checkout', 'Billing Portal Session create (referential to customer)', 'api', 'common', () =>
     withRoot(async (h) => {
       const cust = await h({ m: 'POST', p: '/v1/customers', b: 'email=portal@twin.test' });
@@ -1078,6 +2372,34 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       return ok(bps) && field(bps, 'object') === 'billing_portal.session' && !!field(bps, 'url');
     }),
   ),
+  // The portal's payment method and invoices: the customer saves a new card (the default their subscription charges)
+  // and pays the open invoice a declined renewal left, which makes the subscription active
+  // (docs.stripe.com/customer-management/configure-portal).
+  done('stripe.billing_portal.payment_method_and_pay', 'checkout', 'Billing Portal: update the payment method and pay an open invoice', 'api', 'common', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'stp-portal-'));
+    try {
+      // February's reads come two hours into the renewed period: its invoice is drafted at the period's end and charged
+      // "an hour on" (above; cab4389eb stamps each catch-up write at that moment), so a read at the period's very end
+      // sees the draft, not the paid invoice this claim is about
+      const h = (s: Step & { month?: number }) => handleStripeTwinRequest({ method: s.m, path: s.p, body: s.b, root, occurredAt: `2026-${String(s.month ?? 1).padStart(2, '0')}-10T${(s.month ?? 1) > 1 ? '02' : '00'}:00:00Z` });
+      const prod = await h({ m: 'POST', p: '/v1/products', b: 'name=Box' });
+      const price = await h({ m: 'POST', p: '/v1/prices', b: `unit_amount=3500&currency=usd&recurring[interval]=month&product=${id(prod)}` });
+      const cust = await h({ m: 'POST', p: '/v1/customers', b: 'email=portal-pay@twin.test' });
+      const sub = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(cust)}&items[0][price]=${id(price)}&default_payment_method=pm_card_chargeCustomerFail&trial_period_days=7` });
+      const open = (((await h({ m: 'GET', p: `/v1/invoices?subscription=${id(sub)}&status=open`, month: 2 })).body as Body).data as Body[])[0];
+      const bps = await h({ m: 'POST', p: '/v1/billing_portal/sessions', b: `customer=${id(cust)}`, month: 2 });
+      const flow = stripePortalFlow({ root, clock: () => '2026-02-10T00:00:00Z' });
+      const post = (to: string, form: Record<string, string>) => flow(new Request(`https://billing.stripe.com/p/session/${id(bps)}/${to}`, { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: new URLSearchParams(form).toString() }));
+      const saved = await post('payment_method', { cardNumber: '4242424242424242', cardExpiry: '12/34', cardCvc: '123', billingName: 'Twin', billingCountry: 'US', billingPostalCode: '94105' });
+      const paid = await post('pay', { invoice: String(open?.id) });
+      const after = await h({ m: 'GET', p: `/v1/subscriptions/${id(sub)}`, month: 2 });
+      const inv = await h({ m: 'GET', p: `/v1/invoices/${String(open?.id)}`, month: 2 });
+      return saved?.status === 303 && paid?.status === 303 && field(inv, 'status') === 'paid'
+        && field(after, 'status') === 'active' && field(after, 'default_payment_method') !== 'pm_card_chargeCustomerFail';
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  }),
   done('stripe.billing_portal.configuration', 'checkout', 'Billing Portal Configurations: create + retrieve + update + list', 'api', 'common', () =>
     withRoot(async (h) => {
       const c = await h({ m: 'POST', p: '/v1/billing_portal/configurations', b: 'business_profile[headline]=Hi&features[customer_update][enabled]=true' });
@@ -1087,8 +2409,6 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       return ok(g) && id(g) === id(c) && field(l, 'object') === 'list';
     }),
   ),
-  outOfScope('stripe.checkout.hosted_page', 'checkout', 'Hosted Checkout PAGE pixel rendering', 'ui', 'niche', 'Out of scope: the Session/API is modeled; the hosted PAGE pixels are out of scope.'),
-  outOfScope('stripe.billing_portal.hosted_page', 'checkout', 'Hosted Customer Portal PAGE pixel rendering', 'ui', 'niche', 'Out of scope: the Session/API is modeled; the hosted PAGE pixels are out of scope.'),
   // ── Payment Links / Quotes ────────────────────────────────────────────────────────
   // Payment Links: create (referential to a Price) → active link with a share url + line_items
@@ -1150,10 +2470,13 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       return ok(g) && ok(u) && ok(ll) && field(ll, 'object') === 'login_link' && ok(del) && field(del, 'deleted') === true;
     }),
   ),
-  done('stripe.connect.transfers', 'connect', 'Connect Transfers: create (referential to dest account) + retrieve + list', 'api', 'niche', () =>
+  done('stripe.connect.transfers', 'connect', 'Connect Transfers: to an account whose transfers capability is active, from the platform\'s balance + retrieve + list', 'api', 'niche', () =>
     withRoot(async (h) => {
-      const a = await h({ m: 'POST', p: '/v1/accounts', b: 'type=express' });
-      const t = await h({ m: 'POST', p: '/v1/transfers', b: `amount=500&currency=usd&destination=${id(a)}` });
+      const seller = await onboardedSeller(h);
+      // an account still onboarding cannot receive transfers
+      const fresh = await h({ m: 'POST', p: '/v1/accounts', b: 'type=express&capabilities[transfers][requested]=true' });
+      if ((await h({ m: 'POST', p: '/v1/transfers', b: `amount=500&currency=usd&destination=${id(fresh)}` })).status !== 400) return false;
+      const t = await h({ m: 'POST', p: '/v1/transfers', b: `amount=500&currency=usd&destination=${seller}` });
       if (!ok(t) || field(t, 'object') !== 'transfer') return false;
       const g = await h({ m: 'GET', p: `/v1/transfers/${id(t)}` });
       const l = await h({ m: 'GET', p: '/v1/transfers' });
@@ -1162,6 +2485,48 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       return ok(g) && field(l, 'object') === 'list' && bad.status >= 400;
     }),
   ),
+  // docs.stripe.com/connect/separate-charges-and-transfers, "Transfer availability": a transfer tied to a charge succeeds
+  // while the charge's funds are pending ("if the related charge hasn't settled yet"; once they have, it is held to the
+  // available balance), never takes more than the charge (less what was reversed of it), takes the charge's
+  // transfer_group over one the request names or, the charge having none, `group_` plus its PaymentIntent id, which the
+  // charge takes too, and pays the destination when the charge's funds become available. (Dub pays its partners this
+  // way: a card charge, then source_transaction.)
+  done('stripe.connect.transfer_source_transaction', 'connect', 'Connect Transfers from a charge\'s pending funds (source_transaction)', 'api', 'common', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'stp-src-'));
+    try {
+      const h = (s: Step & { acct?: string; day?: number }) => handleStripeTwinRequest({ method: s.m, path: s.p, body: s.b, root, occurredAt: `2026-06-${String(s.day ?? 1).padStart(2, '0')}T12:00:00Z`, ...(s.acct ? { stripeAccount: s.acct } : {}) });
+      const a = await h({ m: 'POST', p: '/v1/accounts', b: 'type=custom&country=US&capabilities[transfers][requested]=true&business_profile[mcc]=5462&business_profile[url]=https://seller.test&tos_acceptance[date]=1767225600&tos_acceptance[ip]=203.0.113.9&individual[first_name]=Sam&individual[last_name]=Seller&settings[payouts][schedule][interval]=manual' });
+      const seller = id(a);
+      await h({ m: 'POST', p: `/v1/accounts/${seller}/external_accounts`, b: 'external_account[object]=bank_account&external_account[country]=US&external_account[currency]=usd&external_account[routing_number]=110000000&external_account[account_number]=000123456789' });
+      await h({ m: 'POST', p: '/_twin/account', b: 'settings[payouts][schedule][interval]=manual' });
+      const pi = await h({ m: 'POST', p: '/v1/payment_intents', b: 'amount=2592&currency=usd&payment_method=pm_card_visa&confirm=true&transfer_group=inv_7' });
+      const charge = field(pi, 'latest_charge') as string;
+      const t = await h({ m: 'POST', p: '/v1/transfers', b: `amount=2400&currency=usd&destination=${seller}&source_transaction=${charge}&transfer_group=mine` });
+      const over = await h({ m: 'POST', p: '/v1/transfers', b: `amount=500&currency=usd&destination=${seller}&source_transaction=${charge}` });
+      const sellerBalance = await h({ m: 'GET', p: '/v1/balance', acct: seller });
+      const pending = ((sellerBalance.body as Body).pending as Array<{ amount: number }> | undefined)?.[0]?.amount;
+      if (!ok(pi) || !ok(t) || field(t, 'source_transaction') !== charge || field(t, 'transfer_group') !== 'inv_7' || over.status !== 400 || pending !== 2400) return false;
+      // what was reversed of a transfer is room again
+      await h({ m: 'POST', p: `/v1/transfers/${id(t)}/reversals`, b: 'amount=400' });
+      const again = await h({ m: 'POST', p: '/v1/transfers', b: `amount=500&currency=usd&destination=${seller}&source_transaction=${charge}` });
+      // no transfer_group on the charge: group_ plus its PaymentIntent id, on the transfer and on the charge
+      const plain = await h({ m: 'POST', p: '/v1/payment_intents', b: 'amount=2000&currency=usd&payment_method=pm_card_visa&confirm=true' });
+      const plainCharge = field(plain, 'latest_charge') as string;
+      const grouped = await h({ m: 'POST', p: '/v1/transfers', b: `amount=500&currency=usd&destination=${seller}&source_transaction=${plainCharge}` });
+      const chargeAfter = await h({ m: 'GET', p: `/v1/charges/${plainCharge}` });
+      if (!ok(again) || field(grouped, 'transfer_group') !== `group_${id(plain)}` || field(chargeAfter, 'transfer_group') !== `group_${id(plain)}`) return false;
+      // day 5: both charges have settled, so a transfer from one is held to the platform's available balance
+      // (2487 + 1912 − 2400 + 400 − 500 − 500 = 1399)
+      const tooMuch = await h({ m: 'POST', p: '/v1/transfers', b: `amount=1500&currency=usd&destination=${seller}&source_transaction=${plainCharge}`, day: 5 });
+      const fits = await h({ m: 'POST', p: '/v1/transfers', b: `amount=1000&currency=usd&destination=${seller}&source_transaction=${plainCharge}`, day: 5 });
+      // an authorization is no source of funds until it is captured (the twin's rule: the docs are silent)
+      const held = await h({ m: 'POST', p: '/v1/payment_intents', b: 'amount=900&currency=usd&capture_method=manual&payment_method=pm_card_visa&confirm=true', day: 5 });
+      const fromHold = await h({ m: 'POST', p: '/v1/transfers', b: `amount=100&currency=usd&destination=${seller}&source_transaction=${String(field(held, 'latest_charge'))}`, day: 5 });
+      const sellerAfter = (((await h({ m: 'GET', p: '/v1/transfers', day: 5 })).body as Body).data as Body[]) ?? [];
+      return tooMuch.status === 400 && ((tooMuch.body as Body).error as Body)?.code === 'balance_insufficient' && ok(fits)
+        && fromHold.status === 400 && !sellerAfter.some((x) => x.source_transaction === field(held, 'latest_charge'));
+    } finally { rmSync(root, { recursive: true, force: true }); }
+  }),
   // (account_links, persons, external_accounts, transfer_reversals, application_fees,
   // capabilities upgraded to done() in the AUDIT GROWTH block below.)
   // Connect payouts (Stripe-Account): a payout created WITH a Stripe-Account header is attributed
@@ -1171,8 +2536,10 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
     const root = mkdtempSync(join(tmpdir(), 'stp-cpo-'));
     try {
       const h = (s: Step & { acct?: string }) => handleStripeTwinRequest({ method: s.m, path: s.p, body: s.b, root, ...(s.acct ? { stripeAccount: s.acct } : {}) });
-      const acct = await h({ m: 'POST', p: '/v1/accounts', b: 'type=express&country=US' });
-      // a platform payout (no header) and a connected-account payout (with header).
+      const seller = await onboardedSeller(h);
+      const acct = { status: 200, body: { id: seller } } as StripeResponse;
+      await h({ m: 'POST', p: '/v1/transfers', b: `amount=3000&currency=usd&destination=${seller}` });
+      // a platform payout (no header) and a connected-account payout (with header), each from its own balance.
       const plat = await h({ m: 'POST', p: '/v1/payouts', b: 'amount=1000&currency=usd' });
       const conn = await h({ m: 'POST', p: '/v1/payouts', b: 'amount=2000&currency=usd', acct: id(acct) });
       if (!ok(plat) || !ok(conn)) return false;
@@ -1196,27 +2563,106 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   // Top-ups: POST /v1/topups funds the platform balance (amount + currency required); the twin
   // succeeds a test top-up immediately. retrieve/list/update round-trip; a succeeded top-up
   // cannot be canceled (400); missing money 400; unknown id 404.
-  done('stripe.connect.top_ups', 'connect', 'Top-ups (fund platform balance)', 'api', 'niche', () =>
-    withRoot(async (h) => {
+  // Connect webhooks (docs.stripe.com/connect/webhooks): an endpoint created with `connect` true receives the Connected
+  // accounts scope, one without it Your account; "Each event for a connected account contains a top-level `account`
+  // property that identifies the connected account". A write made as the account (the Stripe-Account header) and the
+  // account's own account.updated are its events; the platform's own writes are the platform's.
+  done('stripe.connect.webhook_scope', 'connect', 'Connect webhooks: a connected account\'s events reach only connect endpoints, with top-level account; the platform\'s only the others', 'api', 'common', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'stp-scope-'));
+    const rx = await webhookReceiver();
+    try {
+      const h = fetcher(createStripeTwinFetch({ root }));
+      await h('POST', '/v1/webhook_endpoints', `url=${rx.url('/platform')}&enabled_events[]=*`);
+      await h('POST', '/v1/webhook_endpoints', `url=${rx.url('/connect')}&enabled_events[]=*&connect=true`);
+      const seller = String((await h('POST', '/v1/accounts', 'type=express&country=US')).id);
+      // the account's own event: an update "Occurs whenever an account status or property has changed"
+      // (account.updated, docs.stripe.com/api/events/types). Its creation was asserted to send one when this claim was
+      // written (788199389), which no version of the twin did; an Express account's creation changes nothing Stripe
+      // reviews here (semantics/connect.ts review: an Express account is onboarded on Stripe's pages).
+      await h('POST', `/v1/accounts/${seller}`, 'metadata[tier]=gold');
+      const theirs = String((await h('POST', '/v1/customers', 'email=buyer@seller.test', seller)).id);
+      const ours = String((await h('POST', '/v1/customers', 'email=buyer@platform.test')).id);
+      const at = (path: string, type: string, object: string) => rx.got(path).filter((e) => e.type === type && (e.data.object as Body).id === object);
+      const theirsC = at('/connect', 'customer.created', theirs);
+      const oursP = at('/platform', 'customer.created', ours);
+      return theirsC.length === 1 && theirsC[0]!.account === seller && at('/platform', 'customer.created', theirs).length === 0
+        && oursP.length === 1 && !('account' in oursP[0]!) && at('/connect', 'customer.created', ours).length === 0
+        && rx.got('/connect').some((e) => e.type === 'account.updated' && e.account === seller)
+        && !rx.got('/platform').some((e) => e.type === 'account.updated');
+    } finally {
+      rx.close();
+      rmSync(root, { recursive: true, force: true });
+    }
+  }),
+  // A connected account's event is its own even when no request acted as it: the automatic payout World time makes for
+  // it (semantics/balance.ts) goes to connect endpoints with `account`. The Events API answers each account its own
+  // events: with the Stripe-Account header that account's, without it the platform's (semantics/webhook-endpoints.ts).
+  done('stripe.connect.event_scope', 'connect', 'A connected account\'s automatic payout event is scoped to it; the Events API lists and retrieves per account', 'api', 'common', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'stp-evscope-'));
+    const rx = await webhookReceiver();
+    try {
+      let now = '2026-06-01T12:00:00.000Z';
+      const h = fetcher(createStripeTwinFetch({ root, clock: () => now }));
+      await h('POST', '/v1/webhook_endpoints', `url=${rx.url('/platform')}&enabled_events[]=*`);
+      await h('POST', '/v1/webhook_endpoints', `url=${rx.url('/connect')}&enabled_events[]=*&connect=true`);
+      const seller = String((await h('POST', '/v1/accounts', 'type=custom&country=US&capabilities[transfers][requested]=true&business_profile[mcc]=5462&business_profile[url]=https://seller.test&tos_acceptance[date]=1767225600&tos_acceptance[ip]=203.0.113.9&individual[first_name]=Sam&individual[last_name]=Seller')).id);
+      await h('POST', `/v1/accounts/${seller}/external_accounts`, 'external_account[object]=bank_account&external_account[country]=US&external_account[currency]=usd&external_account[routing_number]=110000000&external_account[account_number]=000123456789');
+      await h('POST', '/v1/charges', 'amount=100000&currency=usd&source=tok_bypassPending');
+      await h('POST', '/v1/transfers', `amount=5000&currency=usd&destination=${seller}`);
+      now = '2026-06-03T12:00:00.000Z';
+      await h('GET', '/v1/balance');
+      const theirPayout = rx.got('/connect').find((e) => e.type === 'payout.created');
+      if (theirPayout?.account !== seller || (theirPayout.data.object as Body).amount !== 5000) return false;
+      if (rx.got('/platform').some((e) => e.type === 'payout.created' && (e.data.object as Body).id === (theirPayout.data.object as Body).id)) return false;
+      const theirs = ((await h('GET', '/v1/events?limit=100', undefined, seller)).data as Body[]) ?? [];
+      const ours = ((await h('GET', '/v1/events?limit=100')).data as Body[]) ?? [];
+      const listed = theirs.find((e) => e.type === 'payout.created');
+      const hidden = await h('GET', `/v1/events/${String(listed?.id)}`);
+      const shown = await h('GET', `/v1/events/${String(listed?.id)}`, undefined, seller);
+      return theirs.length > 0 && theirs.every((e) => e.account === seller) && listed !== undefined
+        && ours.length > 0 && ours.every((e) => !('account' in e)) && ours.some((e) => e.type === 'transfer.created')
+        && (hidden.error as Body | undefined)?.code === 'resource_missing' && shown.id === listed.id && shown.account === seller;
+    } finally {
+      rx.close();
+      rmSync(root, { recursive: true, force: true });
+    }
+  }),
+  // A top-up is pending until its funds arrive five days on ("USA (USD) ACH Debit Transfer 5 days",
+  // docs.stripe.com/connect/top-ups; semantics/terminal.ts, c3519a064), and only a pending one can be canceled; a
+  // succeeded one cannot. The verify runs on a World clock it moves, so the arrival is chosen, not waited for.
+  done('stripe.connect.top_ups', 'connect', 'Top-ups (fund platform balance)', 'api', 'niche', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'stp-topup-'));
+    try {
+      const h = (s: Step & { day?: number }) => handleStripeTwinRequest({ method: s.m, path: s.p, body: s.b, root, occurredAt: `2026-06-${String(s.day ?? 1).padStart(2, '0')}T12:00:00Z` });
       const tu = await h({ m: 'POST', p: '/v1/topups', b: 'amount=50000&currency=usd&statement_descriptor=Top up' });
-      if (!ok(tu) || field(tu, 'object') !== 'topup' || field(tu, 'status') !== 'succeeded') return false;
+      if (!ok(tu) || field(tu, 'object') !== 'topup' || field(tu, 'status') !== 'pending' || field(tu, 'expected_availability_date') !== Number(field(tu, 'created')) + 5 * 86_400) return false;
       const g = await h({ m: 'GET', p: `/v1/topups/${id(tu)}` });
       const u = await h({ m: 'POST', p: `/v1/topups/${id(tu)}`, b: 'metadata[ref]=q3' });
-      const l = await h({ m: 'GET', p: '/v1/topups?status=succeeded' });
-      // a succeeded top-up cannot be canceled.
-      const cancel = await h({ m: 'POST', p: `/v1/topups/${id(tu)}/cancel` });
+      const pendingList = await h({ m: 'GET', p: '/v1/topups?status=pending' });
+      // a second one, canceled while it is still pending
+      const other = await h({ m: 'POST', p: '/v1/topups', b: 'amount=100&currency=usd' });
+      const canceled = await h({ m: 'POST', p: `/v1/topups/${id(other)}/cancel` });
+      // six days on the first has arrived: succeeded, and past canceling
+      const arrived = await h({ m: 'GET', p: `/v1/topups/${id(tu)}`, day: 7 });
+      const l = await h({ m: 'GET', p: '/v1/topups?status=succeeded', day: 7 });
+      const cancel = await h({ m: 'POST', p: `/v1/topups/${id(tu)}/cancel`, day: 7 });
       const noMoney = await h({ m: 'POST', p: '/v1/topups', b: 'currency=usd' });
       const nope = await h({ m: 'GET', p: '/v1/topups/tu_nope' });
-      return ok(g) && id(g) === id(tu) && ok(u) && ((l.body as Body).data as Body[]).length === 1 &&
-        cancel.status === 400 && noMoney.status === 400 && nope.status === 404;
-    }),
-  ),
+      return ok(g) && id(g) === id(tu) && ok(u) && ((pendingList.body as Body).data as Body[]).length === 1
+        && ok(canceled) && field(canceled, 'status') === 'canceled'
+        && field(arrived, 'status') === 'succeeded' && typeof field(arrived, 'balance_transaction') === 'string'
+        && ((l.body as Body).data as Body[]).length === 1 && cancel.status === 400 && noMoney.status === 400 && nope.status === 404;
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  }),
   // ── Identity / Files ──────────────────────────────────────────────────────────────
   done('stripe.identity.verification_sessions', 'identity', 'Identity VerificationSessions: create + retrieve', 'api', 'niche', () =>
     withRoot(async (h) => {
       const v = await h({ m: 'POST', p: '/v1/identity/verification_sessions', b: 'type=document' });
-      if (!ok(v) || field(v, 'object') !== 'verification_session') return false;
+      // the object is named by its namespace: "object": "identity.verification_session" (docs.stripe.com/api/identity/verification_sessions/object)
+      if (!ok(v) || field(v, 'object') !== 'identity.verification_session' || field(v, 'status') !== 'requires_input') return false;
       const g = await h({ m: 'GET', p: `/v1/identity/verification_sessions/${id(v)}` });
       return ok(g) && id(g) === id(v);
     }),
@@ -1226,19 +2672,24 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   // the old fabricating path returned 200 for a missing file and would fail this assertion.
   done('stripe.file_links.create', 'files', 'FileLinks: create (requires file)', 'api', 'niche', () =>
     withRoot(async (h) => {
-      const f = await h({ m: 'POST', p: '/v1/file_links', b: 'file=file_twin' });
-      if (!ok(f) || field(f, 'object') !== 'file_link' || field(f, 'file') !== 'file_twin') return false;
+      const up = await h({ m: 'POST', p: '/v1/files', b: 'purpose=dispute_evidence&file=evidence.png' });
+      const f = await h({ m: 'POST', p: '/v1/file_links', b: `file=${id(up)}` });
+      if (!ok(f) || field(f, 'object') !== 'file_link' || field(f, 'file') !== id(up)) return false;
+      // a file of a purpose the link's file parameter does not list is refused
+      const logo = await h({ m: 'POST', p: '/v1/files', b: 'purpose=issuing_logo&file=logo.png' });
+      if ((await h({ m: 'POST', p: '/v1/file_links', b: `file=${id(logo)}` })).status !== 400) return false;
       const missing = await h({ m: 'POST', p: '/v1/file_links', b: 'expires_at=0' });
       return missing.status === 400 && ((missing.body as Body).error as Body)?.code === 'parameter_missing';
     }),
   ),
   // (files.upload upgraded to done() in the AUDIT GROWTH block below.)
-  // Identity VerificationReports: materialize from a verified session (test helper
-  // POST .../verify), then list (filterable by verification_session) + retrieve. Unknown id 404.
+  // Identity VerificationReports: the person verifies on verify.stripe.com, which makes the report; then list
+  // (filterable by verification_session) + retrieve. Unknown id 404.
   done('stripe.identity.verification_reports', 'identity', 'Identity VerificationReports', 'api', 'niche', () =>
-    withRoot(async (h) => {
+    withRoot(async (h, root) => {
       const vs = await h({ m: 'POST', p: '/v1/identity/verification_sessions', b: 'type=document' });
-      const ver = await h({ m: 'POST', p: `/v1/identity/verification_sessions/${id(vs)}/verify` });
+      await hostedSubmit(root, stripeIdentityFlow, `https://verify.stripe.com/start/${id(vs)}`, { outcome: 'verified' });
+      const ver = await h({ m: 'GET', p: `/v1/identity/verification_sessions/${id(vs)}` });
       if (!ok(ver) || field(ver, 'status') !== 'verified') return false;
       const reportId = field(ver, 'last_verification_report') as string;
       if (!reportId?.startsWith('vr_')) return false;
@@ -1253,10 +2704,12 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   ),
   // ── Events / Webhooks / Idempotency ───────────────────────────────────────────────
-  done('stripe.events.list', 'events', 'Events: create + retrieve + list', 'api', 'core', () =>
+  done('stripe.events.list', 'events', 'Events: a write records its event; retrieve + list', 'api', 'core', () =>
     withRoot(async (h) => {
-      const e = await h({ m: 'POST', p: '/v1/events', b: 'type=twin.synthetic' });
-      if (!ok(e) || field(e, 'object') !== 'event') return false;
+      await h({ m: 'POST', p: '/v1/customers', b: 'email=events@twin.test' });
+      const first = (((await h({ m: 'GET', p: '/v1/events' })).body as Body).data as Body[])[0]!;
+      const e = { status: 200, body: first } as StripeResponse;
+      if (field(e, 'object') !== 'event' || field(e, 'type') !== 'customer.created') return false;
       const g = await h({ m: 'GET', p: `/v1/events/${id(e)}` });
       const l = await h({ m: 'GET', p: '/v1/events' });
       return ok(g) && id(g) === id(e) && field(l, 'object') === 'list';
@@ -1284,7 +2737,17 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
         if (!report.ok || posts.length !== 1) return false;
         // verified with the same scheme stripe.webhooks.constructEvent implements
         const evt = constructEvent(posts[0]!.body, posts[0]!.headers['stripe-signature']!, secret);
-        if (evt.type !== 'invoice.paid' || (evt.data.object as Body).id !== id(inv)) return false;
+        if (evt.type !== 'invoice.paid' || (evt.data.object as Body).id !== id(inv) || 'account' in evt) return false;
+        // a connected account's object re-fires as its event: a payout kept on its books carries the account
+        // (at noon: an automatic payout, made at midnight, would take the funds first)
+        const noon = (m: string, p: string, b?: string, acct?: string) => handleStripeTwinRequest({ method: m, path: p, body: b, root, occurredAt: '2026-08-01T12:00:00Z', ...(acct ? { stripeAccount: acct } : {}) });
+        const seller = await onboardedSeller((s) => noon(s.m, s.p, s.b));
+        await noon('POST', '/v1/transfers', `amount=5000&currency=usd&destination=${seller}`);
+        const po = await noon('POST', '/v1/payouts', 'amount=4000&currency=usd', seller);
+        await H('POST', '/v1/webhook_endpoints', `url=${encodeURIComponent('http://127.0.0.1:1/connect')}&enabled_events[0]=payout.*&connect=true`);
+        const scoped: string[] = [];
+        await emitTwinEvent(stripeEmitter, { type: 'payout.created', subjectId: id(po), root, fetchFn: async (_url, init) => { scoped.push(init.body); return { status: 200 }; } });
+        if (scoped.length === 0 || !scoped.every((b) => (JSON.parse(b) as Body).account === seller)) return false;
         // unknown subject → LOUD, listing what exists
         return await emitTwinEvent(stripeEmitter, { type: 'invoice.paid', subjectId: 'in_twin_999', root }).then(() => false, (e: unknown) => /no invoice "in_twin_999"/.test(String(e)));
       });
@@ -1412,7 +2875,7 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
     withRoot(async (h) => {
       const cus = await h({ m: 'POST', p: '/v1/customers', b: 'email=ev@example.com' });
       if (!ok(cus)) return false;
-      const pi = await h({ m: 'POST', p: '/v1/payment_intents', b: 'amount=2000&currency=usd' });
+      const pi = await h({ m: 'POST', p: '/v1/payment_intents', b: 'amount=2000&currency=usd&transfer_group=inv_42' });
       const conf = await h({ m: 'POST', p: `/v1/payment_intents/${id(pi)}/confirm`, b: 'payment_method=pm_card_visa' });
       const pm = await h({ m: 'POST', p: '/v1/payment_methods', b: 'type=card&card[number]=4242424242424242&card[exp_month]=4&card[exp_year]=2030' });
       const att = await h({ m: 'POST', p: `/v1/payment_methods/${id(pm)}/attach`, b: `customer=${id(cus)}` });
@@ -1421,8 +2884,11 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       if (!ok(list) || (list.body as Body).object !== 'list') return false;
       const events = (list.body as Body).data as Array<Record<string, unknown>>;
       const types = new Set(events.map((e) => e.type as string));
-      const wanted = ['customer.created', 'payment_intent.created', 'payment_intent.succeeded', 'payment_method.attached'];
-      if (!wanted.every((t) => types.has(t))) return false;
+      const wanted = ['customer.created', 'payment_intent.created', 'payment_intent.succeeded', 'charge.succeeded', 'payment_method.attached'];
+      if (!wanted.every((t) => types.has(t)) || types.has('charge.created')) return false;
+      // the payment's charge is the event's object and carries the intent's transfer_group (Dub reads its payout invoice from it)
+      const charged = (events.find((e) => e.type === 'charge.succeeded')?.data as Body)?.object as Body | undefined;
+      if (charged?.object !== 'charge' || charged.payment_intent !== id(pi) || charged.transfer_group !== 'inv_42') return false;
       // envelope shape: object 'event', carries the resource snapshot under data.object
       const succeeded = events.find((e) => e.type === 'payment_intent.succeeded');
       if (!succeeded || succeeded.object !== 'event' || ((succeeded.data as Body)?.object as Body)?.status !== 'succeeded') return false;
@@ -1447,8 +2913,8 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       const e1 = await h({ m: 'GET', p: `/v1/payment_intents/${id(pi)}?expand[]=customer` });
       if (!ok(e1) || ((field(e1, 'customer') as Body)?.object) !== 'customer' || (field(e1, 'customer') as Body)?.id !== id(cust)) return false;
       // a charge whose customer + payment_intent chain expands deeply (charge.payment_intent.customer).
-      const ch = await h({ m: 'POST', p: `/v1/charges`, b: `amount=1000&currency=usd&customer=${id(cust)}&payment_intent=${id(pi)}` });
-      const e2 = await h({ m: 'GET', p: `/v1/charges/${id(ch)}?expand[]=payment_intent.customer` });
+      const ch = await h({ m: 'POST', p: '/v1/payment_intents', b: `amount=1000&currency=usd&customer=${id(cust)}&payment_method=pm_card_visa&confirm=true` });
+      const e2 = await h({ m: 'GET', p: `/v1/charges/${String(field(ch, 'latest_charge'))}?expand[]=payment_intent.customer` });
       const expandedPi = field(e2, 'payment_intent') as Body;
       if (!expandedPi || expandedPi.object !== 'payment_intent' || (expandedPi.customer as Body)?.id !== id(cust)) return false;
       // list-level expand (expand[]=data.customer) expands the field on every row.
@@ -1511,54 +2977,63 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       const events = await handleStripeTwinRequest({ method: 'GET', path: '/v1/events', root });
       const ev = ((events.body as Body).data as Body[]).find((e) => e.type === 'payment_intent.created');
       if (!ev || ev.api_version !== '2022-11-15') return false;
-      // no version → the twin default.
+      // no version → the version the pack serves, its vendored spec's (stripe-version.ts SERVED_VERSION; "answers
+      // render in the served API version", 24e757f60), as a request that pins none gets the account's
       const pi2 = await handleStripeTwinRequest({ method: 'POST', path: '/v1/payment_intents', body: 'amount=500&currency=usd', root });
       const ev2 = (((await handleStripeTwinRequest({ method: 'GET', path: '/v1/events', root })).body as Body).data as Body[])
         .find((e) => e.type === 'payment_intent.created' && ((e.data as Body)?.object as Body)?.id === id(pi2));
-      return ev2 ? ev2.api_version === '2024-06-20' : false;
+      return ev2 ? ev2.api_version === SERVED_VERSION && SERVED_VERSION > '2025-03-31' : false;
     } catch (err) { if (isInfrastructureError(err)) throw harnessError('stripe.api.versioning', err); return false; } finally { rmSync(root, { recursive: true, force: true }); }
   }),
   // ── Test helpers ──────────────────────────────────────────────────────────────────
   // Test clocks: create a clock at a frozen_time, then advance it; advancing past a trialing
   // subscription's trial_end transitions that sub trialing→active (the real clock-tick effect).
-  // Advancing backwards 400s; missing frozen_time 400s; delete removes it. (the clock object +
-  // the trial→active transition on advance are produced ONLY by this feature.)
+  // Advancing backwards 400s; advancing while advancing 400s test_clock_not_ready; missing frozen_time 400s; delete
+  // removes it.
   done('stripe.test_clocks', 'test-helpers', 'Test clocks (advance time for subscription/invoice)', 'api', 'common', () =>
-    withRoot(async (h) => {
+    withRoot(async (h, root) => {
       const clock = await h({ m: 'POST', p: '/v1/test_helpers/test_clocks', b: 'frozen_time=1000&name=T' });
       if (!ok(clock) || field(clock, 'object') !== 'test_helpers.test_clock' || field(clock, 'frozen_time') !== 1000) return false;
-      // a trialing subscription whose trial_end is 5000.
-      const cust = await h({ m: 'POST', p: '/v1/customers', b: 'email=clock@twin.test' });
+      // a trialing subscription whose trial_end is 5000, for a customer ON the clock: a clock moves only what is attached
+      // to it ("create a customer with the test_clock parameter", docs.stripe.com/billing/testing/test-clocks/api-advanced-usage),
+      // and a trial_end is refused unless it is in the future (subscriptions.ts trialEndRefused) — for a clock's customer,
+      // the clock's future. The customer was left off the clock when this was written, which its 1970 trial_end cannot survive.
+      const cust = await h({ m: 'POST', p: '/v1/customers', b: `email=clock@twin.test&test_clock=${id(clock)}` });
       const sub = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(cust)}&trial_end=5000` });
       if (field(sub, 'status') !== 'trialing') return false;
-      // advancing PAST trial_end transitions the sub to active.
+      // advancing PAST trial_end: the clock advances for a few seconds (a second advance meanwhile is refused), then the
+      // trial has ended and the sub is active
       const adv = await h({ m: 'POST', p: `/v1/test_helpers/test_clocks/${id(clock)}/advance`, b: 'frozen_time=6000' });
-      if (!ok(adv) || field(adv, 'frozen_time') !== 6000) return false;
-      const subAfter = await h({ m: 'GET', p: `/v1/subscriptions/${id(sub)}` });
+      if (!ok(adv) || field(adv, 'status') !== 'advancing') return false;
+      const busy = await h({ m: 'POST', p: `/v1/test_helpers/test_clocks/${id(clock)}/advance`, b: 'frozen_time=7000' });
+      if (busy.status !== 400 || ((busy.body as Body).error as Body)?.code !== 'test_clock_not_ready') return false;
+      const later = new Date(Date.now() + 10_000).toISOString();
+      const subAfter = await handleStripeTwinRequest({ method: 'GET', path: `/v1/subscriptions/${id(sub)}`, root, occurredAt: later });
       if (field(subAfter, 'status') !== 'active') return false;
-      const back = await h({ m: 'POST', p: `/v1/test_helpers/test_clocks/${id(clock)}/advance`, b: 'frozen_time=1' });
+      const back = await handleStripeTwinRequest({ method: 'POST', path: `/v1/test_helpers/test_clocks/${id(clock)}/advance`, body: 'frozen_time=1', root, occurredAt: later });
       const noTime = await h({ m: 'POST', p: '/v1/test_helpers/test_clocks' });
       const del = await h({ m: 'DELETE', p: `/v1/test_helpers/test_clocks/${id(clock)}` });
       const gone = await h({ m: 'GET', p: `/v1/test_helpers/test_clocks/${id(clock)}` });
       return back.status === 400 && noTime.status === 400 && ok(del) && field(del, 'deleted') === true && gone.status === 404;
     }),
   ),
-  // Test-helper Issuing endpoints: fund_balance accrues the issuing balance; present an
+  // Issuing: a top-up to the Issuing balance funds it; the test-helper endpoints present an
   // authorization (the test-mode way to simulate card usage) → a 'pending' authorization
   // awaiting approve/decline; create_force_capture lands a settled transaction directly.
   // Missing required params 400; unknown card 400. (Exercised together with the issuing family.)
-  done('stripe.test_helpers.issuing', 'test-helpers', 'Test-helper endpoints (fund balance, present authorization)', 'api', 'niche', () =>
-    withRoot(async (h) => {
-      const fund = await h({ m: 'POST', p: '/v1/test_helpers/issuing/fund_balance', b: 'amount=100000&currency=usd' });
-      if (!ok(fund) || ((field(fund, 'issuing') as Body)?.available as Body[])[0]?.amount !== 100000) return false;
+  done('stripe.test_helpers.issuing', 'test-helpers', 'Test-helper endpoints (present authorization, force capture), on an Issuing balance a top-up funded', 'api', 'niche', () =>
+    withRoot(async (h, root) => {
+      const fund = await fundIssuing(root, 100000);
+      const bal = await h({ m: 'GET', p: '/v1/balance' });
+      if (!ok(fund) || ((field(bal, 'issuing') as Body)?.available as Body[])[0]?.amount !== 100000) return false;
       const ch = await h({ m: 'POST', p: '/v1/issuing/cardholders', b: 'name=Jane&type=individual&billing[address][line1]=1 Main&billing[address][city]=SF&billing[address][country]=US&billing[address][postal_code]=94105&billing[address][state]=CA' });
       const card = await h({ m: 'POST', p: `/v1/issuing/cards`, b: `cardholder=${id(ch)}&currency=usd&type=virtual` });
       const auth = await h({ m: 'POST', p: '/v1/test_helpers/issuing/authorizations', b: `card=${id(card)}&amount=2500` });
       if (!ok(auth) || field(auth, 'status') !== 'pending' || (field(auth, 'card') as Body)?.id !== id(card) || field(auth, 'cardholder') !== id(ch)) return false;
       const forced = await h({ m: 'POST', p: '/v1/test_helpers/issuing/transactions/create_force_capture', b: `card=${id(card)}&amount=1000` });
       if (!ok(forced) || field(forced, 'type') !== 'capture' || field(forced, 'amount') !== -1000) return false;
-      const noAmt = await h({ m: 'POST', p: '/v1/test_helpers/issuing/fund_balance', b: 'currency=usd' });
+      const noAmt = await h({ m: 'POST', p: '/v1/topups', b: 'currency=usd&destination_balance=issuing' });
       const badCard = await h({ m: 'POST', p: '/v1/test_helpers/issuing/authorizations', b: 'card=ic_nope&amount=100' });
       return noAmt.status === 400 && badCard.status === 400;
     }),
@@ -1611,20 +3086,18 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   // the running mirror server → render the mirror's OWN ListPane over both → assert one
   // list-row per seeded object carrying the seeded name. Failable: an empty workspace yields
   // zero rows → zero list-rows.
-  done('stripe.ui.tax', 'ui-dashboard', 'Dashboard: Tax (Tax Rates + Tax Calculations) screens (data-coupled)', 'ui', 'common', uiDataCoupled({
-    markers: ['Tax Rates', 'Tax Calculations', 'list-row'],
+  // Tax Rates only: Stripe publishes no list of tax calculations (a calculation is retrieved by id), so the mirror's
+  // Tax Calculations screen, which read the invented GET /v1/tax/calculations, left with it (5decb1d77).
+  done('stripe.ui.tax', 'ui-dashboard', 'Dashboard: Tax (Tax Rates) screen (data-coupled)', 'ui', 'common', uiDataCoupled({
+    markers: ['Tax Rates', 'list-row'],
     seed: async (h) => {
       await h({ m: 'POST', p: '/v1/tax_rates', b: 'display_name=UI Check Tax&percentage=12.5&inclusive=false&jurisdiction=US' });
-      await h({ m: 'POST', p: '/v1/tax/calculations', b: 'currency=usd&line_items[0][amount]=1000&line_items[0][reference]=ui_check_sku&customer_details[address][country]=US' });
     },
     check: async ({ get }) => {
       const rates = ((await get('/v1/tax_rates')).data as Body[]) as unknown as StripeRow[];
-      const calcs = ((await get('/v1/tax/calculations')).data as Body[]) as unknown as StripeRow[];
-      if (!rates.length || !calcs.length) return false;
+      if (!rates.length) return false;
       const ratesMarkup = renderSectionList('tax_rates', rates);
-      const calcsMarkup = renderSectionList('tax/calculations', calcs);
-      return listRows(ratesMarkup) === rates.length && ratesMarkup.includes('UI Check Tax') &&
-        listRows(calcsMarkup) === calcs.length;
+      return listRows(ratesMarkup) === rates.length && ratesMarkup.includes('UI Check Tax');
     },
   })),
@@ -1665,18 +3138,27 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
         ((l.body as Body).data as Body[]).length === 2 && badCh.status === 400 && badStatus.status === 400;
     }),
   ),
-  // Authorizations (+approve/decline): an authorization is PRESENTED via the test helper (pending),
-  // then /approve closes it (approved:true) AND materializes a captured transaction, or /decline
-  // closes it (approved:false). Acting on a finalized authorization 400s; unknown id 404.
+  // Authorizations (+approve/decline): an authorization is PRESENTED via the test helper (pending);
+  // /approve keeps it pending (approved:true, funds held) until the merchant's capture closes it and
+  // makes the transaction; /decline closes it (approved:false). Deciding twice 400s; unknown id 404.
   done('stripe.issuing.authorizations', 'issuing', 'Issuing Authorizations (+approve/decline)', 'api', 'niche', () =>
-    withRoot(async (h) => {
+    withRoot(async (h, root) => {
+      await fundIssuing(root, 10000000); // the Issuing balance authorizations are paid from
       const ch = await h({ m: 'POST', p: '/v1/issuing/cardholders', b: 'name=Jane&type=individual&billing[address][country]=US' });
       const card = await h({ m: 'POST', p: `/v1/issuing/cards`, b: `cardholder=${id(ch)}&currency=usd&type=virtual` });
+      // with no real-time endpoint an authorization is approved at once (card_active)
+      const plain = await h({ m: 'POST', p: '/v1/test_helpers/issuing/authorizations', b: `card=${id(card)}&amount=1000` });
+      if (field(plain, 'approved') !== true || ((field(plain, 'request_history') as Body[])?.[0] as Body | undefined)?.reason !== 'card_active') return false;
+      // an endpoint that does not answer leaves it pending for the deprecated approve and decline
+      await h({ m: 'POST', p: '/v1/webhook_endpoints', b: `url=${encodeURIComponent('https://rt.twin.test/auth')}&enabled_events[]=issuing_authorization.request` });
       const auth = await h({ m: 'POST', p: '/v1/test_helpers/issuing/authorizations', b: `card=${id(card)}&amount=3000` });
       if (field(auth, 'status') !== 'pending') return false;
       const appr = await h({ m: 'POST', p: `/v1/issuing/authorizations/${id(auth)}/approve` });
-      if (!ok(appr) || field(appr, 'status') !== 'closed' || field(appr, 'approved') !== true) return false;
-      // approve materialized a captured transaction.
+      if (!ok(appr) || field(appr, 'status') !== 'pending' || field(appr, 'approved') !== true) return false;
+      // nothing is transacted until the merchant captures
+      if ((((await h({ m: 'GET', p: '/v1/issuing/transactions' })).body as Body).data as Body[]).length !== 0) return false;
+      const cap = await h({ m: 'POST', p: `/v1/test_helpers/issuing/authorizations/${id(auth)}/capture` });
+      if (!ok(cap) || field(cap, 'status') !== 'closed') return false;
       const txns = await h({ m: 'GET', p: '/v1/issuing/transactions' });
       const txnData = (txns.body as Body).data as Body[];
       if (txnData.length !== 1 || txnData[0]!.authorization !== id(auth) || txnData[0]!.amount !== -3000) return false;
@@ -1696,13 +3178,20 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   // retrieved/updated and disputed. A dispute requires transaction + evidence[reason]; /submit
   // transitions unsubmitted→submitted; submitting twice 400s; unknown transaction 400.
   done('stripe.issuing.transactions', 'issuing', 'Issuing Transactions + disputes', 'api', 'niche', () =>
-    withRoot(async (h) => {
+    withRoot(async (h, root) => {
+      await fundIssuing(root, 10000000); // the Issuing balance authorizations are paid from
       const ch = await h({ m: 'POST', p: '/v1/issuing/cardholders', b: 'name=Jane&type=individual&billing[address][country]=US' });
       const card = await h({ m: 'POST', p: `/v1/issuing/cards`, b: `cardholder=${id(ch)}&currency=usd&type=virtual` });
+      // with no real-time webhook the authorization is approved at once ("If you don't have a real-time authorization
+      // webhook, we approve the authorization without sending the issuing_authorization.request",
+      // docs.stripe.com/issuing/purchases/authorizations), so the approve API refuses it as already decided; the merchant's
+      // capture (the test helper) is what makes the transaction
       const auth = await h({ m: 'POST', p: '/v1/test_helpers/issuing/authorizations', b: `card=${id(card)}&amount=4200` });
-      await h({ m: 'POST', p: `/v1/issuing/authorizations/${id(auth)}/approve` });
+      if (field(auth, 'approved') !== true || (await h({ m: 'POST', p: `/v1/issuing/authorizations/${id(auth)}/approve` })).status !== 400) return false;
+      await h({ m: 'POST', p: `/v1/test_helpers/issuing/authorizations/${id(auth)}/capture` });
       const txns = await h({ m: 'GET', p: '/v1/issuing/transactions' });
       const txn = ((txns.body as Body).data as Body[])[0]!;
+      if (((txns.body as Body).data as Body[]).length !== 1 || txn.amount !== -4200 || txn.authorization !== id(auth)) return false;
       const g = await h({ m: 'GET', p: `/v1/issuing/transactions/${txn.id}` });
       if (!ok(g) || field(g, 'object') !== 'issuing.transaction') return false;
       const u = await h({ m: 'POST', p: `/v1/issuing/transactions/${txn.id}`, b: 'metadata[note]=checked' });
@@ -1729,6 +3218,7 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
     const root = mkdtempSync(join(tmpdir(), 'stp-cap-'));
     try {
       const h = (s: Step) => handleStripeTwinRequest({ method: s.m, path: s.p, body: s.b, root, occurredAt: '2026-06-14T00:00:00Z' });
+      await fundIssuing(root, 10000000, '2026-06-14T00:00:00Z'); // the Issuing balance authorizations are paid from
       const delivered: StripeEvent[] = [];
       setStripeEventDelivery((_url, event) => {
         delivered.push(event);
@@ -1759,6 +3249,9 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       const root2 = mkdtempSync(join(tmpdir(), 'stp-cap-'));
       try {
         const h2 = (s: Step) => handleStripeTwinRequest({ method: s.m, path: s.p, body: s.b, root: root2, occurredAt: '2026-06-14T00:00:00Z' });
+        // funded as the first World is: an authorization the Issuing balance cannot cover is declined insufficient_funds
+        // (docs.stripe.com/issuing/funding/balance), which would decide it before any endpoint could be consulted
+        await fundIssuing(root2, 10000000, '2026-06-14T00:00:00Z');
         let consulted = false;
         setStripeEventDelivery((_url, event) => {
           if (event.type === 'issuing_authorization.request') consulted = true;
@@ -1767,8 +3260,14 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
         const ch2 = await h2({ m: 'POST', p: '/v1/issuing/cardholders', b: 'name=RT2&type=individual&billing[address][country]=US' });
         const card2 = await h2({ m: 'POST', p: '/v1/issuing/cards', b: `cardholder=${id(ch2)}&currency=usd&type=virtual` });
         await h2({ m: 'POST', p: '/v1/webhook_endpoints', b: `url=${encodeURIComponent('https://other.twin.test/hook')}&enabled_events[]=invoice.paid` });
+        // ...and, not enrolled, it is approved at once by the account's default settings: "If you don't have a real-time
+        // authorization webhook, we approve the authorization without sending the issuing_authorization.request"
+        // (docs.stripe.com/issuing/purchases/authorizations; semantics/issuing.ts, reason card_active). It used to stay
+        // pending for the approve API, which is the deprecated path.
         const auth2 = await h2({ m: 'POST', p: '/v1/test_helpers/issuing/authorizations', b: `card=${id(card2)}&amount=100` });
-        return !consulted && field(auth2, 'status') === 'pending' && field(auth2, 'approved') === false;
+        const history2 = (field(auth2, 'request_history') as Body[] | undefined) ?? [];
+        return !consulted && field(auth2, 'status') === 'pending' && field(auth2, 'approved') === true
+          && history2.length === 1 && history2[0]!.reason === 'card_active';
       } finally {
         rmSync(root2, { recursive: true, force: true });
       }
@@ -1781,15 +3280,16 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       rmSync(root, { recursive: true, force: true });
     }
   }),
-  // Real-time authorization fallbacks (the 2s-window posture, fail-closed): a webhook
-  // decline closes the authorization (reason webhook_declined); a TIMEOUT declines with
-  // reason webhook_timeout; an invalid response (non-2xx, non-JSON, missing `approved`)
+  // Real-time authorization fallbacks (the 2s window): a webhook decline closes the
+  // authorization (reason webhook_declined); a TIMEOUT leaves it pending for the deprecated
+  // approve/decline until the window ends, then declines it with reason webhook_timeout; an invalid response (non-2xx, non-JSON, missing `approved`)
   // declines with reason webhook_error + a reason_message; a partial `amount` in the
   // response is held ONLY when the presentment was is_amount_controllable.
-  done('stripe.issuing.realtime_auth_fallbacks', 'issuing', 'Real-time authorization: decline honored; timeout → webhook_timeout; invalid response → webhook_error; partial amount only when controllable', 'api', 'niche', async () => {
+  done('stripe.issuing.realtime_auth_fallbacks', 'issuing', 'Real-time authorization: decline honored; unanswered → pending, approve in the window, webhook_timeout after it; invalid response → webhook_error; partial amount only when controllable', 'api', 'niche', async () => {
     const root = mkdtempSync(join(tmpdir(), 'stp-cap-'));
     try {
       const h = (s: Step) => handleStripeTwinRequest({ method: s.m, path: s.p, body: s.b, root, occurredAt: '2026-06-14T00:00:00Z' });
+      await fundIssuing(root, 10000000, '2026-06-14T00:00:00Z'); // the Issuing balance authorizations are paid from
       const ch = await h({ m: 'POST', p: '/v1/issuing/cardholders', b: 'name=FB&type=individual&billing[address][country]=US' });
       const card = await h({ m: 'POST', p: '/v1/issuing/cards', b: `cardholder=${id(ch)}&currency=usd&type=virtual` });
       await h({ m: 'POST', p: '/v1/webhook_endpoints', b: `url=${encodeURIComponent('https://rt.twin.test/auth')}&enabled_events[]=issuing_authorization.request` });
@@ -1805,10 +3305,17 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       respond({ status: 200, body: '{"approved":false}' });
       const dec = await present(`card=${id(card)}&amount=900`);
       if (field(dec, 'approved') !== false || field(dec, 'status') !== 'closed' || reasonOf(dec).reason !== 'webhook_declined') return false;
-      // timeout → webhook_timeout (the exact TimeoutError AbortSignal.timeout raises)
+      // an unanswered request (the exact TimeoutError AbortSignal.timeout raises) is no decision: pending with its request
       respond(() => { const e = new Error('timed out'); e.name = 'TimeoutError'; throw e; });
       const to = await present(`card=${id(card)}&amount=900`);
-      if (field(to, 'approved') !== false || reasonOf(to).reason !== 'webhook_timeout') return false;
+      if (field(to, 'status') !== 'pending' || field(to, 'approved') !== false || !field(to, 'pending_request')) return false;
+      // the deprecated approve inside the window decides it
+      const held = await present(`card=${id(card)}&amount=800`);
+      const approved = await h({ m: 'POST', p: `/v1/issuing/authorizations/${id(held)}/approve` });
+      if (field(approved, 'approved') !== true || reasonOf(approved).reason !== 'webhook_approved') return false;
+      // once the 2-second window has passed, the one left unanswered is declined with reason webhook_timeout
+      const later = await handleStripeTwinRequest({ method: 'GET', path: `/v1/issuing/authorizations/${id(to)}`, root, occurredAt: '2026-06-14T00:00:03Z' });
+      if (field(later, 'status') !== 'closed' || field(later, 'approved') !== false || reasonOf(later).reason !== 'webhook_timeout') return false;
       // invalid responses → webhook_error with a reason_message
       for (const bad of [{ status: 500, body: 'oops' }, { status: 200, body: 'not-json' }, { status: 200, body: '{"ok":true}' }]) {
         respond(bad);
@@ -1838,6 +3345,7 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
     const root = mkdtempSync(join(tmpdir(), 'stp-cap-'));
     try {
       const h = (s: Step) => handleStripeTwinRequest({ method: s.m, path: s.p, body: s.b, root, occurredAt: '2026-06-14T00:00:00Z' });
+      await fundIssuing(root, 10000000, '2026-06-14T00:00:00Z'); // the Issuing balance authorizations are paid from
       setStripeEventDelivery((_url, event) => {
         if (event.type === 'issuing_authorization.request') return { status: 200, body: '{"approved":true}' };
       });
@@ -1876,7 +3384,7 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       rmSync(root, { recursive: true, force: true });
     }
   }),
-  // Capture debits the issuing balance: fund_balance accrues the float, a webhook-approved
+  // Capture debits the issuing balance: a top-up to Issuing funds the float, a webhook-approved
   // authorization is captured via POST /v1/test_helpers/issuing/authorizations/:id/capture
   // (partial capture_amount honored, refused above the held amount / on a non-approved or
   // closed authorization), the materialized transaction is type 'capture' with a NEGATIVE
@@ -1897,8 +3405,7 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       const ch = await h({ m: 'POST', p: '/v1/issuing/cardholders', b: 'name=Cap&type=individual&billing[address][country]=US' });
       const card = await h({ m: 'POST', p: '/v1/issuing/cards', b: `cardholder=${id(ch)}&currency=usd&type=virtual` });
       await h({ m: 'POST', p: '/v1/webhook_endpoints', b: `url=${encodeURIComponent('https://rt.twin.test/auth')}&enabled_events[]=issuing_authorization.request` });
-      const fund = await h({ m: 'POST', p: '/v1/test_helpers/issuing/fund_balance', b: 'amount=100000&currency=usd' });
-      if (((field(fund, 'issuing') as Body).available as Body[])[0]!.amount !== 100000) return false;
+      await fundIssuing(root, 100000, '2026-06-14T00:00:00Z');
       if (await issuingAvailable() !== 100000) return false;
       const auth = await h({ m: 'POST', p: '/v1/test_helpers/issuing/authorizations', b: `card=${id(card)}&amount=30000` });
       if (field(auth, 'approved') !== true) return false;
@@ -1941,6 +3448,29 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   // Readers (+process_payment_intent): a reader registers with a registration_code (status
   // 'online'); handing it a PaymentIntent sets reader.action to process_payment_intent
   // in_progress; cancel_action clears it. Connection tokens mint a secret. Missing code 400.
+  // A simulated reader processing a PaymentIntent is presented a card by the test helper: the intent is paid and the
+  // reader's action succeeds (docs.stripe.com/api/terminal/readers/present_payment_method).
+  done('stripe.terminal.present_payment_method', 'terminal', 'Terminal test helper: present a card to a reader processing a PaymentIntent', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const loc = await h({ m: 'POST', p: '/v1/terminal/locations', b: 'display_name=Market&address[line1]=1 Main&address[city]=Portland&address[state]=OR&address[postal_code]=97201&address[country]=US' });
+      const rdr = await h({ m: 'POST', p: '/v1/terminal/readers', b: `registration_code=simulated-wpe&location=${id(loc)}` });
+      const pi = await h({ m: 'POST', p: '/v1/payment_intents', b: 'amount=2400&currency=usd&allowed_payment_method_types[0]=card_present' });
+      await h({ m: 'POST', p: `/v1/terminal/readers/${id(rdr)}/process_payment_intent`, b: `payment_intent=${id(pi)}` });
+      const done = await h({ m: 'POST', p: `/v1/test_helpers/terminal/readers/${id(rdr)}/present_payment_method` });
+      const paid = await h({ m: 'GET', p: `/v1/payment_intents/${id(pi)}` });
+      // under manual capture the card holds the amount as an uncaptured charge, which the intent's capture takes
+      const held = await h({ m: 'POST', p: '/v1/payment_intents', b: 'amount=1800&currency=usd&capture_method=manual&allowed_payment_method_types[0]=card_present' });
+      await h({ m: 'POST', p: `/v1/terminal/readers/${id(rdr)}/process_payment_intent`, b: `payment_intent=${id(held)}` });
+      await h({ m: 'POST', p: `/v1/test_helpers/terminal/readers/${id(rdr)}/present_payment_method` });
+      const hold = await h({ m: 'GET', p: `/v1/payment_intents/${id(held)}` });
+      const auth = await h({ m: 'GET', p: `/v1/charges/${String(field(hold, 'latest_charge'))}` });
+      const cap = await h({ m: 'POST', p: `/v1/payment_intents/${id(held)}/capture` });
+      const taken = await h({ m: 'GET', p: `/v1/charges/${String(field(hold, 'latest_charge'))}` });
+      return ((field(done, 'action') as Body)?.status === 'succeeded') && field(paid, 'status') === 'succeeded' && typeof field(paid, 'latest_charge') === 'string'
+        && field(hold, 'status') === 'requires_capture' && field(auth, 'captured') === false && field(auth, 'amount') === 1800
+        && field(cap, 'latest_charge') === id(auth) && field(taken, 'captured') === true && field(taken, 'amount_captured') === 1800;
+    }),
+  ),
   done('stripe.terminal.readers', 'terminal', 'Terminal Readers (+process_payment_intent)', 'api', 'niche', () =>
     withRoot(async (h) => {
       const loc = await h({ m: 'POST', p: '/v1/terminal/locations', b: 'display_name=HQ&address[country]=US&address[line1]=1 Main&address[city]=SF&address[postal_code]=94105&address[state]=CA' });
@@ -1989,10 +3519,17 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   // not a public create). open is the only approvable state → /approve closes it (open:false,
   // closed_reason 'approved'); a second approve 400s. retrieve + list round-trip; unknown id 404.
   // (the open→closed approve transition is produced ONLY by this feature.)
+  // A review is opened by Radar, never by the API (Stripe's API has no review create; the twin's seeding route for it was
+  // removed with the invented endpoints, 5decb1d77): an elevated-risk card's charge is placed in review
+  // (docs.stripe.com/radar/reviews; the test card 4000000000009235, pm_card_riskLevelElevated, docs.stripe.com/testing).
   done('stripe.radar.reviews', 'radar', 'Radar Reviews (approve/list)', 'api', 'niche', () =>
     withRoot(async (h) => {
-      const rv = await h({ m: 'POST', p: '/v1/radar/reviews', b: 'charge=ch_twin&payment_intent=pi_twin' });
-      if (!ok(rv) || field(rv, 'object') !== 'review' || field(rv, 'open') !== true) return false;
+      const risky = await h({ m: 'POST', p: '/v1/payment_intents', b: 'amount=2000&currency=usd&payment_method=pm_card_riskLevelElevated&confirm=true' });
+      if (!ok(risky) || field(risky, 'status') !== 'succeeded') return false;
+      const opened = (((await h({ m: 'GET', p: '/v1/reviews' })).body as Body).data as Body[]) ?? [];
+      if (opened.length !== 1) return false;
+      const rv = await h({ m: 'GET', p: `/v1/reviews/${String(opened[0]!.id)}` });
+      if (!ok(rv) || field(rv, 'object') !== 'review' || field(rv, 'open') !== true || field(rv, 'payment_intent') !== id(risky)) return false;
       const g = await h({ m: 'GET', p: `/v1/reviews/${id(rv)}` });
       const l = await h({ m: 'GET', p: '/v1/reviews' });
       if (!ok(g) || id(g) !== id(rv) || field(l, 'object') !== 'list') return false;
@@ -2029,83 +3566,58 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
         noAlias.status === 400 && badList.status === 400 && noValue.status === 400;
     }),
   ),
-  // Radar Rules: create a custom rule (requires action ∈ {block,review,allow} + predicate),
-  // retrieve, list (filterable by action), delete. Missing action/predicate 400; bad action 400.
-  done('stripe.radar.rules', 'radar', 'Radar rules', 'api', 'niche', () =>
-    withRoot(async (h) => {
-      const rule = await h({ m: 'POST', p: '/v1/radar/rules', b: 'action=block&predicate=:risk_level: = "highest"' });
-      if (!ok(rule) || field(rule, 'object') !== 'radar.rule' || field(rule, 'action') !== 'block') return false;
-      const g = await h({ m: 'GET', p: `/v1/radar/rules/${id(rule)}` });
-      const l = await h({ m: 'GET', p: '/v1/radar/rules?action=block' });
-      if (!ok(g) || id(g) !== id(rule) || ((l.body as Body).data as Body[]).length !== 1) return false;
-      const del = await h({ m: 'DELETE', p: `/v1/radar/rules/${id(rule)}` });
-      const gone = await h({ m: 'GET', p: `/v1/radar/rules/${id(rule)}` });
-      const noAction = await h({ m: 'POST', p: '/v1/radar/rules', b: 'predicate=x' });
-      const badAction = await h({ m: 'POST', p: '/v1/radar/rules', b: 'action=nuke&predicate=x' });
-      const noPred = await h({ m: 'POST', p: '/v1/radar/rules', b: 'action=block' });
-      return ok(del) && field(del, 'deleted') === true && gone.status === 404 &&
-        noAction.status === 400 && badAction.status === 400 && noPred.status === 400;
-    }),
-  ),
-  // Dashboard: Radar (Reviews + Value Lists + Rules) screens — rendered surfaces in the mirror.
-  // Radar (Reviews + Value Lists + Rules) — RUNG-5 data-coupled: the three section markers are
-  // bundled (the screens are wired in) AND, for each of the three Radar collections, we seed
-  // real twin state (a review, a value-list + item, a rule), fetch the SAME /v1 endpoint the
-  // mirror's React client reads off the running mirror server, render the mirror's OWN ListPane
-  // component over those rows, and assert the rendered DOM emits exactly one `list-row` landmark
-  // per seeded object carrying that object's id. Failable: an empty workspace yields zero rows →
-  // zero list-rows → false; and a marker-only/hardcoded render could not surface the seeded ids.
-  done('stripe.ui.radar', 'ui-dashboard', 'Dashboard: Radar (Reviews + Value Lists + Rules) screens', 'ui', 'niche', uiDataCoupled({
-    markers: ['Radar Reviews', 'Radar Value Lists', 'Radar Rules', 'list-row'],
+  // Radar rules are not in Stripe's API: rules are written in the Dashboard (docs.stripe.com/radar/rules), and the
+  // published spec has no /v1/radar/rules. The twin's routes for them were invented and are gone (5decb1d77), so the
+  // `stripe.radar.rules` claim they carried is withdrawn rather than kept as a todo: it is not vendor API surface.
+  // Dashboard: Radar (Reviews + Value Lists) screens — RUNG-5 data-coupled: the section markers are bundled (the screens
+  // are wired in) AND, for each Radar collection, we seed real twin state (a review Radar opens on an elevated-risk
+  // charge, a value-list + item), fetch the SAME /v1 endpoint the mirror's React client reads off the running mirror
+  // server, render the mirror's OWN ListPane component over those rows, and assert the rendered DOM emits exactly one
+  // `list-row` landmark per seeded object carrying it. Failable: an empty workspace yields zero rows → false. The Rules
+  // screen left the mirror with the invented /v1/radar/rules it read (5decb1d77: "The Dashboard mirror no longer lists
+  // ... radar rules"), and the review is no longer seeded through the invented POST /v1/radar/reviews.
+  done('stripe.ui.radar', 'ui-dashboard', 'Dashboard: Radar (Reviews + Value Lists) screens', 'ui', 'niche', uiDataCoupled({
+    markers: ['Radar Reviews', 'Radar Value Lists', 'list-row'],
     seed: async (h) => {
-      // a flagged payment opens a Review; a value list + one item; one custom rule.
-      await h({ m: 'POST', p: '/v1/radar/reviews', b: 'charge=ch_radar_ui&payment_intent=pi_radar_ui' });
+      await h({ m: 'POST', p: '/v1/payment_intents', b: 'amount=2000&currency=usd&payment_method=pm_card_riskLevelElevated&confirm=true' });
       const vl = await h({ m: 'POST', p: '/v1/radar/value_lists', b: 'alias=ui_block_ips&name=UI Blocked IPs&item_type=ip_address' });
       await h({ m: 'POST', p: '/v1/radar/value_list_items', b: `value_list=${(vl.body as Body).id}&value=9.9.9.9` });
-      await h({ m: 'POST', p: '/v1/radar/rules', b: 'action=block&predicate=:risk_level: = "highest"' });
     },
     check: async ({ get }) => {
       const reviews = ((await get('/v1/reviews')).data as Body[]) ?? [];
       const valueLists = ((await get('/v1/radar/value_lists')).data as Body[]) ?? [];
-      const rules = ((await get('/v1/radar/rules')).data as Body[]) ?? [];
-      // the seeded objects must be present in the projections the screen reads
-      const review = reviews.find((r) => r.charge === 'ch_radar_ui');
+      // the review is the one Radar opened on the seeded elevated-risk payment
+      const risky = (((await get('/v1/payment_intents')).data as Body[]) ?? [])[0];
+      const review = reviews.find((r) => r.open === true && r.payment_intent === risky?.id && typeof r.charge === 'string' && r.charge === risky?.latest_charge);
       const vl = valueLists.find((l) => l.alias === 'ui_block_ips');
-      const rule = rules.find((r) => r.predicate === ':risk_level: = "highest"');
-      if (!review || !vl || !rule) return false;
-      // RENDER the mirror's own ListPane over the fetched rows and assert the DOM emits one
-      // list-row per object, each carrying the seeded object's id (subtitle renders r.id).
+      if (!review || !vl) return false;
       const reviewsMarkup = renderSectionList('reviews', reviews as StripeRow[]);
       const valueListsMarkup = renderSectionList('radar/value_lists', valueLists as StripeRow[]);
-      const rulesMarkup = renderSectionList('radar/rules', rules as StripeRow[]);
-      return (
-        // reviews + rules render their id in the row subtitle; the value-list row renders its
-        // name + alias (the id is not surfaced in that section's row), so assert those instead.
-        listRows(reviewsMarkup) === reviews.length && reviewsMarkup.includes(String(review.id)) &&
-        listRows(valueListsMarkup) === valueLists.length && valueListsMarkup.includes('UI Blocked IPs') && valueListsMarkup.includes('ui_block_ips') &&
-        listRows(rulesMarkup) === rules.length && rulesMarkup.includes(String(rule.id)) && rulesMarkup.includes('block')
-      );
+      // a review's row names its charge; the value-list row renders its name + alias
+      return listRows(reviewsMarkup) === reviews.length && reviewsMarkup.includes(String(review.charge))
+        && listRows(valueListsMarkup) === valueLists.length && valueListsMarkup.includes('UI Blocked IPs') && valueListsMarkup.includes('ui_block_ips');
     },
   })),
   // ── Reporting ────────────────────────────────────────────────────────────────────
   // Reporting report_runs + report_types: POST /v1/reporting/report_runs requires
-  // parameters[report_type] (a valid type from the catalog); the twin completes the run
-  // synchronously (status 'succeeded') with a result File ref. Unknown/missing report_type 400.
+  // report_type (a valid type from the catalog); a run starts pending and completes a
+  // minute later (status 'succeeded') with a result File ref. Unknown/missing report_type 400.
   // The report-type catalog is listable/retrievable.
   done('stripe.reporting.report_runs', 'reporting', 'Reporting (report_runs + report_types)', 'api', 'niche', () =>
-    withRoot(async (h) => {
+    withRoot(async (h, root) => {
       const types = await h({ m: 'GET', p: '/v1/reporting/report_types' });
       if (!ok(types) || ((types.body as Body).data as Body[]).length === 0) return false;
       const one = await h({ m: 'GET', p: '/v1/reporting/report_types/balance.summary.1' });
       if (!ok(one) || field(one, 'object') !== 'reporting.report_type') return false;
-      const run = await h({ m: 'POST', p: '/v1/reporting/report_runs', b: 'parameters[report_type]=balance.summary.1&parameters[interval_start]=0&parameters[interval_end]=100' });
-      if (!ok(run) || field(run, 'object') !== 'reporting.report_run' || field(run, 'status') !== 'succeeded' || field(run, 'report_type') !== 'balance.summary.1') return false;
-      if ((field(run, 'result') as Body)?.object !== 'file') return false;
-      const g = await h({ m: 'GET', p: `/v1/reporting/report_runs/${id(run)}` });
+      const run = await h({ m: 'POST', p: '/v1/reporting/report_runs', b: 'report_type=balance.summary.1&parameters[interval_start]=0&parameters[interval_end]=100' });
+      if (!ok(run) || field(run, 'object') !== 'reporting.report_run' || field(run, 'status') !== 'pending' || field(run, 'report_type') !== 'balance.summary.1') return false;
+      // "Most runs complete within a few minutes" (docs.stripe.com/reports/api): read two minutes on, it has succeeded
+      const g = await handleStripeTwinRequest({ method: 'GET', path: `/v1/reporting/report_runs/${id(run)}`, root, occurredAt: new Date(Date.now() + 120_000).toISOString() });
+      if (field(g, 'status') !== 'succeeded' || (field(g, 'result') as Body)?.object !== 'file') return false;
       const l = await h({ m: 'GET', p: '/v1/reporting/report_runs' });
       const noType = await h({ m: 'POST', p: '/v1/reporting/report_runs', b: 'parameters[interval_start]=0' });
-      const badType = await h({ m: 'POST', p: '/v1/reporting/report_runs', b: 'parameters[report_type]=bogus.report' });
+      const badType = await h({ m: 'POST', p: '/v1/reporting/report_runs', b: 'report_type=bogus.report' });
       const nope = await h({ m: 'GET', p: '/v1/reporting/report_runs/frr_nope' });
       const badTypeRetrieve = await h({ m: 'GET', p: '/v1/reporting/report_types/bogus.report' });
       return ok(g) && id(g) === id(run) && ((l.body as Body).data as Body[]).length === 1 &&
@@ -2113,25 +3625,24 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
     }),
   ),
   // Reporting API (the modellable part of Sigma/Financial reports): report_types catalog +
-  // report_runs create→result. A run requires a valid parameters[report_type] (else 400),
-  // starts and completes to 'succeeded' with a result File ref. The Sigma SQL warehouse
-  // itself is out-of-scope (see the out-of-scope entry below). Unknown type 400.
+  // report_runs create→result. A run requires a valid report_type (else 400),
+  // starts pending and completes to 'succeeded' with a result File ref a minute later. The Sigma scheduled-query
+  // surface is filed separately as a todo. Unknown type 400.
   done('stripe.sigma_financial', 'reporting', 'Financial reports / Sigma (Reporting API)', 'api', 'niche', () =>
-    withRoot(async (h) => {
+    withRoot(async (h, root) => {
       const types = await h({ m: 'GET', p: '/v1/reporting/report_types' });
       if (!ok(types) || field(types, 'object') !== 'list' || ((types.body as Body).data as Body[]).length === 0) return false;
-      const run = await h({ m: 'POST', p: '/v1/reporting/report_runs', b: 'parameters[report_type]=balance.summary.1' });
-      if (!ok(run) || field(run, 'object') !== 'reporting.report_run' || field(run, 'status') !== 'succeeded') return false;
-      if ((field(run, 'result') as Body)?.object !== 'file') return false;
-      const get = await h({ m: 'GET', p: `/v1/reporting/report_runs/${id(run)}` });
+      const run = await h({ m: 'POST', p: '/v1/reporting/report_runs', b: 'report_type=balance.summary.1' });
+      if (!ok(run) || field(run, 'object') !== 'reporting.report_run' || field(run, 'status') !== 'pending') return false;
+      const get = await handleStripeTwinRequest({ method: 'GET', path: `/v1/reporting/report_runs/${id(run)}`, root, occurredAt: new Date(Date.now() + 120_000).toISOString() });
+      if (field(get, 'status') !== 'succeeded' || (field(get, 'result') as Body)?.object !== 'file') return false;
       const list = await h({ m: 'GET', p: '/v1/reporting/report_runs' });
-      const badType = await h({ m: 'POST', p: '/v1/reporting/report_runs', b: 'parameters[report_type]=not.a.type' });
-      const missing = await h({ m: 'POST', p: '/v1/reporting/report_runs', b: 'metadata[x]=1' });
+      const badType = await h({ m: 'POST', p: '/v1/reporting/report_runs', b: 'report_type=not.a.type' });
+      const missing = await h({ m: 'POST', p: '/v1/reporting/report_runs', b: 'parameters[interval_start]=0' });
       return ok(get) && field(list, 'object') === 'list' && badType.status === 400 && missing.status === 400;
     }),
   ),
-  outOfScope('stripe.sigma_financial.warehouse', 'reporting', 'Sigma SQL query warehouse (scheduled SQL queries)', 'api', 'niche',
-    'Out of scope: Sigma is a hosted SQL analytics warehouse over your account data — running arbitrary SQL against a managed data lake is not locally reproducible. The Reporting API (report_types + report_runs) IS modeled (stripe.sigma_financial).'),
+  todo('stripe.sigma.scheduled_query_runs', 'reporting', 'Sigma scheduled query runs: GET /v1/sigma/scheduled_query_runs list + retrieve, with the run object\'s status/result-file lifecycle (the Reporting API half is already modeled by stripe.sigma_financial)', 'api', 'niche'),
   // ── Connector (full pull/push) ────────────────────────────────────────────────────
   done('stripe.connector.read_surface', 'connector', 'Connector read surface (list core collections in one pass)', 'connector', 'core', () =>
@@ -2165,8 +3676,11 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
         pushed.push(`${method} ${path}`);
         return { id: 'ext_pushed', object: 'customer' };
       }) as unknown as Parameters<typeof fullSyncStripe>[0];
+      const { performPending } = await import('./stripe-perform-harness.ts');
+      // protocol 2: the head performs the pending write, the refresh folds the account — two halves, not one
+      const sent = await performPending(execute as never, { root, occurredAt: '2024-01-01T00:00:00.000Z' });
       const res = await fullSyncStripe(execute, { root, occurredAt: '2024-01-01T00:00:00.000Z' });
-      if (res.pushed < 1 || pushed.length < 1) return false; // the pending create was pushed
+      if (sent.pushed < 1 || pushed.length < 1) return false; // the pending create was performed
       if (res.observed < 1 || res.collections < 11) return false; // all collections + webhooks pulled
       // the pulled real customer is now in the twin's projection.
       const list = await handleStripeTwinRequest({ method: 'GET', path: '/v1/customers', root });
@@ -2225,12 +3739,15 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   // screen reads → render the mirror's OWN ListPane → assert the seeded charge id survives.
   done('stripe.ui.refunds', 'ui-dashboard', 'Dashboard: Refunds screen (data-coupled)', 'ui', 'core', uiDataCoupled({
     markers: ['Refunds', 'list-row'],
-    seed: async (h) => { await h({ m: 'POST', p: '/v1/refunds', b: 'charge=ch_ui_check_refund&amount=555' }); },
+    seed: async (h) => {
+      const charge = await h({ m: 'POST', p: '/v1/charges', b: 'amount=1000&currency=usd&description=ui_check_refund' });
+      await h({ m: 'POST', p: '/v1/refunds', b: `charge=${id(charge)}&amount=555` });
+    },
     check: async ({ get }) => {
       const rows = ((await get('/v1/refunds')).data as Body[]) as unknown as StripeRow[];
       if (!rows.length) return false;
       const markup = renderSectionList('refunds', rows);
-      return listRows(markup) === rows.length && rows.some((r) => r.charge === 'ch_ui_check_refund' && r.amount === 555);
+      return listRows(markup) === rows.length && rows.some((r) => typeof r.charge === 'string' && r.amount === 555);
     },
   })),
   // TWIN-14 (B4) migration — was a marker-grep over the literal 'Subscriptions'; now
@@ -2308,12 +3825,12 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   // screen reads → render the mirror's OWN ListPane → assert the seeded charge id survives.
   done('stripe.ui.disputes', 'ui-dashboard', 'Dashboard: Disputes screen (data-coupled)', 'ui', 'common', uiDataCoupled({
     markers: ['Disputes', 'list-row'],
-    seed: async (h) => { await h({ m: 'POST', p: '/v1/disputes', b: 'charge=ch_ui_check_dispute&amount=1000&currency=usd' }); },
+    seed: async (h) => { await disputed(h, 1234); },
     check: async ({ get }) => {
       const rows = ((await get('/v1/disputes')).data as Body[]) as unknown as StripeRow[];
       if (!rows.length) return false;
       const markup = renderSectionList('disputes', rows);
-      return listRows(markup) === rows.length && rows.some((d) => d.charge === 'ch_ui_check_dispute' && d.amount === 1000);
+      return listRows(markup) === rows.length && rows.some((d) => d.amount === 1234);
     },
   })),
   // TWIN-14 (B4) migration — was a marker-grep over the literal 'Payouts'; now data-coupled:
@@ -2321,7 +3838,10 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   // reads → render the mirror's OWN ListPane → assert the seeded amount survives.
   done('stripe.ui.payouts', 'ui-dashboard', 'Dashboard: Payouts screen (data-coupled)', 'ui', 'core', uiDataCoupled({
     markers: ['Payouts', 'list-row'],
-    seed: async (h) => { await h({ m: 'POST', p: '/v1/payouts', b: 'amount=7777&currency=usd' }); },
+    seed: async (h) => {
+      await h({ m: 'POST', p: '/v1/charges', b: 'amount=10000&currency=usd&source=tok_bypassPending' });
+      await h({ m: 'POST', p: '/v1/payouts', b: 'amount=7777&currency=usd' });
+    },
     check: async ({ get }) => {
       const rows = ((await get('/v1/payouts')).data as Body[]) as unknown as StripeRow[];
       if (!rows.length) return false;
@@ -2338,15 +3858,17 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   // empty workspace's balance has no buckets → `BalanceSummary` renders nothing.
   done('stripe.ui.balance', 'ui-dashboard', 'Dashboard: Balance + Balance Transactions screens (data-coupled)', 'ui', 'core', uiDataCoupled({
     markers: ['Balance', 'Balance Transactions', 'balance-summary'],
-    seed: async (h) => { await h({ m: 'POST', p: '/v1/balance_transactions', b: 'amount=424200&currency=usd' }); },
+    seed: async (h) => { await h({ m: 'POST', p: '/v1/charges', b: 'amount=424200&currency=usd&source=tok_bypassPending' }); },
     check: async ({ get }) => {
       const balance = await get('/v1/balance');
       const txns = ((await get('/v1/balance_transactions')).data as Body[]) as unknown as StripeRow[];
       if (!txns.length) return false;
       const summaryMarkup = renderToStaticMarkup(createElement(BalanceSummary, { row: { id: 'balance', ...balance } as StripeRow }));
       const txnsMarkup = renderSectionList('balance_transactions', txns);
-      return summaryMarkup.includes('balance-summary') && summaryMarkup.includes(formatStripeAmount(424200, 'usd')) &&
-        listRows(txnsMarkup) === txns.length && txns.some((t) => t.amount === 424200);
+      // the balance is the charge less Stripe's fee, 2.9% + 30¢ (stripe.com/pricing; the ledger, d5c8f9a70):
+      // 424200 - (12302 + 30) = 411868 available, while the transaction keeps the gross amount
+      return summaryMarkup.includes('balance-summary') && summaryMarkup.includes(formatStripeAmount(411868, 'usd')) &&
+        listRows(txnsMarkup) === txns.length && txns.some((t) => t.amount === 424200 && t.fee === 12332 && t.net === 411868);
     },
   })),
   // TWIN-14 (B4) migration — was a marker-grep over the literals 'Connected Accounts',
@@ -2358,8 +3880,8 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   done('stripe.ui.connect', 'ui-dashboard', 'Dashboard: Connect (Connected Accounts + Transfers) screens (data-coupled)', 'ui', 'niche', uiDataCoupled({
     markers: ['Connected Accounts', 'Transfers', 'connect-flag'],
     seed: async (h) => {
-      const acct = await h({ m: 'POST', p: '/v1/accounts', b: 'type=express&country=US' });
-      await h({ m: 'POST', p: '/v1/transfers', b: `amount=999&currency=usd&destination=${(acct.body as Body).id}` });
+      const seller = await onboardedSeller(h);
+      await h({ m: 'POST', p: '/v1/transfers', b: `amount=999&currency=usd&destination=${seller}` });
     },
     check: async ({ get }) => {
       const accounts = ((await get('/v1/accounts')).data as Body[]) as unknown as StripeRow[];
@@ -2377,40 +3899,34 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   // screen reads → render the mirror's OWN ListPane → assert the seeded type survives.
   done('stripe.ui.events', 'ui-dashboard', 'Dashboard: Events log screen (data-coupled)', 'ui', 'core', uiDataCoupled({
     markers: ['Events', 'list-row'],
-    seed: async (h) => { await h({ m: 'POST', p: '/v1/events', b: 'type=ui.check.event' }); },
+    seed: async (h) => { await h({ m: 'POST', p: '/v1/coupons', b: 'percent_off=10&duration=once' }); },
     check: async ({ get }) => {
       const rows = ((await get('/v1/events')).data as Body[]) as unknown as StripeRow[];
       if (!rows.length) return false;
       const markup = renderSectionList('events', rows);
-      return listRows(markup) === rows.length && rows.some((e) => e.type === 'ui.check.event') && markup.includes('ui.check.event');
+      return listRows(markup) === rows.length && rows.some((e) => e.type === 'coupon.created') && markup.includes('coupon.created');
     },
   })),
-  // TWIN-14 (B4) migration — was a marker-grep over the literals 'Credit Notes', 'Customer Tax
-  // IDs', 'Customer Balance'; now data-coupled: seed a credit note, a customer tax id, and a
-  // customer balance transaction, each with a distinct value → fetch the SAME `/v1/credit_notes`
-  // + `/v1/tax_ids` + `/v1/customer_balance_transactions` projections those screens read →
-  // render the mirror's OWN ListPane over each → assert every seeded value survives.
-  done('stripe.ui.billing_credit', 'ui-dashboard', 'Dashboard: Credit Notes + Customer Tax IDs + Customer Balance screens (data-coupled)', 'ui', 'common', uiDataCoupled({
-    markers: ['Credit Notes', 'Customer Tax IDs', 'Customer Balance', 'list-row'],
+  // Dashboard: credit notes and the account's tax IDs, data-coupled: seed a credit note and the account's own VAT
+  // number, fetch the same `/v1/credit_notes` and `/v1/tax_ids` lists those screens read, render the mirror's own
+  // ListPane over each and assert the seeded rows survive.
+  done('stripe.ui.billing_credit', 'ui-dashboard', 'Dashboard: Credit Notes + Tax IDs screens (data-coupled)', 'ui', 'common', uiDataCoupled({
+    markers: ['Credit Notes', 'Tax IDs', 'list-row'],
     seed: async (h) => {
       const cust = await h({ m: 'POST', p: '/v1/customers', b: 'email=billing-credit-check@twin.test' });
       const custId = (cust.body as Body).id;
       const inv = await h({ m: 'POST', p: '/v1/invoices', b: `customer=${custId}` });
       await h({ m: 'POST', p: '/v1/credit_notes', b: `invoice=${(inv.body as Body).id}&amount=2500&reason=order_change` });
-      await h({ m: 'POST', p: `/v1/customers/${custId}/tax_ids`, b: 'type=eu_vat&value=DE999999999' });
-      await h({ m: 'POST', p: `/v1/customers/${custId}/balance_transactions`, b: 'amount=-750&currency=usd' });
+      await h({ m: 'POST', p: '/v1/tax_ids', b: 'type=eu_vat&value=DE999999999' });
     },
     check: async ({ get }) => {
       const notes = ((await get('/v1/credit_notes')).data as Body[]) as unknown as StripeRow[];
       const taxIds = ((await get('/v1/tax_ids')).data as Body[]) as unknown as StripeRow[];
-      const custBal = ((await get('/v1/customer_balance_transactions')).data as Body[]) as unknown as StripeRow[];
-      if (!notes.length || !taxIds.length || !custBal.length) return false;
+      if (!notes.length || !taxIds.length) return false;
       const notesMarkup = renderSectionList('credit_notes', notes);
       const taxMarkup = renderSectionList('tax_ids', taxIds);
-      const balMarkup = renderSectionList('customer_balance_transactions', custBal);
       return listRows(notesMarkup) === notes.length && notes.some((n) => n.amount === 2500) &&
-        listRows(taxMarkup) === taxIds.length && taxIds.some((t) => t.value === 'DE999999999') &&
-        listRows(balMarkup) === custBal.length && custBal.some((b) => b.amount === -750);
+        listRows(taxMarkup) === taxIds.length && taxIds.some((t) => t.value === 'DE999999999');
     },
   })),
   // TWIN-14 (B4) migration — was a marker-grep over the literal 'Payment error'; now
@@ -2468,7 +3984,12 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   // per seeded run carrying its report_type (fails on an empty workspace).
   done('stripe.ui.reports', 'ui-dashboard', 'Dashboard: Reports / analytics screen', 'ui', 'niche', uiDataCoupled({
     markers: ['Reports', 'reporting/report_runs', 'list-row'],
-    seed: async (h) => { await h({ m: 'POST', p: '/v1/reporting/report_runs', b: 'parameters[report_type]=balance.summary.1' }); },
+    // made ten minutes ago on the World's clock: a run starts pending and succeeds a minute on ("Most runs complete within a
+    // few minutes", docs.stripe.com/reports/api; stripe.reporting.report_runs), so one made at the instant the screen reads
+    // it is still pending
+    seed: async (_h, root) => {
+      await handleStripeTwinRequest({ method: 'POST', path: '/v1/reporting/report_runs', body: 'report_type=balance.summary.1&parameters[interval_start]=0&parameters[interval_end]=100', root, occurredAt: new Date(Date.now() - 10 * 60_000).toISOString() });
+    },
     check: async ({ get }) => {
       const rows = ((await get('/v1/reporting/report_runs')).data as Body[]) as unknown as StripeRow[];
       if (!rows || rows.length < 1) return false;
@@ -2482,7 +4003,7 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   done('stripe.ui.settings', 'ui-dashboard', 'Dashboard: Settings (account/team/api keys/webhooks)', 'ui', 'common', uiDataCoupled({
     markers: ['settings-block', 'data-settings', 'API keys', 'settings-payout-schedule', 'payoutScheduleText'],
     seed: async (h) => {
-      await h({ m: 'POST', p: '/v1/account', b: 'settings[payouts][schedule][interval]=weekly&settings[payouts][schedule][weekly_anchor]=monday' });
+      await h({ m: 'POST', p: '/_twin/account', b: 'settings[payouts][schedule][interval]=weekly&settings[payouts][schedule][weekly_anchor]=monday' });
       await h({ m: 'POST', p: '/v1/webhook_endpoints', b: 'url=https://twin.test/hook&enabled_events[]=charge.succeeded' });
     },
     check: async ({ get }) => {
@@ -2541,14 +4062,19 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   // ── SetupIntents full lifecycle (only confirm was tracked before) ──
   done('stripe.setup_intents.lifecycle', 'payment_methods', 'SetupIntents: create / retrieve / list / cancel', 'api', 'common', () =>
     withRoot(async (h) => {
+      // made without a payment method it waits for one: "When the SetupIntent is created, it has a status of
+      // requires_payment_method until a payment method is attached" (docs.stripe.com/payments/setupintents/lifecycle;
+      // 45d8b30d1); with one it waits for confirmation
       const c = await h({ m: 'POST', p: '/v1/setup_intents', b: 'usage=off_session' });
-      if (!ok(c) || field(c, 'status') !== 'requires_confirmation') return false;
+      if (!ok(c) || field(c, 'status') !== 'requires_payment_method') return false;
       const g = await h({ m: 'GET', p: `/v1/setup_intents/${id(c)}` });
       const l = await h({ m: 'GET', p: '/v1/setup_intents' });
       const x = await h({ m: 'POST', p: `/v1/setup_intents/${id(c)}/cancel` });
       // cancelling a succeeded SI is rejected (negative path)
-      const conf = await h({ m: 'POST', p: '/v1/setup_intents', b: 'usage=off_session' });
-      await h({ m: 'POST', p: `/v1/setup_intents/${id(conf)}/confirm` });
+      const conf = await h({ m: 'POST', p: '/v1/setup_intents', b: 'usage=off_session&payment_method=pm_card_visa' });
+      if (field(conf, 'status') !== 'requires_confirmation') return false;
+      const confirmed = await h({ m: 'POST', p: `/v1/setup_intents/${id(conf)}/confirm` });
+      if (field(confirmed, 'status') !== 'succeeded') return false;
       const badCancel = await h({ m: 'POST', p: `/v1/setup_intents/${id(conf)}/cancel` });
       return ok(g) && id(g) === id(c) && field(l, 'object') === 'list'
         && ok(x) && field(x, 'status') === 'canceled' && badCancel.status === 400;
@@ -2574,24 +4100,40 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   // ── Mandates retrieve ──
   done('stripe.mandates.retrieve', 'payment_methods', 'Mandates: retrieve (404 unknown)', 'api', 'niche', () =>
     withRoot(async (h) => {
-      const m = await h({ m: 'POST', p: '/v1/mandates', b: 'payment_method=pm_card_visa' });
-      if (!ok(m) || field(m, 'object') !== 'mandate') return false;
-      const g = await h({ m: 'GET', p: `/v1/mandates/${id(m)}` });
+      // Stripe's API makes no mandate on request (the twin's seeding POST /v1/mandates was invented and is gone,
+      // 5decb1d77): a mandate is the customer's acceptance a verified bank account carries, and a SetupIntent verified by
+      // micro-deposits names its multi-use one (docs.stripe.com/api/mandates, docs.stripe.com/api/setup_intents/object mandate)
+      const si = await h({ m: 'POST', p: '/v1/setup_intents', b: 'allowed_payment_method_types[]=us_bank_account' });
+      await h({ m: 'POST', p: `/v1/setup_intents/${id(si)}/confirm`, b: 'payment_method=pm_us_bank_account' });
+      const verified = await h({ m: 'POST', p: `/v1/setup_intents/${id(si)}/verify_microdeposits`, b: 'descriptor_code=SM11AA' });
+      const mandateId = String(field(verified, 'mandate'));
+      const g = await h({ m: 'GET', p: `/v1/mandates/${mandateId}` });
       const miss = await h({ m: 'GET', p: '/v1/mandates/mandate_nope' });
-      return ok(g) && id(g) === id(m) && field(g, 'status') === 'active' && miss.status === 404;
+      return ok(g) && field(g, 'object') === 'mandate' && id(g) === mandateId && field(g, 'status') === 'active' && field(g, 'type') === 'multi_use' && miss.status === 404;
     }),
   ),
   // ── Refund cancel ──
-  done('stripe.refunds.cancel', 'refunds', 'Refunds: cancel a pending refund (400 if not pending)', 'api', 'niche', () =>
-    withRoot(async (h) => {
-      const pending = await h({ m: 'POST', p: '/v1/refunds', b: 'amount=500&currency=usd&status=pending' });
-      if (!ok(pending)) return false;
-      const x = await h({ m: 'POST', p: `/v1/refunds/${id(pending)}/cancel` });
-      const succeeded = await h({ m: 'POST', p: '/v1/refunds', b: 'amount=500&currency=usd' });
-      const bad = await h({ m: 'POST', p: `/v1/refunds/${id(succeeded)}/cancel` });
+  // A bank-transfer payment's refund waits in requires_action for the customer's bank details (Stripe emails them), and
+  // only such a refund can be canceled, which gives the charge back its amount; a succeeded refund cannot be canceled
+  // (docs.stripe.com/payments/customer-balance/refunding, docs.stripe.com/api/refunds/cancel).
+  done('stripe.refunds.cancel', 'refunds', 'Refunds: a bank-transfer refund awaiting bank details is canceled (400 once succeeded)', 'api', 'niche', () =>
+    withRoot(async (h) => {
+      const cust = await h({ m: 'POST', p: '/v1/customers', b: 'email=wire@twin.test' });
+      await h({ m: 'POST', p: `/v1/test_helpers/customers/${id(cust)}/fund_cash_balance`, b: 'amount=2000&currency=usd' });
+      const pi = await h({ m: 'POST', p: '/v1/payment_intents', b: `amount=2000&currency=usd&customer=${id(cust)}&allowed_payment_method_types[]=customer_balance` });
+      await h({ m: 'POST', p: `/v1/payment_intents/${id(pi)}/apply_customer_balance` });
+      const waiting = await h({ m: 'POST', p: '/v1/refunds', b: `payment_intent=${id(pi)}&amount=500&instructions_email=wire@twin.test` });
+      if (!ok(waiting) || field(waiting, 'status') !== 'requires_action') return false;
+      const charge = String(field(waiting, 'charge'));
+      const held = await h({ m: 'GET', p: `/v1/charges/${charge}` });
+      const x = await h({ m: 'POST', p: `/v1/refunds/${id(waiting)}/cancel` });
+      const released = await h({ m: 'GET', p: `/v1/charges/${charge}` });
+      const back = await h({ m: 'POST', p: '/v1/refunds', b: `payment_intent=${id(pi)}&amount=500&origin=customer_balance` });
+      const bad = await h({ m: 'POST', p: `/v1/refunds/${id(back)}/cancel` });
       const miss = await h({ m: 'POST', p: '/v1/refunds/re_nope/cancel' });
-      return ok(x) && field(x, 'status') === 'canceled' && bad.status === 400 && miss.status === 404;
+      return ok(x) && field(x, 'status') === 'canceled' && field(back, 'status') === 'succeeded' && bad.status === 400 && miss.status === 404
+        && field(held, 'amount_refunded') === 500 && field(released, 'amount_refunded') === 0;
     }),
   ),
@@ -2604,10 +4146,313 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       const inc = await h({ m: 'POST', p: `/v1/payment_intents/${id(pi)}/increment_authorization`, b: 'amount=1500' });
       // must be greater than current → reject lowering
       const bad = await h({ m: 'POST', p: `/v1/payment_intents/${id(pi)}/increment_authorization`, b: 'amount=1000' });
-      return ok(inc) && field(inc, 'amount') === 1500 && field(inc, 'amount_capturable') === 1500 && field(inc, 'status') === 'requires_capture' && bad.status === 400;
+      // the charge holds the grown authorization, so capturing all of it releases nothing
+      const held = await h({ m: 'GET', p: `/v1/charges/${String(field(inc, 'latest_charge'))}` });
+      await h({ m: 'POST', p: `/v1/payment_intents/${id(pi)}/capture` });
+      const taken = await h({ m: 'GET', p: `/v1/charges/${String(field(inc, 'latest_charge'))}` });
+      return ok(inc) && field(inc, 'amount') === 1500 && field(inc, 'amount_capturable') === 1500 && field(inc, 'status') === 'requires_capture' && bad.status === 400
+        && field(held, 'amount') === 1500 && field(taken, 'amount_captured') === 1500 && field(taken, 'amount_refunded') === 0 && field(taken, 'refunded') === false;
     }),
   ),
+  // ── Connect OAuth for Standard accounts (screens/connect-oauth.tsx; docs.stripe.com/connect/oauth-reference) ──
+  // The platform's OAuth settings: "Enable onboarding accounts with OAuth", "Copy your client_id", "Set your redirect_uri
+  // ... If you don't include the redirect_uri parameter in your request, Stripe defaults to using the first address you've
+  // configured" (docs.stripe.com/connect/oauth-standard-accounts). The page shows the client_id and what was saved, and
+  // authorize holds the platform to it.
+  done('stripe.connect.oauth_settings', 'connect', 'Dashboard Connect OAuth settings: the client_id shown, OAuth enabled and redirect URIs registered, which authorize holds the platform to', 'ui', 'common', () =>
+    withOAuth(async (w) => {
+      const read = async (path: string) => (await w.f(new Request(`https://dashboard.stripe.com${path}`))).text();
+      const first = await read('/settings/connect');
+      const shownId = /data-testid="connect-client-id">(ca_[^<]+)</.exec(first)?.[1];
+      // a new platform has OAuth off: authorize refuses it, in JSON, with the state
+      const off = await w.authorize(authorizeQuery());
+      const offBody = (await off.json()) as Body;
+      // a redirect URI that is not an http(s) URL is refused on the page, and nothing is saved
+      const bad = await w.settings(true, 'ftp://files.test/cb');
+      const fragment = await w.settings(true, 'https://app.test/cb#tab');
+      const stillOff = ((await (await w.authorize(authorizeQuery())).json()) as Body).error === 'invalid_client';
+      // OAuth on with no redirect URI: a request naming none has nowhere to go
+      await w.settings(true, '');
+      const nowhere = (await (await w.authorize(authorizeQuery('', null))).json()) as Body;
+      const saved = await w.settings(true, `https://app.test/first\n${OAUTH_CALLBACK}?tab=stripe`);
+      const listed = await read('/settings/connect/onboarding-options/oauth');
+      const uris = [...listed.matchAll(/data-testid="connect-redirect-uri">([^<]+)</g)].map((m) => m[1]!.replace(/&amp;/g, '&'));
+      // no redirect_uri: the first registered; a registered one with its own query keeps it; an unregistered one is refused
+      const defaulted = (await w.authorize(authorizeQuery('', null), 'skip')).headers.get('location') ?? '';
+      const named = (await w.authorize(authorizeQuery('', `${OAUTH_CALLBACK}?tab=stripe`), 'skip')).headers.get('location') ?? '';
+      const unregistered = await w.authorize(authorizeQuery('', OAUTH_CALLBACK));
+      const unregisteredBody = (await unregistered.json()) as Body;
+      // turned off again, authorize refuses again
+      await w.settings(false, OAUTH_CALLBACK);
+      const offAgain = ((await (await w.authorize(authorizeQuery())).json()) as Body).error === 'invalid_client';
+      const testLink = (await read('/test/settings/connect/onboarding-options/oauth')).includes('OAuth is disabled.');
+      return shownId === 'ca_twin_self' && first.includes('OAuth is disabled.') && off.status === 400 && offBody.error === 'invalid_client' && offBody.state === 'st8'
+        && bad.status === 400 && fragment.status === 400 && stillOff && nowhere.error === 'invalid_redirect_uri' && saved.status === 303 && uris.length === 2 && uris[0] === 'https://app.test/first' && uris[1] === `${OAUTH_CALLBACK}?tab=stripe`
+        && listed.includes('OAuth is enabled.') && defaulted.startsWith('https://app.test/first?scope=read_write&code=ac_') && named.startsWith(`${OAUTH_CALLBACK}?tab=stripe&scope=read_write&code=ac_`)
+        && unregistered.status === 400 && unregisteredBody.error === 'invalid_redirect_uri' && String(unregisteredBody.error_description).includes(OAUTH_CALLBACK)
+        && offAgain && testLink;
+    }, false),
+  ),
+  // GET connect.stripe.com/oauth/authorize: the request checked as the reference lists its errors (a JSON dictionary with
+  // error, error_description and state, never a redirect), the page the person answers, "Skip this form" in test mode
+  // creating a new Standard account from the prefill ("Any parameters with invalid values are silently ignored") and
+  // redirecting with code, scope and state; a denial redirects with access_denied and creates nothing.
+  done('stripe.connect.oauth_authorize', 'connect', 'Connect OAuth authorize: request errors, the connect page, Skip this form creates a prefilled Standard account and redirects with code/scope/state; Deny redirects access_denied', 'api', 'common', () =>
+    withOAuth(async (w) => {
+      const err = async (query: string) => { const r = await w.authorize(query); return { status: r.status, ...((await r.json()) as Body) } as Body; };
+      const noClient = await err(authorizeQuery().replace('client_id=ca_twin_self&', ''));
+      const unknown = await err(authorizeQuery().replace('ca_twin_self', 'ca_nope'));
+      const noType = await err(authorizeQuery().replace('&response_type=code', ''));
+      const tokenType = await err(authorizeQuery().replace('response_type=code', 'response_type=token'));
+      const badScope = await err(authorizeQuery().replace('scope=read_write', 'scope=admin'));
+      const errorsRight = noClient.status === 400 && noClient.error === 'invalid_request' && unknown.error === 'invalid_client' && unknown.error_description === 'No application matches the supplied client identifier'
+        && noType.error === 'invalid_request' && tokenType.error === 'unsupported_response_type' && badScope.error === 'invalid_scope' && [noClient, unknown, noType, tokenType, badScope].every((e) => e.state === 'st8' && e.status === 400);
+      const prefillQuery = '&stripe_user%5Bemail%5D=org%40cal.test&stripe_user%5Bfirst_name%5D=Ada&stripe_user%5Bbusiness_name%5D=Ada%20Consulting&stripe_user%5Bcountry%5D=CA&stripe_user%5Burl%5D=not-a-url&stripe_user%5Bbusiness_type%5D=llc&stripe_user%5Bproduct_description%5D=Consulting%20sessions&stripe_user%5Bphone_number%5D=6045550123';
+      const shown = await (await w.authorize(authorizeQuery(prefillQuery))).text();
+      const pageRight = shown.includes('Skip this form') && shown.includes('Deny access') && shown.includes('Read and write access') && shown.includes('org@cal.test') && shown.includes('Twin Inc.');
+      // Deny: back to the platform with access_denied and the state, and no account made
+      const denied = (await w.authorize(authorizeQuery(prefillQuery), 'deny')).headers.get('location');
+      const noneMade = ((await w.api('GET', '/v1/accounts')).body.data as Body[]).length === 0;
+      const { location, code, token } = await w.connect(prefillQuery);
+      const acct = (await w.api('GET', `/v1/accounts/${String(token.stripe_user_id)}`)).body;
+      const profile = acct.business_profile as Body;
+      // scope defaults to read_only
+      const readOnly = new URL((await w.authorize(authorizeQuery().replace('scope=read_write&', ''), 'skip')).headers.get('location') ?? 'about:blank').searchParams.get('scope');
+      // an empty scope is no scope: the default, not invalid_scope
+      const emptyScope = new URL((await w.authorize(authorizeQuery().replace('scope=read_write', 'scope='), 'skip')).headers.get('location') ?? 'about:blank').searchParams.get('scope');
+      // two people connecting at once get two codes, each for its own account (a regression guard: in one process a
+      // count and its write never interleave; the atomic mint is for Worlds whose store two processes write)
+      const both = await Promise.all([w.authorize(authorizeQuery(), 'skip'), w.authorize(authorizeQuery(), 'skip')]);
+      const codes = both.map((r) => new URL(r.headers.get('location') ?? 'about:blank').searchParams.get('code'));
+      const bothTokens = await Promise.all(codes.map(async (c) => (await w.endpoint('token', `grant_type=authorization_code&code=${c}`)).body));
+      return errorsRight && pageRight && noneMade
+        && denied === `${OAUTH_CALLBACK}?error=access_denied&error_description=The%20user%20denied%20your%20request&state=st8`
+        && `${location.origin}${location.pathname}` === OAUTH_CALLBACK && [...location.searchParams.keys()].join(',') === 'scope,code,state' && location.searchParams.get('scope') === 'read_write' && location.searchParams.get('state') === 'st8' && /^ac_/.test(code)
+        && acct.id === token.stripe_user_id && acct.type === 'standard' && (acct.controller as Body)?.type === 'account' && acct.email === 'org@cal.test' && acct.country === 'CA' && acct.default_currency === 'cad'
+        && profile?.name === 'Ada Consulting' && profile?.url === null && profile?.product_description === 'Consulting sessions' && profile?.support_phone === '6045550123'
+        && acct.business_type === 'company' && ((acct.settings as Body)?.dashboard as Body)?.display_name === 'Ada Consulting'
+        && ((acct.requirements as Body)?.currently_due as unknown[])?.length === 0 && acct.details_submitted === true && acct.payouts_enabled === true
+        && acct.charges_enabled === true && (acct.capabilities as Body)?.card_payments === 'active'
+        && readOnly === 'read_only' && emptyScope === 'read_only'
+        && codes[0] !== codes[1] && bothTokens.every((t) => /^acct_/.test(String(t.stripe_user_id))) && bothTokens[0]!.stripe_user_id !== bothTokens[1]!.stripe_user_id && bothTokens[0]!.refresh_token !== bothTokens[1]!.refresh_token;
+    }),
+  ),
+  // POST connect.stripe.com/oauth/token with grant_type=authorization_code, as stripe-node's oauth.token sends it (the
+  // platform's secret key as Bearer; curl's -u as Basic): the reference's response, the connected account usable with the
+  // Stripe-Account header at once; a code "can only be used once and expires in 5 minutes", and "Consuming an
+  // authorization code more than once revokes the account connection"; the reference's error codes.
+  done('stripe.connect.oauth_token', 'connect', 'Connect OAuth token: an authorization code becomes the connection (stripe_user_id, tokens), once, within 5 minutes; reuse revokes; invalid_request / invalid_grant / unsupported_grant_type', 'api', 'common', () =>
+    withOAuth(async (w) => {
+      const { code, token } = await w.connect();
+      const account = String(token.stripe_user_id);
+      const shape = Object.keys(token).sort().join(',') === 'access_token,livemode,refresh_token,scope,stripe_publishable_key,stripe_user_id,token_type'
+        && token.token_type === 'bearer' && token.livemode === false && token.scope === 'read_write' && /^sk_test_/.test(String(token.access_token))
+        && /^pk_test_/.test(String(token.stripe_publishable_key)) && /^rt_/.test(String(token.refresh_token)) && /^acct_/.test(account);
+      // the platform acts as the account (Cal.com: a PaymentIntent with stripeAccount), and reads its default currency
+      const pi = await w.api('POST', '/v1/payment_intents', 'amount=2500&currency=usd', account);
+      const retrieved = (await w.api('GET', `/v1/accounts/${account}`)).body;
+      const e = async (body: string, auth?: string) => { const r = await w.endpoint('token', body, auth); return { status: r.status, ...r.body } as Body; };
+      const noKey = await e(`grant_type=authorization_code&code=${code}`, '');
+      const publishable = await e(`grant_type=authorization_code&code=${code}`, 'Bearer pk_test_platform');
+      const noGrant = await e(`code=${code}`);
+      const password = await e('grant_type=password');
+      const noCode = await e('grant_type=authorization_code');
+      const missing = await e('grant_type=authorization_code&code=ac_nope');
+      // curl -u sk_...: (Basic) works as Bearer does
+      const second = await w.authorize(authorizeQuery(), 'skip');
+      const basic = await e(`grant_type=authorization_code&code=${new URL(second.headers.get('location')!).searchParams.get('code')}`, `Basic ${btoa('sk_test_platform:')}`);
+      // five minutes: a code 299 s old is exchanged, one 300 s old is not
+      const fresh = new URL((await w.authorize(authorizeQuery(), 'skip')).headers.get('location')!).searchParams.get('code');
+      const stale = new URL((await w.authorize(authorizeQuery(), 'skip')).headers.get('location')!).searchParams.get('code');
+      w.at('2026-03-01T00:04:59.000Z');
+      const inTime = await e(`grant_type=authorization_code&code=${fresh}`);
+      w.at('2026-03-01T00:05:00.000Z');
+      const late = await e(`grant_type=authorization_code&code=${stale}`);
+      const liveCode = new URL((await w.authorize(authorizeQuery(), 'skip')).headers.get('location')!).searchParams.get('code');
+      const liveKey = await e(`grant_type=authorization_code&code=${liveCode}`, 'Bearer sk_live_platform');
+      // a JSON body is read as the form is
+      const jsonCode = new URL((await w.authorize(authorizeQuery(), 'skip')).headers.get('location')!).searchParams.get('code');
+      const asJson = await w.f(new Request('https://connect.stripe.com/oauth/token', { method: 'POST', headers: { authorization: 'Bearer sk_test_platform', 'content-type': 'application/json' }, body: JSON.stringify({ grant_type: 'authorization_code', code: jsonCode }) }));
+      const asJsonBody = (await asJson.json()) as Body;
+      // the first code again: refused, and the connection it made is revoked
+      const reused = await e(`grant_type=authorization_code&code=${code}`);
+      const after = await w.api('POST', '/v1/payment_intents', 'amount=2500&currency=usd', account);
+      const others = await w.api('POST', '/v1/payment_intents', 'amount=2500&currency=usd', String(basic.stripe_user_id));
+      // the same code exchanged twice at once (a callback run twice): one exchange wins, and still the connection is revoked
+      // (the order the loser marks first is pinned below, `midway`)
+      const ids = async () => ((await w.api('GET', '/v1/accounts?limit=100')).body.data as Body[]).map((a) => String(a.id));
+      const known = await ids();
+      const raced = new URL((await w.authorize(authorizeQuery(), 'skip')).headers.get('location')!).searchParams.get('code');
+      const racedAccount = (await ids()).find((a) => !known.includes(a)) ?? '';
+      const pair = await Promise.all([e(`grant_type=authorization_code&code=${raced}`), e(`grant_type=authorization_code&code=${raced}`)]);
+      const racedAfter = racedAccount ? await w.api('GET', '/v1/customers', undefined, racedAccount) : { status: 0, body: {} };
+      // the order a race can take the other way: the second use marks the code while the first exchange is still writing
+      // its connection (the state that second use leaves, seeded as it is written), so the first exchange, finding the
+      // mark after its write, revokes the connection itself
+      const midway = new URL((await w.authorize(authorizeQuery(), 'skip')).headers.get('location')!).searchParams.get('code')!;
+      const midAccount = (await ids()).find((a) => !known.includes(a) && a !== racedAccount) ?? '';
+      await applyTwinWrite('stripe', { operation: 'oauth_code.reuse', subjectType: '_oauth_code', subjectId: midway, fields: { reused: true }, occurredAt: '2026-03-01T00:05:00.000Z', actor: { kind: 'agent' } }, w.root);
+      const midExchange = await e(`grant_type=authorization_code&code=${midway}`);
+      const midAfter = midAccount ? await w.api('GET', '/v1/customers', undefined, midAccount) : { status: 0, body: {} };
+      return shape && pi.status === 200 && pi.body.object === 'payment_intent' && retrieved.default_currency === 'usd'
+        && midExchange.status === 400 && midExchange.error === 'invalid_grant' && midAfter.status === 403
+        && noKey.status === 401 && publishable.status === 401 && noGrant.status === 400 && noGrant.error === 'invalid_request' && password.error === 'unsupported_grant_type'
+        && noCode.error === 'invalid_request' && missing.status === 400 && missing.error === 'invalid_grant' && missing.error_description === 'Authorization code does not exist: ac_nope'
+        && basic.status === 200 && basic.token_type === 'bearer' && basic.stripe_user_id !== account
+        && inTime.status === 200 && late.status === 400 && late.error === 'invalid_grant' && String(late.error_description).includes('expired')
+        && liveKey.error === 'invalid_grant' && asJson.status === 200 && /^acct_/.test(String(asJsonBody.stripe_user_id))
+        && reused.status === 400 && reused.error === 'invalid_grant' && String(reused.error_description).includes('already been used')
+        && after.status === 403 && (after.body.error as Body)?.code === 'account_invalid' && others.status === 200
+        && pair.filter((p) => p.status === 200).length <= 1 && pair.some((p) => p.error === 'invalid_grant') && racedAfter.status === 403;
+    }),
+  ),
+  // grant_type=refresh_token: "a new access token of an equal or lesser scope"; "Any existing access token with the same
+  // scope and mode ... is revoked"; a refresh token of a revoked connection is refused.
+  done('stripe.connect.oauth_refresh', 'connect', 'Connect OAuth refresh_token grant: a new access token of equal or lesser scope; invalid_scope / invalid_grant', 'api', 'niche', () =>
+    withOAuth(async (w) => {
+      const { token } = await w.connect();
+      const e = async (body: string) => { const r = await w.endpoint('token', body); return { status: r.status, ...r.body } as Body; };
+      const same = await e(`grant_type=refresh_token&refresh_token=${String(token.refresh_token)}`);
+      const lesser = await e(`grant_type=refresh_token&refresh_token=${String(token.refresh_token)}&scope=read_only`);
+      const bogus = await e(`grant_type=refresh_token&refresh_token=${String(token.refresh_token)}&scope=admin`);
+      const liveRefresh = await w.endpoint('token', `grant_type=refresh_token&refresh_token=${String(token.refresh_token)}`, 'Bearer sk_live_platform');
+      const noToken = await e('grant_type=refresh_token');
+      const unknown = await e('grant_type=refresh_token&refresh_token=rt_nope');
+      // a read_only connection cannot refresh into read_write
+      const ro = (await w.connect('').then(async () => {
+        const loc = new URL((await w.authorize(authorizeQuery().replace('scope=read_write', 'scope=read_only'), 'skip')).headers.get('location')!);
+        return (await w.endpoint('token', `grant_type=authorization_code&code=${loc.searchParams.get('code')}`)).body;
+      }));
+      const greater = await e(`grant_type=refresh_token&refresh_token=${String(ro.refresh_token)}&scope=read_write`);
+      await w.endpoint('deauthorize', `client_id=ca_twin_self&stripe_user_id=${String(token.stripe_user_id)}`);
+      const revoked = await e(`grant_type=refresh_token&refresh_token=${String(token.refresh_token)}`);
+      return same.status === 200 && same.scope === 'read_write' && same.refresh_token === token.refresh_token && same.stripe_user_id === token.stripe_user_id
+        && same.access_token !== token.access_token && /^sk_test_/.test(String(same.access_token))
+        && lesser.status === 200 && lesser.scope === 'read_only' && lesser.access_token !== same.access_token
+        && bogus.error === 'invalid_scope' && liveRefresh.body.error === 'invalid_grant' && noToken.error === 'invalid_request' && unknown.status === 400 && unknown.error === 'invalid_grant'
+        && ro.scope === 'read_only' && greater.error === 'invalid_scope' && revoked.error === 'invalid_grant';
+    }),
+  ),
+  // POST connect.stripe.com/oauth/deauthorize: `{ stripe_user_id }`, and then "the account can't be accessed by your
+  // platform ... through the API" (the Stripe-Account header, /v1/accounts/{account}); invalid_request and invalid_client
+  // as the reference lists them. "You can only revoke a Standard account's access": an account the platform made itself
+  // was never connected by OAuth, so it is not connected to the application.
+  done('stripe.connect.oauth_deauthorize', 'connect', 'Connect OAuth deauthorize: revokes the connection; the account is then refused with the Stripe-Account header; invalid_request / invalid_client', 'api', 'common', () =>
+    withOAuth(async (w) => {
+      const { token } = await w.connect();
+      const other = (await w.connect()).token;
+      const account = String(token.stripe_user_id);
+      const e = async (body: string, auth?: string) => { const r = await w.endpoint('deauthorize', body, auth); return { status: r.status, ...r.body } as Body; };
+      const made = String((await w.api('POST', '/v1/accounts', 'type=standard&country=US')).body.id);
+      const noClient = await e(`stripe_user_id=${account}`);
+      const noKey = await e(`client_id=ca_twin_self&stripe_user_id=${account}`, '');
+      const noAccount = await e('client_id=ca_twin_self');
+      const wrongClient = await e(`client_id=ca_nope&stripe_user_id=${account}`);
+      const liveKey = await e(`client_id=ca_twin_self&stripe_user_id=${account}`, 'Bearer sk_live_platform');
+      const notConnected = await e(`client_id=ca_twin_self&stripe_user_id=${made}`);
+      const before = await w.api('GET', '/v1/customers', undefined, account);
+      const revoked = await e(`client_id=ca_twin_self&stripe_user_id=${account}`);
+      const asIt = await w.api('GET', '/v1/customers', undefined, account);
+      const named = await w.api('GET', `/v1/accounts/${account}`);
+      const again = await e(`client_id=ca_twin_self&stripe_user_id=${account}`);
+      const listed = ((await w.api('GET', '/v1/accounts?limit=100')).body.data as Body[]).map((a) => a.id);
+      const stillOthers = await w.api('GET', '/v1/customers', undefined, String(other.stripe_user_id));
+      const stillMade = await w.api('GET', '/v1/customers', undefined, made);
+      return before.status === 200 && revoked.status === 200 && Object.keys(revoked).sort().join(',') === 'status,stripe_user_id' && revoked.stripe_user_id === account
+        && asIt.status === 403 && (asIt.body.error as Body)?.code === 'account_invalid' && String((asIt.body.error as Body)?.message).includes(account)
+        && named.status === 403 && again.status === 400 && again.error === 'invalid_client'
+        && noKey.status === 401 && noClient.error === 'invalid_request' && noAccount.error === 'invalid_request' && wrongClient.error === 'invalid_client' && liveKey.error === 'invalid_client'
+        && notConnected.error === 'invalid_client' && stillOthers.status === 200 && stillMade.status === 200
+        && !listed.includes(account) && listed.includes(other.stripe_user_id) && listed.includes(made);
+    }),
+  ),
+  // account.application.authorized "Occurs whenever a user authorizes an application" and account.application.deauthorized
+  // "whenever a user deauthorizes an application" (docs.stripe.com/api/events/types), each the connected account's event
+  // (top-level `account`, Connect endpoints: docs.stripe.com/connect/webhooks) carrying the application.
+  done('stripe.connect.oauth_events', 'connect', 'Connect OAuth events: account.application.authorized and .deauthorized reach Connect endpoints with the account and the application', 'api', 'common', async () => {
+    const rx = await webhookReceiver();
+    try {
+      return await withOAuth(async (w) => {
+        await w.api('POST', '/v1/webhook_endpoints', `url=${rx.url('/platform')}&enabled_events[]=*`);
+        const connectEndpoint = await w.api('POST', '/v1/webhook_endpoints', `url=${rx.url('/connect')}&enabled_events[]=*&connect=true`);
+        const { token } = await w.connect();
+        const account = String(token.stripe_user_id);
+        // a charge on the account, whose funds come due after the connection is revoked
+        await w.api('POST', '/v1/charges', 'amount=5000&currency=usd&source=tok_visa', account);
+        const before = rx.got('/connect').filter((e) => e.account === account && e.type === 'charge.succeeded').length;
+        const authorized = rx.got('/connect').filter((e) => e.type === 'account.application.authorized');
+        // two deauthorizations at once: one revokes (and one event is sent), the other finds it no longer connected (a
+        // regression guard: in one process the check and the revoke never interleave)
+        const twice = await Promise.all([1, 2].map(() => w.endpoint('deauthorize', `client_id=ca_twin_self&stripe_user_id=${account}`)));
+        const deauthorized = rx.got('/connect').filter((e) => e.type === 'account.application.deauthorized');
+        const seen = rx.got('/connect').length;
+        // days later its funds are available: the account's own balance.available no longer reaches the platform
+        w.at('2026-03-06T00:00:00.000Z');
+        const drained = await w.f(new Request('http://stripe.test/_twin/drain', { method: 'POST' }));
+        const drainedBody = (await drained.json()) as { delivered: Array<{ type: string; account?: string }> };
+        const leaked = rx.got('/connect').slice(seen).filter((e) => e.account === account);
+        const app = authorized[0]?.data.object as Body | undefined;
+        return connectEndpoint.status === 200 && connectEndpoint.body.connect === true
+          && authorized.length === 1 && authorized[0]!.account === account && app?.object === 'application' && app?.id === 'ca_twin_self' && typeof app?.name === 'string'
+          && before === 1 && drainedBody.delivered.some((d) => d.account === account && d.type === 'balance.available') && leaked.length === 0
+          && twice.filter((r) => r.status === 200).length === 1 && twice.some((r) => r.body.error === 'invalid_client')
+          && deauthorized.length === 1 && deauthorized[0]!.account === account && (deauthorized[0]!.data.object as Body).id === 'ca_twin_self'
+          && !rx.got('/platform').some((e) => e.type.startsWith('account.application.'));
+      });
+    } finally {
+      rx.close();
+    }
+  }),
+  // The token answer's access_token and stripe_publishable_key act as the connected account ("Use the Stripe-Account
+  // header with your platform's secret key", the reference, for the deprecated keys): a request made with one is the
+  // account's (its events are its own, GET /v1/account answers it), and it is not the platform's key at the OAuth
+  // endpoints; a key no live connection holds, after a refresh
+  // ("Any existing access token with the same scope and mode ... is revoked") or a deauthorize, is an invalid API key.
+  done('stripe.connect.oauth_access_token_auth', 'connect', 'Connect OAuth keys: the access_token and stripe_publishable_key act as the connected account; a refreshed-away or revoked token is refused 401', 'api', 'niche', () =>
+    withOAuth(async (w) => {
+      const { token } = await w.connect();
+      const account = String(token.stripe_user_id);
+      const as = async (m: string, p: string, key: unknown, b?: string, acct?: string) => {
+        const r = await w.f(new Request(`http://stripe.test${p}`, { method: m, headers: { authorization: `Bearer ${String(key)}`, 'content-type': 'application/x-www-form-urlencoded', ...(acct ? { 'stripe-account': acct } : {}) }, ...(b !== undefined ? { body: b } : {}) }));
+        return { status: r.status, body: (await r.json()) as Body };
+      };
+      const me = await as('GET', '/v1/account', token.access_token);
+      // curl -u sk_…: (Basic) is the same key
+      const basicMe = await w.f(new Request('http://stripe.test/v1/account', { headers: { authorization: `Basic ${btoa(`${String(token.access_token)}:`)}` } }));
+      const basicBody = (await basicMe.json()) as Body;
+      const unknownAccount = await w.api('GET', '/v1/account', undefined, 'acct_twin_nope');
+      // the account's key is not the platform's: it cannot exchange, refresh or deauthorize
+      const asPlatform = await w.endpoint('token', `grant_type=refresh_token&refresh_token=${String(token.refresh_token)}`, `Bearer ${String(token.access_token)}`);
+      const deauthAsIt = await w.endpoint('deauthorize', `client_id=ca_twin_self&stripe_user_id=${account}`, `Bearer ${String(token.access_token)}`);
+      const platformSelf = await w.api('GET', '/v1/account');
+      const viaHeader = await w.api('GET', '/v1/account', undefined, account);
+      const made = await as('POST', '/v1/customers', token.access_token, 'email=buyer@connected.test');
+      const theirs = ((await w.api('GET', '/v1/events?type=customer.created', undefined, account)).body.data as Body[]).map((e) => ((e.data as Body).object as Body).id);
+      const ours = ((await w.api('GET', '/v1/events?type=customer.created')).body.data as Body[]).map((e) => ((e.data as Body).object as Body).id);
+      // the publishable key acts as the account and is still only a publishable key
+      const pkRead = await as('GET', '/v1/customers', token.stripe_publishable_key);
+      const elsewhere = await as('GET', '/v1/customers', token.access_token, undefined, 'acct_twin_other');
+      const refreshed = (await w.endpoint('token', `grant_type=refresh_token&refresh_token=${String(token.refresh_token)}`)).body;
+      const oldToken = await as('GET', '/v1/customers', token.access_token);
+      const newToken = await as('GET', '/v1/customers', refreshed.access_token);
+      const forged = await as('GET', '/v1/customers', `sk_test_oauth_${account}_9`);
+      await w.endpoint('deauthorize', `client_id=ca_twin_self&stripe_user_id=${account}`);
+      const afterRevoke = await as('GET', '/v1/customers', refreshed.access_token);
+      return me.status === 200 && me.body.id === account && me.body.type === 'standard' && platformSelf.body.id === 'acct_twin_self' && viaHeader.body.id === account
+        && basicMe.status === 200 && basicBody.id === account && unknownAccount.status === 403 && (unknownAccount.body.error as Body)?.code === 'account_invalid'
+        && asPlatform.status === 401 && deauthAsIt.status === 401
+        && made.status === 200 && theirs.includes(made.body.id) && !ours.includes(made.body.id)
+        && pkRead.status === 403 && (pkRead.body.error as Body)?.code === 'secret_key_required'
+        && elsewhere.status === 403 && (elsewhere.body.error as Body)?.code === 'account_invalid'
+        && oldToken.status === 401 && newToken.status === 200 && ((newToken.body.data as Body[]) ?? []).some((c) => c.id === made.body.id)
+        && forged.status === 401 && afterRevoke.status === 401;
+    }),
+  ),
+  todo('stripe.connect.oauth_scope_enforcement', 'connect', 'Connect OAuth: a read_only connection (or access token) is refused writes as the account', 'api', 'niche'),
+  todo('stripe.connect.oauth_existing_account', 'connect', 'Connect OAuth: sign in and connect an existing Stripe account instead of creating one', 'api', 'niche'),
+  todo('stripe.connect.oauth_account_application', 'connect', 'Connect OAuth: the full account application form (the page offers only the test-mode Skip this form)', 'ui', 'niche'),
   // ── Connect: account links (hosted onboarding) ──
   done('stripe.connect.account_links', 'connect', 'Connect: account_links (onboarding URL)', 'api', 'niche', () =>
     withRoot(async (h) => {
@@ -2667,15 +4512,20 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       const g = await h({ m: 'GET', p: `/v1/accounts/${id(acct)}/capabilities/card_payments` });
       const req = await h({ m: 'POST', p: `/v1/accounts/${id(acct)}/capabilities/card_payments`, b: 'requested=true' });
       const miss = await h({ m: 'GET', p: `/v1/accounts/${id(acct)}/capabilities/bogus` });
-      return ok(g) && field(g, 'object') === 'capability' && ok(req) && field(req, 'status') === 'pending' && miss.status === 404;
+      // requested on an account that still owes its information, Stripe's review leaves it inactive with what is due
+      // (the capability's `requirements`; "inactive ... Check requirements", docs.stripe.com/api/capabilities/object;
+      // semantics/connect.ts review, 44dea3cb3), where it used to answer a pending that nothing ever moved
+      const due = ((field(req, 'requirements') as Body | undefined)?.currently_due as string[] | undefined) ?? [];
+      return ok(g) && field(g, 'object') === 'capability' && ok(req) && field(req, 'requested') === true && field(req, 'status') === 'inactive'
+        && due.includes('business_profile.mcc') && miss.status === 404;
     }),
   ),
   // ── Connect: transfer reversals ──
   done('stripe.connect.transfer_reversals', 'connect', 'Connect: transfer reversals (partial + full)', 'api', 'niche', () =>
     withRoot(async (h) => {
-      const acct = await h({ m: 'POST', p: '/v1/accounts', b: 'type=standard' });
-      const tr = await h({ m: 'POST', p: '/v1/transfers', b: `amount=1000&currency=usd&destination=${id(acct)}` });
+      const seller = await onboardedSeller(h);
+      const tr = await h({ m: 'POST', p: '/v1/transfers', b: `amount=1000&currency=usd&destination=${seller}` });
       if (!ok(tr)) return false;
       const rev1 = await h({ m: 'POST', p: `/v1/transfers/${id(tr)}/reversals`, b: 'amount=400' });
       if (!ok(rev1) || field(rev1, 'object') !== 'transfer_reversal') return false;
@@ -2692,8 +4542,11 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   // ── Connect: application fees + refunds ──
   done('stripe.connect.application_fees', 'connect', 'Connect: application fees + fee refunds', 'api', 'niche', () =>
     withRoot(async (h) => {
-      const fee = await h({ m: 'POST', p: '/v1/application_fees', b: 'amount=1000&currency=usd&charge=ch_twin_1&account=acct_1' });
-      if (!ok(fee) || field(fee, 'object') !== 'application_fee') return false;
+      // a destination charge with an application fee earns the platform its fee
+      const acct = await h({ m: 'POST', p: '/v1/accounts', b: 'type=express&country=US' });
+      await h({ m: 'POST', p: '/v1/charges', b: `amount=5000&currency=usd&source=tok_visa&application_fee_amount=1000&transfer_data[destination]=${id(acct)}` });
+      const fee = { status: 200, body: (((await h({ m: 'GET', p: '/v1/application_fees' })).body as Body).data as Body[])[0]! } as StripeResponse;
+      if (!fee.body || field(fee, 'object') !== 'application_fee' || field(fee, 'amount') !== 1000) return false;
       const g = await h({ m: 'GET', p: `/v1/application_fees/${id(fee)}` });
       const l = await h({ m: 'GET', p: '/v1/application_fees' });
       const ref = await h({ m: 'POST', p: `/v1/application_fees/${id(fee)}/refunds`, b: 'amount=400' });
@@ -2706,11 +4559,11 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   // ── Files (uploads) + retrieve ──
   done('stripe.files.upload', 'files', 'Files: upload (purpose required) + retrieve/list', 'api', 'niche', () =>
     withRoot(async (h) => {
-      const f = await h({ m: 'POST', p: '/v1/files', b: 'purpose=dispute_evidence&filename=evidence.png' });
+      const f = await h({ m: 'POST', p: '/v1/files', b: 'purpose=dispute_evidence&file=evidence.png' });
       if (!ok(f) || field(f, 'object') !== 'file' || field(f, 'purpose') !== 'dispute_evidence') return false;
       const g = await h({ m: 'GET', p: `/v1/files/${id(f)}` });
       const l = await h({ m: 'GET', p: '/v1/files' });
-      const bad = await h({ m: 'POST', p: '/v1/files', b: 'filename=x.png' });
+      const bad = await h({ m: 'POST', p: '/v1/files', b: 'file=x.png' });
       return ok(g) && id(g) === id(f) && field(l, 'object') === 'list' && bad.status === 400;
     }),
   ),
@@ -2741,13 +4594,17 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   // scoped overwrite + find/delete are produced ONLY by this feature.)
   done('stripe.connect.secrets', 'connect', 'Connect: apps secret store', 'api', 'niche', () =>
     withRoot(async (h) => {
+      // a secret's value is "nullable string Includable": answered only when the request expands it
+      // (docs.stripe.com/api/secret_management; stripe-version.ts INCLUDABLE, 1d786078c), never on a plain answer
       const set = await h({ m: 'POST', p: '/v1/apps/secrets', b: 'name=api_key&scope[type]=account&payload=sk_secret_1' });
-      if (!ok(set) || field(set, 'object') !== 'apps.secret' || field(set, 'payload') !== 'sk_secret_1') return false;
-      const find = await h({ m: 'GET', p: '/v1/apps/secrets/find?name=api_key&scope[type]=account' });
+      if (!ok(set) || field(set, 'object') !== 'apps.secret' || field(set, 'payload') !== undefined) return false;
+      const plainFind = await h({ m: 'GET', p: '/v1/apps/secrets/find?name=api_key&scope[type]=account' });
+      if (!ok(plainFind) || field(plainFind, 'payload') !== undefined) return false;
+      const find = await h({ m: 'GET', p: '/v1/apps/secrets/find?name=api_key&scope[type]=account&expand[]=payload' });
       if (!ok(find) || field(find, 'payload') !== 'sk_secret_1') return false;
       // overwrite: same name+scope updates in place (no duplicate in the list).
       const set2 = await h({ m: 'POST', p: '/v1/apps/secrets', b: 'name=api_key&scope[type]=account&payload=sk_secret_2' });
-      const find2 = await h({ m: 'GET', p: '/v1/apps/secrets/find?name=api_key&scope[type]=account' });
+      const find2 = await h({ m: 'GET', p: '/v1/apps/secrets/find?name=api_key&scope[type]=account&expand[]=payload' });
       const list = await h({ m: 'GET', p: '/v1/apps/secrets?scope[type]=account' });
       if (!ok(set2) || field(find2, 'payload') !== 'sk_secret_2' || ((list.body as Body).data as Body[]).length !== 1) return false;
       // delete → find 404s.
@@ -2770,16 +4627,17 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   done('stripe.payment_intents.apply_customer_balance', 'payment_intents', 'PaymentIntents: apply_customer_balance', 'api', 'niche', () =>
     withRoot(async (h) => {
       const cust = await h({ m: 'POST', p: '/v1/customers', b: 'email=acb@twin.test' });
-      // partial funds first.
-      await h({ m: 'POST', p: `/v1/customers/${id(cust)}/cash_balance_transactions`, b: 'amount=600&currency=usd' });
-      const pi = await h({ m: 'POST', p: '/v1/payment_intents', b: `amount=1000&currency=usd&customer=${id(cust)}&payment_method_types[]=customer_balance` });
+      // partial funds first, through the test helper ("Create an incoming testmode bank transfer",
+      // docs.stripe.com/api/cash_balance/fund_cash_balance): the twin-invented POST .../cash_balance_transactions is gone (5decb1d77)
+      await h({ m: 'POST', p: `/v1/test_helpers/customers/${id(cust)}/fund_cash_balance`, b: 'amount=600&currency=usd' });
+      const pi = await h({ m: 'POST', p: '/v1/payment_intents', b: `amount=1000&currency=usd&customer=${id(cust)}&allowed_payment_method_types[]=customer_balance` });
       if (!ok(pi)) return false;
       const partial = await h({ m: 'POST', p: `/v1/payment_intents/${id(pi)}/apply_customer_balance` });
       if (!ok(partial) || field(partial, 'status') !== 'requires_action') return false;
       const na = field(partial, 'next_action') as Body;
       if (na?.type !== 'display_bank_transfer_instructions' || (na.display_bank_transfer_instructions as Body).amount_remaining !== 400) return false;
       // top up the rest → succeeds.
-      await h({ m: 'POST', p: `/v1/customers/${id(cust)}/cash_balance_transactions`, b: 'amount=400&currency=usd' });
+      await h({ m: 'POST', p: `/v1/test_helpers/customers/${id(cust)}/fund_cash_balance`, b: 'amount=400&currency=usd' });
       const full = await h({ m: 'POST', p: `/v1/payment_intents/${id(pi)}/apply_customer_balance` });
       if (!ok(full) || field(full, 'status') !== 'succeeded' || field(full, 'amount_received') !== 1000) return false;
       // a succeeded PI 400s; unknown id 404.
@@ -2795,7 +4653,7 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   // + the amount-match check are produced ONLY by this feature.)
   done('stripe.payment_intents.verify_microdeposits', 'payment_intents', 'PaymentIntents: verify_microdeposits (ACH)', 'api', 'common', () =>
     withRoot(async (h) => {
-      const pi = await h({ m: 'POST', p: '/v1/payment_intents', b: 'amount=5000&currency=usd&payment_method_types[]=us_bank_account' });
+      const pi = await h({ m: 'POST', p: '/v1/payment_intents', b: 'amount=5000&currency=usd&allowed_payment_method_types[]=us_bank_account' });
       if (!ok(pi)) return false;
       const conf = await h({ m: 'POST', p: `/v1/payment_intents/${id(pi)}/confirm`, b: 'payment_method=pm_us_bank_account' });
       if (!ok(conf) || field(conf, 'status') !== 'requires_action') return false;
@@ -2806,10 +4664,14 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       const both = await h({ m: 'POST', p: `/v1/payment_intents/${id(pi)}/verify_microdeposits`, b: 'amounts[]=32&amounts[]=45&descriptor_code=SM11AA' });
       const none = await h({ m: 'POST', p: `/v1/payment_intents/${id(pi)}/verify_microdeposits` });
       if (both.status !== 400 || none.status !== 400) return false;
-      // correct amounts → succeeded, next_action cleared.
+      // correct amounts → processing, next_action cleared: "When the bank account is successfully verified, Stripe returns
+      // the PaymentIntent object with a status of `processing`" (docs.stripe.com/payments/ach-direct-debit/accept-a-payment;
+      // 242035d1c); a test-mode debit then settles ("Test transactions settle instantly"), so the next read has succeeded
       const good = await h({ m: 'POST', p: `/v1/payment_intents/${id(pi)}/verify_microdeposits`, b: 'amounts[]=32&amounts[]=45' });
+      const settled = await h({ m: 'GET', p: `/v1/payment_intents/${id(pi)}` });
       const missing = await h({ m: 'POST', p: '/v1/payment_intents/pi_nope/verify_microdeposits', b: 'amounts[]=32&amounts[]=45' });
-      return ok(good) && field(good, 'status') === 'succeeded' && field(good, 'next_action') === null && missing.status === 404;
+      return ok(good) && field(good, 'status') === 'processing' && field(good, 'next_action') === null
+        && field(settled, 'status') === 'succeeded' && missing.status === 404;
     }),
   ),
   // SetupIntent micro-deposit verification: same flow for saving an ACH bank account — confirm
@@ -2817,7 +4679,7 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   // wrong descriptor 400s. (the requires_action microdeposit state is produced ONLY by this feature.)
   done('stripe.setup_intents.verify_microdeposits', 'payment_methods', 'SetupIntents: verify_microdeposits (ACH)', 'api', 'common', () =>
     withRoot(async (h) => {
-      const si = await h({ m: 'POST', p: '/v1/setup_intents', b: 'payment_method_types[]=us_bank_account' });
+      const si = await h({ m: 'POST', p: '/v1/setup_intents', b: 'allowed_payment_method_types[]=us_bank_account' });
       if (!ok(si)) return false;
       const conf = await h({ m: 'POST', p: `/v1/setup_intents/${id(si)}/confirm`, b: 'payment_method=pm_us_bank_account' });
       if (!ok(conf) || field(conf, 'status') !== 'requires_action' || (field(conf, 'next_action') as Body)?.type !== 'verify_with_microdeposits') return false;
@@ -2957,7 +4819,7 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       // editing a finalized (non-draft) invoice 400s; missing lines 400; unknown invoice 404.
       await h({ m: 'POST', p: `/v1/invoices/${id(inv)}/finalize` });
       const afterFinal = await h({ m: 'POST', p: `/v1/invoices/${id(inv)}/add_lines`, b: 'lines[0][amount]=100' });
-      const noLines = await h({ m: 'POST', p: `/v1/invoices/${id(inv)}/add_lines`, b: 'metadata[x]=1' });
+      const noLines = await h({ m: 'POST', p: `/v1/invoices/${id(inv)}/add_lines`, b: 'invoice_metadata[x]=1' });
       const missing = await h({ m: 'GET', p: '/v1/invoices/in_nope/lines' });
       return afterFinal.status === 400 && (noLines.status === 400) && missing.status === 404;
     }),
@@ -3026,28 +4888,35 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   // summary are produced ONLY by this feature.)
   done('stripe.billing.credit_grants', 'billing', 'Billing credit grants (prepaid credits)', 'api', 'niche', () =>
     withRoot(async (h) => {
+      // the served spec requires what a grant applies to (applicability_config) and what a balance summary filters on
+      // (filter), which the parameter check enforces (e6bfff516: "a missing required one [answers] 400
+      // parameter_missing", docs.stripe.com/error-codes#parameter-missing); every request gives them, so each refusal
+      // below is still the one it names
+      const APPLIES = 'applicability_config[scope][price_type]=metered';
+      const METERED = 'filter[type]=applicability_scope&filter[applicability_scope][price_type]=metered';
       const cust = await h({ m: 'POST', p: '/v1/customers', b: 'email=credgr@twin.test' });
-      const g = await h({ m: 'POST', p: '/v1/billing/credit_grants', b: `customer=${id(cust)}&category=promotional&name=Welcome&amount[type]=monetary&amount[monetary][value]=1000&amount[monetary][currency]=usd` });
+      const g = await h({ m: 'POST', p: '/v1/billing/credit_grants', b: `customer=${id(cust)}&category=promotional&name=Welcome&amount[type]=monetary&amount[monetary][value]=1000&amount[monetary][currency]=usd&${APPLIES}` });
       if (!ok(g) || field(g, 'object') !== 'billing.credit_grant' || field(g, 'category') !== 'promotional') return false;
       if (((field(g, 'amount') as Body)?.monetary as Body)?.value !== 1000) return false;
       const get = await h({ m: 'GET', p: `/v1/billing/credit_grants/${id(g)}` });
       const list = await h({ m: 'GET', p: `/v1/billing/credit_grants?customer=${id(cust)}` });
       if (!ok(get) || id(get) !== id(g) || ((list.body as Body).data as Body[]).length !== 1) return false;
       // balance summary reflects the active grant.
-      const sum = await h({ m: 'GET', p: `/v1/billing/credit_balance_summary?customer=${id(cust)}` });
+      const sum = await h({ m: 'GET', p: `/v1/billing/credit_balance_summary?customer=${id(cust)}&${METERED}` });
       const balances = (sum.body as Body).balances as Body[];
       if (!ok(sum) || (((balances[0]!.available_balance as Body).monetary as Body).value) !== 1000) return false;
       // void clears it from the balance.
       const voided = await h({ m: 'POST', p: `/v1/billing/credit_grants/${id(g)}/void` });
       if (!ok(voided) || field(voided, 'voided_at') === null) return false;
-      const sum2 = await h({ m: 'GET', p: `/v1/billing/credit_balance_summary?customer=${id(cust)}` });
+      const sum2 = await h({ m: 'GET', p: `/v1/billing/credit_balance_summary?customer=${id(cust)}&${METERED}` });
       if (((sum2.body as Body).balances as Body[]).length !== 0) return false;
       // vendor errors.
-      const noCust = await h({ m: 'POST', p: '/v1/billing/credit_grants', b: 'customer=cus_nope&category=paid&amount[type]=monetary&amount[monetary][value]=10&amount[monetary][currency]=usd' });
-      const badCat = await h({ m: 'POST', p: '/v1/billing/credit_grants', b: `customer=${id(cust)}&category=bogus&amount[type]=monetary&amount[monetary][value]=10&amount[monetary][currency]=usd` });
-      const noAmt = await h({ m: 'POST', p: '/v1/billing/credit_grants', b: `customer=${id(cust)}&category=paid` });
+      const noCust = await h({ m: 'POST', p: '/v1/billing/credit_grants', b: 'customer=cus_nope&category=paid&amount[type]=monetary&amount[monetary][value]=10&amount[monetary][currency]=usd&' + APPLIES });
+      const badCat = await h({ m: 'POST', p: '/v1/billing/credit_grants', b: `customer=${id(cust)}&category=bogus&amount[type]=monetary&amount[monetary][value]=10&amount[monetary][currency]=usd&${APPLIES}` });
+      const noAmt = await h({ m: 'POST', p: '/v1/billing/credit_grants', b: `customer=${id(cust)}&category=paid&${APPLIES}` });
       const missing = await h({ m: 'GET', p: '/v1/billing/credit_grants/credgr_nope' });
-      return noCust.status === 404 && badCat.status === 400 && noAmt.status === 400 && missing.status === 404;
+      return noCust.status === 404 && badCat.status === 400 && ((badCat.body as Body).error as Body)?.code === 'parameter_invalid_string_enum'
+        && noAmt.status === 400 && ((noAmt.body as Body).error as Body)?.param === 'amount' && missing.status === 404;
     }),
   ),
   // Billing meters lifecycle: create→list (status filter)→deactivate (active→inactive)→
@@ -3064,12 +4933,14 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       const e1 = await h({ m: 'POST', p: '/v1/billing/meter_events', b: `event_name=api_request&timestamp=100&payload[value]=3&payload[stripe_customer_id]=${id(cust)}` });
       const e2 = await h({ m: 'POST', p: '/v1/billing/meter_events', b: `event_name=api_request&timestamp=200&payload[value]=4&payload[stripe_customer_id]=${id(cust)}` });
       if (!ok(e1) || !ok(e2) || field(e1, 'object') !== 'billing.meter_event') return false;
-      const summary = await h({ m: 'GET', p: `/v1/billing/meters/${id(m)}/event_summaries?customer=${id(cust)}&start_time=0&end_time=1000` });
+      const summary = await h({ m: 'GET', p: `/v1/billing/meters/${id(m)}/event_summaries?customer=${id(cust)}&start_time=0&end_time=1020` });
       const sData = (summary.body as Body).data as Body[];
       if (!ok(summary) || sData[0]!.aggregated_value !== 7) return false;
       // an out-of-window event is excluded.
-      const summaryNarrow = await h({ m: 'GET', p: `/v1/billing/meters/${id(m)}/event_summaries?customer=${id(cust)}&start_time=150&end_time=1000` });
+      const summaryNarrow = await h({ m: 'GET', p: `/v1/billing/meters/${id(m)}/event_summaries?customer=${id(cust)}&start_time=120&end_time=1020` });
       if (((summaryNarrow.body as Body).data as Body[])[0]!.aggregated_value !== 4) return false;
+      // the window must be aligned with minute boundaries
+      if ((await h({ m: 'GET', p: `/v1/billing/meters/${id(m)}/event_summaries?customer=${id(cust)}&start_time=150&end_time=1020` })).status !== 400) return false;
       // deactivate → inactive; the active filter excludes it; reactivate → active.
       const off = await h({ m: 'POST', p: `/v1/billing/meters/${id(m)}/deactivate` });
       if (!ok(off) || field(off, 'status') !== 'inactive' || (field(off, 'status_transitions') as Body).deactivated_at === null) return false;
@@ -3088,7 +4959,7 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   done('stripe.billing.alerts', 'billing', 'Billing usage alerts (thresholds)', 'api', 'niche', () =>
     withRoot(async (h) => {
       const m = await h({ m: 'POST', p: '/v1/billing/meters', b: 'display_name=Calls&event_name=calls&default_aggregation[formula]=count' });
-      const a = await h({ m: 'POST', p: `/v1/billing/alerts`, b: `alert_type=usage_threshold&title=Heavy use&usage_threshold[gte]=100&usage_threshold[meter]=${id(m)}` });
+      const a = await h({ m: 'POST', p: `/v1/billing/alerts`, b: `alert_type=usage_threshold&title=Heavy use&usage_threshold[gte]=100&usage_threshold[meter]=${id(m)}&usage_threshold[recurrence]=one_time` });
       if (!ok(a) || field(a, 'object') !== 'billing.alert' || field(a, 'status') !== 'active') return false;
       if ((field(a, 'usage_threshold') as Body).gte !== 100) return false;
       const get = await h({ m: 'GET', p: `/v1/billing/alerts/${id(a)}` });
@@ -3100,7 +4971,7 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       const arch = await h({ m: 'POST', p: `/v1/billing/alerts/${id(a)}/archive` });
       // vendor errors.
       const badType = await h({ m: 'POST', p: '/v1/billing/alerts', b: 'alert_type=bogus&title=x&usage_threshold[gte]=1&usage_threshold[meter]=' + id(m) });
-      const badMeter = await h({ m: 'POST', p: '/v1/billing/alerts', b: 'alert_type=usage_threshold&title=x&usage_threshold[gte]=1&usage_threshold[meter]=mtr_nope' });
+      const badMeter = await h({ m: 'POST', p: '/v1/billing/alerts', b: 'alert_type=usage_threshold&title=x&usage_threshold[gte]=1&usage_threshold[meter]=mtr_nope&usage_threshold[recurrence]=one_time' });
       const missing = await h({ m: 'GET', p: '/v1/billing/alerts/alert_nope' });
       return ok(on) && field(on, 'status') === 'active' && ok(arch) && field(arch, 'status') === 'archived' &&
         badType.status === 400 && badMeter.status === 400 && missing.status === 404;
@@ -3155,8 +5026,9 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       // before subscribing: no active entitlements.
       const before = await h({ m: 'GET', p: `/v1/entitlements/active_entitlements?customer=${id(cust)}` });
       if (!ok(before) || ((before.body as Body).data as Body[]).length !== 0) return false;
-      // subscribe → entitled to the product's feature.
-      const sub = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(cust)}&items[0][price]=${id(price)}` });
+      // subscribe (the card pays the first invoice) → entitled to the product's feature.
+      const card = await h({ m: 'POST', p: '/v1/payment_methods/pm_card_visa/attach', b: `customer=${id(cust)}` });
+      const sub = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(cust)}&items[0][price]=${id(price)}&default_payment_method=${id(card)}` });
       if (!ok(sub)) return false;
       const after = await h({ m: 'GET', p: `/v1/entitlements/active_entitlements?customer=${id(cust)}` });
       const data = (after.body as Body).data as Body[];
@@ -3176,7 +5048,9 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
     withRoot(async (h) => {
       const calc = await h({ m: 'POST', p: '/v1/tax/calculations', b: 'currency=usd&line_items[0][amount]=1000&line_items[0][reference]=sku_1&customer_details[address][country]=US' });
       if (!ok(calc)) return false;
-      const txn = await h({ m: 'POST', p: '/v1/tax/transactions/create_from_calculation', b: `calculation=${id(calc)}&reference=order_123` });
+      // a transaction's line_items is "nullable object Includable" (docs.stripe.com/api/tax/transactions/object; 107591e5f):
+      // absent unless the request expands it, as it is here and on the reversal
+      const txn = await h({ m: 'POST', p: '/v1/tax/transactions/create_from_calculation', b: `calculation=${id(calc)}&reference=order_123&expand[]=line_items` });
       if (!ok(txn) || field(txn, 'object') !== 'tax.transaction' || field(txn, 'type') !== 'transaction' || field(txn, 'reference') !== 'order_123') return false;
       const txnLines = ((field(txn, 'line_items') as Body).data as Body[]) ?? [];
       if (txnLines.length !== 1 || txnLines[0]!.amount_tax !== 100) return false;
@@ -3184,7 +5058,8 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       const li = await h({ m: 'GET', p: `/v1/tax/transactions/${id(txn)}/line_items` });
       if (!ok(g) || id(g) !== id(txn) || ((li.body as Body).data as Body[]).length !== 1) return false;
       // a reversal NEGATES the amounts.
-      const rev = await h({ m: 'POST', p: '/v1/tax/transactions/create_reversal', b: `original_transaction=${id(txn)}&reference=refund_123&mode=full` });
+      if (field(g, 'line_items') !== undefined) return false;
+      const rev = await h({ m: 'POST', p: '/v1/tax/transactions/create_reversal', b: `original_transaction=${id(txn)}&reference=refund_123&mode=full&expand[]=line_items` });
       if (!ok(rev) || field(rev, 'type') !== 'reversal') return false;
       const revLines = ((field(rev, 'line_items') as Body).data as Body[]) ?? [];
       if (revLines[0]!.amount_tax !== -100 || (field(rev, 'reversal') as Body)?.original_transaction !== id(txn)) return false;
@@ -3243,25 +5118,19 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
         ok(li) && ((li.body as Body).data as Body[]).length === 1;
     }),
   ),
-  // Discount delete: attach a coupon to a customer (materializes the discount object) and to a
-  // subscription, then DELETE …/discount on each removes it (→ {object:'discount',deleted:true})
-  // and the resource's discount is cleared. Unknown customer 404. (the customer discount apply +
-  // both deletes are produced ONLY by this feature.)
-  done('stripe.discounts.delete', 'discounts', 'Customer/Subscription discount delete', 'api', 'common', () =>
+  // Discount delete: a subscription's coupon (discounts[0][coupon]) is removed by DELETE …/discount
+  // (→ {object:'discount',deleted:true}) and the subscription's discounts are cleared. A customer's discount has no
+  // create parameter in the served version (the customer-level coupon was removed), so an unknown customer's DELETE
+  // answers 404.
+  done('stripe.discounts.delete', 'discounts', 'Subscription discount delete', 'api', 'common', () =>
     withRoot(async (h) => {
       const coupon = await h({ m: 'POST', p: '/v1/coupons', b: 'percent_off=20&duration=forever' });
-      const cust = await h({ m: 'POST', p: '/v1/customers', b: `email=disc-del@twin.test&coupon=${id(coupon)}` });
-      if (!ok(cust) || (field(cust, 'discount') as Body)?.object !== 'discount') return false;
-      const delCust = await h({ m: 'DELETE', p: `/v1/customers/${id(cust)}/discount` });
-      if (!ok(delCust) || field(delCust, 'deleted') !== true) return false;
-      const c = await h({ m: 'GET', p: `/v1/customers/${id(cust)}` });
-      if (field(c, 'discount') !== null) return false;
-      // subscription discount delete.
-      const sub = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(cust)}&coupon=${id(coupon)}` });
+      const cust = await h({ m: 'POST', p: '/v1/customers', b: 'email=disc-del@twin.test' });
+      const sub = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(cust)}&discounts[0][coupon]=${id(coupon)}` });
       if (((field(sub, 'discounts') as Body[]) ?? []).length !== 1) return false;
       const delSub = await h({ m: 'DELETE', p: `/v1/subscriptions/${id(sub)}/discount` });
       const s = await h({ m: 'GET', p: `/v1/subscriptions/${id(sub)}` });
-      const badCoupon = await h({ m: 'POST', p: '/v1/customers', b: 'email=x@x.co&coupon=coupon_nope' });
+      const badCoupon = await h({ m: 'POST', p: '/v1/subscriptions', b: `customer=${id(cust)}&discounts[0][coupon]=coupon_nope` });
       const missing = await h({ m: 'DELETE', p: '/v1/customers/cus_nope/discount' });
       return ok(delSub) && field(delSub, 'deleted') === true && ((field(s, 'discounts') as Body[]) ?? []).length === 0 &&
         badCoupon.status === 400 && missing.status === 404;
@@ -3272,7 +5141,7 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   done('stripe.promotion_codes.update', 'discounts', 'Promotion codes: update (active toggle)', 'api', 'common', () =>
     withRoot(async (h) => {
       const coupon = await h({ m: 'POST', p: '/v1/coupons', b: 'percent_off=10&duration=once' });
-      const pc = await h({ m: 'POST', p: '/v1/promotion_codes', b: `coupon=${id(coupon)}&code=UPD10` });
+      const pc = await h({ m: 'POST', p: '/v1/promotion_codes', b: `promotion[type]=coupon&promotion[coupon]=${id(coupon)}&code=UPD10` });
       if (!ok(pc) || field(pc, 'active') !== true) return false;
       const off = await h({ m: 'POST', p: `/v1/promotion_codes/${id(pc)}`, b: 'active=false&metadata[campaign]=spring' });
       if (!ok(off) || field(off, 'active') !== false || ((field(off, 'metadata') as Body)?.campaign) !== 'spring') return false;
@@ -3327,21 +5196,23 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   // retrieve returned nothing, if a status update didn't persist, or if filtering were broken.
   done('stripe.issuing.tokens', 'issuing', 'Issuing: network tokens', 'api', 'niche', () =>
     withRoot(async (h) => {
-      // empty account: lists none, unknown ids 404 on retrieve + update.
-      const empty = await h({ m: 'GET', p: '/v1/issuing/tokens' });
+      const ch = await h({ m: 'POST', p: '/v1/issuing/cardholders', b: 'name=Jane&type=individual&billing[address][country]=US' });
+      const card = await h({ m: 'POST', p: '/v1/issuing/cards', b: `cardholder=${id(ch)}&currency=usd&type=virtual` });
+      // a card with no wallet yet lists none; the list is always of one card's tokens (the served spec requires `card`,
+      // which the parameter check enforces, e6bfff516), so the bare list is refused; unknown ids 404 on retrieve + update.
+      const empty = await h({ m: 'GET', p: `/v1/issuing/tokens?card=${id(card)}` });
       if (!ok(empty) || field(empty, 'object') !== 'list' || ((empty.body as Body).data as Body[]).length !== 0) return false;
+      const unscoped = await h({ m: 'GET', p: '/v1/issuing/tokens' });
+      if (unscoped.status !== 400 || ((unscoped.body as Body).error as Body)?.param !== 'card') return false;
       const missing = await h({ m: 'GET', p: '/v1/issuing/tokens/iss_tok_nope' });
       const badUpd = await h({ m: 'POST', p: '/v1/issuing/tokens/iss_tok_nope', b: 'status=active' });
       if (missing.status !== 404 || badUpd.status !== 404) return false;
-      // seed: a token is network-minted for a real card (no public create) via test_helpers.
-      const ch = await h({ m: 'POST', p: '/v1/issuing/cardholders', b: 'name=Jane&type=individual&billing[address][country]=US' });
-      const card = await h({ m: 'POST', p: '/v1/issuing/cards', b: `cardholder=${id(ch)}&currency=usd&type=virtual` });
-      const seeded = await h({ m: 'POST', p: '/v1/test_helpers/issuing/tokens', b: `card=${id(card)}` });
+      // a token is network-minted when the cardholder adds a real card to a phone's wallet (the twin's stand-in).
+      const seeded = await h({ m: 'POST', p: `/_twin/issuing/cards/${id(card)}/wallets`, b: 'wallet_provider=apple_pay' });
       if (!ok(seeded) || field(seeded, 'object') !== 'issuing.token' || field(seeded, 'status') !== 'active' || field(seeded, 'card') !== id(card)) return false;
       // minting requires a real card.
-      const badCard = await h({ m: 'POST', p: '/v1/test_helpers/issuing/tokens', b: 'card=ic_nope' });
-      const noCard = await h({ m: 'POST', p: '/v1/test_helpers/issuing/tokens' });
-      if (badCard.status !== 400 || noCard.status !== 400) return false;
+      const badCard = await h({ m: 'POST', p: '/_twin/issuing/cards/ic_nope/wallets', b: 'wallet_provider=apple_pay' });
+      if (badCard.status !== 400) return false;
       // retrieve the seeded token.
       const get = await h({ m: 'GET', p: `/v1/issuing/tokens/${id(seeded)}` });
       if (!ok(get) || id(get) !== id(seeded) || field(get, 'card') !== id(card) || field(get, 'status') !== 'active') return false;
@@ -3373,8 +5244,12 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   // (the design object + review status machine are produced ONLY by this feature.)
   done('stripe.issuing.personalization_designs', 'issuing', 'Issuing: card personalization designs', 'api', 'niche', () =>
     withRoot(async (h) => {
-      const d = await h({ m: 'POST', p: '/v1/issuing/personalization_designs', b: 'physical_bundle=ipb_test&name=Gold card' });
-      if (!ok(d) || field(d, 'object') !== 'issuing.personalization_design' || field(d, 'status') !== 'inactive') return false;
+      // the card logo must be a file of purpose issuing_logo; another purpose is refused
+      const logo = await h({ m: 'POST', p: '/v1/files', b: 'purpose=issuing_logo&file=logo.png' });
+      const icon = await h({ m: 'POST', p: '/v1/files', b: 'purpose=business_logo&file=icon.png' });
+      if ((await h({ m: 'POST', p: '/v1/issuing/personalization_designs', b: `physical_bundle=ics_NLuXJPDYSTjFON&card_logo=${id(icon)}` })).status !== 400) return false;
+      const d = await h({ m: 'POST', p: '/v1/issuing/personalization_designs', b: `physical_bundle=ics_NLuXJPDYSTjFON&name=Gold card&card_logo=${id(logo)}` });
+      if (!ok(d) || field(d, 'object') !== 'issuing.personalization_design' || field(d, 'status') !== 'review') return false;
       const get = await h({ m: 'GET', p: `/v1/issuing/personalization_designs/${id(d)}` });
       const upd = await h({ m: 'POST', p: `/v1/issuing/personalization_designs/${id(d)}`, b: 'name=Platinum' });
       if (!ok(get) || !ok(upd) || field(upd, 'name') !== 'Platinum') return false;
@@ -3383,7 +5258,8 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       if (!ok(act) || field(act, 'status') !== 'active') return false;
       const list = await h({ m: 'GET', p: '/v1/issuing/personalization_designs?status=active' });
       if (((list.body as Body).data as Body[]).length !== 1) return false;
-      const rej = await h({ m: 'POST', p: `/v1/test_helpers/issuing/personalization_designs/${id(d)}/reject` });
+      // a rejection says why: the served spec requires rejection_reasons (enforced by the parameter check, e6bfff516)
+      const rej = await h({ m: 'POST', p: `/v1/test_helpers/issuing/personalization_designs/${id(d)}/reject`, b: 'rejection_reasons[card_logo][]=inappropriate' });
       const noBundle = await h({ m: 'POST', p: '/v1/issuing/personalization_designs', b: 'name=x' });
       const missing = await h({ m: 'GET', p: '/v1/issuing/personalization_designs/pd_nope' });
       return ok(rej) && field(rej, 'status') === 'rejected' && noBundle.status === 400 && missing.status === 404;
@@ -3424,12 +5300,17 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   // produced ONLY by this feature.)
   done('stripe.treasury.financial_accounts', 'treasury', 'Treasury: financial accounts', 'api', 'niche', () =>
     withRoot(async (h) => {
-      const fa = await h({ m: 'POST', p: '/v1/treasury/financial_accounts', b: 'supported_currencies[]=usd&features[card_issuing][requested]=true&features[outbound_payments][requested]=true' });
+      // features as the served spec's treasury.financial_account_features gives them: a toggle (card_issuing) or one per
+      // network (outbound_payments.ach); a requested one is active at once in test mode and one never requested is left
+      // out, each being optional in the spec (semantics/treasury.ts featuresOf, dd5d4344f)
+      const fa = await h({ m: 'POST', p: '/v1/treasury/financial_accounts', b: 'supported_currencies[]=usd&features[card_issuing][requested]=true&features[outbound_payments][ach][requested]=true' });
       if (!ok(fa) || field(fa, 'object') !== 'treasury.financial_account' || field(fa, 'status') !== 'open') return false;
       const bal = field(fa, 'balance') as Body;
       if ((bal.cash as Body).usd !== 0) return false;
-      if ((((field(fa, 'features') as Body).card_issuing) as Body).status !== 'active') return false;
-      if ((((field(fa, 'features') as Body).deposit_insurance) as Body).status !== 'restricted') return false;
+      const features = field(fa, 'features') as Body;
+      if ((features.card_issuing as Body).status !== 'active' || ((features.outbound_payments as Body).ach as Body)?.status !== 'active') return false;
+      if (features.deposit_insurance !== undefined) return false;
+      if ((field(fa, 'active_features') as string[]).join(',') !== 'card_issuing,outbound_payments.ach') return false;
       const get = await h({ m: 'GET', p: `/v1/treasury/financial_accounts/${id(fa)}` });
       const list = await h({ m: 'GET', p: '/v1/treasury/financial_accounts?status=open' });
       const feats = await h({ m: 'GET', p: `/v1/treasury/financial_accounts/${id(fa)}/features` });
@@ -3489,20 +5370,27 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
         badFa.status === 400 && noDest.status === 400 && nope.status === 404;
     }),
   ),
-  // Treasury InboundTransfers: pull funds into a FinancialAccount. create→succeeded (test-mode
-  // synchronous settle), posting a ledger Transaction (cash↑). Requires amount/currency/
-  // financial_account/origin_payment_method. Unknown id 404. id ibt_.
+  // Treasury InboundTransfers: pull funds into a FinancialAccount. create→processing (funds inbound_pending), the
+  // test helper's succeed→succeeded, posting its ledger Transaction (cash↑). Requires amount/currency/
+  // financial_account/origin_payment_method, a bank account set up for inbound flows and verified. Unknown id 404. id ibt_.
   done('stripe.treasury.inbound_transfers', 'treasury', 'Treasury: inbound transfers / received credits', 'api', 'niche', () =>
     withRoot(async (h) => {
       const fa = await h({ m: 'POST', p: '/v1/treasury/financial_accounts', b: 'supported_currencies[]=usd&features[inbound_transfers][requested]=true' });
-      const it = await h({ m: 'POST', p: `/v1/treasury/inbound_transfers`, b: `amount=3000&currency=usd&financial_account=${id(fa)}&origin_payment_method=pm_y` });
-      if (!ok(it) || field(it, 'object') !== 'treasury.inbound_transfer' || field(it, 'status') !== 'succeeded' || !id(it).startsWith('ibt_')) return false;
-      if ((field(it, 'status_transitions') as Body)?.succeeded_at == null) return false;
+      // the pulled account is set up for inbound flows and verified with a SetupIntent; one that is not is refused
+      const si = await h({ m: 'POST', p: '/v1/setup_intents', b: 'attach_to_self=true&flow_directions[]=inbound&allowed_payment_method_types[]=us_bank_account&payment_method_options[us_bank_account][verification_method]=microdeposits' });
+      const conf = await h({ m: 'POST', p: `/v1/setup_intents/${id(si)}/confirm`, b: 'payment_method_data[type]=us_bank_account&payment_method_data[us_bank_account][account_number]=000123456789&payment_method_data[us_bank_account][routing_number]=110000000&payment_method_data[us_bank_account][account_holder_type]=company&payment_method_data[billing_details][name]=Ops' });
+      const pm = String(field(conf, 'payment_method'));
+      if ((await h({ m: 'POST', p: `/v1/treasury/inbound_transfers`, b: `amount=3000&currency=usd&financial_account=${id(fa)}&origin_payment_method=${pm}` })).status !== 400) return false;
+      await h({ m: 'POST', p: `/v1/setup_intents/${id(si)}/verify_microdeposits`, b: 'amounts[]=32&amounts[]=45' });
+      const it = await h({ m: 'POST', p: `/v1/treasury/inbound_transfers`, b: `amount=3000&currency=usd&financial_account=${id(fa)}&origin_payment_method=${pm}` });
+      if (!ok(it) || field(it, 'object') !== 'treasury.inbound_transfer' || field(it, 'status') !== 'processing' || !id(it).startsWith('ibt_')) return false;
+      const done = await h({ m: 'POST', p: `/v1/test_helpers/treasury/inbound_transfers/${id(it)}/succeed` });
+      if (!ok(done) || field(done, 'status') !== 'succeeded' || (field(done, 'status_transitions') as Body)?.succeeded_at == null) return false;
       const get = await h({ m: 'GET', p: `/v1/treasury/inbound_transfers/${id(it)}` });
       const list = await h({ m: 'GET', p: `/v1/treasury/inbound_transfers?financial_account=${id(fa)}` });
       if (!ok(get) || ((list.body as Body).data as Body[]).length !== 1) return false;
       // a ledger transaction was posted with cash↑.
-      const txns = await h({ m: 'GET', p: `/v1/treasury/transactions?financial_account=${id(fa)}&flow_type=inbound_transfer` });
+      const txns = await h({ m: 'GET', p: `/v1/treasury/transactions?financial_account=${id(fa)}` });
       const tdata = (txns.body as Body).data as Body[];
       if (tdata.length !== 1 || (tdata[0]!.balance_impact as Body)?.cash !== 3000 || tdata[0]!.status !== 'posted') return false;
       // received_credits/debits read surface exists (empty until a test flow materializes one).
@@ -3513,7 +5401,7 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
     }),
   ),
   // Climate (carbon removal): products/suppliers catalog (read-only) + orders. An order needs
-  // a valid product + exactly one of amount/metric_tons (else 400); starts awaiting_funds;
+  // a valid product + exactly one of amount/metric_tons (else 400); is confirmed when made;
   // cancel→canceled. amount_total = subtotal+fees. Unknown product 400; unknown order 404.
   done('stripe.climate.orders', 'climate', 'Climate: orders / products / suppliers', 'api', 'niche', () =>
     withRoot(async (h) => {
@@ -3522,8 +5410,8 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       if (pdata.length === 0 || pdata[0]!.object !== 'climate.product') return false;
       const suppliers = await h({ m: 'GET', p: '/v1/climate/suppliers' });
       if (((suppliers.body as Body).data as Body[])[0]?.object !== 'climate.supplier') return false;
-      const order = await h({ m: 'POST', p: '/v1/climate/orders', b: 'product=climsku_direct_air_capture&metric_tons=2' });
-      if (!ok(order) || field(order, 'object') !== 'climate.order' || field(order, 'status') !== 'awaiting_funds' || !id(order).startsWith('climorder_')) return false;
+      const order = await h({ m: 'POST', p: '/v1/climate/orders', b: 'product=climsku_frontier_offtake_portfolio_2027&metric_tons=2' });
+      if (!ok(order) || field(order, 'object') !== 'climate.order' || field(order, 'status') !== 'confirmed' || !id(order).startsWith('climorder_')) return false;
       if (field(order, 'amount_total') !== (field(order, 'amount_subtotal') as number) + (field(order, 'amount_fees') as number)) return false;
       const get = await h({ m: 'GET', p: `/v1/climate/orders/${id(order)}` });
       const list = await h({ m: 'GET', p: '/v1/climate/orders' });
@@ -3531,25 +5419,27 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       const cancel = await h({ m: 'POST', p: `/v1/climate/orders/${id(order)}/cancel` });
       if (!ok(cancel) || field(cancel, 'status') !== 'canceled') return false;
       const badProduct = await h({ m: 'POST', p: '/v1/climate/orders', b: 'product=climsku_nope&metric_tons=1' });
-      const bothAmounts = await h({ m: 'POST', p: '/v1/climate/orders', b: 'product=climsku_direct_air_capture&metric_tons=1&amount=1000' });
+      const bothAmounts = await h({ m: 'POST', p: '/v1/climate/orders', b: 'product=climsku_frontier_offtake_portfolio_2027&metric_tons=1&amount=1000' });
       const nope = await h({ m: 'GET', p: '/v1/climate/orders/climorder_nope' });
       return badProduct.status === 400 && bothAmounts.status === 400 && nope.status === 404;
     }),
   ),
-  // Financial Connections: create a session (requires account_holder + permissions), link an
-  // account via the hosted-flow test helper, then read accounts + the session's accounts
-  // sub-list. id fcsess_ / fca_. Missing permissions 400; unknown id 404.
+  // Financial Connections: create a session (requires account_holder + permissions), the person links the test
+  // bank's accounts in the flow Stripe.js opens, then read accounts + the session's accounts sub-list. id fcsess_ /
+  // fca_. Missing permissions 400; unknown id 404.
   done('stripe.financial_connections.sessions', 'financial_connections', 'Financial Connections: sessions + accounts', 'api', 'niche', () =>
-    withRoot(async (h) => {
+    withRoot(async (h, root) => {
       const sess = await h({ m: 'POST', p: '/v1/financial_connections/sessions', b: 'account_holder[type]=customer&account_holder[customer]=cus_1&permissions[]=transactions&permissions[]=balances' });
       if (!ok(sess) || field(sess, 'object') !== 'financial_connections.session' || !id(sess).startsWith('fcsess_')) return false;
       if (typeof field(sess, 'client_secret') !== 'string') return false;
-      const acc = await h({ m: 'POST', p: `/v1/financial_connections/sessions/${id(sess)}/link_account` });
-      if (!ok(acc) || field(acc, 'object') !== 'financial_connections.account' || !id(acc).startsWith('fca_') || field(acc, 'status') !== 'active') return false;
+      await hostedSubmit(root, stripeFinancialConnectionsFlow, `https://js.stripe.com/v3/financial-connections/${String(field(sess, 'client_secret'))}`, { answer: 'link' });
       const getSess = await h({ m: 'GET', p: `/v1/financial_connections/sessions/${id(sess)}` });
-      if (((field(getSess, 'accounts') as Body)?.data as Body[]).length !== 1) return false;
+      const linked = ((field(getSess, 'accounts') as Body)?.data as Body[]) ?? [];
+      if (!linked.length) return false;
+      const acc = { status: 200, body: linked[0]! } as StripeResponse;
+      if (field(acc, 'object') !== 'financial_connections.account' || !id(acc).startsWith('fca_') || field(acc, 'status') !== 'active') return false;
       const accounts = await h({ m: 'GET', p: '/v1/financial_connections/accounts' });
-      if (((accounts.body as Body).data as Body[]).length !== 1) return false;
+      if (((accounts.body as Body).data as Body[]).length !== linked.length) return false;
       const getAcc = await h({ m: 'GET', p: `/v1/financial_connections/accounts/${id(acc)}` });
       const disc = await h({ m: 'POST', p: `/v1/financial_connections/accounts/${id(acc)}/disconnect` });
       const noPerms = await h({ m: 'POST', p: '/v1/financial_connections/sessions', b: 'account_holder[type]=customer&account_holder[customer]=cus_1' });
@@ -3557,20 +5447,17 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       return ok(getAcc) && ok(disc) && field(disc, 'status') === 'disconnected' && noPerms.status === 400 && nope.status === 404;
     }),
   ),
-  // Financial Connections account transactions: list a linked account's transactions
-  // (also via /v1/financial_connections/transactions?account=). Requires account; 404 unknown.
+  // Financial Connections transactions: a linked account's, listed by account. Requires account.
   done('stripe.financial_connections.transactions', 'financial_connections', 'Financial Connections: account transactions', 'api', 'niche', () =>
-    withRoot(async (h) => {
+    withRoot(async (h, root) => {
       const sess = await h({ m: 'POST', p: '/v1/financial_connections/sessions', b: 'account_holder[type]=customer&account_holder[customer]=cus_1&permissions[]=transactions' });
-      const acc = await h({ m: 'POST', p: `/v1/financial_connections/sessions/${id(sess)}/link_account` });
-      const txns = await h({ m: 'GET', p: `/v1/financial_connections/accounts/${id(acc)}/transactions` });
-      const tdata = (txns.body as Body).data as Body[];
-      if (tdata.length !== 2 || tdata[0]!.object !== 'financial_connections.transaction' || tdata[0]!.account !== id(acc)) return false;
-      const flat = await h({ m: 'GET', p: `/v1/financial_connections/transactions?account=${id(acc)}` });
-      if (((flat.body as Body).data as Body[]).length !== 2) return false;
+      await hostedSubmit(root, stripeFinancialConnectionsFlow, `https://js.stripe.com/v3/financial-connections/${String(field(sess, 'client_secret'))}`, { answer: 'link' });
+      const acc = ((field(await h({ m: 'GET', p: `/v1/financial_connections/sessions/${id(sess)}` }), 'accounts') as Body).data as Body[])[0]!;
+      const flat = await h({ m: 'GET', p: `/v1/financial_connections/transactions?account=${String(acc.id)}` });
+      const tdata = (flat.body as Body).data as Body[];
+      if (!tdata.length || tdata[0]!.object !== 'financial_connections.transaction' || tdata[0]!.account !== acc.id) return false;
       const noAcct = await h({ m: 'GET', p: '/v1/financial_connections/transactions' });
-      const nope = await h({ m: 'GET', p: '/v1/financial_connections/accounts/fca_nope/transactions' });
-      return noAcct.status === 400 && nope.status === 404;
+      return noAcct.status === 400;
     }),
   ),
   // Forwarding: PAN forwarding requests. create requires payment_method + url; stores the
@@ -3589,19 +5476,10 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       return noPm.status === 400 && noUrl.status === 400 && nope.status === 404;
     }),
   ),
-  // Crypto onramp sessions: create an initialized session with a client_secret + transaction
-  // details, then retrieve. id cos_. Unknown id 404. (The hosted purchase widget is OOS.)
-  done('stripe.crypto.onramp', 'core', 'Crypto onramp sessions', 'api', 'niche', () =>
-    withRoot(async (h) => {
-      const cos = await h({ m: 'POST', p: '/v1/crypto/onramp_sessions', b: 'transaction_details[destination_currency]=eth&transaction_details[destination_network]=ethereum&transaction_details[source_amount]=100' });
-      if (!ok(cos) || field(cos, 'object') !== 'crypto.onramp_session' || field(cos, 'status') !== 'initialized' || !id(cos).startsWith('cos_')) return false;
-      if (typeof field(cos, 'client_secret') !== 'string') return false;
-      if ((field(cos, 'transaction_details') as Body)?.destination_currency !== 'eth') return false;
-      const get = await h({ m: 'GET', p: `/v1/crypto/onramp_sessions/${id(cos)}` });
-      const nope = await h({ m: 'GET', p: '/v1/crypto/onramp_sessions/cos_nope' });
-      return ok(get) && field(get, 'id') === id(cos) && nope.status === 404;
-    }),
-  ),
+  // Crypto onramp sessions (POST/GET /v1/crypto/onramp_sessions, docs.stripe.com/crypto/onramp/api-reference) are Stripe
+  // API, but not in the spec this pack vendors and serves; the twin's hand route for them was removed with the other
+  // routes outside the served spec (5decb1d77), so the capability is a todo again until the lane models it.
+  todo('stripe.crypto.onramp', 'core', 'Crypto onramp sessions', 'api', 'niche'),
   // ── HONEST DENOMINATOR GROWTH (real Stripe surfaces NOT yet modeled) ────────────────
   // The gaps above were closed this cycle; these enumerate genuine remaining surface so the