@volter/twin-stripe 2.0.38 → 3.0.1

package/dist/src/semantics/accounts.js

@@ -0,0 +1,40 @@
+import { externalList } from "../engine/common.js";
+import { controllerOf, expressRequirements, keptKyc } from "../engine/connect.js";
+import { ACCOUNT_TYPES, accountCapabilities, accountRequirements, accountSettings, nowUnix } from "../engine/stripe.js";
+import { accountMissing, accountRow, at, connectReview, created, fail, list, newest } from "./shared.js";
+export async function GetAccountsAccountExternalAccounts(ctx) {
+    const account = at(ctx, 'account');
+    if (!accountRow(ctx, account))
+        return accountMissing(ctx, account);
+    return list(ctx, 'external_account', newest(ctx, 'external_account').filter((e) => e.account === account));
+}
+// the requested capabilities become Stripe's status map, and settings its canonical shape
+export async function PostAccounts(ctx) {
+    const params = ctx.params;
+    const type = typeof params.type === 'string' ? params.type : 'standard';
+    if (!ACCOUNT_TYPES.has(type))
+        return fail(ctx, 'Invalid account type: must be one of express, standard, or custom.', 400, 'parameter_invalid_string_enum');
+    const { capabilities: _caps, settings: _settings, ...accountParams } = keptKyc(params);
+    const id = ctx.mint('account');
+    const made = await created(ctx, 'account', { ...accountParams, id, type }, {
+        business_type: null, charges_enabled: false, payouts_enabled: false, details_submitted: false,
+        capabilities: accountCapabilities(params), requirements: type === 'express' ? expressRequirements(params) : accountRequirements(),
+        country: typeof params.country === 'string' ? params.country : 'US',
+        default_currency: 'usd', email: params.email ?? null, metadata: {}, livemode: false,
+        settings: accountSettings(params.settings), business_profile: {},
+        controller: controllerOf(type), external_accounts: externalList(id, []),
+        future_requirements: { alternatives: [], current_deadline: null, currently_due: [], disabled_reason: null, errors: [], eventually_due: [], past_due: [], pending_verification: [] },
+        tos_acceptance: { date: null, ip: null, user_agent: null },
+    });
+    await connectReview(ctx, String(made.id));
+    return ctx.reply(ctx.expand('account', ctx.get('account', String(made.id))));
+}
+// a single-use Express dashboard link, not stored
+export async function PostAccountsAccountLoginLinks(ctx) {
+    const id = at(ctx, 'account');
+    if (!ctx.get('account', id))
+        return accountMissing(ctx, id);
+    return ctx.reply({ object: 'login_link', created: nowUnix(ctx.occurredAt), url: `https://connect.twin.local/express/${id}` });
+}
+// source: spec:PostAccountsAccount "left unchanged."
+// source: https://docs.stripe.com/connect/account-capabilities "If a connected account has both card_payments and transfers"

package/dist/src/semantics/apps.d.ts

@@ -0,0 +1,4 @@
+import type { HandlerContext } from '@volter/world-core';
+export declare function GetAppsSecretsFind(ctx: HandlerContext): Promise<Response>;
+export declare function PostAppsSecrets(ctx: HandlerContext): Promise<Response>;
+export declare function PostAppsSecretsDelete(ctx: HandlerContext): Promise<Response>;

package/dist/src/semantics/{apps-secrets.js → apps.js}

@@ -1,12 +1,14 @@
-import { created, fail, list, newest, kept } from "./shared.js";
-const SECRET = 'apps.secret';
-function scopeKeyOf(ctx) {
-    const scope = ctx.params.scope && typeof ctx.params.scope === 'object' ? ctx.params.scope : undefined;
-    const scopeType = scope && typeof scope.type === 'string' ? scope.type : 'account';
-    return scopeType === 'user' ? `user:${String(scope.user)}` : 'account';
+import { SECRET } from "../engine/apps-secrets.js";
+import { nowUnix } from "../engine/stripe.js";
+import { created, fail, named, scopeKeyOf } from "./shared.js";
+export async function GetAppsSecretsFind(ctx) {
+    const name = typeof ctx.params.name === 'string' ? ctx.params.name : '';
+    if (!name)
+        return fail(ctx, 'Missing required param: name.', 400, 'parameter_missing');
+    const s = named(ctx, name);
+    return s ? ctx.reply(s) : fail(ctx, `No such secret: '${name}'`, 404, 'resource_missing');
 }
-const named = (ctx, name) => ctx.rows(SECRET).find((s) => s.name === name && kept(ctx, SECRET, s, '_scope_key') === scopeKeyOf(ctx));
-const set = async (ctx) => {
+export async function PostAppsSecrets(ctx) {
     const params = ctx.params;
     const name = typeof params.name === 'string' ? params.name : '';
     if (!name)
@@ -22,21 +24,14 @@ const set = async (ctx) => {
     const expiresAt = params.expires_at !== undefined ? Math.trunc(Number(params.expires_at)) : null;
     const existing = named(ctx, name);
     if (existing)
-        return ctx.reply(await ctx.write(SECRET, String(existing.id), { payload: params.payload, expires_at: expiresAt, _updated: ctx.now() }, 'apps_secret.update'));
+        return ctx.reply(await ctx.write(SECRET, String(existing.id), { payload: params.payload, expires_at: expiresAt, _updated: nowUnix(ctx.occurredAt) }, 'apps_secret.update'));
     return ctx.reply(await created(ctx, SECRET, { name }, {
         livemode: false, deleted: false, expires_at: expiresAt, payload: params.payload,
         scope: scopeType === 'user' ? { type: 'user', user: scope.user } : { type: 'account' },
         _scope_key: scopeKeyOf(ctx),
     }));
-};
-const find = async (ctx) => {
-    const name = typeof ctx.params.name === 'string' ? ctx.params.name : '';
-    if (!name)
-        return fail(ctx, 'Missing required param: name.', 400, 'parameter_missing');
-    const s = named(ctx, name);
-    return s ? ctx.reply(s) : fail(ctx, `No such secret: '${name}'`, 404, 'resource_missing');
-};
-const remove = async (ctx) => {
+}
+export async function PostAppsSecretsDelete(ctx) {
     const name = typeof ctx.params.name === 'string' ? ctx.params.name : '';
     if (!name)
         return fail(ctx, 'Missing required param: name.', 400, 'parameter_missing');
@@ -44,11 +39,4 @@ const remove = async (ctx) => {
     if (!s)
         return fail(ctx, `No such secret: '${name}'`, 404, 'resource_missing');
     return ctx.reply(await ctx.write(SECRET, String(s.id), { deleted: true }, 'apps_secret.delete'));
-};
-const listSecrets = async (ctx) => list(ctx, SECRET, newest(ctx, SECRET).filter((s) => kept(ctx, SECRET, s, '_scope_key') === scopeKeyOf(ctx)));
-export const appsSecrets = {
-    PostAppsSecrets: set,
-    GetAppsSecretsFind: find,
-    PostAppsSecretsDelete: remove,
-    GetAppsSecrets: listSecrets,
-};
+}

package/dist/src/semantics/around.d.ts

@@ -0,0 +1,2 @@
+import type { HandlerContext } from '@volter/world-core';
+export declare function around(ctx: HandlerContext, next: (request?: Request) => Promise<Response>): Promise<Response>;

package/dist/src/semantics/around.js

@@ -0,0 +1,13 @@
+import { platformKeyRefused, publishableKeyRefused, refuseParameters, rendered, withMetadata } from "./shared.js";
+export async function around(ctx, next) {
+    const arrived = ctx.call.request;
+    const unkeyed = platformKeyRefused(ctx, arrived);
+    if (unkeyed)
+        return unkeyed;
+    if (ctx.call.operation.id !== 'unmatched') {
+        const refused = publishableKeyRefused(ctx) ?? refuseParameters(ctx);
+        if (refused)
+            return refused;
+    }
+    return rendered(arrived, await next(withMetadata(ctx, arrived.clone())));
+}

package/dist/src/semantics/balance.d.ts

@@ -1,11 +1,2 @@
-import type { Semantics, SemanticsContext } from '@volter/world-core';
-import { type Row } from './shared.js';
-/** The acting account's Balance object (docs.stripe.com/api/balance/balance_object). */
-export declare function balanceBody(ctx: SemanticsContext): Row;
-/** Time's arrivals, written: each of the acting account's payouts whose arrival date has come moves pending → paid
- *  (the clock's move, as asOf reads it), written as `payout.paid`, the event Stripe sends for it. Answers their ids. */
-export declare function payDuePayouts(ctx: SemanticsContext): Promise<string[]>;
-/** Time's payouts, caught up to the World's clock: each account on an automatic schedule is paid out, on each of its
- *  scheduled days that has come, what became available by then. */
-export declare function advancePayouts(ctx: SemanticsContext): Promise<void>;
-export declare const balances: Record<string, Semantics>;
+import type { HandlerContext } from '@volter/world-core';
+export declare function GetBalance(ctx: HandlerContext): Promise<Response>;

package/dist/src/semantics/balance.js

@@ -1,195 +1,4 @@
-import { validateMoney } from "../stripe-twin.js";
-import { accountSettings, PLATFORM_ACCOUNT_ID } from "../stripe-twin.js";
-import { actingAccount, balanceOf, refusePayout, settleAutomaticPayout, settlePayout, unpaidEntries } from "./ledger.js";
-import { at, at_, created, fail, inRange, list, newest, send, where, kept } from "./shared.js";
-const account = actingAccount;
-const DAY = 86_400;
-const payoutMissing = (ctx, id) => fail(ctx, `No such payout: '${id}'`, 404, 'resource_missing');
-/** The acting account's Balance object (docs.stripe.com/api/balance/balance_object). */
-export function balanceBody(ctx) {
-    const { available, pending, issuing } = balanceOf(ctx);
-    const toArr = (m) => {
-        const out = [...m.entries()].map(([currency, amount]) => ({ amount, currency, source_types: { card: amount } }));
-        return out.length ? out : [{ amount: 0, currency: 'usd', source_types: { card: 0 } }];
-    };
-    // a platform's balance holds its connected accounts' reserve, "Funds held due to negative balances on connected accounts
-    // where account.controller.requirement_collection is `application`" (docs.stripe.com/api/balance/balance_object, whose
-    // example answers `[{"amount": 0, "currency": "usd"}]`); the twin models no such reserve, so it is zero in each currency
-    const reserved = account(ctx) ? {} : { connect_reserved: toArr(available).map((b) => ({ amount: 0, currency: b.currency })) };
-    return {
-        object: 'balance', available: toArr(available), pending: toArr(pending), ...reserved, livemode: false,
-        ...(issuing.size ? { issuing: { available: [...issuing.entries()].map(([currency, amount]) => ({ amount, currency, source_types: { card: amount } })) } } : {}),
-    };
+import { balanceBody } from "./shared.js";
+export async function GetBalance(ctx) {
+    return ctx.reply(balanceBody(ctx));
 }
-const balance = async (ctx) => ctx.reply(balanceBody(ctx));
-/** Time's arrivals, written: each of the acting account's payouts whose arrival date has come moves pending → paid
- *  (the clock's move, as asOf reads it), written as `payout.paid`, the event Stripe sends for it. Answers their ids. */
-export async function payDuePayouts(ctx) {
-    const acct = account(ctx);
-    const now = Number(ctx.now());
-    const paid = [];
-    for (const p of newest(ctx, 'payout')) {
-        if ((acct ? kept(ctx, 'payout', p, '_account') !== acct : !!kept(ctx, 'payout', p, '_account')) || p.status !== 'pending' || Number(p.arrival_date) > now)
-            continue;
-        if (ctx.legal('payout', 'status', ctx.call.operation.id, 'pending', 'paid', String(p.id), 'time'))
-            continue;
-        await ctx.write('payout', String(p.id), { status: 'paid' }, 'payout.paid');
-        paid.push(String(p.id));
-    }
-    return paid;
-}
-/** Where a connected account's payout goes: "ID of the bank account or card the payout is sent to" (served spec,
- *  payout.destination), its default external account for the currency, "When multiple accounts are available for a given
- *  currency, Stripe uses the one set as `default_for_currency`" (docs.stripe.com/connect/payouts-bank-accounts), the
- *  newest such. Where the documentation stops and the twin decides: the platform's own bank account is not modelled, so
- *  its payouts name none. */
-function payoutBank(ctx, account, currency) {
-    const banks = newest(ctx, 'external_account').filter((e) => e.account === account && String(e.currency ?? currency) === currency);
-    return String((banks.find((e) => e.default_for_currency === true) ?? banks[0])?.id ?? '') || null;
-}
-const payoutDefaults = (ctx) => ({
-    method: 'standard', type: 'bank_account', source_type: 'card', automatic: false,
-    reconciliation_status: 'not_applicable', arrival_date: Number(ctx.now()) + 2 * DAY, livemode: false, metadata: {},
-});
-/** A payout as the clock reads it: paid once its arrival date has come, the clock's move, asked of the
- *  machine as a write asks it. */
-function asOf(ctx, p) {
-    if (p.status !== 'pending' || Number(p.arrival_date) > Number(ctx.now()))
-        return p;
-    ctx.legal('payout', 'status', ctx.call.operation.id, 'pending', 'paid', String(p.id), 'time');
-    return { ...p, status: 'paid' };
-}
-/** A connected account's payout in a currency none of its bank accounts takes. */
-function noExternalAccount(ctx, currency) {
-    return fail(ctx, `Sorry, you don't have any external accounts in that currency (${currency}).`, 400);
-}
-const createPayout = async (ctx) => {
-    const bad = validateMoney(ctx.params);
-    if (bad)
-        return send(ctx, bad);
-    const acct = account(ctx);
-    if (acct && !ctx.get('account', acct))
-        return fail(ctx, `No such account: '${acct}'`, 400, 'account_invalid');
-    const amount = Math.trunc(Number(ctx.params.amount) || 0);
-    const currency = String(ctx.params.currency ?? 'usd');
-    // a connected account is paid out to its own bank account
-    if (acct && !ctx.rows('external_account').some((e) => e.account === acct && (e.currency ?? currency) === currency))
-        return noExternalAccount(ctx, currency);
-    const refused = refusePayout(ctx, amount, currency);
-    if (refused)
-        return refused;
-    const id = ctx.mint('payout');
-    const bt = await settlePayout(ctx, id, -amount, currency);
-    return ctx.reply(await created(ctx, 'payout', { ...ctx.params, id }, { status: 'pending', ...payoutDefaults(ctx), balance_transaction: bt, destination: acct ? payoutBank(ctx, acct, currency) : null, ...(acct ? { _account: acct } : {}) }));
-};
-const listPayouts = async (ctx) => {
-    const acct = account(ctx);
-    const scoped = newest(ctx, 'payout').filter((p) => (acct ? kept(ctx, 'payout', p, '_account') === acct : !kept(ctx, 'payout', p, '_account'))).map((p) => asOf(ctx, p));
-    return list(ctx, 'payout', where(ctx, scoped, { status: (p, v) => p.status === v, created: (p, v) => inRange(p.created, v), arrival_date: (p, v) => inRange(p.arrival_date, v) }));
-};
-const DAYS = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'];
-/** The first scheduled payout time on or after `from`: midnight UTC of a day the schedule pays out on. */
-function payoutDay(from, schedule) {
-    const first = Math.ceil(from / DAY) * DAY;
-    const pays = (day) => {
-        const d = new Date(day * 1000);
-        if (schedule.interval === 'weekly')
-            return DAYS[d.getUTCDay()] === String(schedule.weekly_anchor ?? 'monday');
-        if (schedule.interval === 'monthly')
-            return d.getUTCDate() === Math.min(Number(schedule.monthly_anchor ?? 1), new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth() + 1, 0)).getUTCDate());
-        return true;
-    };
-    return Array.from({ length: 62 }, (_, i) => first + i * DAY).find(pays) ?? first;
-}
-/** Time's payouts, caught up to the World's clock: each account on an automatic schedule is paid out, on each of its
- *  scheduled days that has come, what became available by then. */
-export async function advancePayouts(ctx) {
-    const now = Number(ctx.now());
-    const platform = ctx.get('account', PLATFORM_ACCOUNT_ID);
-    const accounts = [{ id: undefined, settings: platform?.settings }];
-    for (const a of ctx.rows('account')) {
-        if (a.id === PLATFORM_ACCOUNT_ID || a.payouts_enabled !== true)
-            continue;
-        if (!ctx.rows('external_account').some((e) => e.account === a.id))
-            continue;
-        accounts.push({ id: String(a.id), settings: a.settings });
-    }
-    for (const acct of accounts) {
-        const schedule = (accountSettings(acct.settings, acct.settings ?? undefined).payouts.schedule ?? {});
-        if (schedule.interval === 'manual')
-            continue;
-        const unpaid = unpaidEntries(ctx, acct.id);
-        const days = [...new Set(unpaid.map((t) => payoutDay(Number(t.available_on) || 0, schedule)))].filter((d) => d <= now).sort((x, y) => x - y);
-        const paid = new Set();
-        for (const day of days) {
-            const due = unpaid.filter((t) => !paid.has(t.id) && (Number(t.available_on) || 0) <= day);
-            const byCurrency = new Map();
-            for (const t of due)
-                byCurrency.set(String(t.currency ?? 'usd'), [...(byCurrency.get(String(t.currency ?? 'usd')) ?? []), t]);
-            for (const [currency, entries] of byCurrency) {
-                const amount = entries.reduce((n, t) => n + (Number(t.net) || 0), 0);
-                // nothing to pay yet: what came due is carried to the next payout
-                if (amount <= 0)
-                    continue;
-                // made on its day, as Stripe makes it, whenever the request that catches it up comes
-                const c = await at_(ctx)(day);
-                const id = c.mint('payout');
-                const bt = await settleAutomaticPayout(c, id, amount, currency, acct.id, day, entries);
-                await created(c, 'payout', { id, amount, currency }, {
-                    status: 'pending', ...payoutDefaults(c), arrival_date: day + 2 * DAY, automatic: true, balance_transaction: bt, destination: acct.id ? payoutBank(c, String(acct.id), currency) : null,
-                    description: 'STRIPE PAYOUT', ...(acct.id ? { _account: acct.id } : {}),
-                });
-                for (const t of entries)
-                    paid.add(t.id);
-            }
-        }
-    }
-}
-const retrievePayout = async (ctx) => {
-    const p = ctx.get('payout', at(ctx, 'payout'));
-    return p ? ctx.reply(asOf(ctx, p)) : payoutMissing(ctx, at(ctx, 'payout'));
-};
-const cancelPayout = async (ctx) => {
-    const id = at(ctx, 'payout');
-    const po = ctx.get('payout', id);
-    if (!po)
-        return payoutMissing(ctx, id);
-    const refused = ctx.legal('payout', 'status', 'PostPayoutsPayoutCancel', asOf(ctx, po).status, undefined, id);
-    if (refused)
-        return ctx.refuse(refused);
-    // the money comes back to the balance it left
-    const owner = kept(ctx, 'payout', po, '_account');
-    await settlePayout(ctx, id, Number(po.amount) || 0, String(po.currency ?? 'usd'), typeof owner === 'string' ? owner : null);
-    return ctx.reply(await ctx.write('payout', id, { status: 'canceled' }, 'payout.cancel'));
-};
-// a reversal is itself a payout in the other direction, back into the connected account's balance, as the reverse page's
-// example answers it: a negative amount, pending until it arrives, carrying the request's metadata
-// (docs.stripe.com/api/payouts/reverse); the original stays paid and names it
-const reversePayout = async (ctx) => {
-    const id = at(ctx, 'payout');
-    const po = ctx.get('payout', id);
-    if (!po)
-        return payoutMissing(ctx, id);
-    const owner = kept(ctx, 'payout', po, '_account');
-    if (typeof owner !== 'string')
-        return fail(ctx, "Payout reversals are only supported for payouts to connected accounts' bank accounts.", 400);
-    const status = String(asOf(ctx, po).status);
-    if (po.reversed_by || status !== 'paid')
-        return ctx.refuse({ status: 400, code: 'payout_reversal_not_allowed', message: po.reversed_by ? 'This payout has already been reversed.' : `This payout cannot be reversed because it has a status of ${status}. A pending payout can be canceled instead.` });
-    const reversalId = ctx.mint('payout');
-    const bt = await settlePayout(ctx, reversalId, Number(po.amount) || 0, String(po.currency ?? 'usd'), owner);
-    const metadata = ctx.params.metadata && typeof ctx.params.metadata === 'object' ? { metadata: ctx.params.metadata } : {};
-    const reversal = await created(ctx, 'payout', { id: reversalId, amount: -(Number(po.amount) || 0), currency: po.currency, ...metadata }, {
-        status: 'pending', ...payoutDefaults(ctx), balance_transaction: bt, original_payout: id, destination: po.destination ?? null, _account: owner,
-    });
-    await ctx.write('payout', id, { reversed_by: reversal.id }, 'payout.reversed');
-    return ctx.reply(reversal);
-};
-export const balances = {
-    GetBalance: balance,
-    PostPayouts: createPayout,
-    GetPayouts: listPayouts,
-    GetPayoutsPayout: retrievePayout,
-    PostPayoutsPayoutCancel: cancelPayout,
-    PostPayoutsPayoutReverse: reversePayout,
-};

package/dist/src/semantics/balance_transactions.d.ts

@@ -0,0 +1,2 @@
+import type { HandlerContext } from '@volter/world-core';
+export declare function GetBalanceTransactions(ctx: HandlerContext): Promise<Response>;

package/dist/src/semantics/balance_transactions.js

@@ -0,0 +1,15 @@
+import { inRange } from "../engine/common.js";
+import { BT } from "../engine/ledger.js";
+import { commonAsOf, kept, list, mine, newest, where } from "./shared.js";
+export async function GetBalanceTransactions(ctx) {
+    const own = mine(ctx);
+    return list(ctx, BT, where(ctx, newest(ctx, BT).filter((t) => own.has(t.id)).map((t) => commonAsOf(ctx, t)), {
+        type: (t, v) => t.type === v,
+        currency: (t, v) => t.currency === v,
+        source: (t, v) => t.source === v,
+        // an automatic payout lists the entries it paid out, its own debit among them
+        payout: (t, v) => t.source === v || kept(ctx, BT, t, '_payout') === v,
+        // a range of creation times (docs.stripe.com/api/balance_transactions/list#balance_transaction_list-created)
+        created: (t, v) => inRange(t.created, v),
+    }));
+}

package/dist/src/semantics/billing_portal.d.ts

@@ -0,0 +1,4 @@
+import type { HandlerContext } from '@volter/world-core';
+export declare function GetBillingPortalConfigurations(ctx: HandlerContext): Promise<Response>;
+export declare function PostBillingPortalConfigurations(ctx: HandlerContext): Promise<Response>;
+export declare function PostBillingPortalSessions(ctx: HandlerContext): Promise<Response>;

package/dist/src/semantics/billing_portal.js

@@ -0,0 +1,36 @@
+import { filled, PBC, PORTAL_FEATURES } from "../engine/files.js";
+import { asBool, nowUnix } from "../engine/stripe.js";
+import { actingAccount, created, fail, list, newest, where } from "./shared.js";
+export async function GetBillingPortalConfigurations(ctx) {
+    return list(ctx, PBC, where(ctx, newest(ctx, PBC), {
+        active: (c, v) => asBool(c.active) === asBool(v),
+        is_default: (c, v) => asBool(c.is_default) === asBool(v),
+    }));
+}
+export async function PostBillingPortalConfigurations(ctx) {
+    return ctx.reply(await created(ctx, PBC, { ...ctx.params, business_profile: filled({ headline: null, privacy_policy_url: null, terms_of_service_url: null }, ctx.params.business_profile), features: filled(PORTAL_FEATURES, ctx.params.features) }, {
+        active: true, is_default: false, livemode: false,
+        login_page: { enabled: false, url: null },
+        metadata: {}, default_return_url: ctx.params.default_return_url ?? null,
+        updated: nowUnix(ctx.occurredAt),
+    }));
+}
+// ── the customer portal ──
+// the configuration defaults to the account's default one
+export async function PostBillingPortalSessions(ctx) {
+    const customer = typeof ctx.params.customer === 'string' ? ctx.params.customer : '';
+    if (!customer)
+        return fail(ctx, 'Missing required param: customer.', 400, 'parameter_missing');
+    if (!ctx.row('customer', customer, { withDeleted: true }))
+        return fail(ctx, `No such customer: '${customer}'`, 404, 'resource_missing');
+    const configuration = typeof ctx.params.configuration === 'string' && ctx.params.configuration
+        ? ctx.params.configuration
+        : (ctx.rowsRaw('billing_portal.configuration', { withDeleted: true }).find((c) => c.is_default)?.id ?? 'bpc_twin_default');
+    const id = ctx.mint('billing_portal.session');
+    return ctx.reply(await created(ctx, 'billing_portal.session', {
+        id, customer, configuration, return_url: ctx.params.return_url ?? null, url: `https://billing.stripe.com/p/session/${id}`,
+        locale: ctx.params.locale ?? null, on_behalf_of: ctx.params.on_behalf_of ?? null, livemode: false,
+        // the account the session was made on (Stripe-Account), whose name the portal shows (screens/billing-portal.tsx)
+        ...(actingAccount(ctx) ? { _brand_account: actingAccount(ctx) } : {}),
+    }, {}));
+}

package/dist/src/semantics/charges.d.ts

@@ -1,28 +1,3 @@
-import type { Semantics, SemanticsContext } from '@volter/world-core';
-import { type Row } from './shared.js';
-/** Every egress of a charge carries its refunds, derived from the refund rows in list order. */
-export declare function chargeBody(ctx: SemanticsContext, c: Row): Row;
-/** A capture=false charge refunded while uncaptured: its authorization is released by the refund, as it would be
- *  "automatically refunded if uncaptured" (spec/openapi.json.gz, `capture_before`). The charge stays uncaptured and
- *  becomes refunded in full, a Refund records the release, and no money moves: none was ever received. Written as
- *  charge.refunded. Where the documentation stops and the twin decides: Stripe's basil change ("Partially capturing or
- *  canceling payments no longer creates a Refund", docs.stripe.com/changelog/basil/2025-03-31/remove-refund-from-partial-
- *  capture-and-payment-cancellation-flow) names partial capture and cancellation, not a refund asked for, so a refund
- *  still makes one; its reason is null and it has no balance transaction. Answers the Refund. */
-export declare function releaseAuthorization(ctx: SemanticsContext, ch: Row, operationId: string, given?: Row): Promise<Row>;
-/** A PaymentIntent's authorization released by its cancel: "For PaymentIntents with a `status` of `requires_capture`, the
- *  remaining `amount_capturable` is automatically refunded" (docs.stripe.com/api/payment_intents/cancel), and since basil
- *  a cancellation makes no Refund: "`amount_captured` will be 0 instead of `nil` in payment cancellation flows",
- *  "`amount_refunded` will no longer be updated by these actions", "`refunded` will no longer be `true` for payment
- *  cancellation flows", and no charge.refunded is sent (docs.stripe.com/changelog/basil/2025-03-31/remove-refund-from-
- *  partial-capture-and-payment-cancellation-flow). The charge stays uncaptured; nothing is written as an event. */
-export declare function cancelAuthorization(ctx: SemanticsContext, ch: Row): Promise<Row>;
-/** An authorized charge captured, by the charge's capture or its PaymentIntent's: what is captured credits the balance.
- *  Written as charge.captured, "Occurs whenever a previously uncaptured charge is captured" (docs.stripe.com/api/events/types).
- *  A partial capture releases the rest with no Refund and leaves amount_refunded and refunded as they were: "The following
- *  flows no longer result in a `Refund` object created and linked to the payment: Partial capture", "`amount_refunded`
- *  will no longer be updated by these actions", and "There will only be a single balance transaction for partial captures"
- *  (docs.stripe.com/changelog/basil/2025-03-31/remove-refund-from-partial-capture-and-payment-cancellation-flow).
- *  The caller has asked the machine whether it may capture. */
-export declare function captureAuthorization(ctx: SemanticsContext, ch: Row, toCapture: number, _operationId: string): Promise<Row>;
-export declare const charges: Record<string, Semantics>;
+import type { HandlerContext } from '@volter/world-core';
+export declare function GetCharges(ctx: HandlerContext): Promise<Response>;
+export declare function GetChargesCharge(ctx: HandlerContext): Promise<Response>;