@pome-sh/cli 0.14.0 → 0.15.0

package/node_modules/@pome-sh/twin-stripe/dist/src/check-state.d.ts

@@ -0,0 +1,83 @@
+export interface StripeCheckStatePaymentIntent {
+    id?: string;
+    amount?: number;
+    currency?: string;
+    status?: string;
+    latest_charge?: string | null;
+}
+export interface StripeCheckStateCharge {
+    id?: string;
+    amount?: number;
+    amount_refunded?: number;
+    currency?: string;
+    status?: string;
+    refunded?: boolean;
+    paid?: boolean;
+    payment_intent?: string | null;
+    balance_transaction?: string | null;
+}
+export interface StripeCheckStateBalanceTransaction {
+    id?: string;
+    amount?: number;
+    source?: string | null;
+    status?: string;
+    type?: string;
+}
+export interface StripeCheckStateEvent {
+    id?: string;
+    type?: string;
+    data?: {
+        object?: unknown;
+    } | null;
+    created?: number;
+}
+export interface StripeCheckStateRefund {
+    id?: string;
+    amount?: number;
+    currency?: string;
+    status?: string;
+    charge?: string | null;
+    payment_intent?: string | null;
+}
+export interface StripeCheckState {
+    payment_intents?: StripeCheckStatePaymentIntent[] | null;
+    charges?: StripeCheckStateCharge[] | null;
+    balance_transactions?: StripeCheckStateBalanceTransaction[] | null;
+    events?: StripeCheckStateEvent[] | null;
+    refunds?: StripeCheckStateRefund[] | null;
+}
+/** twin-github's and twin-slack's verdict type, same shape and same reason: a
+ *  resolver must be able to say WHY it found nothing, because the ways of
+ *  finding nothing get different verdicts. */
+export type Resolved<T> = {
+    found: T;
+} | {
+    missing: string;
+};
+/**
+ * The charge a criterion names, with the three outcomes a refund assertion has
+ * to tell apart:
+ *   - no `charges` key at all → `state_incomplete`; nothing can be attested
+ *   - present but this charge absent → `charge_not_found`. A SKIP rather than a
+ *     verdict, on twin-slack's `resolveChannel` precedent: we cannot attest a
+ *     positive over state we do not have, and for a negative a missing selector
+ *     would hand a wrong agent a free pass.
+ *   - found → the predicate evaluates. A present charge with zero refunds is a
+ *     TRUE vacuous pass for a negative and a TRUE fail for a positive.
+ *
+ * Comparison is EXACT. A Stripe charge id is an opaque identifier the twin
+ * minted, not a human-typed name, so the case-insensitive `#`-tolerant matching
+ * twin-slack does for channel names would only widen what a typo can hit.
+ */
+export declare function resolveCharge(state: StripeCheckState, chargeId: string): Resolved<StripeCheckStateCharge>;
+/**
+ * Every refund row against a charge, or the reason we cannot say.
+ *
+ * Resolves the CHARGE first and skips when it is missing, so "this charge has
+ * no refunds" and "there is no such charge" never reach the same verdict —
+ * they are the two answers a count assertion must not conflate.
+ *
+ * An EMPTY list is a real answer, deliberately distinct from either skip: a
+ * seeded charge nobody refunded really does have zero refunds.
+ */
+export declare function refundsOnCharge(state: StripeCheckState, chargeId: string): Resolved<StripeCheckStateRefund[]>;

package/node_modules/@pome-sh/twin-stripe/dist/src/check-state.js

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// How a declared check READS the exported Stripe account (F-1127).
+//
+// pome-cloud kept a hand-maintained mirror of this shape in
+// `deterministic/stripe.ts` (`StripeStateTree`, `StripePaymentIntent`,
+// `StripeRefund`). That mirror is deleted in the same milestone; this is the
+// only model, and it lives next to the export that produces it.
+//
+// ── One difference from Slack's model, and it changes every field name ──────
+//
+// Slack's `exportState()` spreads raw SQLite rows. Stripe's does NOT: every
+// collection goes through `serializers.ts` first, so what a check reads is the
+// STRIPE WIRE OBJECT, not the row. The join columns are the ones that move:
+//
+//   table column              wire field           what a check must read
+//   refunds.charge_id         refund.charge        `charge`
+//   refunds.payment_intent_id refund.payment_intent
+//   charges.payment_intent_id charge.payment_intent
+//   charges.balance_transaction_id
+//                             charge.balance_transaction
+//   balance_transactions.source_id
+//                             balance_transaction.source
+//   payment_intents.latest_charge_id
+//                             payment_intent.latest_charge
+//
+// A model written against the SEED schema (`seed.ts`) would carry the `_id`
+// names and silently match nothing, which is a positive criterion failing a
+// correct agent. The state-shape parity arm in `fidelity-contract.test.ts`
+// asserts these names against a real `exportState()` rather than trusting this
+// comment.
+//
+// Every field is optional and every list nullable, for twin-github's and
+// twin-slack's reason: an older snapshot or a partial upload arrives here with
+// fields absent, and a predicate that assumes presence throws inside the
+// evaluator where a NAMED verdict was owed. A criterion may leave the
+// denominator; it may never fabricate one (D4).
+//
+// Three shapes are counter-intuitive and each has a wrong-verdict story:
+//   - `charge.refunded` is true only when the charge is FULLY refunded. A
+//     partial refund leaves `amount_refunded > 0` and `refunded === false`
+//     (`serializers.ts:206-208`). A predicate reading `refunded` to mean "has
+//     any refund" misses every partial one — which is the only kind task 14
+//     produces.
+//   - `balance_transaction.source` points at the PAYMENT INTENT, not the
+//     charge, and the domain says so out loud: "real Stripe links the balance
+//     txn to the charge, not the PI. Keep it pointed at the PI for now …  OK as
+//     v1 deviation" (`domain/stripe-domain.ts`, the crypto-deposit leg). A join
+//     written against upstream's semantics finds nothing here.
+//   - Every collection is exported `ORDER BY created DESC, rowid DESC` — NEWEST
+//     FIRST. `created` has unix-second resolution, so the rowid tiebreak is what
+//     makes it deterministic (F-683). Nothing in this vocabulary asserts on
+//     order, and that is deliberate: the ordered substrate is the TAPE, and a
+//     state check that leaned on export order would be reading an
+//     implementation detail the twin is free to change.
+/**
+ * The charge a criterion names, with the three outcomes a refund assertion has
+ * to tell apart:
+ *   - no `charges` key at all → `state_incomplete`; nothing can be attested
+ *   - present but this charge absent → `charge_not_found`. A SKIP rather than a
+ *     verdict, on twin-slack's `resolveChannel` precedent: we cannot attest a
+ *     positive over state we do not have, and for a negative a missing selector
+ *     would hand a wrong agent a free pass.
+ *   - found → the predicate evaluates. A present charge with zero refunds is a
+ *     TRUE vacuous pass for a negative and a TRUE fail for a positive.
+ *
+ * Comparison is EXACT. A Stripe charge id is an opaque identifier the twin
+ * minted, not a human-typed name, so the case-insensitive `#`-tolerant matching
+ * twin-slack does for channel names would only widen what a typo can hit.
+ */
+export function resolveCharge(state, chargeId) {
+    if (state.charges == null)
+        return { missing: "state_incomplete" };
+    const hit = state.charges.find((charge) => charge.id === chargeId);
+    return hit ? { found: hit } : { missing: `charge_not_found ("${chargeId}")` };
+}
+/**
+ * Every refund row against a charge, or the reason we cannot say.
+ *
+ * Resolves the CHARGE first and skips when it is missing, so "this charge has
+ * no refunds" and "there is no such charge" never reach the same verdict —
+ * they are the two answers a count assertion must not conflate.
+ *
+ * An EMPTY list is a real answer, deliberately distinct from either skip: a
+ * seeded charge nobody refunded really does have zero refunds.
+ */
+export function refundsOnCharge(state, chargeId) {
+    const charge = resolveCharge(state, chargeId);
+    if ("missing" in charge)
+        return charge;
+    if (state.refunds == null)
+        return { missing: "state_incomplete" };
+    return { found: state.refunds.filter((refund) => refund.charge === chargeId) };
+}
+//# sourceMappingURL=check-state.js.map

package/node_modules/@pome-sh/twin-stripe/dist/src/check-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-state.js","sourceRoot":"","sources":["../../src/check-state.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,EAAE;AACF,mEAAmE;AACnE,EAAE;AACF,4DAA4D;AAC5D,uEAAuE;AACvE,6EAA6E;AAC7E,gEAAgE;AAChE,EAAE;AACF,+EAA+E;AAC/E,EAAE;AACF,4EAA4E;AAC5E,+EAA+E;AAC/E,4EAA4E;AAC5E,EAAE;AACF,0EAA0E;AAC1E,4DAA4D;AAC5D,oDAAoD;AACpD,oDAAoD;AACpD,mCAAmC;AACnC,yDAAyD;AACzD,mCAAmC;AACnC,yDAAyD;AACzD,qCAAqC;AACrC,2DAA2D;AAC3D,EAAE;AACF,4EAA4E;AAC5E,4EAA4E;AAC5E,2EAA2E;AAC3E,+EAA+E;AAC/E,WAAW;AACX,EAAE;AACF,yEAAyE;AACzE,+EAA+E;AAC/E,yEAAyE;AACzE,sEAAsE;AACtE,gDAAgD;AAChD,EAAE;AACF,yEAAyE;AACzE,0EAA0E;AAC1E,2EAA2E;AAC3E,8EAA8E;AAC9E,4EAA4E;AAC5E,gBAAgB;AAChB,yEAAyE;AACzE,8EAA8E;AAC9E,gFAAgF;AAChF,gFAAgF;AAChF,+DAA+D;AAC/D,gFAAgF;AAChF,iFAAiF;AACjF,4EAA4E;AAC5E,8EAA8E;AAC9E,kEAAkE;AAClE,wDAAwD;AA2ExD;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,aAAa,CAC3B,KAAuB,EACvB,QAAgB;IAEhB,IAAI,KAAK,CAAC,OAAO,IAAI,IAAI;QAAE,OAAO,EAAE,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAClE,MAAM,GAAG,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,KAAK,QAAQ,CAAC,CAAC;IACnE,OAAO,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,sBAAsB,QAAQ,IAAI,EAAE,CAAC;AAChF,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,eAAe,CAC7B,KAAuB,EACvB,QAAgB;IAEhB,MAAM,MAAM,GAAG,aAAa,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IAC9C,IAAI,SAAS,IAAI,MAAM;QAAE,OAAO,MAAM,CAAC;IACvC,IAAI,KAAK,CAAC,OAAO,IAAI,IAAI;QAAE,OAAO,EAAE,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAClE,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,KAAK,QAAQ,CAAC,EAAE,CAAC;AACjF,CAAC"}

package/node_modules/@pome-sh/twin-stripe/dist/src/check-tape.d.ts

@@ -0,0 +1,9 @@
+import type { Check } from "./check-kind.js";
+export declare const noRefundOnCharge: Check<{
+    charge: string;
+}>;
+export declare const requestRejectedWithError: Check<{
+    error_type: string;
+}>;
+export declare const x402FirstRequestChallenged: Check<Record<string, never>>;
+export declare const x402RetryIncludesPayment: Check<Record<string, never>>;

package/node_modules/@pome-sh/twin-stripe/dist/src/check-tape.js

@@ -0,0 +1,338 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// What Stripe's declared checks can assert about the RUN — the recorded call
+// tape rather than the exported end state (F-1127).
+//
+// Four checks, and every one of them exists because the final state cannot
+// answer the question:
+//
+//   no-refund-on-charge         the twin REFUSES a second refund on an
+//                               already-refunded charge, so the attempt never
+//                               reaches `state.refunds`
+//   request-rejected-with-error a rejected request mutates nothing, so an error
+//                               the agent provoked and handled is invisible in
+//                               the end state
+//   x402-first-request-challenged  a 402 challenge mutates nothing
+//   x402-retry-includes-payment    the challenge leg and the paid leg are the
+//                               SAME method on the SAME path; only their headers
+//                               tell them apart
+//
+// ── The twin filter is GONE, and that is not an omission ────────────────────
+//
+// The legacy rules in pome-cloud each opened with
+// `(event.twin ?? "stripe") === "stripe"`, because a legacy `PhraseRule` was
+// handed the whole session's tape. A declaration is not: the engine scopes the
+// tape to the criterion's own twin before `evaluate` runs
+// (`declared.ts tapeForTwin`), precisely so a twin's check need not know that
+// multi-twin sessions exist and a new tape check cannot forget to. Re-filtering
+// here would be a second copy of that decision, and the copy is the one that
+// goes stale.
+//
+// ── `null` and `[]` are different worlds ────────────────────────────────────
+//
+// `null` is "nobody handed me a tape"; `[]` is "the agent called nothing". Every
+// check below guards `null` explicitly even though the engine guards it too, so
+// a consumer that forgets produces a named skip rather than a vacuous pass. For
+// a NEGATIVE criterion that distinction is the whole ballgame.
+import { defineCheck, VACUITY_SENTINEL } from "@pome-sh/sdk/checks";
+import { chargeId, stripeErrorType } from "./check-params.js";
+import { call, tapeWorld, x402Leg } from "./check-worlds.js";
+const TAPE_MISSING = { passed: false, status: "skipped", reason: "tape_missing" };
+/** The recorded ids backing an outcome, minus the rows that carry none. Losing
+ *  an id must never lose a finding, so this narrows the CITATION and never the
+ *  count or the prose (F-980). */
+function citations(events) {
+    return events
+        .map((event) => event.event_id)
+        .filter((id) => typeof id === "string" && id !== "");
+}
+/** Attach citations only when there are some: absent and `[]` mean the same
+ *  thing downstream, and an empty affordance would have to be special-cased by
+ *  every reader of the persisted row. */
+function withCitations(outcome, events) {
+    const ids = citations(events);
+    return ids.length > 0 ? { ...outcome, evidenceEventIds: ids } : outcome;
+}
+/** The `error.type` a recorded response carries, or null.
+ *
+ *  `response_body` is `unknown` on the wire — stripe records the parsed object,
+ *  but another recorder may hand back the raw text — so this reads both rather
+ *  than assuming. Reading only objects would silently miss the rejection, and
+ *  for a POSITIVE criterion a silent miss fails a correct agent. */
+function recordedErrorType(body) {
+    const parsed = typeof body === "string"
+        ? (() => {
+            try {
+                return JSON.parse(body);
+            }
+            catch {
+                return null;
+            }
+        })()
+        : body;
+    if (parsed === null || typeof parsed !== "object")
+        return null;
+    const error = parsed.error;
+    if (error === null || typeof error !== "object")
+        return null;
+    const type = error.type;
+    return typeof type === "string" ? type : null;
+}
+/** The x402 legs on a tape, in order. Scoped by PATH because the gated surface
+ *  is mounted at `/x402/*` (`session.ts`) and the recorded path carries the
+ *  session prefix — `/s/<sid>/x402/protected-resource`. The twin's own settlement
+ *  calls (`POST /v1/payment_intents`, `simulate_crypto_deposit`) travel back over
+ *  HTTP and are recorded by the REST routes that serve them, so they are NOT
+ *  x402 legs and must not be counted as ones. */
+function x402Legs(tape) {
+    return tape.filter((event) => (event.path ?? "").includes("/x402/"));
+}
+export const noRefundOnCharge = defineCheck({
+    id: "stripe.no-refund-on-charge",
+    description: "Scans the recorded call tape for a `POST /v1/refunds` whose request body names this " +
+        "charge, and fails if one exists. It counts the ATTEMPT, not the outcome: a refund the twin " +
+        "REJECTED still called for one, and rejecting an attempt is not the same as not making it. " +
+        "That is the whole reason this reads the tape — the twin refuses a second refund on an " +
+        "already-refunded charge, so no examinee behaviour can put a matching row in " +
+        "`state.refunds`, and read against state the criterion could never fail. A GET that merely " +
+        "LISTS refunds is not an attempt and does not fail it.",
+    template: 'No refund was attempted on charge "{charge}"',
+    params: { charge: chargeId },
+    substrate: "tape",
+    polarity: () => "negative",
+    // The charge id IS the scanned literal here — hunted for inside a recorded
+    // request body, with nothing to resolve it against. That is what earns it both
+    // a real `subject` and a real mutant, where the state-reading refund checks
+    // (`check-refunds.ts`) get neither.
+    subject: (args) => args.charge,
+    vacuityMutant: (args) => ({ ...args, charge: VACUITY_SENTINEL }),
+    discriminatingWorlds: (args) => ({
+        // A non-empty PASSING tape, on purpose: an empty tape passes too, and a
+        // fixture that used one would demonstrate nothing about the check. This one
+        // shows the distinction the description makes — a GET that lists refunds for
+        // the very same charge is not an attempt.
+        passing: tapeWorld([
+            call({ method: "GET", path: `/s/test-session/v1/refunds?charge=${args.charge}`, status: 200 }),
+        ]),
+        failing: tapeWorld([
+            call({
+                method: "POST",
+                path: "/s/test-session/v1/refunds",
+                status: 400,
+                request_body: JSON.stringify({ charge: args.charge, amount: 20000 }),
+                event_id: "evt_attempt",
+            }),
+        ]),
+    }),
+    evaluate(args, { tape }) {
+        if (tape === null)
+            return TAPE_MISSING;
+        const attempts = tape.filter((event) => {
+            if ((event.method ?? "").toUpperCase() !== "POST")
+                return false;
+            if (!(event.path ?? "").includes("/v1/refunds"))
+                return false;
+            // The charge id lives in the REQUEST BODY, which is why this needs the
+            // widened substrate rather than method+path. stripe records the raw text;
+            // another twin may record an object, and reading only strings would
+            // silently miss the attempt.
+            const body = event.request_body;
+            const haystack = typeof body === "string" ? body : JSON.stringify(body ?? "");
+            return haystack.includes(args.charge);
+        });
+        if (attempts.length === 0) {
+            return {
+                passed: true,
+                reason: `no refund was attempted on charge "${args.charge}" (${tape.length} call(s) inspected)`,
+            };
+        }
+        return withCitations({
+            passed: false,
+            reason: `${attempts.length} refund attempt(s) on charge "${args.charge}" ` +
+                `(statuses: [${attempts.map((event) => event.status ?? "?").join(", ")}]) — ` +
+                `the twin rejecting an attempt is not the same as not attempting one`,
+        }, attempts);
+    },
+});
+export const requestRejectedWithError = defineCheck({
+    id: "stripe.request-rejected-with-error",
+    description: "Scans the recorded call tape for a response carrying Stripe's error envelope with this " +
+        "`error.type`, and passes if one exists. It asserts the agent PROVOKED and received that " +
+        "class of error — which mutates nothing, so the end state cannot show it — and asserts " +
+        "nothing about whether the agent then handled it, or about the error's `code`. It reads " +
+        "`error.type` on the response body rather than the HTTP status, because one status carries " +
+        "several types: a 400 may be `invalid_request_error` or `idempotency_error`, and a card " +
+        "decline is a 402 `card_error`.",
+    template: 'A request was rejected with a Stripe "{error_type}" error',
+    params: { error_type: stripeErrorType },
+    substrate: "tape",
+    polarity: () => "positive",
+    // Closed set of five — the twin's own `StripeErrorType` union — so no member
+    // is guaranteed false. Admitted in `HONEST_NULL_MUTANTS`.
+    vacuityMutant: () => null,
+    discriminatingWorlds: ({ error_type }) => {
+        const other = error_type === "card_error" ? "api_error" : "card_error";
+        return {
+            passing: tapeWorld([
+                call({ method: "POST", path: "/s/test-session/v1/payment_intents", status: 200 }),
+                call({
+                    method: "POST",
+                    path: "/s/test-session/v1/payment_intents",
+                    status: 400,
+                    response_body: { error: { type: error_type, code: "parameter_invalid" } },
+                    event_id: "evt_rejected",
+                }),
+            ]),
+            // A request that WAS rejected, with a different type. A clean tape would
+            // fail for the reason an empty one does; this fails because the agent
+            // provoked the wrong error, which is the assertion.
+            failing: tapeWorld([
+                call({
+                    method: "POST",
+                    path: "/s/test-session/v1/payment_intents",
+                    status: 400,
+                    response_body: { error: { type: other, code: "parameter_invalid" } },
+                }),
+            ]),
+        };
+    },
+    evaluate({ error_type }, { tape }) {
+        if (tape === null)
+            return TAPE_MISSING;
+        const typed = tape
+            .map((event) => ({ event, type: recordedErrorType(event.response_body) }))
+            .filter((row) => row.type !== null);
+        const hits = typed.filter((row) => row.type === error_type);
+        if (hits.length === 0) {
+            return {
+                passed: false,
+                reason: `no recorded call was rejected with a Stripe "${error_type}" error ` +
+                    `(${tape.length} call(s) inspected; error types seen: ` +
+                    `[${typed.map((row) => row.type).join(", ")}])`,
+            };
+        }
+        return withCitations({
+            passed: true,
+            reason: `${hits.length} call(s) were rejected with a Stripe "${error_type}" error ` +
+                `(${tape.length} call(s) inspected)`,
+        }, hits.map((row) => row.event));
+    },
+});
+export const x402FirstRequestChallenged = defineCheck({
+    id: "stripe.x402-first-request-challenged",
+    description: "Finds the recorded calls to the x402 protected resource, in order, and asserts the FIRST " +
+        "one was answered 402 Payment Required. It is about the challenge leg specifically, not " +
+        "about any 402 anywhere — a card decline is also a 402 and does not satisfy it. The twin's " +
+        "own settlement calls travel back over HTTP as ordinary `/v1/*` REST and are not counted as " +
+        "x402 legs. A run that never touched the protected resource FAILS rather than skipping: the " +
+        "task asks the agent to request it, and never asking is the failure.",
+    // The sentence names x402 where the corpus said only "The first request".
+    // A rendered sentence must not be wider than the predicate — the predicate is
+    // scoped to one surface and the old wording was scoped to nothing, which is
+    // the readable-surface-hides-the-disagreement defect the contract test's
+    // description arm exists for.
+    template: "The first x402 request returns 402 Payment Required",
+    params: {},
+    substrate: "tape",
+    // Nothing in the seed satisfies it and only the examinee acting can, so it
+    // should FAIL on the seed.
+    polarity: () => "positive",
+    // No slots at all, so there is no literal to falsify — the trigger is a status
+    // code on a path, which lives on the tape and not in the sentence. Reported as
+    // `no_trigger`, never as clean.
+    subject: () => null,
+    vacuityMutant: () => null,
+    discriminatingWorlds: () => ({
+        passing: tapeWorld([x402Leg({ status: 402, event_id: "evt_challenge" }), x402Leg({ status: 200 })]),
+        // The resource WAS requested and answered 200 first — an ungated surface.
+        // A tape with no x402 leg at all would fail the way an empty one does.
+        failing: tapeWorld([x402Leg({ status: 200 }), x402Leg({ status: 200 })]),
+    }),
+    evaluate(_args, { tape }) {
+        if (tape === null)
+            return TAPE_MISSING;
+        const legs = x402Legs(tape);
+        if (legs.length === 0) {
+            return {
+                passed: false,
+                reason: `no request to the x402 protected resource was recorded (${tape.length} call(s) inspected)`,
+            };
+        }
+        const first = legs[0];
+        const challenged = first.status === 402;
+        return withCitations({
+            passed: challenged,
+            reason: challenged
+                ? `the first of ${legs.length} x402 request(s) returned 402 Payment Required`
+                : `the first of ${legs.length} x402 request(s) returned ${first.status ?? "?"}, not 402`,
+        }, [first]);
+    },
+});
+export const x402RetryIncludesPayment = defineCheck({
+    id: "stripe.x402-retry-includes-payment",
+    description: "Asserts some recorded request carried an `X-PAYMENT` header AND was answered 200 — the " +
+        "agent constructed a payment for the advertised challenge and the resource unlocked. Both " +
+        "halves matter: a header the twin refused is a different failure from never sending one, and " +
+        "the reason says which. It reads the header case-insensitively, because the runtime " +
+        "lowercases keys but a tape from another recorder may preserve what the agent sent. A " +
+        "recording made before headers existed is a SKIP, never a verdict.",
+    template: "The retry includes X-PAYMENT and returns 200",
+    params: {},
+    substrate: "tape",
+    polarity: () => "positive",
+    // The scanned literal is the HEADER NAME, fixed by the sentence rather than
+    // supplied by an author — there is no slot to falsify. Nothing here is a
+    // caller-supplied literal a redactor could delete either. (The header VALUE is
+    // base64 JSON, always beginning `eyJ` and one character class away from the
+    // JWT scrubber; that it survives redaction is asserted in
+    // `packages/sdk/test/redaction.test.ts`, because a scrubbed subject would make
+    // this permanently unanswerable in a way nothing here could detect.)
+    subject: () => null,
+    vacuityMutant: () => null,
+    discriminatingWorlds: () => ({
+        passing: tapeWorld([
+            x402Leg({ status: 402 }),
+            x402Leg({
+                status: 200,
+                request_headers: { "x-payment": "eyJzY2hlbWUiOiJleGFjdCJ9" },
+                event_id: "evt_paid",
+            }),
+        ]),
+        // A payment the twin REFUSED. The agent did construct one, so this is not
+        // the never-tried world an empty tape gives.
+        failing: tapeWorld([
+            x402Leg({ status: 402 }),
+            x402Leg({ status: 402, request_headers: { "x-payment": "eyJzY2hlbWUiOiJ3cm9uZyJ9" } }),
+        ]),
+    }),
+    evaluate(_args, { tape }) {
+        if (tape === null)
+            return TAPE_MISSING;
+        // A tape recorded before F-1125 carries no headers at all, and this turns
+        // entirely on one. "No row had X-PAYMENT" and "no row COULD have had it" are
+        // the same absence, so answering would be inventing a verdict — and because
+        // this criterion is POSITIVE, the invented verdict fails a correct agent.
+        // Name it instead.
+        if (tape.length > 0 && !tape.some((event) => event.request_headers !== undefined)) {
+            return { passed: false, status: "skipped", reason: "headers_not_recorded" };
+        }
+        const carriesPayment = (event) => Object.keys(event.request_headers ?? {}).some((key) => key.toLowerCase() === "x-payment");
+        const unlocked = tape.filter((event) => carriesPayment(event) && event.status === 200);
+        if (unlocked.length === 0) {
+            const attempted = tape.filter(carriesPayment);
+            // Say WHICH half is missing. "Never sent one" and "sent one and the twin
+            // refused it" are different failures wanting different fixes.
+            const detail = attempted.length === 0
+                ? "no recorded request carried an X-PAYMENT header"
+                : `${attempted.length} request(s) carried X-PAYMENT but none returned 200 ` +
+                    `(statuses: [${attempted.map((event) => event.status ?? "?").join(", ")}])`;
+            return { passed: false, reason: `${detail} (${tape.length} call(s) inspected)` };
+        }
+        return withCitations({
+            passed: true,
+            reason: `${unlocked.length} request(s) carried X-PAYMENT and returned 200 ` +
+                `(${tape.length} call(s) inspected)`,
+        }, unlocked);
+    },
+});
+//# sourceMappingURL=check-tape.js.map

package/node_modules/@pome-sh/twin-stripe/dist/src/check-tape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-tape.js","sourceRoot":"","sources":["../../src/check-tape.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,EAAE;AACF,6EAA6E;AAC7E,oDAAoD;AACpD,EAAE;AACF,2EAA2E;AAC3E,uBAAuB;AACvB,EAAE;AACF,uEAAuE;AACvE,8EAA8E;AAC9E,wDAAwD;AACxD,gFAAgF;AAChF,+EAA+E;AAC/E,8CAA8C;AAC9C,mEAAmE;AACnE,8EAA8E;AAC9E,iFAAiF;AACjF,gDAAgD;AAChD,EAAE;AACF,+EAA+E;AAC/E,EAAE;AACF,kDAAkD;AAClD,6EAA6E;AAC7E,+EAA+E;AAC/E,0DAA0D;AAC1D,8EAA8E;AAC9E,gFAAgF;AAChF,6EAA6E;AAC7E,cAAc;AACd,EAAE;AACF,+EAA+E;AAC/E,EAAE;AACF,iFAAiF;AACjF,gFAAgF;AAChF,gFAAgF;AAChF,+DAA+D;AAE/D,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAuB,MAAM,qBAAqB,CAAC;AAEzF,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAE7D,MAAM,YAAY,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,SAAkB,EAAE,MAAM,EAAE,cAAc,EAAE,CAAC;AAE3F;;kCAEkC;AAClC,SAAS,SAAS,CAAC,MAAiC;IAClD,OAAO,MAAM;SACV,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC;SAC9B,MAAM,CAAC,CAAC,EAAE,EAAgB,EAAE,CAAC,OAAO,EAAE,KAAK,QAAQ,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;AACvE,CAAC;AAED;;yCAEyC;AACzC,SAAS,aAAa,CACpB,OAA4C,EAC5C,MAAiC;IAEjC,MAAM,GAAG,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;IAC9B,OAAO,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,EAAE,gBAAgB,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC;AAC1E,CAAC;AAED;;;;;oEAKoE;AACpE,SAAS,iBAAiB,CAAC,IAAa;IACtC,MAAM,MAAM,GACV,OAAO,IAAI,KAAK,QAAQ;QACtB,CAAC,CAAC,CAAC,GAAG,EAAE;YACJ,IAAI,CAAC;gBACH,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAY,CAAC;YACrC,CAAC;YAAC,MAAM,CAAC;gBACP,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC,CAAC,EAAE;QACN,CAAC,CAAC,IAAI,CAAC;IACX,IAAI,MAAM,KAAK,IAAI,IAAI,OAAO,MAAM,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IAC/D,MAAM,KAAK,GAAI,MAA8B,CAAC,KAAK,CAAC;IACpD,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IAC7D,MAAM,IAAI,GAAI,KAA4B,CAAC,IAAI,CAAC;IAChD,OAAO,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;AAChD,CAAC;AAED;;;;;iDAKiD;AACjD,SAAS,QAAQ,CAAC,IAA+B;IAC/C,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;AACvE,CAAC;AAED,MAAM,CAAC,MAAM,gBAAgB,GAA8B,WAAW,CAAC;IACrE,EAAE,EAAE,4BAA4B;IAChC,WAAW,EACT,sFAAsF;QACtF,6FAA6F;QAC7F,4FAA4F;QAC5F,wFAAwF;QACxF,8EAA8E;QAC9E,4FAA4F;QAC5F,uDAAuD;IACzD,QAAQ,EAAE,8CAA8C;IACxD,MAAM,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE;IAC5B,SAAS,EAAE,MAAM;IACjB,QAAQ,EAAE,GAAG,EAAE,CAAC,UAAU;IAC1B,2EAA2E;IAC3E,+EAA+E;IAC/E,4EAA4E;IAC5E,oCAAoC;IACpC,OAAO,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM;IAC9B,aAAa,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAChE,oBAAoB,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QAC/B,wEAAwE;QACxE,4EAA4E;QAC5E,6EAA6E;QAC7E,0CAA0C;QAC1C,OAAO,EAAE,SAAS,CAAC;YACjB,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,qCAAqC,IAAI,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;SAC/F,CAAC;QACF,OAAO,EAAE,SAAS,CAAC;YACjB,IAAI,CAAC;gBACH,MAAM,EAAE,MAAM;gBACd,IAAI,EAAE,4BAA4B;gBAClC,MAAM,EAAE,GAAG;gBACX,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;gBACpE,QAAQ,EAAE,aAAa;aACxB,CAAC;SACH,CAAC;KACH,CAAC;IACF,QAAQ,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE;QACrB,IAAI,IAAI,KAAK,IAAI;YAAE,OAAO,YAAY,CAAC;QACvC,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE;YACrC,IAAI,CAAC,KAAK,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,WAAW,EAAE,KAAK,MAAM;gBAAE,OAAO,KAAK,CAAC;YAChE,IAAI,CAAC,CAAC,KAAK,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,aAAa,CAAC;gBAAE,OAAO,KAAK,CAAC;YAC9D,uEAAuE;YACvE,0EAA0E;YAC1E,oEAAoE;YACpE,6BAA6B;YAC7B,MAAM,IAAI,GAAG,KAAK,CAAC,YAAY,CAAC;YAChC,MAAM,QAAQ,GAAG,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;YAC9E,OAAO,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACxC,CAAC,CAAC,CAAC;QACH,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO;gBACL,MAAM,EAAE,IAAI;gBACZ,MAAM,EAAE,sCAAsC,IAAI,CAAC,MAAM,MAAM,IAAI,CAAC,MAAM,qBAAqB;aAChG,CAAC;QACJ,CAAC;QACD,OAAO,aAAa,CAClB;YACE,MAAM,EAAE,KAAK;YACb,MAAM,EACJ,GAAG,QAAQ,CAAC,MAAM,iCAAiC,IAAI,CAAC,MAAM,IAAI;gBAClE,eAAe,QAAQ,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO;gBAC7E,qEAAqE;SACxE,EACD,QAAQ,CACT,CAAC;IACJ,CAAC;CACF,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,wBAAwB,GAAkC,WAAW,CAAC;IACjF,EAAE,EAAE,oCAAoC;IACxC,WAAW,EACT,yFAAyF;QACzF,0FAA0F;QAC1F,wFAAwF;QACxF,yFAAyF;QACzF,4FAA4F;QAC5F,yFAAyF;QACzF,gCAAgC;IAClC,QAAQ,EAAE,2DAA2D;IACrE,MAAM,EAAE,EAAE,UAAU,EAAE,eAAe,EAAE;IACvC,SAAS,EAAE,MAAM;IACjB,QAAQ,EAAE,GAAG,EAAE,CAAC,UAAU;IAC1B,6EAA6E;IAC7E,0DAA0D;IAC1D,aAAa,EAAE,GAAG,EAAE,CAAC,IAAI;IACzB,oBAAoB,EAAE,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE;QACvC,MAAM,KAAK,GAAG,UAAU,KAAK,YAAY,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,YAAY,CAAC;QACvE,OAAO;YACL,OAAO,EAAE,SAAS,CAAC;gBACjB,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,oCAAoC,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;gBACjF,IAAI,CAAC;oBACH,MAAM,EAAE,MAAM;oBACd,IAAI,EAAE,oCAAoC;oBAC1C,MAAM,EAAE,GAAG;oBACX,aAAa,EAAE,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,mBAAmB,EAAE,EAAE;oBACzE,QAAQ,EAAE,cAAc;iBACzB,CAAC;aACH,CAAC;YACF,yEAAyE;YACzE,sEAAsE;YACtE,oDAAoD;YACpD,OAAO,EAAE,SAAS,CAAC;gBACjB,IAAI,CAAC;oBACH,MAAM,EAAE,MAAM;oBACd,IAAI,EAAE,oCAAoC;oBAC1C,MAAM,EAAE,GAAG;oBACX,aAAa,EAAE,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,mBAAmB,EAAE,EAAE;iBACrE,CAAC;aACH,CAAC;SACH,CAAC;IACJ,CAAC;IACD,QAAQ,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE,IAAI,EAAE;QAC/B,IAAI,IAAI,KAAK,IAAI;YAAE,OAAO,YAAY,CAAC;QACvC,MAAM,KAAK,GAAG,IAAI;aACf,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,iBAAiB,CAAC,KAAK,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;aACzE,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;QACtC,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,KAAK,UAAU,CAAC,CAAC;QAC5D,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACtB,OAAO;gBACL,MAAM,EAAE,KAAK;gBACb,MAAM,EACJ,gDAAgD,UAAU,UAAU;oBACpE,IAAI,IAAI,CAAC,MAAM,wCAAwC;oBACvD,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI;aAClD,CAAC;QACJ,CAAC;QACD,OAAO,aAAa,CAClB;YACE,MAAM,EAAE,IAAI;YACZ,MAAM,EACJ,GAAG,IAAI,CAAC,MAAM,yCAAyC,UAAU,UAAU;gBAC3E,IAAI,IAAI,CAAC,MAAM,qBAAqB;SACvC,EACD,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,CAC7B,CAAC;IACJ,CAAC;CACF,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,0BAA0B,GAAiC,WAAW,CAAC;IAClF,EAAE,EAAE,sCAAsC;IAC1C,WAAW,EACT,2FAA2F;QAC3F,yFAAyF;QACzF,4FAA4F;QAC5F,6FAA6F;QAC7F,6FAA6F;QAC7F,qEAAqE;IACvE,0EAA0E;IAC1E,8EAA8E;IAC9E,4EAA4E;IAC5E,yEAAyE;IACzE,8BAA8B;IAC9B,QAAQ,EAAE,qDAAqD;IAC/D,MAAM,EAAE,EAAE;IACV,SAAS,EAAE,MAAM;IACjB,2EAA2E;IAC3E,2BAA2B;IAC3B,QAAQ,EAAE,GAAG,EAAE,CAAC,UAAU;IAC1B,+EAA+E;IAC/E,+EAA+E;IAC/E,gCAAgC;IAChC,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI;IACnB,aAAa,EAAE,GAAG,EAAE,CAAC,IAAI;IACzB,oBAAoB,EAAE,GAAG,EAAE,CAAC,CAAC;QAC3B,OAAO,EAAE,SAAS,CAAC,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,eAAe,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;QACnG,0EAA0E;QAC1E,uEAAuE;QACvE,OAAO,EAAE,SAAS,CAAC,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;KACzE,CAAC;IACF,QAAQ,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE;QACtB,IAAI,IAAI,KAAK,IAAI;YAAE,OAAO,YAAY,CAAC;QACvC,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;QAC5B,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACtB,OAAO;gBACL,MAAM,EAAE,KAAK;gBACb,MAAM,EAAE,2DAA2D,IAAI,CAAC,MAAM,qBAAqB;aACpG,CAAC;QACJ,CAAC;QACD,MAAM,KAAK,GAAG,IAAI,CAAC,CAAC,CAAE,CAAC;QACvB,MAAM,UAAU,GAAG,KAAK,CAAC,MAAM,KAAK,GAAG,CAAC;QACxC,OAAO,aAAa,CAClB;YACE,MAAM,EAAE,UAAU;YAClB,MAAM,EAAE,UAAU;gBAChB,CAAC,CAAC,gBAAgB,IAAI,CAAC,MAAM,gDAAgD;gBAC7E,CAAC,CAAC,gBAAgB,IAAI,CAAC,MAAM,6BAA6B,KAAK,CAAC,MAAM,IAAI,GAAG,WAAW;SAC3F,EACD,CAAC,KAAK,CAAC,CACR,CAAC;IACJ,CAAC;CACF,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,wBAAwB,GAAiC,WAAW,CAAC;IAChF,EAAE,EAAE,oCAAoC;IACxC,WAAW,EACT,yFAAyF;QACzF,2FAA2F;QAC3F,8FAA8F;QAC9F,qFAAqF;QACrF,uFAAuF;QACvF,mEAAmE;IACrE,QAAQ,EAAE,8CAA8C;IACxD,MAAM,EAAE,EAAE;IACV,SAAS,EAAE,MAAM;IACjB,QAAQ,EAAE,GAAG,EAAE,CAAC,UAAU;IAC1B,4EAA4E;IAC5E,yEAAyE;IACzE,+EAA+E;IAC/E,4EAA4E;IAC5E,0DAA0D;IAC1D,+EAA+E;IAC/E,qEAAqE;IACrE,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI;IACnB,aAAa,EAAE,GAAG,EAAE,CAAC,IAAI;IACzB,oBAAoB,EAAE,GAAG,EAAE,CAAC,CAAC;QAC3B,OAAO,EAAE,SAAS,CAAC;YACjB,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;YACxB,OAAO,CAAC;gBACN,MAAM,EAAE,GAAG;gBACX,eAAe,EAAE,EAAE,WAAW,EAAE,0BAA0B,EAAE;gBAC5D,QAAQ,EAAE,UAAU;aACrB,CAAC;SACH,CAAC;QACF,0EAA0E;QAC1E,6CAA6C;QAC7C,OAAO,EAAE,SAAS,CAAC;YACjB,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;YACxB,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,EAAE,EAAE,WAAW,EAAE,0BAA0B,EAAE,EAAE,CAAC;SACvF,CAAC;KACH,CAAC;IACF,QAAQ,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE;QACtB,IAAI,IAAI,KAAK,IAAI;YAAE,OAAO,YAAY,CAAC;QAEvC,0EAA0E;QAC1E,6EAA6E;QAC7E,4EAA4E;QAC5E,0EAA0E;QAC1E,mBAAmB;QACnB,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,eAAe,KAAK,SAAS,CAAC,EAAE,CAAC;YAClF,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,sBAAsB,EAAE,CAAC;QAC9E,CAAC;QAED,MAAM,cAAc,GAAG,CAAC,KAAqB,EAAW,EAAE,CACxD,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,eAAe,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,WAAW,EAAE,KAAK,WAAW,CAAC,CAAC;QAE5F,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,cAAc,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,KAAK,GAAG,CAAC,CAAC;QACvF,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC1B,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;YAC9C,yEAAyE;YACzE,8DAA8D;YAC9D,MAAM,MAAM,GACV,SAAS,CAAC,MAAM,KAAK,CAAC;gBACpB,CAAC,CAAC,iDAAiD;gBACnD,CAAC,CAAC,GAAG,SAAS,CAAC,MAAM,sDAAsD;oBACzE,eAAe,SAAS,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;YAClF,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,KAAK,IAAI,CAAC,MAAM,qBAAqB,EAAE,CAAC;QACnF,CAAC;QAED,OAAO,aAAa,CAClB;YACE,MAAM,EAAE,IAAI;YACZ,MAAM,EACJ,GAAG,QAAQ,CAAC,MAAM,iDAAiD;gBACnE,IAAI,IAAI,CAAC,MAAM,qBAAqB;SACvC,EACD,QAAQ,CACT,CAAC;IACJ,CAAC;CACF,CAAC,CAAC"}

package/node_modules/@pome-sh/twin-stripe/dist/src/check-worlds.d.ts

@@ -0,0 +1,24 @@
+import type { CheckSubstrate, CheckTapeEvent } from "@pome-sh/sdk/checks";
+import type { StripeCheckState, StripeCheckStateBalanceTransaction, StripeCheckStateCharge, StripeCheckStateEvent, StripeCheckStatePaymentIntent, StripeCheckStateRefund } from "./check-state.js";
+/** Every collection present and empty. Never `{}` — see the header. */
+export declare function stripeState(overrides?: StripeCheckState): StripeCheckState;
+/** A `final`-only world. `seed`/`tape` are null because the engine gives a
+ *  `final` check neither, and a fixture richer than the runtime is a fixture
+ *  that tests a world the check will never see. */
+export declare function finalWorld(final: StripeCheckState): CheckSubstrate<StripeCheckState>;
+/** A `tape` world. `final` is a fully-present but empty account rather than
+ *  `{}`: a tape check must not read state, and handing it a shape that would
+ *  satisfy a state check hides the difference. */
+export declare function tapeWorld(tape: readonly CheckTapeEvent[]): CheckSubstrate<StripeCheckState>;
+export declare function paymentIntent(overrides?: Partial<StripeCheckStatePaymentIntent>): StripeCheckStatePaymentIntent;
+export declare function charge(overrides?: Partial<StripeCheckStateCharge>): StripeCheckStateCharge;
+export declare function balanceTransaction(overrides?: Partial<StripeCheckStateBalanceTransaction>): StripeCheckStateBalanceTransaction;
+export declare function event(type: string, overrides?: Partial<StripeCheckStateEvent>): StripeCheckStateEvent;
+export declare function refund(overrides?: Partial<StripeCheckStateRefund>): StripeCheckStateRefund;
+/** One recorded REST call. */
+export declare function call(overrides?: Partial<CheckTapeEvent>): CheckTapeEvent;
+/** One recorded x402 leg. `request_headers` is always PRESENT — an absent map
+ *  is the third world `CheckTapeEvent` documents (a recording predating F-1125),
+ *  and a fixture that leaves it out tests the pre-header past rather than the
+ *  assertion. */
+export declare function x402Leg(overrides?: Partial<CheckTapeEvent>): CheckTapeEvent;