@volter/twin-stripe 2.0.0 → 2.0.2

package/src/semantics/checkout.ts

@@ -155,9 +155,20 @@ async function complete(ctx: SemanticsContext, id: string, existing: Row, card?:
   const link: Row = { status: 'complete' };
   const customer = typeof existing.customer === 'string' ? existing.customer : undefined;
   const currency = typeof existing.currency === 'string' ? existing.currency : 'usd';
-  // the entered card becomes a PaymentMethod, on the customer when there is one, carrying what a later charge to it
-  // answers and what Stripe does after it succeeds (docs.stripe.com/testing#declined-payments, #disputes)
-  const pm = card && existing.mode !== 'setup' ? await created(ctx, 'payment_method', {}, { type: 'card', customer: customer ?? null, livemode: false, billing_details: { address: null, email: null, name: null, phone: null }, ...paymentMethodSubObject('card', { card }), _declineOutcome: declineFor(() => undefined, { card }) ?? null, ...(afterSuccessOf(ctx, card) ? { _afterSuccess: afterSuccessOf(ctx, card) } : {}) }) : undefined;
+  // the entered card becomes a PaymentMethod carrying what a later charge to it answers and what Stripe does after it
+  // succeeds (docs.stripe.com/testing#declined-payments, #disputes)
+  const made = card ? await created(ctx, 'payment_method', {}, { type: 'card', customer: null, livemode: false, billing_details: { address: null, email: null, name: null, phone: null }, ...paymentMethodSubObject('card', { card }), _declineOutcome: declineFor(() => undefined, { card }) ?? null, ...(afterSuccessOf(ctx, card) ? { _afterSuccess: afterSuccessOf(ctx, card) } : {}) }) : undefined;
+  // and Checkout attaches it to the customer when it saves it: a subscription's card ("If your Checkout Session uses
+  // subscription mode, Stripe saves the payment method by default", docs.stripe.com/payments/checkout/how-checkout-works),
+  // a setup session's (it exists to save one), and a payment's only under payment_intent_data.setup_future_usage ("to have
+  // Checkout automatically attach the payment method to the Customer you pass in", docs.stripe.com/api/checkout/sessions/
+  // create#create_checkout_session-customer). Attaching is its own write, so payment_method.attached is delivered ("Occurs
+  // whenever a new payment method is attached to a customer", docs.stripe.com/api/events/types) before what the card then
+  // pays for. Where the documentation stops and the twin decides: the order of the events, which Stripe does not
+  // guarantee (docs.stripe.com/webhooks#event-ordering). A gap: the customer's own opt-in to save a payment's card
+  // (saved_payment_method_options.payment_method_save) is not modelled; the page offers no such box.
+  const saves = existing.mode !== 'payment' || !!((ctx.row(CS, id)?._payment_intent_data ?? {}) as Row).setup_future_usage;
+  const pm = made && customer && saves ? await ctx.write('payment_method', String(made.id), { customer }, 'payment_method.attach') : made;
   if (existing.mode === 'payment') {
     const amount = Number(existing.amount_total) || 0;
     const piId = ctx.mint('payment_intent');
@@ -166,6 +177,8 @@ async function complete(ctx: SemanticsContext, id: string, existing: Row, card?:
       ...(pid.application_fee_amount !== undefined ? { application_fee_amount: Math.trunc(Number(pid.application_fee_amount) || 0) } : {}),
       ...(pid.transfer_data && typeof pid.transfer_data === 'object' ? { transfer_data: { destination: (pid.transfer_data as Row).destination } } : {}),
       ...(typeof pid.description === 'string' ? { description: pid.description } : {}),
+      // the session's setup_future_usage is its PaymentIntent's (payment_intent_data: "A subset of parameters to be passed to PaymentIntent creation")
+      ...(typeof pid.setup_future_usage === 'string' ? { setup_future_usage: pid.setup_future_usage } : {}),
       ...(pid.metadata && typeof pid.metadata === 'object' ? { metadata: pid.metadata } : {}),
     };
     const fields = { amount, currency, id: piId, ...(customer ? { customer } : {}), ...(pm ? { payment_method: pm.id } : {}), ...connect };
@@ -219,7 +232,7 @@ async function complete(ctx: SemanticsContext, id: string, existing: Row, card?:
       link.invoice = invoice;
     }
     link.payment_status = 'paid';
-  } else link.setup_intent = await completeSetup(ctx, customer);
+  } else link.setup_intent = await completeSetup(ctx, customer, pm);
   return link;
 }
 
@@ -254,9 +267,9 @@ async function sessionPrices(ctx: SemanticsContext, lines: Row[], inline: Array<
 }
 
 /** A setup session saves the card through a succeeded SetupIntent (docs.stripe.com/payments/save-and-reuse?platform=checkout). */
-async function completeSetup(ctx: SemanticsContext, customer: string | undefined): Promise<unknown> {
+async function completeSetup(ctx: SemanticsContext, customer: string | undefined, pm: Row | undefined): Promise<unknown> {
   const siId = ctx.mint('setup_intent');
-  const si = await created(ctx, 'setup_intent', { id: siId, ...(customer ? { customer } : {}) }, { status: 'succeeded', usage: 'off_session', client_secret: mintClientSecret(siId), payment_method_types: ['card'], livemode: false });
+  const si = await created(ctx, 'setup_intent', { id: siId, ...(customer ? { customer } : {}), ...(pm ? { payment_method: pm.id } : {}) }, { status: 'succeeded', usage: 'off_session', client_secret: mintClientSecret(siId), payment_method_types: ['card'], livemode: false });
   return si.id;
 }
 

package/src/semantics/connect.ts

@@ -7,6 +7,7 @@ import type { Semantics, SemanticsContext } from '@volter/world-core';
 import { ACCOUNT_TYPES, accountCapabilities, accountRequirements, accountSettings, asBool, PLATFORM_ACCOUNT_ID } from '../stripe-twin.ts';
 import { currentlyDue, kindOf } from '../screens/onboarding.tsx';
 import { at, created, externalList, fail, list, newest, path, syncExternals, type Row } from './shared.ts';
+import { OAUTH_CONNECTIONS } from '../stripe-shared.ts';
 
 const accountMissing = (ctx: SemanticsContext, id: string, status = 404): Response => fail(ctx, `No such account: '${id}'`, status, 'resource_missing');
 /** The account, tombstones included where the hand-written routes looked past a deletion. */
@@ -27,7 +28,17 @@ export const platformAccountDefault = (): Row => ({
   external_accounts: externalList(PLATFORM_ACCOUNT_ID, []), tos_acceptance: { date: null, ip: null, user_agent: null }, business_profile: {},
   settings: accountSettings(undefined), livemode: false,
 });
-const platform: Semantics = async (ctx) => ctx.reply(ctx.get('account', PLATFORM_ACCOUNT_ID) ?? platformAccountDefault());
+// GET /v1/account answers the account the request acts as: with the Stripe-Account header (or a connected account's OAuth
+// key, which acts as it: stripe-server.ts) that connected account, "Retrieves the details of an account"
+// (docs.stripe.com/api/accounts/retrieve; docs.stripe.com/connect/authentication), else the platform's own
+const platform: Semantics = async (ctx) => {
+  const acting = ctx.call.request.headers.get('stripe-account');
+  const connected = acting && acting !== PLATFORM_ACCOUNT_ID ? ctx.get('account', acting) : undefined;
+  // a Stripe-Account naming no account is refused as Stripe refuses a Stripe-Account the key cannot use (account_invalid,
+  // docs.stripe.com/error-codes; stripe-server.ts revokedAccountRefused words it the same)
+  if (acting && acting !== PLATFORM_ACCOUNT_ID && !connected) return fail(ctx, `The provided key does not have access to account '${acting}' (or that account does not exist). Application access may have been revoked.`, 403, 'account_invalid');
+  return ctx.reply(connected ?? ctx.get('account', PLATFORM_ACCOUNT_ID) ?? platformAccountDefault());
+};
 
 /** A new Express account owes what its hosted onboarding will ask for (screens/onboarding.tsx; the US sets
  *  docs.stripe.com/connect/required-verification-information lists), or, where the twin does not model the set, the
@@ -70,8 +81,13 @@ function controllerOf(type: string): Row {
   return { type: 'application', is_controller: true, losses: { payments: losses }, fees: { payer }, requirement_collection: collection, stripe_dashboard: { type: dashboard } };
 }
 
-// connected accounts only: the platform's own is not one
-const listAccounts: Semantics = async (ctx) => list(ctx, 'account', newest(ctx, 'account').filter((a) => a.id !== PLATFORM_ACCOUNT_ID));
+// connected accounts only: the platform's own is not one, and neither is an account whose OAuth connection was revoked,
+// which "can't be accessed by your platform in the Dashboard or through the API" (docs.stripe.com/connect/oauth-reference;
+// its connection row is OAUTH_CONNECTIONS, screens/connect-oauth.tsx)
+const listAccounts: Semantics = async (ctx) => {
+  const revoked = new Set(ctx.rowsRaw(OAUTH_CONNECTIONS).filter((c) => c.revoked === true).map((c) => c.id));
+  return list(ctx, 'account', newest(ctx, 'account').filter((a) => a.id !== PLATFORM_ACCOUNT_ID && !revoked.has(a.id)));
+};
 
 /** What a Custom account still owes, from what the platform has given for it, as Stripe's requirements endpoint lists it
  *  for a US account with no Stripe Dashboard and the full service agreement

package/src/semantics/invoices.ts

@@ -314,7 +314,11 @@ const pay: Semantics = async (ctx) => {
   if (decline) return send(ctx, cardError(decline, intent ? { payment_intent: intent } : {}));
   const amountPaid = Number(inv.total ?? inv.amount_due) || 0;
   let body = await ctx.write(INV, id, {
+    // paid outside Stripe, the invoice counts it as such: `amount_paid_off_stripe`, "Amount, in cents (or local
+    // equivalent), that was paid on the invoice outside of Stripe" (served spec, invoice), the only place the served
+    // version shows it now that basil renders no `paid_out_of_band` (stripe-version.ts)
     status: 'paid', paid: true, paid_out_of_band: paidOutOfBand, amount_paid: amountPaid, amount_remaining: 0,
+    ...(paidOutOfBand ? { amount_paid_off_stripe: amountPaid } : {}),
     status_transitions: { ...transitions(inv), paid_at: ctx.now() },
   }, 'invoice.pay');
   if (!paidOutOfBand && typeof inv.payment_intent === 'string' && inv.payment_intent) {

package/src/semantics/issuing.ts

@@ -393,10 +393,15 @@ const captureAuthorization: Semantics = async (ctx) => {
   const remaining = (Number(auth.amount) || 0) - capturedSoFar;
   const captureAmount = ctx.params.capture_amount !== undefined ? Math.trunc(Number(ctx.params.capture_amount) || 0) : remaining;
   if (captureAmount <= 0 || captureAmount > remaining) return fail(ctx, 'Invalid capture_amount: must be a positive integer no greater than the uncaptured authorized amount.', 400, 'parameter_invalid_integer');
-  // the capture releases what the approval held and debits the transaction
+  // the capture releases what the approval held and debits the transaction; a capture that closes the authorization
+  // releases ALL it still holds, the uncaptured rest included: the amount is held "until the authorization is either
+  // captured, voided, or expired without capture" (docs.stripe.com/issuing/purchases/authorizations), and a closed
+  // authorization can be captured no further (close_authorization "Defaults to true. Set to false to enable
+  // multi-capture flows", the served spec). A capture that keeps it open releases only what it captured.
   const currency = typeof auth.currency === 'string' ? auth.currency : 'usd';
+  const released = closeAuthorization ? remaining : captureAmount;
   const release = await created(ctx, 'balance_transaction', {}, {
-    amount: captureAmount, currency, fee: 0, net: captureAmount, type: 'issuing_authorization_release',
+    amount: released, currency, fee: 0, net: released, type: 'issuing_authorization_release',
     status: 'available', balance_type: 'issuing', reporting_category: 'issuing_authorization_release',
     available_on: ctx.now(), fee_details: [], source: id,
   });

package/src/semantics/ledger.ts

@@ -6,8 +6,29 @@
 //
 // Where the documentation stops and the twin decides: the fee is Stripe's standard US card pricing, 2.9% + 30¢
 // (stripe.com/pricing), for every charge; funds become available two days after capture (Stripe's standard US
-// payout schedule counts business days); the card 4000000000000077 settles at once, as Stripe's test card of that
-// number does (docs.stripe.com/testing#available-balance).
+// payout schedule counts business days).
+//
+// Test mode (the twin serves livemode: false), as docs.stripe.com/testing documents it:
+// - cards keep that delay but two: "Other test cards send funds from a successful payment to your pending balance",
+//   while 4000000000000077 and 4000003720000278 (and their test names pm_card_bypassPending,
+//   pm_card_bypassPendingInternational, tok_bypassPending, tok_bypassPendingInternational) "succeed. Funds are added
+//   directly to your available balance, bypassing your pending balance" (#available-balance; test-cards.ts). A
+//   PaymentMethod made from one keeps that (payment-methods.ts, after-payment.ts), so a saved card charged later by
+//   id bypasses too;
+// - a US bank account debit: "Test transactions settle instantly and are added to your available test balance. This
+//   behavior differs from live mode" (ACH Direct Debit, "Test settlement behavior");
+// - a source_transaction transfer "takes on the pending status of the associated charge"
+//   (docs.stripe.com/connect/separate-charges-and-transfers), so it is available at once when its charge is;
+// - "Test payouts simulate a live payout but aren't processed with the bank" (docs.stripe.com/payouts#test-payouts):
+//   the payout clock (semantics/balance.ts) is live's.
+// No other test-mode speed-up is documented, so 4242 4242 4242 4242 funds sit pending the two days.
+//
+// Where the documentation stops and the twin decides: every credit written available at once (a bypass or bank-debit
+// charge, a transfer, a transfer from such a charge, an application fee, a top-up, an Issuing top-up included, a reversal) is marked not yet
+// sent, and the drain sends its account balance.available for it ("Occurs whenever your Stripe balance has been
+// updated (e.g., when a charge is available to be paid out). ... This event is not fired for negative
+// transactions", docs.stripe.com/api/events/types), as it does for funds that came due after the delay. The Balance
+// it carries is the account's at the drain: a debit or an automatic payout landing first shows in it.
 //
 // Each connected account keeps its own balance (docs.stripe.com/connect/account-balances): a transaction belongs to
 // the account the request acts for (the Stripe-Account header), else to the platform. A transfer takes its amount out
@@ -15,45 +36,53 @@
 // less the application fee, available when the charge's funds are; a direct charge's application fee moves from the
 // connected account to the platform.
 import type { Semantics, SemanticsContext } from '@volter/world-core';
-import { at, created, fail, inRange, kept, list, newest, where, type Row } from './shared.ts';
+import { asOf, at, created, fail, inRange, kept, list, newest, where, type Row } from './shared.ts';
+import { BYPASS_PENDING_CARDS } from './test-cards.ts';
 
 const BT = 'balance_transaction';
 const DAY = 86_400;
-const BYPASS_PENDING = '4000000000000077';
+/** A ledger entry's mark: available at once, its balance.available not yet sent (settleDueEntries). */
+const UNSENT = '_availableUnsent';
+const BYPASS_NUMBERS = new Set(Object.values(BYPASS_PENDING_CARDS).map((c) => c.number));
+
+/** Whether a charge's funds go straight to the available balance: a bypass card as a raw number, a test name (pm_card_*
+ *  or tok_*), or a stored PaymentMethod made from one (which records it as what follows its success, after-payment.ts);
+ *  or a US bank account, stored or one of Stripe's test bank accounts named as one (pm_usBankAccount_*). */
+export function bypassesPending(ctx: SemanticsContext, card: string | undefined): boolean {
+  if (!card) return false;
+  const stored = ctx.row('payment_method', card);
+  // the row carries what the method recorded; its type is the vendor object's (ctx.get), not the row's envelope
+  if (stored) return stored._afterSuccess === 'available' || ctx.get('payment_method', card)?.type === 'us_bank_account';
+  if (/^pm_us_?bank_?account/i.test(card)) return true;
+  return BYPASS_NUMBERS.has(card.replace(/\D/g, '')) || card.replace(/^tok_/, 'pm_card_') in BYPASS_PENDING_CARDS;
+}
 
 const feeOf = (amount: number): number => (amount > 0 ? Math.round(amount * 0.029) + 30 : 0);
 
-/** A transaction as the clock reads it: available once its available_on has passed, the clock's move,
- *  asked of the machine as a write asks it. */
-function asOf(ctx: SemanticsContext, t: Row): Row {
-  const due = Number(t.available_on);
-  if (t.status !== 'pending' || !Number.isFinite(due) || due > Number(ctx.now())) return t;
-  ctx.legal('balance_transaction', 'status', ctx.call.operation.id, 'pending', 'available', String(t.id), 'time');
-  return { ...t, status: 'available' };
-}
-
 /** The connected account a request acts for, or undefined for the platform. */
 export const actingAccount = (ctx: SemanticsContext): string | undefined => ctx.call.request.headers.get('stripe-account') ?? undefined;
 
 /** A ledger entry on an account's balance: the acting account's unless one is named (null names the platform). */
 async function write(ctx: SemanticsContext, fields: Row, account: string | null | undefined = actingAccount(ctx)): Promise<string> {
-  const bt = await created(ctx, BT, {}, { status: 'available', fee_details: [], description: null, exchange_rate: null, balance_type: 'payments', ...fields, ...(account ? { _account: account } : {}) });
+  // a credit available at once waits for the drain's balance.available (settleDueEntries)
+  const unsent = (fields.status ?? 'available') === 'available' && Number(fields.net) > 0 ? { [UNSENT]: true } : {};
+  const bt = await created(ctx, BT, {}, { status: 'available', fee_details: [], description: null, exchange_rate: null, balance_type: 'payments', ...fields, ...unsent, ...(account ? { _account: account } : {}) });
   return String(bt.id);
 }
 
 /** Whether a stored ledger entry is on this account's balance (undefined: the platform's). */
 const onAccount = (t: Row, account: string | undefined): boolean => (typeof t._account === 'string' ? t._account : undefined) === account;
 
-/** A captured charge's credit: its amount less the fee, pending two days unless the card (a number, or a test
- *  payment method or token named for it) settles at once. The
+/** A captured charge's credit: its amount less the fee, pending two days unless the card bypasses the pending
+ *  balance (bypassesPending), when it is due at once. The
  *  caller mints the charge's id first and stores the returned id as the charge's balance_transaction. */
 export async function settleCharge(ctx: SemanticsContext, chargeId: string, amount: number, currency: string, card?: string): Promise<string> {
   const now = Number(ctx.now());
   const fee = feeOf(amount);
-  const settled = !!card && (card.replace(/\D/g, '') === BYPASS_PENDING || /bypassPending/i.test(card));
+  const atOnce = bypassesPending(ctx, card);
   const id = await write(ctx, {
     amount, currency, fee, net: amount - fee, type: 'charge', reporting_category: 'charge', source: chargeId,
-    status: settled ? 'available' : 'pending', available_on: settled ? now : now + 2 * DAY,
+    ...(atOnce ? { status: 'available', available_on: now } : { status: 'pending', available_on: now + 2 * DAY }),
     fee_details: fee ? [{ amount: fee, application: null, currency, description: 'Stripe processing fees', type: 'stripe_fee' }] : [],
   });
   return id;
@@ -118,9 +147,11 @@ export async function settlePayout(ctx: SemanticsContext, payoutId: string, amou
   return write(ctx, { amount, currency, fee: 0, net: amount, type, reporting_category: type === 'payout' ? 'payout' : 'payout_reversal', source: payoutId, available_on: Number(ctx.now()) }, account);
 }
 
-/** A transfer's two entries: out of the platform's balance at once, into the destination's when `availableOn` comes
- *  (a plain transfer's funds are available already). Answers the platform's entry. */
-export async function settleTransfer(ctx: SemanticsContext, transferId: string, amount: number, currency: string, destination: string, availableOn = Number(ctx.now()), fromPending = false): Promise<string> {
+/** A transfer's two entries: out of the platform's balance at once, into the destination's when `fromCharge` (its
+ *  charge's funds' availability) comes (a plain transfer, with no `fromCharge`, moves funds available already).
+ *  Answers the platform's entry. */
+export async function settleTransfer(ctx: SemanticsContext, transferId: string, amount: number, currency: string, destination: string, fromCharge?: number, fromPending = false): Promise<string> {
+  const availableOn = fromCharge ?? Number(ctx.now());
   const settled = availableOn <= Number(ctx.now());
   // a transfer from a charge's pending funds (source_transaction) leaves the platform when they arrive, not before
   const platform = await write(ctx, { amount: -amount, currency, fee: 0, net: -amount, type: 'transfer', reporting_category: 'transfer', source: transferId, ...(fromPending ? { status: settled ? 'available' : 'pending', available_on: availableOn } : { available_on: Number(ctx.now()) }) }, null);
@@ -152,13 +183,19 @@ export async function settleTopup(ctx: SemanticsContext, topupId: string, amount
 /** Time's settlements, written: each entry on the acting account's balance whose funds came due by the World's clock
  *  moves pending → available (the clock's move the machine allows), so a settlement is recorded once. A read already
  *  sees it (asOf); the record is what lets Stripe's balance.available be sent once (stripe-server.ts, the drain).
- *  Answers the entries that moved. */
+ *  Funds that were available at once and not yet sent are taken too, and marked sent. Answers the entries taken. */
 export async function settleDueEntries(ctx: SemanticsContext): Promise<Row[]> {
   const now = Number(ctx.now());
   const account = actingAccount(ctx);
   const moved: Row[] = [];
   for (const t of ctx.rowsRaw(BT)) {
-    if (!onAccount(t, account) || t.status !== 'pending' || !(Number(t.available_on) <= now)) continue;
+    if (!onAccount(t, account)) continue;
+    if (t.status === 'available' && t[UNSENT] === true) {
+      await ctx.write(BT, String(t.id), { [UNSENT]: false }, 'balance_transaction.available_sent');
+      moved.push(t);
+      continue;
+    }
+    if (t.status !== 'pending' || !(Number(t.available_on) <= now)) continue;
     if (ctx.legal(BT, 'status', ctx.call.operation.id, 'pending', 'available', String(t.id), 'time')) continue;
     await ctx.write(BT, String(t.id), { status: 'available' }, 'balance_transaction.available');
     moved.push(t);

package/src/semantics/payment-methods.ts

@@ -130,6 +130,8 @@ export async function methodFromData(ctx: SemanticsContext, data: unknown): Prom
     type, customer: null, livemode: false, metadata: {},
     billing_details: { ...noBilling, ...((d.billing_details as Row | undefined) ?? {}) },
     ...paymentMethodSubObject(type, d),
+    // what follows its card's success (a dispute, funds straight to available), as a PaymentMethod created directly carries
+    ...(type === 'card' && afterSuccessOf(ctx, d.card) ? { _afterSuccess: afterSuccessOf(ctx, d.card) } : {}),
   });
   return String(made.id);
 }

package/src/semantics/shared.ts

@@ -125,8 +125,18 @@ function expandPaths(ctx: SemanticsContext): string[][] {
   return Array.isArray(expand) ? expand.map((p) => String(p).split('.')) : [];
 }
 
+/** A balance transaction as the clock reads it: available once its available_on has passed, the clock's move,
+ *  asked of the machine as a write asks it (semantics/ledger.ts). */
+export function asOf(ctx: SemanticsContext, t: Row): Row {
+  const due = Number(t.available_on);
+  if (t.status !== 'pending' || !Number.isFinite(due) || due > Number(ctx.now())) return t;
+  ctx.legal('balance_transaction', 'status', ctx.call.operation.id, 'pending', 'available', String(t.id), 'time');
+  return { ...t, status: 'available' };
+}
+
 /** Stripe's expand walk: each dotted path replaces an id with the resource the manifest says it
- *  holds, one segment at a time; an id the tree lacks stays an id. */
+ *  holds, one segment at a time; an id the tree lacks stays an id. A balance transaction reads as the clock has it
+ *  (asOf), as its own retrieve does. */
 export function expandRow(ctx: SemanticsContext, resource: string, body: Row, paths: string[][]): Row {
   const embeds = manifest.resources[resource]?.embeds;
   if (!embeds || paths.length === 0) return body;
@@ -142,8 +152,9 @@ export function expandRow(ctx: SemanticsContext, resource: string, body: Row, pa
     const target = embeds[head];
     if (!target) continue;
     const cur = out[head];
-    const sub = typeof cur === 'string' && cur ? ctx.get(target, cur) : cur && typeof cur === 'object' && !Array.isArray(cur) ? (cur as Row) : undefined;
-    if (!sub) continue;
+    const found = typeof cur === 'string' && cur ? ctx.get(target, cur) : cur && typeof cur === 'object' && !Array.isArray(cur) ? (cur as Row) : undefined;
+    if (!found) continue;
+    const sub = target === 'balance_transaction' ? asOf(ctx, found) : found;
     const deeper = tails.filter((t) => t.length > 0);
     out = { ...out, [head]: deeper.length ? expandRow(ctx, target, sub, deeper) : sub };
   }

package/src/semantics/test-cards.ts

@@ -0,0 +1,7 @@
+// Stripe's test cards whose funds bypass the pending balance, by their test names and numbers
+// (docs.stripe.com/testing#available-balance: "Funds are added directly to your available balance, bypassing your
+// pending balance"). A leaf: ledger.ts reads it to settle a charge, after-payment.ts to record it on a PaymentMethod.
+export const BYPASS_PENDING_CARDS: Record<string, { brand: string; number: string }> = {
+  pm_card_bypassPending: { brand: 'visa', number: '4000000000000077' },
+  pm_card_bypassPendingInternational: { brand: 'visa', number: '4000003720000278' },
+};

package/src/semantics/transfers.ts

@@ -66,7 +66,7 @@ const create: Semantics = async (ctx) => {
     if (refused) return refused;
   }
   const id = ctx.mint('transfer');
-  const bt = await settleTransfer(ctx, id, amount, currency, destination, availableOn ?? Number(ctx.now()), sourceId !== undefined);
+  const bt = await settleTransfer(ctx, id, amount, currency, destination, availableOn, sourceId !== undefined);
   return ctx.reply(
     await created(ctx, 'transfer', { id, ...ctx.params, ...(group ? { transfer_group: group } : {}) }, {
       amount_reversed: 0, balance_transaction: bt, livemode: false, metadata: {},