npm - @volter/twin-stripe - Versions diffs - 2.0.0 → 2.0.2 - Mend

@volter/twin-stripe 2.0.0 → 2.0.2

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 (67) hide show

package/README.md +33 -1
package/dist/src/index.js +6 -4
package/dist/src/manifest.js +8 -3
package/dist/src/screens/checkout.js +20 -6
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/portal.js +2 -0
package/dist/src/semantics/after-payment.d.ts +1 -1
package/dist/src/semantics/after-payment.js +6 -0
package/dist/src/semantics/charges.js +10 -2
package/dist/src/semantics/checkout.js +19 -6
package/dist/src/semantics/connect.js +20 -3
package/dist/src/semantics/invoices.js +4 -0
package/dist/src/semantics/issuing.js +7 -2
package/dist/src/semantics/ledger.d.ts +11 -6
package/dist/src/semantics/ledger.js +40 -21
package/dist/src/semantics/payment-methods.js +2 -0
package/dist/src/semantics/shared.d.ts +5 -1
package/dist/src/semantics/shared.js +14 -3
package/dist/src/semantics/test-cards.d.ts +4 -0
package/dist/src/semantics/test-cards.js +7 -0
package/dist/src/semantics/transfers.js +1 -1
package/dist/src/stripe-capabilities.js +829 -186
package/dist/src/stripe-conformance.d.ts +2 -0
package/dist/src/stripe-conformance.js +11 -2
package/dist/src/stripe-emit.js +2 -2
package/dist/src/stripe-events.js +14 -10
package/dist/src/stripe-mirror-ui.js +3 -3
package/dist/src/stripe-server.js +97 -24
package/dist/src/stripe-shared.d.ts +3 -0
package/dist/src/stripe-shared.js +3 -0
package/dist/src/stripe-twin.js +7 -1
package/dist/src/stripe-version.d.ts +2 -0
package/dist/src/stripe-version.js +2 -0
package/dist/test-fixtures/stripe-known-deviations.json +6 -1
package/dist/test-fixtures/stripe-schemas.json +85 -12
package/package.json +4 -4
package/src/index.ts +6 -4
package/src/manifest.ts +8 -3
package/src/screens/checkout.tsx +21 -6
package/src/screens/connect-oauth.tsx +400 -0
package/src/screens/connect-settings.tsx +121 -0
package/src/screens/portal.tsx +2 -0
package/src/semantics/after-payment.ts +6 -1
package/src/semantics/charges.ts +11 -2
package/src/semantics/checkout.ts +19 -6
package/src/semantics/connect.ts +19 -3
package/src/semantics/invoices.ts +4 -0
package/src/semantics/issuing.ts +7 -2
package/src/semantics/ledger.ts +60 -23
package/src/semantics/payment-methods.ts +2 -0
package/src/semantics/shared.ts +14 -3
package/src/semantics/test-cards.ts +7 -0
package/src/semantics/transfers.ts +1 -1
package/src/stripe-capabilities.ts +826 -182
package/src/stripe-conformance.ts +13 -2
package/src/stripe-emit.ts +2 -2
package/src/stripe-events.ts +14 -10
package/src/stripe-mirror-ui.ts +3 -3
package/src/stripe-server.ts +85 -24
package/src/stripe-shared.ts +3 -0
package/src/stripe-twin.ts +6 -1
package/src/stripe-version.ts +3 -0
package/test-fixtures/stripe-known-deviations.json +6 -1
package/test-fixtures/stripe-schemas.json +85 -12

package/src/stripe-capabilities.ts CHANGED Viewed

@@ -8,7 +8,7 @@
 import { mkdtempSync, rmSync } from 'node:fs';
 import { createServer } from 'node:http';
 import type { AddressInfo } from 'node:net';
-import { emitTwinEvent } from '@volter/world-core';
+import { applyTwinWrite, emitTwinEvent } from '@volter/world-core';
 import { stripeEmitter } from './stripe-emit.ts';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
@@ -31,6 +31,7 @@ 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';
@@ -54,7 +55,7 @@ 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 () => {
@@ -64,7 +65,7 @@ function uiDataCoupled(opts: {
     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>);
@@ -124,9 +125,11 @@ async function fundIssuing(root: string, amount: number, at?: string): Promise<S
 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, a bank account), and funds in the platform's balance to send it. Answers the account id. */
+ *  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' });
+  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);
@@ -150,6 +153,57 @@ function fetcher(f: (r: Request) => Promise<Response>): (m: string, p: string, b
     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` });
@@ -256,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', () =>
@@ -265,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;
@@ -336,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;
     }),
   ),
@@ -629,7 +689,11 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       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;
-      const partial = await h({ m: 'GET', p: `/v1/charges/${id(c)}` });
+      // `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;
@@ -793,16 +857,22 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   done('stripe.payouts.reverse', 'payouts', 'Payout reverse (a connected account\'s paid payout)', 'api', 'niche', async () => {
     const root = mkdtempSync(join(tmpdir(), 'stp-rev-'));
     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')}T00:00:00Z`, ...(s.acct ? { stripeAccount: s.acct } : {}) });
+      // 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 });
-      if (!ok(rev) || field(rev, 'original_payout') !== id(p) || field(rev, 'amount') !== 4000) return false;
+      // 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 plat = await h({ m: 'POST', p: '/v1/payouts', b: 'amount=1000&currency=usd' });
       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' });
@@ -872,7 +942,7 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       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&settings[payouts][schedule][interval]=manual')).id);
+      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');
@@ -906,6 +976,96 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
     }
   }),
+  // 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
@@ -920,7 +1080,7 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       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&settings[payouts][schedule][interval]=manual')).id);
+        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)}`);
@@ -1104,7 +1264,10 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
     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: `promotion[type]=coupon&promotion[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;
+      // 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' });
@@ -1284,9 +1447,14 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       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: 'POST', p: '/v1/invoices/create_preview', b: `subscription=${id(sub)}&subscription_details[proration_date]=100` });
-      if (!ok(up) || field(up, 'object') !== 'invoice' || field(up, 'id') !== null) return false;
+      // 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);
     }),
   ),
@@ -1296,7 +1464,10 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   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 {
-      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')}-10T00:00:00Z` });
+      // 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' });
@@ -1471,7 +1642,10 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   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 {
-      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')}-10T00:00:00Z` });
+      // 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' });
@@ -1528,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),
@@ -1622,11 +1797,12 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       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.
+      // 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)}` });
+      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)}` });
@@ -1651,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` });
@@ -1676,7 +1856,10 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       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)}&discounts[0][coupon]=${id(coupon)}` });
       const up = await h({ m: 'POST', p: '/v1/invoices/create_preview', b: `subscription=${id(sub)}` });
-      if (!ok(up) || field(up, 'object') !== 'invoice' || field(up, 'id') !== null) return false;
+      // 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[];
@@ -1694,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` });
@@ -1750,15 +1939,21 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   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;
       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
@@ -1773,12 +1968,101 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       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'))}` });
-      const pi = await h({ m: 'GET', p: `/v1/payment_intents/${String(field(inv, 'payment_intent'))}` });
+      // 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.
@@ -1786,7 +2070,7 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
     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(`https://api.stripe.com${path}`, { method, headers: { 'content-type': 'application/x-www-form-urlencoded' }, ...(body ? { body } : {}) }))).json() as Promise<Body>;
+      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();
@@ -1822,7 +2106,7 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
     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(`https://api.stripe.com${path}`, { method, headers: { 'content-type': 'application/x-www-form-urlencoded' }, ...(body ? { body } : {}) }))).json() as Promise<Body>;
+      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)}`);
@@ -1840,13 +2124,13 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       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('https://api.stripe.com/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}` }));
+      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(`https://api.stripe.com${path}`))).json() as Promise<Body>;
+      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) ?? [];
@@ -2020,7 +2304,7 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
     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(`https://api.stripe.com${path}`, { method, headers: { 'content-type': 'application/x-www-form-urlencoded', ...(account ? { 'stripe-account': account } : {}) }, ...(body ? { body } : {}) }))).json() as Promise<Body>;
+      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');
@@ -2059,12 +2343,12 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       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('https://api.stripe.com/_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' }));
+      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('https://api.stripe.com/_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('https://api.stripe.com/v1/account'))).json() as Body;
-      const doorEvents = (((await (await door(new Request('https://api.stripe.com/v1/events?type=account.updated'))).json()) as Body).data as Body[] | undefined) ?? [];
+      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')
@@ -2094,7 +2378,10 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
   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 {
-      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')}-10T00:00:00Z` });
+      // 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' });
@@ -2208,7 +2495,7 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
     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&settings[payouts][schedule][interval]=manual' });
+      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' });
@@ -2288,6 +2575,11 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       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);
@@ -2313,7 +2605,7 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       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')).id);
+      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}`);
@@ -2335,27 +2627,42 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       rmSync(root, { recursive: true, force: true });
     }
   }),
-  done('stripe.connect.top_ups', 'connect', 'Top-ups (fund platform balance)', 'api', 'niche', () =>
-    withRoot(async (h) => {
+  // 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);
     }),
@@ -2670,11 +2977,12 @@ 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 }); }
   }),
@@ -2687,8 +2995,11 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
     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: the clock advances for a few seconds (a second advance meanwhile is refused), then the
@@ -2775,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');
     },
   })),
@@ -2873,10 +3182,16 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       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' });
@@ -2934,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;
@@ -2942,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 });
       }
@@ -3195,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;
@@ -3235,62 +3566,36 @@ 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');
     },
   })),
@@ -3560,8 +3865,10 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       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',
@@ -3677,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: '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;
@@ -3750,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;
@@ -3783,11 +4100,16 @@ 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;
     }),
   ),
@@ -3833,6 +4155,304 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
     }),
   ),
+  // ── 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) => {
@@ -3892,7 +4512,12 @@ 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;
     }),
   ),
@@ -3969,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.
@@ -3998,8 +4627,9 @@ 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' });
+      // 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` });
@@ -4007,7 +4637,7 @@ export const STRIPE_CAPABILITIES: CapabilitySpec[] = [
       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.
@@ -4034,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
@@ -4254,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)→
@@ -4407,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;
@@ -4415,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;
@@ -4552,15 +5196,18 @@ 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;
       // a token is network-minted when the cardholder adds a real card to a phone's wallet (the twin's stand-in).
-      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: `/_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.
@@ -4611,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;
@@ -4652,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` });
@@ -4823,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