@volter/twin-stripe 2.0.0 → 2.0.1

package/dist/src/stripe-capabilities.js

@@ -7,7 +7,7 @@
 // hidden gap, and a high % against a thin list is a misleading metric (the bug this fixes).
 import { mkdtempSync, rmSync } from 'node:fs';
 import { createServer } from 'node:http';
-import { emitTwinEvent } from '@volter/world-core';
+import { applyTwinWrite, emitTwinEvent } from '@volter/world-core';
 import { stripeEmitter } from "./stripe-emit.js";
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
@@ -21,6 +21,7 @@ import { fullSyncStripe } from "./stripe-connector.js";
 import { buildStripeMirrorClient, createStripeMirrorServer, formatStripeAmount } from "./stripe-mirror-ui.js";
 import { handleStripeTwinRequest } from "./stripe-twin.js";
 import { createStripeTwinFetch } from "./stripe-server.js";
+import { SERVED_VERSION } from "./stripe-version.js";
 import { pack } from "./index.js";
 import { stripeIdentityFlow } from "./screens/identity.js";
 import { stripeFinancialConnectionsFlow } from "./screens/financial-connections.js";
@@ -38,7 +39,7 @@ function uiDataCoupled(opts) {
         const server = await createStripeMirrorServer({ root, port: 0 });
         try {
             const h = (s) => 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 = (path) => fetch(`${base}${path}`).then((r) => r.json());
             const post = (path, body) => fetch(`${base}${path}`, { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: body ?? '' }).then((r) => r.json());
@@ -93,9 +94,11 @@ async function fundIssuing(root, amount, at) {
 }
 const ok = (r) => 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) {
-    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);
@@ -119,6 +122,47 @@ function fetcher(f) {
         method: m, headers: { authorization: 'Bearer sk_test_twin', 'content-type': 'application/x-www-form-urlencoded', ...(acct ? { 'stripe-account': acct } : {}) }, ...(b !== undefined ? { body: b } : {}),
     }))).json());
 }
+// ── 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 = OAUTH_CALLBACK) => `client_id=ca_twin_self&scope=read_write&response_type=code${redirect === null ? '' : `&redirect_uri=${encodeURIComponent(redirect)}`}&state=st8${extra}`;
+/** A fresh World with a Connect platform whose OAuth is on and whose callback is registered (unless `configure` is false). */
+async function withOAuth(run, configure = true) {
+    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 = {
+        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()) };
+        },
+        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()) };
+        },
+        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, amount = 1000) {
     await h({ m: 'POST', p: '/v1/charges', b: `amount=${amount}&currency=usd&source=tok_createDispute` });
@@ -222,8 +266,10 @@ export const STRIPE_CAPABILITIES = [
             l2.body.data.length === 0 && noType.status === 400 && missingCust.status === 404;
     })),
     // 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', () => withRoot(async (h) => {
@@ -231,10 +277,10 @@ export const STRIPE_CAPABILITIES = [
         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` });
@@ -310,7 +356,11 @@ export const STRIPE_CAPABILITIES = [
         const beforeN = before.body.data.length;
         const afterN = after.body.data.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;
     })),
     // ── PaymentIntents ───────────────────────────────────────────────────────────────
     done('stripe.payment_intents.create', 'payment_intents', 'PaymentIntents: create + retrieve + list', 'api', 'core', () => withRoot(async (h) => {
@@ -593,7 +643,12 @@ export const STRIPE_CAPABILITIES = [
         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')?.data;
@@ -746,19 +801,26 @@ export const STRIPE_CAPABILITIES = [
     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) => 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) => 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)
+            // 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' });
@@ -832,7 +894,7 @@ export const STRIPE_CAPABILITIES = [
             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');
@@ -866,6 +928,98 @@ export const STRIPE_CAPABILITIES = [
             rmSync(root, { recursive: true, force: true });
         }
     }),
+    // Test mode's clock, as Stripe documents it (docs.stripe.com/testing#available-balance; semantics/ledger.ts): a card
+    // that bypasses the pending balance (4000000000000077, 4000003720000278, their pm_card_/tok_ names) puts its funds in
+    // the available balance at once, a PaymentMethod saved from it too when a later charge names it by id, and a
+    // source_transaction transfer from that charge is available on the connected account at once ("takes on the pending
+    // status of the associated charge", docs.stripe.com/connect/separate-charges-and-transfers); the drain in that same
+    // instant sends each account balance.available. Every other card keeps the delay (4242 pending), and a test payout
+    // keeps live timing ("Test payouts simulate a live payout", docs.stripe.com/payouts#test-payouts): paid at its
+    // arrival_date, not before. Dub's partner payout reaches Completed this way without World time for the funds. A US
+    // bank account debit settles at once too ("Test transactions settle instantly and are added to your available test
+    // balance", docs.stripe.com/testing), and every credit available at once is sent as balance.available.
+    done('stripe.balance.test_mode_bypass_pending', 'balance', 'Test-mode funds timing: bypass cards (raw, by test name, saved as a PaymentMethod) and bank debits available at once with balance.available sent, source_transaction transfers inheriting it; 4242 and test payouts keep their timing', 'api', 'common', async () => {
+        const root = mkdtempSync(join(tmpdir(), 'stp-bypass-'));
+        const rx = await webhookReceiver();
+        try {
+            let now = '2026-06-01T12:00:00.000Z';
+            const h = fetcher(createStripeTwinFetch({ root, clock: () => now }));
+            await h('POST', '/v1/webhook_endpoints', `url=${rx.url('/connect')}&enabled_events[]=balance.available&enabled_events[]=payout.paid&connect=true`);
+            const seller = String((await h('POST', '/v1/accounts', 'type=custom&country=US&capabilities[transfers][requested]=true&business_profile[mcc]=5462&business_profile[url]=https://seller.test&tos_acceptance[date]=1767225600&tos_acceptance[ip]=203.0.113.9&business_type=individual&individual[first_name]=Jordan&individual[last_name]=Lee&settings[payouts][schedule][interval]=manual')).id);
+            await h('POST', `/v1/accounts/${seller}/external_accounts`, 'external_account[object]=bank_account&external_account[country]=US&external_account[currency]=usd&external_account[routing_number]=110000000&external_account[account_number]=000123456789');
+            await h('POST', '/_twin/account', 'settings[payouts][schedule][interval]=manual');
+            const btOf = async (charge) => h('GET', `/v1/balance_transactions/${String((await h('GET', `/v1/charges/${String(charge)}`)).balance_transaction)}`);
+            const amounts = async (acct) => {
+                const b = await h('GET', '/v1/balance', undefined, acct);
+                return { available: b.available[0]?.amount ?? 0, pending: b.pending[0]?.amount ?? 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?.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?.balance_transaction?.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 () => (await h('POST', '/_twin/drain')).delivered.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.available?.[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?.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
@@ -880,7 +1034,7 @@ export const STRIPE_CAPABILITIES = [
             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 () => {
-                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)}`);
@@ -1061,7 +1215,11 @@ export const STRIPE_CAPABILITIES = [
     done('stripe.promotion_codes.create', 'discounts', 'PromotionCode create + activate/deactivate', 'api', 'common', () => withRoot(async (h) => {
         const coupon = await h({ m: 'POST', p: '/v1/coupons', b: 'percent_off=10&duration=once' });
         const pc = await h({ m: 'POST', p: '/v1/promotion_codes', b: `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))
+        // 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')?.type !== 'coupon' || field(pc, 'promotion')?.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' });
@@ -1253,10 +1411,16 @@ export const STRIPE_CAPABILITIES = [
             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)
+        // 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').data;
-        const prorations = lines.filter((l) => l.proration === true);
+        const prorationOf = (l) => l.parent?.subscription_item_details?.proration ?? l.parent?.invoice_item_details?.proration;
+        if (lines.some((l) => 'proration' in l))
+            return false;
+        const prorations = lines.filter((l) => prorationOf(l) === true);
         return prorations.length === 2 && prorations.some((l) => Number(l.amount) < 0) && prorations.some((l) => Number(l.amount) > 0);
     })),
     // Renewal over time: at the period's end a subscription_cycle invoice is drafted and, an hour on, charged to the
@@ -1265,7 +1429,10 @@ export const STRIPE_CAPABILITIES = [
     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) => 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) => 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' });
@@ -1454,7 +1621,10 @@ export const STRIPE_CAPABILITIES = [
     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) => 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) => 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' });
@@ -1514,31 +1684,32 @@ export const STRIPE_CAPABILITIES = [
         return ok(g) && id(g) === id(sched) && l.body.data.length === 1 &&
             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', () => 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' });
+    // 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 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.data;
         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.data;
-        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),
     // materialized as the canonical discount object on the sub; update can attach/replace, and
@@ -1614,11 +1785,12 @@ export const STRIPE_CAPABILITIES = [
         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)}` });
@@ -1642,12 +1814,17 @@ export const STRIPE_CAPABILITIES = [
     done('stripe.invoices.send', 'invoices', 'Invoice send / mark_uncollectible / pay out-of-band', 'api', 'common', () => 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)
+        // 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)
             return false;
         // a second invoice can be marked uncollectible
         const inv2 = await h({ m: 'POST', p: '/v1/invoices', b: `customer=${id(cust)}` });
@@ -1667,7 +1844,11 @@ export const STRIPE_CAPABILITIES = [
         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)
+        // 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)
@@ -1686,14 +1867,21 @@ export const STRIPE_CAPABILITIES = [
     done('stripe.credit_notes', 'invoices', 'CreditNotes (create/preview/void/list)', 'api', 'common', () => 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)}` });
@@ -1739,7 +1927,9 @@ export const STRIPE_CAPABILITIES = [
     // becomes a real trialing window) — and the Session itself never echoes the param.
     done('stripe.checkout.subscription_data', 'checkout', 'Checkout completion copies subscription_data (metadata + trial) onto the created subscription', 'api', 'core', () => withRoot(async (h) => {
         const cust = await h({ m: 'POST', p: '/v1/customers', b: 'email=subdata@twin.test' });
-        const cs = await h({ m: 'POST', p: '/v1/checkout/sessions', b: `mode=subscription&success_url=https://x.test&customer=${id(cust)}&line_items[0][price_data][currency]=usd&line_items[0][price_data][unit_amount]=999&line_items[0][quantity]=1&subscription_data[metadata][attemptId]=att_cap_1&subscription_data[trial_period_days]=7` });
+        // the inline price is a subscription's: a product and a recurring interval (docs.stripe.com/api/checkout/sessions/create,
+        // line_items.price_data), so the subscription has an item to carry its period (c3a378808 bills inline prices)
+        const cs = await h({ m: 'POST', p: '/v1/checkout/sessions', b: `mode=subscription&success_url=https://x.test&customer=${id(cust)}&line_items[0][price_data][currency]=usd&line_items[0][price_data][unit_amount]=999&line_items[0][price_data][product_data][name]=Plan&line_items[0][price_data][recurring][interval]=month&line_items[0][quantity]=1&subscription_data[metadata][attemptId]=att_cap_1&subscription_data[trial_period_days]=7` });
         if (!ok(cs) || field(cs, 'subscription_data') !== undefined || field(cs, '_subscription_data') !== undefined)
             return false;
         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' });
@@ -1748,8 +1938,12 @@ export const STRIPE_CAPABILITIES = [
             return false;
         const sub = await h({ m: 'GET', p: `/v1/subscriptions/${field(completed, 'subscription')}` });
         const md = field(sub, 'metadata');
+        // 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')?.data ?? [])[0];
         return ok(sub) && md?.attemptId === 'att_cap_1' && field(sub, 'status') === 'trialing'
-            && typeof field(sub, 'trial_end') === 'number' && field(sub, 'trial_end') === field(sub, 'current_period_end');
+            && typeof field(sub, 'trial_end') === 'number' && field(sub, 'trial_end') === item?.current_period_end
+            && field(sub, 'current_period_end') === undefined;
     })),
     // A subscription session's customer pays its first invoice on the page: the invoice is paid through a succeeded
     // PaymentIntent and its charge, and the card is the subscription's default payment method
@@ -1762,11 +1956,100 @@ export const STRIPE_CAPABILITIES = [
         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.data ?? [];
+        const pi = await h({ m: 'GET', p: `/v1/payment_intents/${String(payments[0]?.payment?.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.data ?? [];
+        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.data ?? [];
+        // the list is newest first: the attach is older than the subscription's creation and the session's completion
+        const at = (type) => 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.object.id === pmId && attached[0].data.object.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) => 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.object.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.object.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, path, body) => (await f(new Request(`http://stripe.test${path}`, { method, headers: { 'content-type': 'application/x-www-form-urlencoded' }, ...(body ? { body } : {}) }))).json();
+            const post = (url, email) => 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) => 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?.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 ?? [];
+            const typed = bareInput !== '' && !/readonly/i.test(bareInput) && paid2.status === 303 && bareAfter.email === 'typed@twin.test'
+                && updated.length === 1 && updated[0].data.object.id === bare.id && updated[0].data.object.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.
@@ -1774,7 +2057,7 @@ export const STRIPE_CAPABILITIES = [
         const root = mkdtempSync(join(tmpdir(), 'stp-expiry-'));
         try {
             const f = createStripeTwinFetch({ root, clock: () => '2026-03-01T00:00:00Z' });
-            const api = async (method, path, body) => (await f(new Request(`https://api.stripe.com${path}`, { method, headers: { 'content-type': 'application/x-www-form-urlencoded' }, ...(body ? { body } : {}) }))).json();
+            const api = async (method, path, body) => (await f(new Request(`http://stripe.test${path}`, { method, headers: { 'content-type': 'application/x-www-form-urlencoded' }, ...(body ? { body } : {}) }))).json();
             const pay = (cs, expiry) => 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();
@@ -1811,7 +2094,7 @@ export const STRIPE_CAPABILITIES = [
         const root = mkdtempSync(join(tmpdir(), 'stp-trialpage-'));
         try {
             const f = createStripeTwinFetch({ root, clock: () => '2026-03-01T00:00:00Z' });
-            const api = async (method, path, body) => (await f(new Request(`https://api.stripe.com${path}`, { method, headers: { 'content-type': 'application/x-www-form-urlencoded' }, ...(body ? { body } : {}) }))).json();
+            const api = async (method, path, body) => (await f(new Request(`http://stripe.test${path}`, { method, headers: { 'content-type': 'application/x-www-form-urlencoded' }, ...(body ? { body } : {}) }))).json();
             const text = async (cs) => (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)}`);
@@ -1829,14 +2112,14 @@ export const STRIPE_CAPABILITIES = [
             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) => (await later(new Request(`https://api.stripe.com${path}`))).json();
+            const read = async (path) => (await later(new Request(`http://stripe.test${path}`))).json();
             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 ?? [];
@@ -2013,7 +2296,7 @@ export const STRIPE_CAPABILITIES = [
         const root = mkdtempSync(join(tmpdir(), 'stp-public-'));
         try {
             const f = createStripeTwinFetch({ root });
-            const api = async (method, path, body, account) => (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();
+            const api = async (method, path, body, account) => (await f(new Request(`http://stripe.test${path}`, { method, headers: { 'content-type': 'application/x-www-form-urlencoded', ...(account ? { 'stripe-account': account } : {}) }, ...(body ? { body } : {}) }))).json();
             const page = async (url) => (await f(new Request(url))).text();
             const save = (name) => 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');
@@ -2052,12 +2335,12 @@ export const STRIPE_CAPABILITIES = [
             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();
-            const doorEvents = (await (await door(new Request('https://api.stripe.com/v1/events?type=account.updated'))).json()).data ?? [];
+            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();
+            const doorEvents = (await (await door(new Request('http://stripe.test/v1/events?type=account.updated'))).json()).data ?? [];
             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')
@@ -2086,7 +2369,10 @@ export const STRIPE_CAPABILITIES = [
     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) => 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) => 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' });
@@ -2200,7 +2486,7 @@ export const STRIPE_CAPABILITIES = [
         const root = mkdtempSync(join(tmpdir(), 'stp-src-'));
         try {
             const h = (s) => 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' });
@@ -2291,6 +2577,11 @@ export const STRIPE_CAPABILITIES = [
             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, type, object) => rx.got(path).filter((e) => e.type === type && e.data.object.id === object);
@@ -2317,7 +2608,7 @@ export const STRIPE_CAPABILITIES = [
             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}`);
@@ -2342,24 +2633,42 @@ export const STRIPE_CAPABILITIES = [
             rmSync(root, { recursive: true, force: true });
         }
     }),
-    done('stripe.connect.top_ups', 'connect', 'Top-ups (fund platform balance)', 'api', 'niche', () => withRoot(async (h) => {
-        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;
-        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 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.data.length === 1 &&
-            cancel.status === 400 && noMoney.status === 400 && nope.status === 404;
-    })),
+    // 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) => 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') !== '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 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) && pendingList.body.data.length === 1
+                && ok(canceled) && field(canceled, 'status') === 'canceled'
+                && field(arrived, 'status') === 'succeeded' && typeof field(arrived, 'balance_transaction') === 'string'
+                && l.body.data.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')
+        // 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);
@@ -2724,11 +3033,12 @@ export const STRIPE_CAPABILITIES = [
             const ev = events.body.data.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.data
                 .find((e) => e.type === 'payment_intent.created' && e.data?.object?.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))
@@ -2748,8 +3058,11 @@ export const STRIPE_CAPABILITIES = [
         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;
@@ -2838,21 +3151,19 @@ export const STRIPE_CAPABILITIES = [
     // 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;
-            const calcs = (await get('/v1/tax/calculations')).data;
-            if (!rates.length || !calcs.length)
+            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');
         },
     })),
     // ── Issuing ──────────────────────────────────────────────────────────────────────
@@ -2941,10 +3252,18 @@ export const STRIPE_CAPABILITIES = [
         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.data[0];
+        if (txns.body.data.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;
@@ -3012,6 +3331,9 @@ export const STRIPE_CAPABILITIES = [
             const root2 = mkdtempSync(join(tmpdir(), 'stp-cap-'));
             try {
                 const h2 = (s) => 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')
@@ -3021,8 +3343,14 @@ export const STRIPE_CAPABILITIES = [
                 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') ?? [];
+                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 });
@@ -3310,9 +3638,18 @@ export const STRIPE_CAPABILITIES = [
     // 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)
+        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.data ?? [];
+        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' });
@@ -3352,62 +3689,37 @@ export const STRIPE_CAPABILITIES = [
             ok(delList) && field(delList, 'deleted') === true && gone.status === 404 &&
             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.data.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.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 ?? [];
             const valueLists = (await get('/v1/radar/value_lists')).data ?? [];
-            const rules = (await get('/v1/radar/rules')).data ?? [];
-            // 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 ?? [])[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)
+            if (!review || !vl)
                 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).
             const reviewsMarkup = renderSectionList('reviews', reviews);
             const valueListsMarkup = renderSectionList('radar/value_lists', valueLists);
-            const rulesMarkup = renderSectionList('radar/rules', rules);
-            return (
-            // reviews + rules render their id in the row subtitle; the value-list row renders its
-            // name + alias (the id is not surfaced in that section's row), so assert those instead.
-            listRows(reviewsMarkup) === reviews.length && reviewsMarkup.includes(String(review.id)) &&
-                listRows(valueListsMarkup) === valueLists.length && valueListsMarkup.includes('UI Blocked IPs') && valueListsMarkup.includes('ui_block_ips') &&
-                listRows(rulesMarkup) === rules.length && rulesMarkup.includes(String(rule.id)) && rulesMarkup.includes('block'));
+            // a review's row names its charge; the value-list row renders its name + alias
+            return listRows(reviewsMarkup) === reviews.length && reviewsMarkup.includes(String(review.charge))
+                && listRows(valueListsMarkup) === valueLists.length && valueListsMarkup.includes('UI Blocked IPs') && valueListsMarkup.includes('ui_block_ips');
         },
     })),
     // ── Reporting ────────────────────────────────────────────────────────────────────
@@ -3700,8 +4012,10 @@ export const STRIPE_CAPABILITIES = [
                 return false;
             const summaryMarkup = renderToStaticMarkup(createElement(BalanceSummary, { row: { id: 'balance', ...balance } }));
             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',
@@ -3821,7 +4135,12 @@ export const STRIPE_CAPABILITIES = [
     // 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;
             if (!rows || rows.length < 1)
@@ -3894,15 +4213,22 @@ export const STRIPE_CAPABILITIES = [
     // ════════════════════════════════════════════════════════════════════════════════════
     // ── 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')
+        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;
@@ -3925,12 +4251,16 @@ export const STRIPE_CAPABILITIES = [
     })),
     // ── Mandates retrieve ──
     done('stripe.mandates.retrieve', 'payment_methods', 'Mandates: retrieve (404 unknown)', 'api', 'niche', () => withRoot(async (h) => {
-        const m = await h({ m: 'POST', p: '/v1/mandates', b: 'payment_method=pm_card_visa' });
-        if (!ok(m) || field(m, 'object') !== 'mandate')
-            return false;
-        const g = await h({ m: 'GET', p: `/v1/mandates/${id(m)}` });
+        // Stripe's API makes no mandate on request (the twin's seeding POST /v1/mandates was invented and is gone,
+        // 5decb1d77): a mandate is the customer's acceptance a verified bank account carries, and a SetupIntent verified by
+        // micro-deposits names its multi-use one (docs.stripe.com/api/mandates, docs.stripe.com/api/setup_intents/object mandate)
+        const si = await h({ m: 'POST', p: '/v1/setup_intents', b: 'allowed_payment_method_types[]=us_bank_account' });
+        await h({ m: 'POST', p: `/v1/setup_intents/${id(si)}/confirm`, b: 'payment_method=pm_us_bank_account' });
+        const verified = await h({ m: 'POST', p: `/v1/setup_intents/${id(si)}/verify_microdeposits`, b: 'descriptor_code=SM11AA' });
+        const mandateId = String(field(verified, 'mandate'));
+        const g = await h({ m: 'GET', p: `/v1/mandates/${mandateId}` });
         const miss = await h({ m: 'GET', p: '/v1/mandates/mandate_nope' });
-        return ok(g) && id(g) === id(m) && field(g, 'status') === 'active' && miss.status === 404;
+        return ok(g) && field(g, 'object') === 'mandate' && id(g) === mandateId && field(g, 'status') === 'active' && field(g, 'type') === 'multi_use' && miss.status === 404;
     })),
     // ── Refund cancel ──
     // A bank-transfer payment's refund waits in requires_action for the customer's bank details (Stripe emails them), and
@@ -3970,6 +4300,292 @@ export const STRIPE_CAPABILITIES = [
         return ok(inc) && field(inc, 'amount') === 1500 && field(inc, 'amount_capturable') === 1500 && field(inc, 'status') === 'requires_capture' && bad.status === 400
             && field(held, 'amount') === 1500 && field(taken, 'amount_captured') === 1500 && field(taken, 'amount_refunded') === 0 && field(taken, 'refunded') === false;
     })),
+    // ── Connect OAuth for Standard accounts (screens/connect-oauth.tsx; docs.stripe.com/connect/oauth-reference) ──
+    // The platform's OAuth settings: "Enable onboarding accounts with OAuth", "Copy your client_id", "Set your redirect_uri
+    // ... If you don't include the redirect_uri parameter in your request, Stripe defaults to using the first address you've
+    // configured" (docs.stripe.com/connect/oauth-standard-accounts). The page shows the client_id and what was saved, and
+    // authorize holds the platform to it.
+    done('stripe.connect.oauth_settings', 'connect', 'Dashboard Connect OAuth settings: the client_id shown, OAuth enabled and redirect URIs registered, which authorize holds the platform to', 'ui', 'common', () => withOAuth(async (w) => {
+        const read = async (path) => (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());
+        // 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()).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());
+        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());
+        // turned off again, authorize refuses again
+        await w.settings(false, OAUTH_CALLBACK);
+        const offAgain = (await (await w.authorize(authorizeQuery())).json()).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) => { const r = await w.authorize(query); return { status: r.status, ...(await r.json()) }; };
+        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.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;
+        // 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?.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?.dashboard?.display_name === 'Ada Consulting'
+            && acct.requirements?.currently_due?.length === 0 && acct.details_submitted === true && acct.payouts_enabled === true
+            && acct.charges_enabled === true && acct.capabilities?.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, auth) => { const r = await w.endpoint('token', body, auth); return { status: r.status, ...r.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());
+        // 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.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?.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) => { const r = await w.endpoint('token', body); return { status: r.status, ...r.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, auth) => { const r = await w.endpoint('deauthorize', body, auth); return { status: r.status, ...r.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.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?.code === 'account_invalid' && String(asIt.body.error?.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());
+                const leaked = rx.got('/connect').slice(seen).filter((e) => e.account === account);
+                const app = authorized[0]?.data.object;
+                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.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, p, key, b, acct) => {
+            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()) };
+        };
+        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());
+        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.map((e) => e.data.object.id);
+        const ours = (await w.api('GET', '/v1/events?type=customer.created')).body.data.map((e) => e.data.object.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?.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?.code === 'secret_key_required'
+            && elsewhere.status === 403 && elsewhere.body.error?.code === 'account_invalid'
+            && oldToken.status === 401 && newToken.status === 200 && (newToken.body.data ?? []).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) => {
         const acct = await h({ m: 'POST', p: '/v1/accounts', b: 'type=express' });
@@ -4026,7 +4642,12 @@ export const STRIPE_CAPABILITIES = [
         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')?.currently_due ?? [];
+        return ok(g) && field(g, 'object') === 'capability' && ok(req) && field(req, 'requested') === true && field(req, 'status') === 'inactive'
+            && due.includes('business_profile.mcc') && miss.status === 404;
     })),
     // ── Connect: transfer reversals ──
     done('stripe.connect.transfer_reversals', 'connect', 'Connect: transfer reversals (partial + full)', 'api', 'niche', () => withRoot(async (h) => {
@@ -4097,15 +4718,20 @@ export const STRIPE_CAPABILITIES = [
     // duplicate); /delete deletes it. A user-scope secret requires scope[user]. (the
     // 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')
+        if (!ok(set) || field(set, 'object') !== 'apps.secret' || field(set, 'payload') !== undefined)
             return false;
-        const find = await h({ m: 'GET', p: '/v1/apps/secrets/find?name=api_key&scope[type]=account' });
+        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.data.length !== 1)
             return false;
@@ -4128,8 +4754,9 @@ export const STRIPE_CAPABILITIES = [
     // 400s; unknown id 404. (the balance-reconciliation transition is produced ONLY here.)
     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;
@@ -4140,7 +4767,7 @@ export const STRIPE_CAPABILITIES = [
         if (na?.type !== 'display_bank_transfer_instructions' || na.display_bank_transfer_instructions.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;
@@ -4171,10 +4798,14 @@ export const STRIPE_CAPABILITIES = [
         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
     // with the verification PM → requires_action; descriptor_code SM11AA verifies → succeeded; a
@@ -4398,8 +5029,14 @@ export const STRIPE_CAPABILITIES = [
     // active (non-voided, non-expired) grants per currency. (the prepaid balance + draw-down
     // 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')?.monetary?.value !== 1000)
@@ -4409,7 +5046,7 @@ export const STRIPE_CAPABILITIES = [
         if (!ok(get) || id(get) !== id(g) || list.body.data.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.balances;
         if (!ok(sum) || (balances[0].available_balance.monetary.value) !== 1000)
             return false;
@@ -4417,15 +5054,16 @@ export const STRIPE_CAPABILITIES = [
         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.balances.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.error?.code === 'parameter_invalid_string_enum'
+            && noAmt.status === 400 && noAmt.body.error?.param === 'amount' && missing.status === 404;
     })),
     // Billing meters lifecycle: create→list (status filter)→deactivate (active→inactive)→
     // reactivate, plus meter event_summaries that aggregate the meter's events for a customer
@@ -4567,7 +5205,9 @@ export const STRIPE_CAPABILITIES = [
         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').data ?? [];
@@ -4578,7 +5218,9 @@ export const STRIPE_CAPABILITIES = [
         if (!ok(g) || id(g) !== id(txn) || li.body.data.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').data ?? [];
@@ -4719,17 +5361,21 @@ export const STRIPE_CAPABILITIES = [
     // / list+filter. An empty account still lists none; unknown ids still 404. This fails if
     // 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.data.length !== 0)
             return false;
+        const unscoped = await h({ m: 'GET', p: '/v1/issuing/tokens' });
+        if (unscoped.status !== 400 || unscoped.body.error?.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;
@@ -4793,7 +5439,8 @@ export const STRIPE_CAPABILITIES = [
         const list = await h({ m: 'GET', p: '/v1/issuing/personalization_designs?status=active' });
         if (list.body.data.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;
@@ -4830,15 +5477,21 @@ export const STRIPE_CAPABILITIES = [
     // Unknown id 404. (the opened account + per-currency zero balance + feature map are
     // 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');
         if (bal.cash.usd !== 0)
             return false;
-        if ((field(fa, 'features').card_issuing).status !== 'active')
+        const features = field(fa, 'features');
+        if (features.card_issuing.status !== 'active' || features.outbound_payments.ach?.status !== 'active')
+            return false;
+        if (features.deposit_insurance !== undefined)
             return false;
-        if ((field(fa, 'features').deposit_insurance).status !== 'restricted')
+        if (field(fa, 'active_features').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' });
@@ -5021,20 +5674,10 @@ export const STRIPE_CAPABILITIES = [
         const nope = await h({ m: 'GET', p: '/v1/forwarding/requests/fwdr_nope' });
         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')?.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
     // % stays honest (a missing entry is a hidden gap). Each is a real Stripe API.