@volter/twin-stripe 3.0.0 → 3.0.1

package/dist/src/semantics/states.js

@@ -1,8 +1,3 @@
-const unexpected = (verb, allowed) => ({
-    status: 400,
-    code: 'payment_intent_unexpected_state',
-    message: `This PaymentIntent could not be ${verb} because it has a status of {from}. ${allowed}`,
-});
 const OPEN = ['requires_payment_method', 'requires_confirmation', 'requires_action', 'requires_capture', 'processing'];
 /** A move no API call makes: Stripe's own (`vendor`), the clock's (`time`), or the person on a
  *  Stripe-hosted page (`external`: Checkout, the billing portal, a hosted invoice or 3DS page). */
@@ -22,18 +17,9 @@ const paymentIntentStatus = {
     transitions: [
         // created with its payment method, it "enters the `requires_confirmation` status and is ready to confirm" (the same page)
         { operation: 'PostPaymentIntents', from: ['requires_payment_method'], to: 'requires_confirmation', source: 'https://docs.stripe.com/payments/paymentintents/lifecycle' },
-        // confirm lands on one of its outcomes, decided by the payment method and the capture method
-        ...['requires_payment_method', 'requires_action', 'requires_capture', 'succeeded'].map((to) => ({
-            operation: 'PostPaymentIntentsIntentConfirm',
-            from: ['requires_payment_method', 'requires_confirmation', 'requires_action'],
-            to,
-            refusal: { status: 400, code: 'payment_intent_unexpected_state', message: 'You cannot confirm this PaymentIntent because it has a status of {from}.' },
-            source: 'https://docs.stripe.com/api/payment_intents/confirm',
-        })),
-        // a bank debit confirmed (created with `confirm`, confirmed, or verified by micro-deposits) is submitted and
-        // processes: "The PaymentIntent you create initially has a status of `processing`"; "When the bank account is
-        // successfully verified, Stripe returns the PaymentIntent object with a status of `processing`"
-        ...['PostPaymentIntents', 'PostPaymentIntentsIntentConfirm'].map((operation) => ({
+        // a bank debit confirmed (created with `confirm`, or confirmed) is submitted and processes: "The PaymentIntent you
+        // create initially has a status of `processing`"
+        ...['PostPaymentIntents',].map((operation) => ({
             operation, from: ['requires_payment_method', 'requires_confirmation', 'requires_action'], to: 'processing',
             source: 'https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment?payment-ui=direct-api',
         })),
@@ -48,33 +34,10 @@ const paymentIntentStatus = {
             source: 'spec:PostPaymentIntents "Set to `true` to attempt to [confirm this PaymentIntent](https://docs.stripe.com/api/payment_intents/confirm) immediately."',
         })),
         {
-            operation: 'PostPaymentIntentsIntentCapture',
-            from: ['requires_capture'],
-            to: 'succeeded',
-            refusal: unexpected('captured', 'Only a PaymentIntent with one of the following statuses may be captured: requires_capture.'),
-            source: 'https://docs.stripe.com/api/payment_intents/capture',
-        },
-        {
-            operation: 'PostPaymentIntentsIntentIncrementAuthorization',
-            from: ['requires_capture'],
-            to: 'requires_capture',
-            refusal: unexpected('incremented', 'Only a PaymentIntent with a status of requires_capture may be incremented.'),
-            source: 'https://docs.stripe.com/api/payment_intents/increment_authorization',
-        },
-        {
-            operation: 'PostPaymentIntentsIntentCancel',
-            from: OPEN,
-            to: 'canceled',
-            refusal: unexpected('canceled', 'Only a PaymentIntent with one of the following statuses may be canceled: requires_payment_method, requires_capture, requires_confirmation, requires_action, processing.'),
+            operation: 'PostPaymentIntentsIntentCancel', from: OPEN, to: 'canceled',
+            refusal: { status: 400, code: 'payment_intent_unexpected_state', message: 'You cannot cancel this PaymentIntent because it has a status of {from}. Only a PaymentIntent with one of the following statuses may be canceled: requires_payment_method, requires_capture, requires_confirmation, requires_action, processing.' },
             source: 'https://docs.stripe.com/api/payment_intents/cancel',
         },
-        {
-            operation: 'PostPaymentIntentsIntentVerifyMicrodeposits',
-            from: ['requires_action'],
-            to: 'processing',
-            refusal: { status: 400, code: 'payment_intent_unexpected_state', message: 'This PaymentIntent could not be verified because it has a status of {from}.' },
-            source: 'https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment?payment-ui=direct-api',
-        },
         {
             // paying the invoice an intent collects for settles the intent
             operation: 'PostInvoicesInvoicePay',
@@ -82,49 +45,30 @@ const paymentIntentStatus = {
             to: 'succeeded',
             source: 'https://docs.stripe.com/api/invoices/pay',
         },
-        ...['succeeded', 'requires_action'].map((to) => ({
-            operation: 'PostPaymentIntentsIntentApplyCustomerBalance',
-            from: OPEN,
-            to,
-            refusal: { status: 400, code: 'payment_intent_unexpected_state', message: 'This PaymentIntent could not be updated because it has a status of {from}.' },
-            source: 'https://docs.stripe.com/api/payment_intents/apply_customer_balance',
-        })),
-        // a card presented to the Terminal reader processing an intent pays it (held, under manual capture)
-        ...['succeeded', 'requires_capture'].map((to) => ({
-            operation: 'PostTestHelpersTerminalReadersReaderPresentPaymentMethod', from: ['requires_payment_method', 'requires_confirmation'], to,
-            source: 'https://docs.stripe.com/api/terminal/readers/present_payment_method',
-        })),
         // the customer pays, in the billing portal, the invoice an intent collects for after its charge was declined
         by('external', ['requires_payment_method'], 'succeeded', 'https://docs.stripe.com/customer-management'),
         // Stripe also fails a bank debit back to needing a payment method, completes 3-D Secure on the bank's page and
         // cancels a hold left uncaptured; the twin's bank debits succeed unless their test account stays processing, it has no 3-D Secure page, and it keeps
-        // holds until they are captured or canceled
+        // holds until they are canceled. Capture, increment_authorization, verify_microdeposits, apply_customer_balance and
+        // the Terminal reader's present_payment_method are the gap (no demand, life step or refresh sends them:
+        // ../manifest.ts unmodeled), so no move of theirs is declared.
     ],
 };
-/** A charge's `captured`: an authorization (capture=false) is captured once. */
+/** A charge's `captured`: an authorization (capture_method=manual) is captured once, by the Charges API's capture or
+ *  its PaymentIntent's; both are the gap here (no demand, life step or refresh sends them: ../manifest.ts unmodeled), so
+ *  a held charge stays uncaptured until its intent is canceled, and no move is declared. */
 const chargeCaptured = {
     initial: true,
-    transitions: [
-        {
-            operation: 'PostChargesChargeCapture',
-            from: ['false'],
-            to: 'true',
-            refusal: { status: 400, code: 'charge_already_captured', message: 'Charge ch_xxx has already been captured.' },
-            source: 'https://docs.stripe.com/api/charges/capture',
-        },
-        // a manual-capture intent's capture captures the charge its confirm authorized
-        { operation: 'PostPaymentIntentsIntentCapture', from: ['false'], to: 'true', source: 'https://docs.stripe.com/api/payment_intents/capture' },
-    ],
+    transitions: [],
 };
-/** A charge's `refunded`: true once refunds take its whole amount, false again when a refund that made it so is
- *  canceled. A capture or a cancel never makes it so: "`refunded` will no longer be `true` for payment cancellation
+/** A charge's `refunded`: true once refunds take its whole amount. A capture or a cancel never makes it so: "`refunded` will no longer be `true` for payment cancellation
  *  flows", and a partial capture makes no Refund (docs.stripe.com/changelog/basil/2025-03-31/remove-refund-from-partial-
  *  capture-and-payment-cancellation-flow). */
 const chargeRefunded = {
     initial: false,
     transitions: [
-        ...['PostRefunds', 'PostChargesChargeRefunds', 'PostCreditNotes'].map((operation) => ({ operation, from: ['false'], to: 'true', source: 'https://docs.stripe.com/api/charges/object#charge_object-refunded' })),
-        { operation: 'PostRefundsRefundCancel', from: ['true'], to: 'false', source: 'https://docs.stripe.com/api/refunds/cancel' },
+        { operation: 'PostRefunds', from: ['false'], to: 'true', source: 'https://docs.stripe.com/api/charges/object#charge_object-refunded' },
+        // (a charge's own refunds path, a credit note's refund and a refund's cancel are the gap here: ../manifest.ts unmodeled)
         // (an authorization left uncaptured is canceled after seven days, "Uncaptured PaymentIntents are cancelled a set
         // number of days (7 by default) after their creation", docs.stripe.com/api/payment_intents/capture; the twin keeps it)
     ],
@@ -143,63 +87,26 @@ const chargePaid = {
     // (a charge is paid when it settles; the twin's settle when made)
     transitions: [],
 };
-/** A refund's `status`: only one waiting on the customer (requires_action) may be canceled; the
- *  rest is the network's. */
+/** A refund's `status`: held pending for want of balance, then made; the rest is the network's. (Canceling one that
+ *  waits on the customer is the gap here: ../manifest.ts unmodeled.) */
 const refundStatus = {
     initial: 'succeeded',
     transitions: [
-        {
-            operation: 'PostRefundsRefundCancel',
-            from: ['requires_action'],
-            to: 'canceled',
-            refusal: { status: 400, code: 'refund_status_invalid', message: 'Refund {id} cannot be canceled because its status is {from}.' },
-            source: 'https://docs.stripe.com/api/refunds/cancel',
-        },
-        // a card refund the available balance does not cover is held pending, and made once the balance covers it: "Stripe
-        // holds the refund as pending for card transactions ... until your Stripe balance becomes sufficient"
-        // (docs.stripe.com/refunds; semantics/refunds.ts)
-        // (a paid invoice's credit note makes its refund as a refund call does: "Refunds: create a new refund (using
-        // refund_amount)", docs.stripe.com/api/credit_notes/create)
-        ...['PostRefunds', 'PostChargesChargeRefunds', 'PostCreditNotes'].map((operation) => ({ operation, from: ['succeeded'], to: 'pending', source: 'https://docs.stripe.com/refunds' })),
+        { operation: 'PostRefunds', from: ['succeeded'], to: 'pending', source: 'https://docs.stripe.com/refunds' },
         by('vendor', ['pending'], 'succeeded', 'https://docs.stripe.com/refunds'),
         // a bank-transfer payment's refund waits in requires_action for the customer's bank details, and is made so
         // (semantics/refunds.ts); (Stripe also fails some refunds; the twin's do not fail)
     ],
 };
-const SETUP_OPEN = ['requires_payment_method', 'requires_confirmation', 'requires_action'];
-const setupUnexpected = (verb) => ({ status: 400, code: 'setup_intent_unexpected_state', message: `You cannot ${verb} this SetupIntent because it has a status of {from}.` });
-/** A SetupIntent's `status`: confirm settles it (or leaves a bank account awaiting micro-deposits),
- *  cancel ends an open one, and verification completes the micro-deposit wait. */
+/** A SetupIntent's `status`: confirm settles it, or leaves a bank account awaiting micro-deposits. (Its cancel and its
+ *  micro-deposit verification are the gap here: ../manifest.ts unmodeled.) */
 const setupIntentStatus = {
     // "After you create the SetupIntent, it has a status of `requires_payment_method` until you attach a payment method"
     // (docs.stripe.com/payments/paymentintents/lifecycle)
     initial: 'requires_payment_method',
     transitions: [
-        // created with its payment method, it "enters the `requires_confirmation` status and is ready to confirm" (the same page)
-        { operation: 'PostSetupIntents', from: ['requires_payment_method'], to: 'requires_confirmation', source: 'https://docs.stripe.com/payments/paymentintents/lifecycle' },
-        ...['requires_action', 'succeeded'].map((to) => ({
-            operation: 'PostSetupIntentsIntentConfirm',
-            from: SETUP_OPEN,
-            to,
-            refusal: setupUnexpected('confirm'),
-            source: 'https://docs.stripe.com/api/setup_intents/confirm',
-        })),
-        {
-            operation: 'PostSetupIntentsIntentCancel',
-            from: SETUP_OPEN,
-            to: 'canceled',
-            refusal: setupUnexpected('cancel'),
-            source: 'https://docs.stripe.com/api/setup_intents/cancel',
-        },
-        {
-            operation: 'PostSetupIntentsIntentVerifyMicrodeposits',
-            from: ['requires_action'],
-            to: 'succeeded',
-            refusal: { status: 400, code: 'setup_intent_unexpected_state', message: 'This SetupIntent could not be verified because it has a status of {from}.' },
-            source: 'https://docs.stripe.com/api/setup_intents/verify_microdeposits',
-        },
-        // (Stripe completes 3-D Secure on the bank's page and settles an asynchronous method from processing; the
-        // twin has no such page and settles every method at once)
+    // (Stripe completes 3-D Secure on the bank's page and settles an asynchronous method from processing; the
+    // twin has no such page and settles every method at once)
     ],
 };
 const invoiceRefusal = (message) => ({ status: 400, code: 'invoice_not_editable', message });
@@ -208,38 +115,20 @@ const invoiceRefusal = (message) => ({ status: 400, code: 'invoice_not_editable'
 const invoiceStatus = {
     initial: 'draft',
     transitions: [
+        { operation: 'PostInvoicesInvoicePay', from: ['draft'], to: 'open', source: 'https://docs.stripe.com/invoicing/integration' },
         {
-            operation: 'PostInvoicesInvoiceFinalize',
-            from: ['draft'],
-            to: 'open',
-            refusal: invoiceRefusal('This invoice cannot be finalized because it has status {from}.'),
-            source: 'https://docs.stripe.com/api/invoices/finalize',
-        },
-        // docs.stripe.com/invoicing/integration: "To finalize a draft invoice, use the Dashboard, send it to the customer, or pay it."
-        { operation: 'PostInvoicesInvoiceSend', from: ['draft'], to: 'open', source: 'https://docs.stripe.com/invoicing/integration' },
-        { operation: 'PostInvoicesInvoiceSend', from: ['open', 'paid', 'uncollectible', 'void'], source: 'https://docs.stripe.com/api/invoices/send' },
-        {
+            // paying a draft finalizes it on the way: "To finalize a draft invoice, use the Dashboard, send it to the customer, or
+            // pay it" (docs.stripe.com/invoicing/integration)
             operation: 'PostInvoicesInvoicePay',
-            from: ['open', 'uncollectible'],
+            from: ['draft', 'open', 'uncollectible'],
             to: 'paid',
             refusal: invoiceRefusal('This invoice cannot be paid because it has status {from}.'),
             refusals: { paid: { status: 400, code: 'invoice_payment_intent_requires_action', message: 'This invoice has already been paid.' } },
             source: 'https://docs.stripe.com/api/invoices/pay',
         },
-        {
-            operation: 'PostInvoicesInvoiceMarkUncollectible',
-            from: ['open'],
-            to: 'uncollectible',
-            refusal: invoiceRefusal('Only open invoices can be marked uncollectible (this one is {from}).'),
-            source: 'https://docs.stripe.com/api/invoices/mark_uncollectible',
-        },
+        // (marking one uncollectible is the gap here: ../manifest.ts unmodeled)
         // a guard: only a draft is deleted; a finalized invoice is voided instead
-        {
-            operation: 'DeleteInvoicesInvoice',
-            from: ['draft'],
-            refusal: invoiceRefusal('You can only delete draft invoices.'),
-            source: 'https://docs.stripe.com/api/invoices/delete',
-        },
+        // in any other state it is refused (a refusal with no `to` refuses where it stands)
         {
             // only a finalized invoice is voided; a draft is deleted
             operation: 'PostInvoicesInvoiceVoid',
@@ -248,15 +137,11 @@ const invoiceStatus = {
             refusal: invoiceRefusal('This invoice cannot be voided because it has status {from}.'),
             source: 'https://docs.stripe.com/api/invoices/void',
         },
-        // confirming or capturing the PaymentIntent an invoice collects through pays the invoice
-        ...['PostPaymentIntentsIntentConfirm', 'PostPaymentIntentsIntentCapture'].map((operation) => ({
-            operation, from: ['draft', 'open', 'uncollectible'], to: 'paid', source: 'https://docs.stripe.com/billing/subscriptions/build-subscriptions',
-        })),
+        // confirming the PaymentIntent an invoice collects through pays the invoice
         // as does its bank debit succeeding once submitted (../engine/payment-intents.ts settleBankDebits)
         by('vendor', ['draft', 'open', 'uncollectible'], 'paid', 'https://docs.stripe.com/billing/subscriptions/build-subscriptions'),
-        // a bank transfer that arrives in the customer's cash balance pays an open invoice that takes transfers
-        // (automatic reconciliation; in test mode the funding helper stands in for the transfer)
-        { operation: 'PostTestHelpersCustomersCustomerFundCashBalance', from: ['open'], to: 'paid', source: 'https://docs.stripe.com/payments/customer-balance/reconciliation' },
+        // (a bank transfer reconciled from the customer's cash balance pays one at Stripe; funding a cash balance is the gap
+        // here: ../manifest.ts unmodeled)
         // a subscription's first invoice is paid on the Checkout page that started it
         by('external', ['draft'], 'paid', 'https://docs.stripe.com/payments/checkout/how-checkout-works'),
         // a subscription's renewal, drafted at its period's end, is finalized about an hour later and charged: paid, or
@@ -268,7 +153,6 @@ const invoiceStatus = {
         { operation: 'PostSubscriptionsSubscriptionExposedId', from: ['draft'], to: 'paid', source: 'https://docs.stripe.com/billing/subscriptions/upgrade-downgrade#immediate-payment' },
         // a trialing subscription's first invoice, for nothing, is paid as it is made ("An immediate invoice is still
         // created, but the amount is 0", docs.stripe.com/billing/subscriptions/trials/free-trials)
-        { operation: 'PostSubscriptions', from: ['draft'], to: 'paid', source: 'https://docs.stripe.com/billing/subscriptions/trials/free-trials' },
         { operation: 'PostSubscriptionsSubscriptionExposedId', from: ['draft'], to: 'open', source: 'https://docs.stripe.com/billing/subscriptions/upgrade-downgrade#immediate-payment' },
         // the customer pays an open invoice in the billing portal
         by('external', ['open'], 'paid', 'https://docs.stripe.com/customer-management'),
@@ -284,16 +168,8 @@ const subscriptionStatus = {
         { operation: 'DeleteSubscriptionsSubscriptionExposedId', from: '*', to: 'canceled', source: 'https://docs.stripe.com/api/subscriptions/cancel' },
         // (a test clock's advance moves no subscription itself: when the clock reaches its target, a trial that ended there
         // ends by time's move below, on the next request; ../engine/test-clocks.ts finishClockAdvances)
-        // "Deleting the simulation also deletes the test customers associated with the clock and cancels their
-        // subscriptions" (docs.stripe.com/billing/testing/test-clocks/api-advanced-usage)
-        { operation: 'DeleteTestHelpersTestClocksTestClock', from: '*', to: 'canceled', source: 'https://docs.stripe.com/billing/testing/test-clocks/api-advanced-usage' },
-        // "Cancels a subscription schedule and its associated subscription immediately" (docs.stripe.com/api/subscription_schedules/cancel)
-        { operation: 'PostSubscriptionSchedulesScheduleCancel', from: ['active', 'trialing', 'past_due', 'incomplete'], to: 'canceled', source: 'https://docs.stripe.com/api/subscription_schedules/cancel' },
-        // confirming or capturing the first invoice's PaymentIntent, or paying the invoice itself, pays it and
-        // activates the subscription
-        ...['PostPaymentIntentsIntentConfirm', 'PostPaymentIntentsIntentCapture'].map((operation) => ({
-            operation, from: ['incomplete'], to: 'active', source: 'https://docs.stripe.com/billing/subscriptions/build-subscriptions',
-        })),
+        // (canceling a subscription schedule, which cancels its subscription, is the gap here: ../manifest.ts unmodeled)
+        // confirming the first invoice's PaymentIntent, or paying the invoice itself, pays it and activates the subscription
         // or when its bank debit succeeds once submitted (../engine/payment-intents.ts settleBankDebits)
         by('vendor', ['incomplete'], 'active', 'https://docs.stripe.com/billing/subscriptions/build-subscriptions'),
         // paying the invoice a subscription waits on (its first, or a renewal that failed) makes it active
@@ -332,7 +208,6 @@ const notOpen = (verb) => ({ status: 400, code: 'checkout_session_not_open', mes
 const checkoutStatus = {
     initial: 'open',
     transitions: [
-        { operation: 'PostCheckoutSessionsSessionExpire', from: ['open'], to: 'expired', refusal: notOpen('expire'), source: 'https://docs.stripe.com/api/checkout/sessions/expire' },
         { actor: 'external', from: ['open'], to: 'complete', refusal: notOpen('complete'), source: 'https://docs.stripe.com/api/checkout/sessions/object#checkout_session_object-status' },
         // (Stripe expires an open session at expires_at; the twin keeps it open until asked)
     ],
@@ -346,73 +221,48 @@ const checkoutPaymentStatus = {
         // (a delayed method settles a session later at Stripe; the twin's settle on the page)
     ],
 };
-/** A dispute's `status`: closing concedes it; the bank decides the rest, and an unanswered one is
- *  lost when its evidence is due. */
+/** A dispute's `status`: a disputed test card's charge opens one (needs_response, or warning_needs_response for an
+ *  inquiry). Submitting evidence and closing (conceding) are the gap here (../manifest.ts unmodeled), so nothing puts a
+ *  dispute under review for the bank to decide; the bank escalates an inquiry and loses one left unanswered at
+ *  Stripe, and the twin decides none. */
 const disputeStatus = {
     initial: 'warning_needs_response',
-    transitions: [
-        { operation: 'PostDisputesDisputeClose', from: '*', to: 'lost', source: 'https://docs.stripe.com/api/disputes/close' },
-        // submitting evidence puts a dispute (or an inquiry) under review; in test mode the evidence decides it
-        { operation: 'PostDisputesDispute', from: ['needs_response'], to: 'under_review', source: 'https://docs.stripe.com/api/disputes/update#update_dispute-submit' },
-        { operation: 'PostDisputesDispute', from: ['warning_needs_response'], to: 'warning_under_review', source: 'https://docs.stripe.com/api/disputes/update#update_dispute-submit' },
-        by('vendor', ['under_review'], 'won', 'https://docs.stripe.com/testing#evidence'),
-        by('vendor', ['under_review'], 'lost', 'https://docs.stripe.com/testing#evidence'),
-        // (the bank decides a dispute under review, escalates an inquiry and loses one left unanswered; the twin
-        // decides none)
-        // Stripe also closes an inquiry the bank drops (warning_closed); no inquiry the twin holds is dropped
-    ],
+    transitions: [],
 };
 /** A payout's `status`: cancel ends it; reversing cancels it and pays a reversal, never twice. */
 const payoutStatus = {
     initial: 'pending',
     transitions: [
-        // only a pending payout can be canceled (docs.stripe.com/api/payouts/cancel); reversing a paid one makes a new
-        // payout and leaves the original paid (semantics/balance.ts)
-        { operation: 'PostPayoutsPayoutCancel', from: ['pending'], to: 'canceled', source: 'https://docs.stripe.com/api/payouts/cancel' },
+        // (canceling a pending payout and reversing a paid one are the gap here: ../manifest.ts unmodeled)
         // it arrives in the bank on its arrival date
         by('time', ['pending'], 'paid', 'https://docs.stripe.com/payouts#payout-statuses'),
         // (a bank may fail a payout at Stripe; the twin's arrive)
     ],
 };
-/** A credit note's `status`: issued, then voided once. */
+/** A credit note's `status`: issued, then voided once at Stripe. Issuing and voiding one are the gap here
+ *  (../manifest.ts unmodeled): a vendor-backed World reads credit notes back from its root (GetCreditNotes). */
 const creditNoteStatus = {
     initial: 'issued',
-    transitions: [
-        {
-            operation: 'PostCreditNotesIdVoid',
-            from: ['issued'],
-            to: 'void',
-            refusal: { status: 400, code: 'credit_note_already_voided', message: 'This credit note has already been voided.' },
-            source: 'https://docs.stripe.com/api/credit_notes/void',
-        },
-    ],
+    transitions: [],
 };
-const scheduleEnded = (verb) => ({ status: 400, code: 'subscription_schedule_status_invalid', message: `This subscription schedule has status {from} and cannot be ${verb}.` });
-/** A subscription schedule's `status`: canceling or releasing ends it; an ended one refuses both. */
+/** A subscription schedule's `status`: releasing ends it, and an ended one refuses it. (Canceling one is the gap here:
+ *  ../manifest.ts unmodeled.) */
 const scheduleStatus = {
     initial: 'active',
     transitions: [
-        // "A subscription schedule can only be canceled if its status is not_started or active"; "A schedule can only be
-        // released if its status is not_started or active" (the cancel and release pages)
-        { operation: 'PostSubscriptionSchedulesScheduleCancel', from: ['active', 'not_started'], to: 'canceled', refusal: scheduleEnded('canceled'), source: 'https://docs.stripe.com/api/subscription_schedules/cancel' },
-        { operation: 'PostSubscriptionSchedulesScheduleRelease', from: ['active', 'not_started'], to: 'released', refusal: scheduleEnded('released'), source: 'https://docs.stripe.com/api/subscription_schedules/release' },
-        // its phases run on the clock: it starts at its start date and ends with its last phase
-        // (a schedule whose end_behavior is cancel completes at its end at Stripe; the twin's release)
-        // (Stripe starts a schedule at its start date and ends it with its last phase; the twin's start at once
-        // and end when canceled or released)
+    // "A schedule can only be released if its status is not_started or active" (the release page)
+    // its phases run on the clock: it starts at its start date and ends with its last phase
+    // (a schedule whose end_behavior is cancel completes at its end at Stripe; the twin's release)
+    // (Stripe starts a schedule at its start date and ends it with its last phase; the twin's start at once
+    // and end when canceled or released)
     ],
 };
-const quoteRefusal = (verb) => ({ status: 400, code: 'quote_invalid_status', message: `This quote cannot be ${verb} because it has status {from}.` });
-/** A quote's `status`: a draft is finalized into open, an open one accepted, and either canceled. */
+/** A quote's `status`: at Stripe a draft is finalized into open, an open one accepted, and either canceled. Quotes are
+ *  the gap here (../manifest.ts unmodeled): a vendor-backed World reads them back from its root (GetQuotes), so no
+ *  move is the twin's. */
 const quoteStatus = {
     initial: 'draft',
-    transitions: [
-        { operation: 'PostQuotesQuoteFinalize', from: ['draft'], to: 'open', refusal: quoteRefusal('finalized'), source: 'https://docs.stripe.com/api/quotes/finalize' },
-        { operation: 'PostQuotesQuoteAccept', from: ['open'], to: 'accepted', refusal: quoteRefusal('accepted'), source: 'https://docs.stripe.com/api/quotes/accept' },
-        { operation: 'PostQuotesQuoteCancel', from: ['draft', 'open'], to: 'canceled', refusal: quoteRefusal('canceled'), source: 'https://docs.stripe.com/api/quotes/cancel' },
-        // an open quote not accepted by its expires_at is canceled
-        // (Stripe cancels an open quote at its expires_at; the twin keeps it open)
-    ],
+    transitions: [],
 };
 const setBy = (operation, values, source) => values.map((to) => ({ operation, from: '*', to, source }));
 /** An Issuing authorization's `status`: approve and decline close a pending one, once; a capture
@@ -421,7 +271,9 @@ const issuingAuthorizationStatus = {
     initial: 'pending',
     transitions: [
         // approving keeps it pending (approved) until the merchant captures; declining closes it
-        { operation: 'PostIssuingAuthorizationsAuthorizationApprove', from: ['pending'], refusal: { status: 400, code: 'authorization_already_finalized', message: 'This authorization has already been finalized (status {from}).' }, source: 'https://docs.stripe.com/issuing/purchases/authorizations' },
+        { operation: 'PostIssuingAuthorizationsAuthorizationApprove', from: ['pending'], source: 'https://docs.stripe.com/issuing/purchases/authorizations' },
+        // in any other state it is refused (a refusal with no `to` refuses where it stands)
+        { operation: 'PostIssuingAuthorizationsAuthorizationApprove', from: '*', refusal: { status: 400, code: 'authorization_already_finalized', message: 'This authorization has already been finalized (status {from}).' }, source: 'https://docs.stripe.com/issuing/purchases/authorizations' },
         { operation: 'PostIssuingAuthorizationsAuthorizationDecline', from: ['pending'], to: 'closed', refusal: { status: 400, code: 'authorization_already_finalized', message: 'This authorization has already been finalized (status {from}).' }, source: 'https://docs.stripe.com/api/issuing/authorizations/decline' },
         { operation: 'PostTestHelpersIssuingAuthorizationsAuthorizationCapture', from: ['pending'], to: 'closed', source: 'https://docs.stripe.com/api/issuing/authorizations/test_mode_capture' },
         { operation: 'PostTestHelpersIssuingAuthorizationsAuthorizationCapture', from: ['pending'], source: 'https://docs.stripe.com/api/issuing/authorizations/test_mode_capture' },
@@ -433,34 +285,22 @@ const issuingAuthorizationStatus = {
         // capture helper above closes it, and the twin serves no other)
     ],
 };
-/** A Treasury flow's `status` as the twin's own operations move it: only a processing flow cancels. */
-const flowCancel = (operation, code, name, network) => ({
-    initial: 'processing',
-    transitions: [
-        { operation, from: ['processing'], to: 'canceled', refusal: { status: 400, code, message: `This ${name} cannot be canceled because it is no longer processing.` }, source: 'https://docs.stripe.com/api/treasury' },
-        ...network,
-    ],
-});
-/** An outbound flow on the network: Stripe posts or fails it and a posted one may come back returned (in
- *  test mode by test helpers the twin does not serve), so none of those moves is the twin's. */
-const outbound = (_doc) => [];
+/** A Treasury flow's `status`: at Stripe a processing flow cancels, the network posts or fails it, and a posted one may
+ *  come back returned. Treasury's flows are the gap here (../manifest.ts unmodeled): a vendor-backed World reads them
+ *  back from its root, so no move is the twin's. */
+const flow = { initial: 'processing', transitions: [] };
 export const states = {
     'billing.meter': {
         notState: ['event_time_window'],
-        state: { status: { initial: 'active', transitions: [
-                    { operation: 'PostBillingMetersIdDeactivate', from: '*', to: 'inactive', source: 'https://docs.stripe.com/api/billing/meter/deactivate' },
-                    { operation: 'PostBillingMetersIdReactivate', from: '*', to: 'active', source: 'https://docs.stripe.com/api/billing/meter/reactivate' },
-                ] } },
+        // (deactivating and reactivating a meter are the gap here: ../manifest.ts unmodeled)
+        state: { status: { initial: 'active', transitions: [] } },
     },
     'billing.credit_grant': {
         notState: ['category'],
     },
     'billing.alert': {
-        state: { status: { initial: 'active', transitions: [
-                    { operation: 'PostBillingAlertsIdActivate', from: '*', to: 'active', source: 'https://docs.stripe.com/api/billing/alert/activate' },
-                    { operation: 'PostBillingAlertsIdDeactivate', from: '*', to: 'inactive', source: 'https://docs.stripe.com/api/billing/alert/deactivate' },
-                    { operation: 'PostBillingAlertsIdArchive', from: '*', to: 'archived', source: 'https://docs.stripe.com/api/billing/alert/archive' },
-                ] } },
+        // (activating, deactivating and archiving an alert are the gap here: ../manifest.ts unmodeled)
+        state: { status: { initial: 'active', transitions: [] } },
     },
     payment_intent: {
         state: { status: paymentIntentStatus },
@@ -523,17 +363,10 @@ export const states = {
         notState: ['billing_address_collection', 'customer_creation', 'locale', 'mode', 'origin_context', 'payment_method_collection', 'redirect_on_completion', 'submit_type', 'ui_mode'],
     },
     mandate: {
-        state: {
-            status: {
-                initial: 'active',
-                transitions: [
-                    // a single-use mandate is spent by its payment: inactive "The mandate was rejected, revoked, or previously
-                    // used, and may not be used to initiate future payments" (../engine/payment-intents.ts settleBankDebits)
-                    by('vendor', ['active'], 'inactive', 'https://docs.stripe.com/api/mandates/object'),
-                    // (Stripe also activates a pending mandate and deactivates one revoked; the twin's are active when made)
-                ],
-            },
-        },
+        // Stripe activates a pending mandate, spends a single-use one with its payment and deactivates one revoked; the twin
+        // makes no mandate (micro-deposit verification, which accepts one, is the gap here: ../manifest.ts unmodeled), so no
+        // move is the twin's
+        state: { status: { initial: 'active', transitions: [] } },
         notState: ['type'],
     },
     dispute: {
@@ -571,7 +404,8 @@ export const states = {
         notState: ['end_behavior'],
     },
     'entitlements.feature': {
-        state: { active: { initial: true, transitions: flag('PostEntitlementsFeaturesId', 'spec:PostEntitlementsFeaturesId "Update a feature’s metadata or permanently deactivate it."') } },
+        // (updating a feature, which "permanently" deactivates it, is the gap here: ../manifest.ts unmodeled)
+        state: { active: { initial: true, transitions: [] } },
     },
     'test_helpers.test_clock': {
         state: {
@@ -580,7 +414,6 @@ export const states = {
                 transitions: [
                     // "advancing: The clock has started to advance but hasn't reached the specified time"; "ready: The clock has
                     // completed advancing to the specified time" (docs.stripe.com/billing/testing/test-clocks/api-advanced-usage)
-                    { operation: 'PostTestHelpersTestClocksTestClockAdvance', from: ['ready'], to: 'advancing', refusal: { status: 400, code: 'test_clock_not_ready', message: 'This test clock is still advancing.' }, source: 'https://docs.stripe.com/api/test_clocks/advance' },
                     by('vendor', ['advancing'], 'ready', 'https://docs.stripe.com/billing/testing/test-clocks/api-advanced-usage'),
                     // (Stripe may also end an advance in internal_failure; the twin's advances complete)
                 ],
@@ -588,14 +421,8 @@ export const states = {
         },
     },
     webhook_endpoint: {
-        state: {
-            status: {
-                initial: 'enabled',
-                transitions: [
-                    ...['enabled', 'disabled'].map((to) => ({ operation: 'PostWebhookEndpointsWebhookEndpoint', from: '*', to, source: 'https://docs.stripe.com/api/webhook_endpoints/update#update_webhook_endpoint-disabled' })),
-                ],
-            },
-        },
+        // (disabling and enabling an endpoint by its update is the gap here: ../manifest.ts unmodeled)
+        state: { status: { initial: 'enabled', transitions: [] } },
     },
     account: {
         notState: ['business_type', 'type'],
@@ -608,10 +435,8 @@ export const states = {
             status: {
                 initial: 'unrequested',
                 transitions: [
-                    ...['pending', 'inactive'].map((to) => ({ operation: 'PostAccountsAccountCapabilitiesCapability', from: '*', to, source: 'https://docs.stripe.com/api/capabilities/update' })),
-                    // Stripe reviews the account's requirements
-                    by('vendor', ['pending', 'inactive'], 'active', 'https://docs.stripe.com/connect/account-capabilities#capability-status'),
-                    by('vendor', ['active', 'pending'], 'inactive', 'https://docs.stripe.com/connect/account-capabilities#capability-status'),
+                // (requesting or unrequesting a capability by its update is the gap here: ../manifest.ts unmodeled)
+                // Stripe reviews the account's requirements
                 ],
             },
         },
@@ -622,25 +447,17 @@ export const states = {
     },
     application_fee: {
         state: { refunded: { initial: false, transitions: [
-                    { operation: 'PostApplicationFeesIdRefunds', from: ['false'], to: 'true', source: 'https://docs.stripe.com/api/fee_refunds/create' },
-                    // a refund of its charge with refund_application_fee refunds it in proportion
-                    ...['PostRefunds', 'PostChargesChargeRefunds'].map((operation) => ({ operation, from: ['false'], to: 'true', source: 'https://docs.stripe.com/api/refunds/create#create_refund-refund_application_fee' })),
+                    { operation: 'PostRefunds', from: ['false'], to: 'true', source: 'https://docs.stripe.com/connect/destination-charges#issue-refunds' },
                 ] } },
     },
     file: {
         notState: ['purpose'],
     },
     'identity.verification_session': {
-        state: {
-            status: {
-                initial: 'requires_input',
-                transitions: [
-                    by('external', ['requires_input'], 'processing', 'https://docs.stripe.com/identity/how-sessions-work'),
-                    by('vendor', ['processing'], 'verified', 'https://docs.stripe.com/identity/how-sessions-work'),
-                    by('vendor', ['processing'], 'requires_input', 'https://docs.stripe.com/identity/how-sessions-work'),
-                ],
-            },
-        },
+        // the person verifies on Stripe's hosted page, and Stripe decides (docs.stripe.com/identity/how-sessions-work);
+        // sessions are the gap here (../manifest.ts unmodeled) and a vendor-backed World reads them back from its root,
+        // so no move is the twin's
+        state: { status: { initial: 'requires_input', transitions: [] } },
         notState: ['type'],
     },
     'identity.verification_report': {
@@ -650,11 +467,12 @@ export const states = {
         notState: ['locale'],
     },
     'billing_portal.configuration': {
-        state: { active: { initial: true, transitions: flag('PostBillingPortalConfigurationsConfiguration', 'https://docs.stripe.com/api/customer_portal/configurations/update') } },
+        state: { active: { initial: true, transitions: [] } },
         notState: ['is_default'],
     },
     tax_rate: {
-        state: { active: { initial: true, transitions: flag('PostTaxRatesTaxRate', 'https://docs.stripe.com/api/tax_rates/update') } },
+        // (archiving a rate by its update is the gap here: ../manifest.ts unmodeled)
+        state: { active: { initial: true, transitions: [] } },
         notState: ['jurisdiction_level', 'rate_type', 'state', 'tax_type'],
     },
     'tax.settings': {
@@ -671,7 +489,8 @@ export const states = {
         notState: ['type'],
     },
     payment_link: {
-        state: { active: { initial: true, transitions: flag('PostPaymentLinksPaymentLink', 'https://docs.stripe.com/api/payment_links/payment_links/update') } },
+        // (switching a link off by its update is the gap here: ../manifest.ts unmodeled)
+        state: { active: { initial: true, transitions: [] } },
         notState: ['billing_address_collection', 'customer_creation', 'payment_method_collection', 'submit_type'],
     },
     quote: {
@@ -679,26 +498,22 @@ export const states = {
         notState: ['collection_method'],
     },
     review: {
-        state: {
-            open: {
-                initial: true,
-                transitions: [
-                    // (Stripe also closes one when the payment is refunded or disputed; the twin's close only on approval)
-                    { operation: 'PostReviewsReviewApprove', from: ['true'], to: 'false', refusal: { status: 400, code: 'review_already_closed', message: 'This review has already been closed.' }, source: 'https://docs.stripe.com/api/radar/reviews/approve' },
-                ],
-            },
-        },
+        // an elevated-risk card's charge opens one (shared.ts openReview); approving it is the gap here (../manifest.ts
+        // unmodeled), and Stripe closes one when the payment is refunded or disputed, which the twin does not
+        state: { open: { initial: true, transitions: [] } },
         notState: ['closed_reason', 'opened_reason'],
     },
     'radar.value_list': {
         notState: ['item_type'],
     },
     'issuing.cardholder': {
-        state: { status: { initial: 'active', transitions: setBy('PostIssuingCardholdersCardholder', ['active', 'inactive', 'blocked'], 'https://docs.stripe.com/api/issuing/cardholders/update') } },
+        // (a cardholder's status set by its update is the gap here: ../manifest.ts unmodeled)
+        state: { status: { initial: 'active', transitions: [] } },
         notState: ['type'],
     },
     'issuing.card': {
-        state: { status: { initial: 'active', transitions: setBy('PostIssuingCardsCard', ['active', 'inactive', 'canceled'], 'https://docs.stripe.com/api/issuing/cards/update') } },
+        // a card is made inactive unless its create names a status: "Defaults to inactive" (docs.stripe.com/api/issuing/cards/create)
+        state: { status: { initial: 'inactive', transitions: setBy('PostIssuingCardsCard', ['active', 'inactive', 'canceled'], 'https://docs.stripe.com/api/issuing/cards/update') } },
         notState: ['cancellation_reason', 'replacement_reason', 'type'],
     },
     'issuing.authorization': {
@@ -709,34 +524,15 @@ export const states = {
         notState: ['type', 'wallet'],
     },
     'issuing.dispute': {
-        state: {
-            status: {
-                initial: 'unsubmitted',
-                transitions: [
-                    { operation: 'PostIssuingDisputesDisputeSubmit', from: ['unsubmitted'], to: 'submitted', refusal: { status: 400, code: 'dispute_unsubmitted_required', message: 'This dispute has already been submitted (status {from}).' }, source: 'spec:PostIssuingDisputesDisputeSubmit "Submits an Issuing <code>Dispute</code> to the card network."' },
-                    // (Stripe decides a submitted dispute won or lost and expires one never submitted; the twin decides none)
-                ],
-            },
-        },
+        // (submitting one to the network is the gap here, ../manifest.ts unmodeled, and Stripe decides a submitted dispute
+        // won or lost and expires one never submitted: a vendor-backed World reads them back from its root)
+        state: { status: { initial: 'unsubmitted', transitions: [] } },
         notState: ['loss_reason'],
     },
-    'issuing.token': {
-        state: { status: { initial: 'active', transitions: [...setBy('PostIssuingTokensToken', ['active', 'deleted', 'suspended'], 'https://docs.stripe.com/api/issuing/tokens/update')] } },
-        notState: ['network', 'wallet_provider'],
-    },
     'issuing.personalization_design': {
-        state: {
-            status: {
-                // a new design waits on Stripe's review (docs.stripe.com/issuing/cards/physical/personalization-design)
-                initial: 'review',
-                transitions: [
-                    ...setBy('PostTestHelpersIssuingPersonalizationDesignsPersonalizationDesignActivate', ['active'], 'spec:PostTestHelpersIssuingPersonalizationDesignsPersonalizationDesignActivate "to <code>active</code>"'),
-                    ...setBy('PostTestHelpersIssuingPersonalizationDesignsPersonalizationDesignDeactivate', ['inactive'], 'spec:PostTestHelpersIssuingPersonalizationDesignsPersonalizationDesignDeactivate "to <code>inactive</code>"'),
-                    ...setBy('PostTestHelpersIssuingPersonalizationDesignsPersonalizationDesignReject', ['rejected'], 'spec:PostTestHelpersIssuingPersonalizationDesignsPersonalizationDesignReject "to <code>rejected</code>"'),
-                    // (outside test mode Stripe's review decides it; the twin is test mode, where these helpers do)
-                ],
-            },
-        },
+        // a new design waits on Stripe's review (docs.stripe.com/issuing/cards/physical/personalization-design); designs and
+        // the test helpers that decide them are the gap here (../manifest.ts unmodeled), read back from a vendor-backed root
+        state: { status: { initial: 'review', transitions: [] } },
     },
     'terminal.reader': {
         notState: ['device_type'],
@@ -753,7 +549,7 @@ export const states = {
                 // later: "USA (USD) ACH Debit Transfer 5 days" (docs.stripe.com/connect/top-ups; semantics/terminal.ts)
                 initial: 'pending',
                 transitions: [
-                    { operation: 'PostTopupsTopupCancel', from: ['pending'], to: 'canceled', refusal: { status: 400, code: 'topup_unexpected_state', message: 'This top-up cannot be canceled because it has a status of {from}.' }, source: 'https://docs.stripe.com/api/topups/cancel' },
+                    // (canceling a pending top-up is the gap here: ../manifest.ts unmodeled)
                     // to the Issuing balance alike: "Your top-ups can take up to 5 business days to become available"
                     // (docs.stripe.com/issuing/funding/balance)
                     by('vendor', ['pending'], 'succeeded', 'https://docs.stripe.com/connect/top-ups'),
@@ -768,17 +564,13 @@ export const states = {
         notState: ['is_default'],
     },
     'treasury.outbound_payment': {
-        state: { status: flowCancel('PostTreasuryOutboundPaymentsIdCancel', 'outbound_payment_not_cancelable', 'OutboundPayment', outbound('https://docs.stripe.com/treasury/moving-money/financial-accounts/out-of/outbound-payments')) },
+        state: { status: flow },
     },
     'treasury.outbound_transfer': {
-        state: { status: flowCancel('PostTreasuryOutboundTransfersOutboundTransferCancel', 'outbound_transfer_not_cancelable', 'OutboundTransfer', outbound('https://docs.stripe.com/treasury/moving-money/financial-accounts/out-of/outbound-transfers')) },
+        state: { status: flow },
     },
     'treasury.inbound_transfer': {
-        // "An InboundTransfer is processing if it is created and pending. The status changes to succeeded once the funds have
-        // been "confirmed""; in test mode the succeed helper confirms them (docs.stripe.com/api/treasury/inbound_transfers)
-        state: { status: flowCancel('PostTreasuryInboundTransfersInboundTransferCancel', 'inbound_transfer_not_cancelable', 'InboundTransfer', [
-                { operation: 'PostTestHelpersTreasuryInboundTransfersIdSucceed', from: ['processing'], to: 'succeeded', refusal: { status: 400, code: 'inbound_transfer_not_processing', message: 'This InboundTransfer cannot succeed because it is no longer processing.' }, source: 'https://docs.stripe.com/api/treasury/inbound_transfers' },
-            ]) },
+        state: { status: flow },
     },
     'treasury.received_credit': {
         state: { status: { initial: 'succeeded', transitions: [] } },
@@ -790,15 +582,9 @@ export const states = {
     },
     'treasury.transaction': {
         notState: ['flow_type'],
-        // void: "The Transaction never impacted the balance. For example, a Transaction would enter this state if an
-        // OutboundPayment was initiated but then canceled" (docs.stripe.com/api/treasury/transactions/object); canceling an
-        // outbound flow voids its open transaction (semantics/treasury.ts). (Stripe also posts an open transaction as its
-        // flow settles; the twin's outbound flows stay processing)
-        state: { status: { initial: 'open', transitions: [
-                    ...['PostTreasuryOutboundPaymentsIdCancel', 'PostTreasuryOutboundTransfersOutboundTransferCancel', 'PostTreasuryInboundTransfersInboundTransferCancel'].map((operation) => ({ operation, from: ['open'], to: 'void', source: 'https://docs.stripe.com/api/treasury/transactions/object' })),
-                    // an inbound transfer's transaction posts when it succeeds ("a transaction is created and posted")
-                    { operation: 'PostTestHelpersTreasuryInboundTransfersIdSucceed', from: ['open'], to: 'posted', source: 'https://docs.stripe.com/api/treasury/inbound_transfers' },
-                ] } },
+        // a transaction posts as its flow settles and is voided when its flow is canceled, both Stripe's (the flows are the
+        // gap here: ../manifest.ts unmodeled)
+        state: { status: { initial: 'open', transitions: [] } },
     },
     'treasury.transaction_entry': {
         notState: ['flow_type', 'type'],
@@ -809,11 +595,9 @@ export const states = {
                 // an order is created confirmed: the create page's example answers "status": "confirmed" with confirmed_at set
                 // (docs.stripe.com/api/climate/order/create)
                 initial: 'confirmed',
-                transitions: [
-                    { operation: 'PostClimateOrdersOrderCancel', from: ['awaiting_funds', 'confirmed', 'open'], to: 'canceled', refusal: { status: 400, code: 'climate_order_not_cancelable', message: 'This order can no longer be canceled because it is {from}.' }, source: 'https://docs.stripe.com/api/climate/order/cancel' },
-                    // funded, confirmed by the supplier, then delivered
-                    // (Stripe funds, confirms and delivers an order over months; the twin's orders stay where they are made)
-                ],
+                // (Stripe funds, confirms and delivers an order over months, and cancels one asked to; orders are the gap here,
+                // ../manifest.ts unmodeled, read back from a vendor-backed root)
+                transitions: [],
             },
         },
         notState: ['cancellation_reason'],
@@ -822,10 +606,9 @@ export const states = {
         state: {
             status: {
                 initial: 'active',
-                transitions: [
-                    { operation: 'PostFinancialConnectionsAccountsAccountDisconnect', from: '*', to: 'disconnected', source: 'https://docs.stripe.com/api/financial_connections/accounts/disconnect' },
-                    // (Stripe marks an account inactive when the bank link breaks, and active again; the twin's links hold)
-                ],
+                // (disconnecting one is the gap here, ../manifest.ts unmodeled; Stripe marks an account inactive when the bank
+                // link breaks, and active again)
+                transitions: [],
             },
         },
         notState: ['category', 'subcategory'],
@@ -836,17 +619,16 @@ export const states = {
     },
     'reporting.report_run': {
         // "When first created, the object appears with status="pending""; "When the run completes, Stripe updates the
-        // object, and it has a status of succeeded" (docs.stripe.com/reports/api; ../engine/platform.ts finishReportRuns).
-        // (Stripe may also fail a run; the twin's runs succeed)
-        state: { status: { initial: 'pending', transitions: [by('vendor', ['pending'], 'succeeded', 'https://docs.stripe.com/reports/api')] } },
+        // object, and it has a status of succeeded" (docs.stripe.com/reports/api). Report runs are the gap here
+        // (../manifest.ts unmodeled), read back from a vendor-backed root, so Stripe's move is not the twin's.
+        state: { status: { initial: 'pending', transitions: [] } },
     },
     product: {
-        state: { active: { initial: true, transitions: flag('PostProductsId', 'https://docs.stripe.com/api/products/update#update_product-active') } },
+        state: { active: { initial: true, transitions: [] } },
     },
     price: {
         notState: ['billing_scheme', 'tax_behavior', 'tiers_mode', 'type'],
-        // deleting a plan leaves its price for its subscribers, inactive: "Deleting plans means new subscribers can’t be added.
-        // Existing subscribers aren’t affected." (docs.stripe.com/api/plans/delete; semantics/plans.ts)
-        state: { active: { initial: true, transitions: [...flag('PostPricesPrice', 'https://docs.stripe.com/api/prices/update#update_price-active'), { operation: 'DeletePlansPlan', from: ['true'], to: 'false', source: 'https://docs.stripe.com/api/plans/delete' }] } },
+        // (deleting a plan, which leaves its price inactive, is the gap here: ../manifest.ts unmodeled)
+        state: { active: { initial: true, transitions: [] } },
     },
 };