@volter/twin-stripe 3.0.0 → 3.0.2

package/src/semantics/accounts.ts

@@ -1,12 +1,10 @@
 // Stripe's accounts operations (docs/contributing/architecture.md, "What an author writes"): each handler over the
 // handler contract's context, computing with the engine (../engine/).
 import type { HandlerContext } from '@volter/world-core';
-import { externalList, type Row } from '../engine/common.ts';
-import { capabilityBody, controllerOf, expressRequirements, keptKyc, keptPerson, RELATIONSHIP } from '../engine/connect.ts';
-import { OAUTH_CONNECTIONS } from '../engine/display.ts';
-import { ACCOUNT_TYPES, accountCapabilities, accountRequirements, accountSettings, asBool, nowUnix, PLATFORM_ACCOUNT_ID } from '../engine/stripe.ts';
-import { accountExternal, accountMissing, accountPerson, accountRow, at, connectReview, created, externalMissing, fail, list, newest, path, personMissing, refuseExternalWrite, syncExternals } from './shared.ts';
-
+import { externalList } from '../engine/common.ts';
+import { controllerOf, expressRequirements, keptKyc } from '../engine/connect.ts';
+import { ACCOUNT_TYPES, accountCapabilities, accountRequirements, accountSettings, nowUnix } from '../engine/stripe.ts';
+import { accountMissing, accountRow, at, connectReview, created, fail, list, newest } from './shared.ts';
 export async function GetAccountsAccountExternalAccounts(ctx: HandlerContext): Promise<Response> {
   const account = at(ctx, 'account');
   if (!accountRow(ctx, account)) return accountMissing(ctx, account);
@@ -31,7 +29,7 @@ export async function PostAccounts(ctx: HandlerContext): Promise<Response> {
     tos_acceptance: { date: null, ip: null, user_agent: null },
   });
   await connectReview(ctx, String(made.id));
-  return ctx.reply(ctx.get('account', String(made.id))!);
+  return ctx.reply(ctx.expand('account', ctx.get('account', String(made.id))!));
 }
 
 // a single-use Express dashboard link, not stored
@@ -41,3 +39,6 @@ export async function PostAccountsAccountLoginLinks(ctx: HandlerContext): Promis
   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/src/semantics/apps.ts

@@ -4,8 +4,7 @@ import type { HandlerContext } from '@volter/world-core';
 import { SECRET } from '../engine/apps-secrets.ts';
 import type { Row } from '../engine/common.ts';
 import { nowUnix } from '../engine/stripe.ts';
-import { created, fail, kept, list, named, newest, scopeKeyOf } from './shared.ts';
-
+import { created, fail, named, scopeKeyOf } from './shared.ts';
 export async function GetAppsSecretsFind(ctx: HandlerContext): Promise<Response> {
   const name = typeof ctx.params.name === 'string' ? ctx.params.name : '';
   if (!name) return fail(ctx, 'Missing required param: name.', 400, 'parameter_missing');

package/src/semantics/around.ts

@@ -4,17 +4,14 @@
 // refused and the parameters are checked against the operation's; a metadata hash merges; and every answer is rendered
 // in the caller's API version (../engine/front.ts).
 import type { HandlerContext } from '@volter/world-core';
-import { actingAsOAuthKey, platformKeyRefused, publishableKeyRefused, refuseParameters, rendered, revokedAccountRefused, withMetadata } from './shared.ts';
-
+import { platformKeyRefused, publishableKeyRefused, refuseParameters, rendered, withMetadata } from './shared.ts';
 export async function around(ctx: HandlerContext, next: (request?: Request) => Promise<Response>): Promise<Response> {
   const arrived = ctx.call.request;
   const unkeyed = platformKeyRefused(ctx, arrived);
   if (unkeyed) return unkeyed;
-  const acting = await actingAsOAuthKey(ctx, arrived.clone());
-  if (acting instanceof Response) return acting;
   if (ctx.call.operation.id !== 'unmatched') {
-    const refused = publishableKeyRefused(ctx) ?? revokedAccountRefused(ctx) ?? refuseParameters(ctx);
+    const refused = publishableKeyRefused(ctx) ?? refuseParameters(ctx);
     if (refused) return refused;
   }
-  return rendered(arrived, await next(withMetadata(ctx, acting)));
+  return rendered(arrived, await next(withMetadata(ctx, arrived.clone())));
 }

package/src/semantics/balance.ts

@@ -2,7 +2,6 @@
 // handler contract's context, computing with the engine (../engine/).
 import type { HandlerContext } from '@volter/world-core';
 import { balanceBody } from './shared.ts';
-
 export async function GetBalance(ctx: HandlerContext): Promise<Response> {
   return ctx.reply(balanceBody(ctx));
 }

package/src/semantics/balance_transactions.ts

@@ -3,8 +3,7 @@
 import type { HandlerContext } from '@volter/world-core';
 import { inRange } from '../engine/common.ts';
 import { BT } from '../engine/ledger.ts';
-import { at, commonAsOf, kept, list, mine, newest, where } from './shared.ts';
-
+import { commonAsOf, kept, list, mine, newest, where } from './shared.ts';
 export async function GetBalanceTransactions(ctx: HandlerContext): Promise<Response> {
   const own = mine(ctx);
   return list(ctx, BT, where(ctx, newest(ctx, BT).filter((t) => own.has(t.id)).map((t) => commonAsOf(ctx, t)), {
@@ -17,4 +16,3 @@ export async function GetBalanceTransactions(ctx: HandlerContext): Promise<Respo
     created: (t, v) => inRange(t.created, v),
   }));
 }
-

package/src/semantics/billing_portal.ts

@@ -3,8 +3,7 @@
 import type { HandlerContext } from '@volter/world-core';
 import { filled, PBC, PORTAL_FEATURES } from '../engine/files.ts';
 import { asBool, nowUnix } from '../engine/stripe.ts';
-import { actingAccount, at, created, fail, list, mergeUpdate, newest, where } from './shared.ts';
-
+import { actingAccount, created, fail, list, newest, where } from './shared.ts';
 export async function GetBillingPortalConfigurations(ctx: HandlerContext): Promise<Response> {
   return list(ctx, PBC, where(ctx, newest(ctx, PBC), {
     active: (c, v) => asBool(c.active) === asBool(v),
@@ -23,11 +22,6 @@ export async function PostBillingPortalConfigurations(ctx: HandlerContext): Prom
   );
 }
 
-export async function PostBillingPortalConfigurationsConfiguration(ctx: HandlerContext): Promise<Response> {
-  const id = at(ctx, 'configuration');
-  if (!ctx.get(PBC, id)) return ctx.notFound(PBC, id);
-  return ctx.reply(await ctx.write(PBC, id, mergeUpdate(ctx, PBC, id, { ...ctx.params, updated: nowUnix(ctx.occurredAt) }), 'billing_portal.configuration.update'));
-}
 
 // ── the customer portal ──
 

package/src/semantics/charges.ts

@@ -1,11 +1,7 @@
 // Stripe's charges operations (docs/contributing/architecture.md, "What an author writes"): each handler over the
 // handler contract's context, computing with the engine (../engine/).
 import type { HandlerContext } from '@volter/world-core';
-import { withoutCard } from '../engine/charges.ts';
-import type { Row } from '../engine/common.ts';
-import { asBool, chargeDefaults, declineFor, searchOver, validateMoney } from '../engine/stripe.ts';
-import { afterCharge, at, captureAuthorization, chargeBody, chargeMissing, chargeRefund, created, declinedCharge, expanded, fail, finder, fraudReport, list, newest, path, paymentMethodDetails, refundCharge, send, settleCharge, where } from './shared.ts';
-
+import { at, chargeBody, chargeMissing, expanded, list, newest, where } from './shared.ts';
 export async function GetCharges(ctx: HandlerContext): Promise<Response> {
   const items = where(ctx, newest(ctx, 'charge'), {
     customer: (c, v) => c.customer === v,
@@ -18,4 +14,3 @@ export async function GetChargesCharge(ctx: HandlerContext): Promise<Response> {
   const c = ctx.get('charge', at(ctx, 'charge'));
   return c ? ctx.reply(expanded(ctx, 'charge', chargeBody(ctx, c))) : chargeMissing(ctx, at(ctx, 'charge'));
 }
-

package/src/semantics/checkout.ts

@@ -6,14 +6,24 @@ import type { Row } from '../engine/common.ts';
 import { applyCouponDiscount, lineItemEntries, nowUnix, paginate, resolveLineItem } from '../engine/stripe.ts';
 import { actingAccount, at, checkoutNoDestination, created, discountOf, fail, finder, noLineItems, path, sessionMissing, sessionTrialRefused } from './shared.ts';
 
+export async function GetCheckoutSessionsSessionLineItems(ctx: HandlerContext): Promise<Response> {
+  const s = ctx.get(CS, at(ctx, 'session'));
+  if (!s) return sessionMissing(ctx, at(ctx, 'session'));
+  // source: spec:GetCheckoutSessionsSessionLineItems "There is also a URL where you can retrieve the full (paginated) list of line items."
+  const li = s.line_items as { data?: Row[] } | undefined;
+  const { page, hasMore } = paginate(Array.isArray(li?.data) ? li!.data! : [], ctx.params);
+  return ctx.reply({ object: 'list', url: path(ctx), has_more: hasMore, data: page });
+}
+
 export async function PostCheckoutSessions(ctx: HandlerContext): Promise<Response> {
   const params = ctx.params;
   const mode = typeof params.mode === 'string' ? params.mode : 'payment';
   if (!['payment', 'subscription', 'setup'].includes(mode)) return fail(ctx, 'Invalid mode: must be one of payment, subscription, or setup.', 400, 'parameter_invalid_string_enum');
   const entries = lineItemEntries(params);
   if (mode !== 'setup' && entries.length === 0) return noLineItems(ctx);
-  // hosted Checkout (the only ui_mode the twin models) needs success_url
-  if (params.success_url === undefined || params.success_url === '') return fail(ctx, 'Missing required param: success_url.', 400, 'parameter_missing');
+  // source: spec:/paths/~1v1~1checkout~1sessions/post/requestBody/content/application~1x-www-form-urlencoded/schema/properties/ui_mode "The UI mode of the Session."
+  const custom = params.ui_mode === 'custom';
+  if (!custom && (params.success_url === undefined || params.success_url === '')) return fail(ctx, 'Missing required param: success_url.', 400, 'parameter_missing');
   const sessionCurrency = typeof params.currency === 'string' ? params.currency : 'usd';
   const resolved = entries.map((e, i) => resolveLineItem(e, i, sessionCurrency, finder(ctx)));
   const missing = resolved.find((r) => r.priceMissing);
@@ -31,7 +41,10 @@ export async function PostCheckoutSessions(ctx: HandlerContext): Promise<Respons
   const fields: Row = {
     mode, status: 'open',
     payment_status: mode === 'setup' ? 'no_payment_required' : 'unpaid',
-    url: `https://checkout.stripe.com/c/pay/${id}`, success_url: params.success_url ?? null, cancel_url: params.cancel_url ?? null,
+    ui_mode: custom ? 'custom' : 'hosted',
+    ...(custom ? { client_secret: `${id}_secret_${await ctx.secret(`checkout-secret:${id}`)}`, return_url: params.return_url ?? null } : {}),
+    allow_promotion_codes: params.allow_promotion_codes === true || params.allow_promotion_codes === 'true',
+    url: custom ? null : `https://checkout.stripe.com/c/pay/${id}`, success_url: params.success_url ?? null, cancel_url: params.cancel_url ?? null,
     customer: params.customer ?? null, client_reference_id: params.client_reference_id ?? null,
     customer_email: params.customer_email ?? null,
     // whether paying makes a customer: in payment mode only when asked (`always`), `if_required` by default
@@ -67,12 +80,3 @@ export async function PostCheckoutSessions(ctx: HandlerContext): Promise<Respons
   if (discount) fields._discount = { coupon: String(discount.coupon.id), promotion_code: discount.promotion ?? null };
   return ctx.reply(await created(ctx, CS, { id, ...fields }, {}));
 }
-
-export async function PostCheckoutSessionsSessionExpire(ctx: HandlerContext): Promise<Response> {
-  const id = at(ctx, 'session');
-  const s = ctx.get(CS, id);
-  if (!s) return sessionMissing(ctx, id);
-  const refused = ctx.legal(CS, 'status', 'PostCheckoutSessionsSessionExpire', s.status, undefined, id);
-  if (refused) return ctx.refuse(refused);
-  return ctx.reply(await ctx.write(CS, id, { status: 'expired', url: null }, 'checkout.session.expire'));
-}

package/src/semantics/clock.ts

@@ -2,21 +2,14 @@
 // the World's clock before anything is answered, so every door (the API, the hosted pages) reads the account as it
 // stands now. Each move is the engine's.
 import type { HandlerContext } from '@volter/world-core';
-import { advanceBilling, advancePayouts, finishClockAdvances, finishReportRuns, lapseCoupons, lapseRealtimeRequests, settleBankDebits, settleHeldRefunds, settleTopups } from './shared.ts';
-
+import { advanceBilling, advancePayouts, lapseCoupons, lapseRealtimeRequests, settleBankDebits, settleHeldRefunds } from './shared.ts';
 export async function clock(ctx: HandlerContext): Promise<void> {
-  // a test clock advanced by the last request has reached its time
-  await finishClockAdvances(ctx);
   // a subscription renews at its period's end, its renewal charged an hour later
   await advanceBilling(ctx);
   // a submitted bank debit settles (in test mode at once)
   await settleBankDebits(ctx);
   // a coupon past its redeem_by is no longer valid
   await lapseCoupons(ctx);
-  // a top-up's funds arrive five days after it is made
-  await settleTopups(ctx);
-  // a report run completes
-  await finishReportRuns(ctx);
   // a real-time authorization request no one answered is decided when its window ends
   await lapseRealtimeRequests(ctx);
   // a refund held for want of balance is made when funds cover it, before any payout takes them

package/src/semantics/coupons.ts

@@ -2,7 +2,6 @@
 // handler contract's context, computing with the engine (../engine/).
 import type { HandlerContext } from '@volter/world-core';
 import { amountOffOf, created, fail } from './shared.ts';
-
 export async function PostCoupons(ctx: HandlerContext): Promise<Response> {
   const params = ctx.params;
   const hasPct = params.percent_off !== undefined;

package/src/semantics/customers.ts

@@ -1,11 +1,9 @@
 // Stripe's customers operations (docs/contributing/architecture.md, "What an author writes"): each handler over the
 // handler contract's context, computing with the engine (../engine/).
 import type { HandlerContext } from '@volter/world-core';
-import { deletedDiscount, type Row } from '../engine/common.ts';
 import { newCustomer } from '../engine/customers.ts';
 import { nowUnix } from '../engine/stripe.ts';
-import { at, attachable, attachPaymentMethod, cashBalance, created, customerDiscount, customerMissing, customerSource, expanded, fail, list, makeTaxId, newest, redeemCoupon, search, sourceMissing, where } from './shared.ts';
-
+import { at, attachable, attachPaymentMethod, created, customerMissing, expanded, fail, search } from './shared.ts';
 // "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)
 export async function GetCustomersCustomer(ctx: HandlerContext): Promise<Response> {
@@ -16,23 +14,11 @@ export async function GetCustomersCustomer(ctx: HandlerContext): Promise<Respons
   return ctx.reply(expanded(ctx, 'customer', ctx.get('customer', id)!));
 }
 
-// the payment methods attached to a customer (customers.listPaymentMethods), optionally by `type`
-export async function GetCustomersCustomerPaymentMethods(ctx: HandlerContext): Promise<Response> {
-  const customer = at(ctx, 'customer');
-  if (!ctx.get('customer', customer)) return customerMissing(ctx, customer);
-  const items = where(ctx, newest(ctx, 'payment_method').filter((m) => m.customer === customer), { type: (m, v) => m.type === v });
-  return list(ctx, 'payment_method', items);
-}
-
 export async function GetCustomersSearch(ctx: HandlerContext): Promise<Response> {
   return search(ctx, 'customer');
 }
 
 export async function PostCustomers(ctx: HandlerContext): Promise<Response> {
-  // a `coupon` on create materializes the discount object on the customer (the coupon must exist)
-  const couponId = typeof ctx.params.coupon === 'string' ? ctx.params.coupon : '';
-  const discount = couponId ? customerDiscount(ctx, couponId) : null;
-  if (discount instanceof Response) return discount;
   // `payment_method` attaches that method to the new customer; it is not a field of the customer
   // (docs.stripe.com/api/customers/create#create_customer-payment_method)
   const pmId = typeof ctx.params.payment_method === 'string' ? ctx.params.payment_method : '';
@@ -40,30 +26,41 @@ export async function PostCustomers(ctx: HandlerContext): Promise<Response> {
   const given = ctx.params;
   const { coupon: _c, payment_method: _pm, ...rest } = given;
   const id = ctx.mint('customer');
-  const customer = await created(ctx, 'customer', { ...rest, id }, { livemode: false, discount: discount ? { ...discount, customer: id } : null, ...newCustomer(id) });
-  if (discount) await redeemCoupon(ctx, couponId);
+  const customer = await created(ctx, 'customer', { ...rest, id }, { livemode: false, discount: null, ...newCustomer(id) });
+  // source: https://docs.stripe.com/billing/customer/balance "Represents the starting value of the customer invoice balance when a customer is created using the API with a non-zero invoice balance."
+  if (Number(customer.balance ?? 0) !== 0) {
+    await created(ctx, 'customer_balance_transaction', {
+      customer: id, amount: Number(customer.balance), ending_balance: Number(customer.balance),
+      currency: customer.currency ?? 'usd', type: 'initial', description: null, metadata: {},
+      livemode: false, invoice: null, credit_note: null, checkout_session: null, customer_account: null,
+    }, {});
+  }
   if (pmId) await attachPaymentMethod(ctx, pmId, String(customer.id));
   return ctx.reply(customer);
 }
 
 // ── the credit-balance ledger: a negative amount is a credit; `ending_balance` is the running sum,
 // mirrored onto the customer's `balance` ──
-export async function PostCustomersCustomerBalanceTransactions(ctx: HandlerContext): Promise<Response> {
-  const customer = at(ctx, 'customer');
-  if (!ctx.get('customer', customer)) return customerMissing(ctx, customer);
-  const params = ctx.params;
-  if (params.amount === undefined) return fail(ctx, 'Missing required param: amount.', 400, 'parameter_missing');
-  const amount = Number(params.amount);
-  if (!Number.isInteger(amount)) return fail(ctx, 'Invalid integer: amount.', 400, 'parameter_invalid_integer');
-  if (params.currency === undefined || params.currency === '') return fail(ctx, 'Missing required param: currency.', 400, 'parameter_missing');
-  const prior = ctx.rows('customer_balance_transaction').filter((t) => t.customer === customer).reduce((s, t) => s + (Number(t.amount) || 0), 0);
-  const ending = prior + amount;
-  const body = await created(ctx, 'customer_balance_transaction', { ...params, customer, amount }, {
-    ending_balance: ending, type: 'adjustment', livemode: false, metadata: {},
-    description: params.description ?? null, credit_note: null, invoice: null, checkout_session: null,
-  });
-  // keyed by the new transaction so two adjustments at one instant are two writes, the last winning
-  await ctx.write('customer', customer, { balance: ending }, `customer.balance_adjusted:${String(body.id)}`);
-  return ctx.reply(body);
-}
 
+
+// source: spec:PostCustomersCustomer "Updates the specified customer by setting the values of the parameters passed."
+export async function PostCustomersCustomer(ctx: HandlerContext): Promise<Response> {
+  const id = at(ctx, 'customer');
+  const customer = ctx.get('customer', id);
+  if (!customer) return customerMissing(ctx, id);
+  const { customer: _pathCustomer, ...fields } = ctx.params;
+  // source: https://docs.stripe.com/billing/customer/balance "All modifications to the invoice balance are recorded as Transactions"
+  // source: https://docs.stripe.com/billing/customer/balance "All Transactions created with the API or in the Dashboard have a type value of adjustment"
+  if (typeof fields.balance === 'number' && fields.balance !== Number(customer.balance ?? 0)) {
+    const balance = fields.balance;
+    await created(ctx, 'customer_balance_transaction', {
+      customer: id, amount: balance - Number(customer.balance ?? 0), ending_balance: balance,
+      // Stripe inherits the customer's billing currency. Where no invoice has set it, this World's invoice currency is USD.
+      currency: customer.currency ?? 'usd', type: 'adjustment',
+      description: null, metadata: {}, livemode: false,
+      invoice: null, credit_note: null, checkout_session: null, customer_account: null,
+      created: nowUnix(ctx.occurredAt),
+    }, {});
+  }
+  return ctx.reply(ctx.expand('customer', await ctx.write('customer', id, fields, 'customer.update')));
+}

package/src/semantics/doors.ts

@@ -2,9 +2,8 @@
 import type { HandlerContext } from '@volter/world-core';
 import type { Row } from '../engine/common.ts';
 import { platformAccountDefault } from '../engine/connect.ts';
-import { accountSettings, nowUnix, PLATFORM_ACCOUNT_ID } from '../engine/stripe.ts';
-import { at, balanceBody, created, fail, payDuePayouts, settleDueEntries } from './shared.ts';
-
+import { accountSettings, PLATFORM_ACCOUNT_ID } from '../engine/stripe.ts';
+import { balanceBody, payDuePayouts, settleDueEntries } from './shared.ts';
 /** The platform's own account settings (its payout schedule, its public name) change on Stripe's Dashboard, which has no
  *  API: this stands in for that page. The account is Stripe's default until the page first changes it (the same default
  *  GET /v1/account answers); a hash is merged into what the account holds, as an update merges it. */

package/src/semantics/entitlements.ts

@@ -1,47 +1,3 @@
 // Stripe's entitlements operations (docs/contributing/architecture.md, "What an author writes"): each handler over the
 // handler contract's context, computing with the engine (../engine/).
-import type { HandlerContext } from '@volter/world-core';
-import type { Row } from '../engine/common.ts';
-import { FEAT } from '../engine/entitlements.ts';
-import { asBool, subscriptionItemPairs } from '../engine/stripe.ts';
-import { at, created, fail, kept, list, lookupKeyTaken, newest, path, where } from './shared.ts';
-
-// a customer is entitled to every feature granted to a product its live subscriptions bill, as the product stood when
-// the subscription's current period began: "When a customer purchases or subscribes to a product with an attached
-// feature, Stripe creates and manages an Active Entitlement for that customer and feature"; "Existing subscriptions will
-// create active entitlements for any product feature changes at the start of the next billing period"
-// (docs.stripe.com/billing/entitlements). Where the documentation stops and the twin decides: a feature removed from a
-// product is kept, the same way, until the next period begins.
-export async function GetEntitlementsActiveEntitlements(ctx: HandlerContext): Promise<Response> {
-  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');
-  // each product a live subscription bills, with the start of the period it is billed for
-  const productIds = new Map<string, number>();
-  for (const sub of newest(ctx, 'subscription')) {
-    // a subscription entitles while it runs: not before its first payment (incomplete), nor once it has ended
-    // (docs.stripe.com/billing/entitlements; past_due keeps access during retries — that edge is the twin's reading)
-    if (sub.customer !== customer || !['active', 'trialing', 'past_due'].includes(String(sub.status))) continue;
-    const periodStart = Number(sub.current_period_start ?? sub.start_date ?? sub.created ?? 0);
-    for (const it of subscriptionItemPairs(sub)) {
-      const price = ctx.get('price', it.price);
-      if (price && typeof price.product === 'string') productIds.set(price.product, Math.max(productIds.get(price.product) ?? -Infinity, periodStart));
-    }
-  }
-  const seen = new Set<string>();
-  const data: Row[] = [];
-  for (const pf of ctx.rowsRaw('product_feature', { withDeleted: true })) {
-    const periodStart = productIds.get(String(pf._product));
-    if (periodStart === undefined) continue;
-    // attached by the period's start, and not removed before it
-    if (Number(pf._created ?? 0) > periodStart) continue;
-    if (pf.deleted && !(Number(pf._removed_at) > periodStart)) continue;
-    const featId = String(pf._feature ?? (pf.entitlement_feature as Row | undefined)?.id ?? pf.entitlement_feature);
-    if (seen.has(featId)) continue;
-    seen.add(featId);
-    const feat = ctx.get(FEAT, featId);
-    if (feat) data.push({ id: `ent_twin_${customer}_${featId}`, object: 'entitlements.active_entitlement', feature: featId, lookup_key: feat.lookup_key, livemode: false });
-  }
-  return ctx.reply({ object: 'list', url: path(ctx), has_more: false, data });
-}
-
+// source: spec:PostEntitlementsFeatures "Creates a feature"

package/src/semantics/events.ts

@@ -1,22 +1,16 @@
 // Stripe's Events API (the events family: the account's stored events, which the kernel keeps as each is sent), and how
 // Stripe renders the events its writes send (`data` and `values`, bound in the manifest's `events`).
-import type { EventWrite, HandlerContext, WriteHookContext } from '@volter/world-core';
-import { inRange } from '../engine/common.ts';
-import { planOf } from '../engine/plans.ts';
-import { embedIssuingAuthorizationCard, isValidApiVersion, PLATFORM_ACCOUNT_ID, TWIN_API_VERSION } from '../engine/stripe.ts';
+import type { EventWrite, WriteHookContext } from '@volter/world-core';
+import { isValidApiVersion, PLATFORM_ACCOUNT_ID, TWIN_API_VERSION } from '../engine/stripe.ts';
 import { render } from '../engine/version.ts';
-import { at, connectionRevoked, finder, list, newest, ownEvent, where } from './shared.ts';
-
 // ── the events Stripe's writes send (the manifest's `events`: ./shared.ts STRIPE_EVENTS) ──
 
-/** An event's `data`: the object the write concerns, as Stripe sends it in the event's API version. A plan is stored as
- *  the recurring price it is, and its own events carry the plan object; an Issuing authorization carries its full card;
- *  the balance notice the drain writes carries the account's Balance. */
+/** An event's `data`: the object the write concerns, as Stripe sends it in the event's API version. An Issuing
+ *  authorization carries its full card; the balance notice the drain writes carries the account's Balance. */
 export function data(ctx: WriteHookContext, write: EventWrite): Record<string, unknown> {
   const object = write.storedType === '_balance_notice' ? (write.body.balance as Record<string, unknown>)
-    : write.storedType === 'price' && write.operation.startsWith('plan.') ? planOf(write.body)
-    : write.storedType === 'issuing_authorization' ? embedIssuingAuthorizationCard({ ...write.body }, finder(ctx))
-    : write.body;
+    : write.storedType === 'issuing_authorization' ? ctx.expand('issuing.authorization', write.body)
+    : write.storedType === 'issuing_card' ? ctx.expand('issuing.card', write.body) : ctx.expand(String(write.body.object ?? write.storedType), write.body);
   return { object: render(object, eventVersion(write)) as Record<string, unknown> };
 }
 
@@ -33,8 +27,7 @@ export function values(ctx: WriteHookContext, write: EventWrite, type: string):
     ?? (write.storedType === 'account' && typeof id === 'string' && id !== PLATFORM_ACCOUNT_ID ? id : undefined)
     ?? (write.storedType === '_balance_notice' && typeof write.body.account === 'string' ? write.body.account : undefined)
     ?? (typeof kept === 'string' ? kept : undefined);
-  const withheld = account !== undefined && type !== 'account.application.deauthorized' && connectionRevoked(ctx, account);
-  return { $account: account, $version: eventVersion(write), ...(withheld ? { $send: false } : {}) };
+  return { $account: account, $version: eventVersion(write) };
 }
 
 /** The API version an event is rendered in: the one the writing request pinned, when it is one, else the served one. */

package/src/semantics/index.ts

@@ -1,6 +1,7 @@
 // GENERATED by scripts/create-pack.ts --index: the handler map, by operationId, from the families' files (each
 // handler named as its operation). Do not edit; add a handler to its family's file and generate again.
 import type { Handler } from '@volter/world-core';
+import * as account from './account.ts';
 import * as account_links from './account_links.ts';
 import * as accounts from './accounts.ts';
 import * as apps from './apps.ts';
@@ -11,11 +12,9 @@ import * as charges from './charges.ts';
 import * as checkout from './checkout.ts';
 import * as coupons from './coupons.ts';
 import * as customers from './customers.ts';
-import * as disputes from './disputes.ts';
-import * as entitlements from './entitlements.ts';
 import * as invoice_payments from './invoice_payments.ts';
-import * as invoiceitems from './invoiceitems.ts';
 import * as invoices from './invoices.ts';
+import * as issuing from './issuing.ts';
 import * as payment_intents from './payment_intents.ts';
 import * as payment_methods from './payment_methods.ts';
 import * as payouts from './payouts.ts';
@@ -24,20 +23,15 @@ import * as products from './products.ts';
 import * as promotion_codes from './promotion_codes.ts';
 import * as radar from './radar.ts';
 import * as refunds from './refunds.ts';
-import * as setup_intents from './setup_intents.ts';
-import * as subscription_items from './subscription_items.ts';
-import * as subscription_schedules from './subscription_schedules.ts';
 import * as subscriptions from './subscriptions.ts';
 import * as test_helpers from './test_helpers.ts';
 import * as transfers from './transfers.ts';
+import * as webhook_endpoints from './webhook_endpoints.ts';
 
 export const stripeSemantics: Record<string, Handler> = {
-  DeleteInvoiceitemsInvoiceitem: invoiceitems.DeleteInvoiceitemsInvoiceitem,
-  DeleteInvoicesInvoice: invoices.DeleteInvoicesInvoice,
-  DeleteProductsId: products.DeleteProductsId,
-  DeleteSubscriptionItemsItem: subscription_items.DeleteSubscriptionItemsItem,
   DeleteSubscriptionsSubscriptionExposedId: subscriptions.DeleteSubscriptionsSubscriptionExposedId,
-  DeleteTestHelpersTestClocksTestClock: test_helpers.DeleteTestHelpersTestClocksTestClock,
+  DeleteSubscriptionsSubscriptionExposedIdDiscount: subscriptions.DeleteSubscriptionsSubscriptionExposedIdDiscount,
+  GetAccount: account.GetAccount,
   GetAccountsAccountExternalAccounts: accounts.GetAccountsAccountExternalAccounts,
   GetAppsSecretsFind: apps.GetAppsSecretsFind,
   GetBalance: balance.GetBalance,
@@ -45,25 +39,19 @@ export const stripeSemantics: Record<string, Handler> = {
   GetBillingPortalConfigurations: billing_portal.GetBillingPortalConfigurations,
   GetCharges: charges.GetCharges,
   GetChargesCharge: charges.GetChargesCharge,
+  GetCheckoutSessionsSessionLineItems: checkout.GetCheckoutSessionsSessionLineItems,
   GetCustomersCustomer: customers.GetCustomersCustomer,
-  GetCustomersCustomerPaymentMethods: customers.GetCustomersCustomerPaymentMethods,
   GetCustomersSearch: customers.GetCustomersSearch,
-  GetDisputesDispute: disputes.GetDisputesDispute,
-  GetEntitlementsActiveEntitlements: entitlements.GetEntitlementsActiveEntitlements,
   GetInvoicePayments: invoice_payments.GetInvoicePayments,
   GetInvoicesInvoice: invoices.GetInvoicesInvoice,
-  GetInvoicesInvoiceLines: invoices.GetInvoicesInvoiceLines,
+  GetIssuingCardsCard: issuing.GetIssuingCardsCard,
   GetPaymentMethodsPaymentMethod: payment_methods.GetPaymentMethodsPaymentMethod,
+  GetPayouts: payouts.GetPayouts,
   GetPrices: prices.GetPrices,
   GetPricesPrice: prices.GetPricesPrice,
   GetProducts: products.GetProducts,
-  GetProductsSearch: products.GetProductsSearch,
   GetPromotionCodes: promotion_codes.GetPromotionCodes,
-  GetRefundsRefund: refunds.GetRefundsRefund,
-  GetSubscriptionItemsItem: subscription_items.GetSubscriptionItemsItem,
-  GetSubscriptionSchedulesSchedule: subscription_schedules.GetSubscriptionSchedulesSchedule,
   GetSubscriptions: subscriptions.GetSubscriptions,
-  GetSubscriptionsSearch: subscriptions.GetSubscriptionsSearch,
   GetSubscriptionsSubscriptionExposedId: subscriptions.GetSubscriptionsSubscriptionExposedId,
   PostAccountLinks: account_links.PostAccountLinks,
   PostAccounts: accounts.PostAccounts,
@@ -71,25 +59,21 @@ export const stripeSemantics: Record<string, Handler> = {
   PostAppsSecrets: apps.PostAppsSecrets,
   PostAppsSecretsDelete: apps.PostAppsSecretsDelete,
   PostBillingPortalConfigurations: billing_portal.PostBillingPortalConfigurations,
-  PostBillingPortalConfigurationsConfiguration: billing_portal.PostBillingPortalConfigurationsConfiguration,
   PostBillingPortalSessions: billing_portal.PostBillingPortalSessions,
   PostCheckoutSessions: checkout.PostCheckoutSessions,
-  PostCheckoutSessionsSessionExpire: checkout.PostCheckoutSessionsSessionExpire,
   PostCoupons: coupons.PostCoupons,
   PostCustomers: customers.PostCustomers,
-  PostCustomersCustomerBalanceTransactions: customers.PostCustomersCustomerBalanceTransactions,
-  PostInvoiceitems: invoiceitems.PostInvoiceitems,
+  PostCustomersCustomer: customers.PostCustomersCustomer,
   PostInvoices: invoices.PostInvoices,
   PostInvoicesCreatePreview: invoices.PostInvoicesCreatePreview,
-  PostInvoicesInvoiceFinalize: invoices.PostInvoicesInvoiceFinalize,
   PostInvoicesInvoicePay: invoices.PostInvoicesInvoicePay,
-  PostInvoicesInvoiceSend: invoices.PostInvoicesInvoiceSend,
   PostInvoicesInvoiceVoid: invoices.PostInvoicesInvoiceVoid,
+  PostIssuingAuthorizationsAuthorizationApprove: issuing.PostIssuingAuthorizationsAuthorizationApprove,
+  PostIssuingAuthorizationsAuthorizationDecline: issuing.PostIssuingAuthorizationsAuthorizationDecline,
+  PostIssuingCards: issuing.PostIssuingCards,
+  PostIssuingCardsCard: issuing.PostIssuingCardsCard,
   PostPaymentIntents: payment_intents.PostPaymentIntents,
   PostPaymentIntentsIntentCancel: payment_intents.PostPaymentIntentsIntentCancel,
-  PostPaymentIntentsIntentConfirm: payment_intents.PostPaymentIntentsIntentConfirm,
-  PostPaymentMethods: payment_methods.PostPaymentMethods,
-  PostPaymentMethodsPaymentMethodAttach: payment_methods.PostPaymentMethodsPaymentMethodAttach,
   PostPaymentMethodsPaymentMethodDetach: payment_methods.PostPaymentMethodsPaymentMethodDetach,
   PostPayouts: payouts.PostPayouts,
   PostPrices: prices.PostPrices,
@@ -97,15 +81,9 @@ export const stripeSemantics: Record<string, Handler> = {
   PostPromotionCodes: promotion_codes.PostPromotionCodes,
   PostRadarValueListItems: radar.PostRadarValueListItems,
   PostRefunds: refunds.PostRefunds,
-  PostSetupIntents: setup_intents.PostSetupIntents,
-  PostSetupIntentsIntentConfirm: setup_intents.PostSetupIntentsIntentConfirm,
-  PostSubscriptionItems: subscription_items.PostSubscriptionItems,
-  PostSubscriptionItemsItem: subscription_items.PostSubscriptionItemsItem,
-  PostSubscriptionSchedules: subscription_schedules.PostSubscriptionSchedules,
-  PostSubscriptionSchedulesScheduleRelease: subscription_schedules.PostSubscriptionSchedulesScheduleRelease,
-  PostSubscriptions: subscriptions.PostSubscriptions,
   PostSubscriptionsSubscriptionExposedId: subscriptions.PostSubscriptionsSubscriptionExposedId,
-  PostTestHelpersTestClocks: test_helpers.PostTestHelpersTestClocks,
-  PostTestHelpersTestClocksTestClockAdvance: test_helpers.PostTestHelpersTestClocksTestClockAdvance,
+  PostTestHelpersIssuingAuthorizations: test_helpers.PostTestHelpersIssuingAuthorizations,
+  PostTestHelpersIssuingAuthorizationsAuthorizationCapture: test_helpers.PostTestHelpersIssuingAuthorizationsAuthorizationCapture,
   PostTransfers: transfers.PostTransfers,
+  PostWebhookEndpoints: webhook_endpoints.PostWebhookEndpoints,
 };

package/src/semantics/invoice_payments.ts

@@ -3,8 +3,7 @@
 import type { HandlerContext } from '@volter/world-core';
 import type { Row } from '../engine/common.ts';
 import { INV, invoicePayment } from '../engine/invoices.ts';
-import { at, fail, list, newest } from './shared.ts';
-
+import { list, newest } from './shared.ts';
 export async function GetInvoicePayments(ctx: HandlerContext): Promise<Response> {
   const p = ctx.params;
   const wanted = (p.payment as Row | undefined)?.payment_intent;
@@ -15,4 +14,3 @@ export async function GetInvoicePayments(ctx: HandlerContext): Promise<Response>
     .filter((x) => typeof p.status !== 'string' || x.status === p.status);
   return list(ctx, 'invoice_payment', items);
 }
-