@agent-cards/checkout 0.17.0 → 0.18.0

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## Unreleased
 
+- Pay a Stripe Checkout Elements page with a vaulted card. A page built with `stripe.initCheckout` (Checkout Elements) sends the card inline in the Checkout Session confirm, `/v1/payment_pages/{cs_...}/confirm`, which the SDK never recognized, so the placeholder card reached Stripe and the purchase failed. The confirm now pauses for the cardholder's approval like a PaymentIntent confirm, and the phone sends the real card. The API refuses it unless the amount you pass equals the total the Session will charge (`expected_amount`). Hosted and embedded Checkout confirm the same endpoint with the payment method they created first; that confirm carries no card and continues untouched, as before, even after the approval. `syncRegistry()` asks for `features=checkout_sessions`: the API serves the Checkout Session endpoint only to an SDK that lets such a request through ahead of its holds.
+
+- Let a page pay with the Stripe card token the cardholder just approved. A page that tokenizes first (`stripe.createPaymentMethod`, `createToken`, `createSource`, `createConfirmationToken`) and then confirms the payment in the browser with what came back (`confirmCardPayment` with `payment_method: 'pm_...'`, `confirmPayment` with the confirmation token) used to fail: the SDK held that card-free confirmation, because the token alone could pay any amount. The SDK now asks the API (`VaultClient.checkStripeContinuation`), which reads the payment from Stripe and allows it only for the approved amount and currency, on the same Stripe account, paid with exactly the approved token. Allowed, the page's own request continues untouched, the SDK emits `stripe_payment_continued`, and the controller reads `awaiting_merchant` with reason `stripe_payment_continued`. One confirmation continues per approval; later ones stay held, and a refused one is `blocked` with the API's code (at most three checks per approval). The matching API release is required; an older API refuses, which leaves the hold as it was.
+
+- Pause Stripe confirmation tokens and card sources. A page that calls `stripe.createConfirmationToken` (collect the card, confirm on your own server) or the older `stripe.createSource` sends the card to `/v1/confirmation_tokens` or `/v1/sources`; the SDK never recognized either, so the placeholder card reached Stripe and the purchase failed. Both now pause for the cardholder's approval, and the page receives a real confirmation token or card source. A confirmation token for a saved method, or a bank source, carries no card and continues untouched. The matching API serves these endpoints only to an SDK that asks for `features=card_fields`, which this release does. They are not eligible for auto-approval yet.
+
+- Refuse a Stripe confirmation that carries no card at once. A page that pays with a method it created itself confirms with `payment_method=pm_...`; the SDK used to pause that request and ask the cardholder to approve something their card could not complete. The SDK now reads the body after its holds: a Stripe request without `card[number]` or `payment_method_data[card][number]` is refused at once with a `blocked` event (`request_without_card`) and never reaches the API. A confirmation that follows an approved card token keeps its existing hold. `VaultClient.withoutCard(url, body)` exposes the judgement, and `syncRegistry()` asks for `features=card_fields` (an older API ignores it). The matching API refuses a Stripe request with no card as `400 card_fields_missing`.
+
 - Approve a Paysafe Checkout 1.8.0 fresh-card checkout before Pay with `prepare({ psp: 'paysafe', environment: 'production' | 'sandbox' })`. Phone approval finishes before the hosted checkout starts its card request. One matching request consumes the approval; saved cards and other Paysafe APIs do not use preparation. Matching API, Vault and database releases are required. A token does not confirm merchant payment.
 
 - Keep the cardholder's approval when the merchant page gives up on its own card request. A page whose script times out its tokenization while the person is still deciding (Braintree after 60 seconds, Square after about 10) no longer cancels the approval: the SDK reports `merchant_request_lost`, answers the page's next request for the same purchase from the same authorization, and reads `ready_to_submit` with reason `awaiting_merchant_retry` when the approval lands before the page asks again, so one more Pay click completes the purchase with no second prompt. The wait for that request is bounded by `merchantRetryWaitMs` (two minutes by default, never past the approval window); an approval the page never asks for again is retired through the API as `merchant_never_retried` and the controller reads `declined` with that reason. Applies to `token` and `cse` checkouts; hosted forms, prepared checkouts and native Stripe Checkout keep cancelling. `VaultClient.cancelAuthorization` takes the reason and `checkoutModeOf` reads a request's mode. The matching API and Vault releases are required for the new reason; an older API answers its retirement as unknown, which the SDK holds.

package/README.md

@@ -458,14 +458,22 @@ the original request's claim. Do not cancel that checkout in response to the dup
 authorization before another attempt. Neither disposition proves a payment outcome.
 
 With `requireMerchantResult`, subsequent card requests stay blocked after
-handoff. Stripe `/v1/payment_methods` and `/v1/tokens` handoffs always hold further
-recognized card requests, even when that option is false. A tokenization approval has no
-authoritative binding to a specific PaymentIntent, amount or currency. The first
-observed confirm cannot supply that binding. The SDK therefore blocks every
-follow-up confirm on that attachment, including the same token, an unrelated
-intent, changed amounts and retries. It reports `awaiting_merchant` with reason
+handoff. Stripe tokenization handoffs (`/v1/payment_methods`, `/v1/tokens`,
+`/v1/sources`, `/v1/confirmation_tokens`) always hold further recognized card
+requests, even when that option is false. A tokenization approval has no
+authoritative binding to a specific PaymentIntent, amount or currency, and the
+page cannot supply one. The SDK reports `awaiting_merchant` with reason
 `stripe_tokenization_unbound`, while ordinary browser traffic stays available.
-There is no automatic token-to-intent continuation or merchant-continuation hook.
+
+One follow-up can continue: the page's own card-free PaymentIntent confirm that
+pays with the approved token (`confirmCardPayment` with `payment_method: 'pm_...'`,
+`confirmPayment` with the confirmation token). The SDK asks the API, which reads
+the payment from Stripe and allows it only for the approved amount and
+currency, on the same Stripe account, paid with exactly the approved token.
+Allowed, the request continues untouched, the SDK emits `stripe_payment_continued`
+and the reason becomes `stripe_payment_continued`. One confirm continues per
+approval; every other follow-up, including an unrelated intent, a changed
+amount and a retry, stays blocked.
 Unrecognized merchant-server endpoints remain outside this guard unless listed
 in `paymentEndpoints`; this is not a guarantee against a merchant charging a
 saved token on its own server.

package/dist/builtin-registry.generated.js

@@ -1 +1 @@
-export const BUILTIN_REGISTRY = [{ "psp": "spreedly", "match": /core\.spreedly\.com\/v1\/payment_methods\/restricted\.json/i, "hosts": ["^core\\.spreedly\\.com$"], "encoding": "json", "passthroughHeaders": [/^spreedly-environment-key$/i] }, { "psp": "shopify", "match": /(checkout\.pci\.shopifyinc\.com|deposit\.[a-z0-9-]+\.shopifycs\.com)\/sessions/i, "hosts": ["^checkout\\.pci\\.shopifyinc\\.com$", "^deposit\\.[a-z0-9-]+\\.shopifycs\\.com$"], "encoding": "json", "passthroughHeaders": [/^shopify-identification-signature$/i] }, { "psp": "stripe", "match": /api\.stripe\.com\/v1\/(payment_methods|tokens|setup_intents\/seti_\w+\/confirm|payment_intents\/pi_\w+\/confirm)/i, "hosts": ["^api\\.stripe\\.com$"], "encoding": "form", "passthroughHeaders": [/^authorization$/i, /^stripe-version$/i, /^x-stripe-client-user-agent$/i] }, { "psp": "braintree", "match": /payments(\.sandbox)?\.braintree-api\.com\/graphql/i, "hosts": ["^payments\\.braintree-api\\.com$", "^payments\\.sandbox\\.braintree-api\\.com$"], "encoding": "json", "passthroughHeaders": [/^authorization$/i, /^braintree-version$/i] }, { "psp": "checkout_com", "match": /(api|card-acquisition-gateway)(\.sandbox)?\.checkout\.com\/tokens/i, "hosts": ["^api\\.checkout\\.com$", "^api\\.sandbox\\.checkout\\.com$", "^card-acquisition-gateway\\.checkout\\.com$", "^card-acquisition-gateway\\.sandbox\\.checkout\\.com$"], "encoding": "json", "passthroughHeaders": [/^authorization$/i] }, { "psp": "adyen", "match": /(checkoutshopper-(test|live(-[a-z]+)?)\.adyen\.com|([a-z0-9-]+\.)*adyenpayments\.com)\/checkoutshopper\/v1\/sessions\/[A-Za-z0-9_-]+\/payments/i, "hosts": ["^checkoutshopper-(test|live(-[a-z]+)?)\\.adyen\\.com$", "^([a-z0-9-]+\\.)*adyenpayments\\.com$"], "encoding": "json", "passthroughHeaders": [], "clientSideEncrypted": true, "mode": "cse" }, { "psp": "tranzila", "match": /(direct\.tranzila\.com\/process\/n\/|directng\.tranzila\.com\/process\/?)/i, "hosts": ["^direct\\.tranzila\\.com$", "^directng\\.tranzila\\.com$"], "encoding": "form", "passthroughHeaders": [], "mode": "hosted_form" }, { "psp": "square", "match": /pci-connect\.squareup(?:sandbox)?\.com\/v2\/card-nonce/i, "hosts": ["^pci-connect\\.squareup\\.com$", "^pci-connect\\.squareupsandbox\\.com$"], "encoding": "json", "passthroughHeaders": [] }, { "psp": "authorize_net", "match": /(api2|apitest)\.authorize\.net\/xml\/v1\/request\.api/i, "hosts": ["^api2\\.authorize\\.net$", "^apitest\\.authorize\\.net$"], "encoding": "json", "passthroughHeaders": [] }, { "psp": "worldpay", "match": /(try\.)?access\.worldpay\.com\/(sessions\/card|verifiedTokens\/sessions)/i, "hosts": ["^access\\.worldpay\\.com$", "^try\\.access\\.worldpay\\.com$"], "encoding": "json", "passthroughHeaders": [/^accept$/i] }, { "psp": "nuvei", "match": /(secure|ppp-test)\.safecharge\.com\/ppp\/api\/v1\/(?:cardTokenization|clientPayment|websdk\/initPaymentWithCardTokenization)\.do/i, "hosts": ["^secure\\.safecharge\\.com$", "^ppp-test\\.safecharge\\.com$"], "encoding": "json", "passthroughHeaders": [] }, { "psp": "airwallex", "match": /(checkout(\.sandbox)?\.airwallex\.com|pci-api(\.sandbox)?\.airwallex\.com)\/api\/v1\/pa\/(payment_intents\/[^/?#]+\/confirm|payment_consents\/[^/?#]+\/verify|payment_methods\/create)(\?|$)/i, "hosts": ["^checkout\\.airwallex\\.com$", "^checkout\\.sandbox\\.airwallex\\.com$", "^pci-api\\.airwallex\\.com$", "^pci-api\\.sandbox\\.airwallex\\.com$"], "encoding": "json", "passthroughHeaders": [/^client-secret$/i, /^authorization$/i, /^x-auth-token$/i, /^x-on-behalf-of$/i, /^x-api-version$/i] }, { "psp": "rapyd", "match": /(api|sandboxapi)\.rapyd\.net\/v1\/(?:hosted\/collect\/card\/[^/?#]+\/payment_method|checkout\/checkout_[A-Za-z0-9]+)(?:[?#]|$)/i, "hosts": ["^api\\.rapyd\\.net$", "^sandboxapi\\.rapyd\\.net$"], "encoding": "json", "passthroughHeaders": [] }, { "psp": "dlocal", "match": /ppmcc(-sandbox)?\.dlocal\.com\/cvault\/credit-card\/temporal/i, "hosts": ["^ppmcc\\.dlocal\\.com$", "^ppmcc-sandbox\\.dlocal\\.com$"], "encoding": "json", "passthroughHeaders": [/^x-fields-api-key$/i, /^x-uow$/i, /^x-dlocal-infrav2$/i] }, { "psp": "ebanx", "match": /(?:(?:customer-frontier|customer|api-local-latam|api|sandbox-local-latam|sandbox)\.ebanx\.com|(?:api-diamond|api|sandbox)\.ebanxpay\.com)\/ws\/token/i, "hosts": ["^customer\\.ebanx\\.com$", "^customer-frontier\\.ebanx\\.com$", "^api\\.ebanx\\.com$", "^sandbox\\.ebanx\\.com$", "^api-local-latam\\.ebanx\\.com$", "^sandbox-local-latam\\.ebanx\\.com$", "^api-diamond\\.ebanxpay\\.com$", "^api\\.ebanxpay\\.com$", "^sandbox\\.ebanxpay\\.com$"], "encoding": "json", "passthroughHeaders": [] }, { "psp": "mercado_pago", "match": /api\.mercadopago\.com\/v1\/card_tokens(?![\w/-])/i, "hosts": ["^api\\.mercadopago\\.com$"], "encoding": "json", "passthroughHeaders": [/^x-product-id$/i] }, { "psp": "payu", "match": /(secure\.payu\.com|(merch-prod|secure)\.snd\.payu\.com)\/api\/front\/tokens/i, "hosts": ["^secure\\.payu\\.com$", "^(merch-prod|secure)\\.snd\\.payu\\.com$"], "encoding": "json", "passthroughHeaders": [/^authorization$/i] }, { "psp": "razorpay", "match": /api\.razorpay\.com\/v1\/(?:standard_checkout\/)?payments\/create\/(?:ajax|checkout|fees)/i, "hosts": ["^api\\.razorpay\\.com$"], "encoding": "form", "passthroughHeaders": [/^x-razorpay-sessionid$/i, /^x-customer-access-token$/i] }, { "psp": "mollie", "match": /api\.cc\.mollie\.com\/v1\/card-tokens/i, "hosts": ["^api\\.cc\\.mollie\\.com$"], "encoding": "json", "passthroughHeaders": [] }, { "psp": "paysafe", "match": /(?:api(\.test)?\.paysafe\.com\/(?:paymenthub\/v1\/singleusepaymenthandles|js\/api\/v1\/tokenize)|hosted(\.test)?\.paysafe\.com\/checkout\/api\/v1\/tokenize)(?![\w/-])/i, "hosts": ["^api\\.paysafe\\.com$", "^api\\.test\\.paysafe\\.com$", "^hosted\\.paysafe\\.com$", "^hosted\\.test\\.paysafe\\.com$"], "encoding": "json", "passthroughHeaders": [/^authorization$/i, /^x-paysafe-credentials$/i, /^correlationid$/i] }, { "psp": "recurly", "match": /api(\.eu)?\.recurly\.com\/js\/v1\/token(?![\w-])/i, "hosts": ["^api\\.recurly\\.com$", "^api\\.eu\\.recurly\\.com$"], "encoding": "form", "passthroughHeaders": [/^recurly-credential-checkout-hostname$/i] }, { "psp": "moneris", "match": /(www3|esqa|gateway|gatewayqa|gatewayt|gatewaydev)\.moneris\.com\/HPPtoken\/request\.php/i, "hosts": ["^www3\\.moneris\\.com$", "^esqa\\.moneris\\.com$", "^gateway\\.moneris\\.com$", "^gatewayqa\\.moneris\\.com$", "^gatewayt\\.moneris\\.com$", "^gatewaydev\\.moneris\\.com$"], "encoding": "form", "passthroughHeaders": [] }, { "psp": "bambora", "match": /(api\.na\.bambora\.com|api\.bam\.shift4api\.net)\/scripts\/tokenization\/tokens/i, "hosts": ["^api\\.na\\.bambora\\.com$", "^api\\.bam\\.shift4api\\.net$"], "encoding": "json", "passthroughHeaders": [] }, { "psp": "global_payments", "match": /(?:api\.heartlandportico\.com\/SecureSubmit\.v1\/api\/token|cert\.api2\.heartlandportico\.com\/Hps\.Exchange\.PosGateway\.Hpf\.v1\/api\/token|apis(?:\.sandbox)?(?:\.eu)?\.globalpay\.com\/ucp\/(?:merchants\/[^/]+\/)?payment-methods)/i, "hosts": ["^api\\.heartlandportico\\.com$", "^cert\\.api2\\.heartlandportico\\.com$", "^apis\\.globalpay\\.com$", "^apis\\.sandbox\\.globalpay\\.com$", "^apis\\.eu\\.globalpay\\.com$", "^apis\\.sandbox\\.eu\\.globalpay\\.com$"], "encoding": "json", "passthroughHeaders": [/^authorization$/i, /^x-gp-version$/i] }];
+export const BUILTIN_REGISTRY = [{ "psp": "spreedly", "match": /core\.spreedly\.com\/v1\/payment_methods\/restricted\.json/i, "hosts": ["^core\\.spreedly\\.com$"], "encoding": "json", "passthroughHeaders": [/^spreedly-environment-key$/i] }, { "psp": "shopify", "match": /(checkout\.pci\.shopifyinc\.com|deposit\.[a-z0-9-]+\.shopifycs\.com)\/sessions/i, "hosts": ["^checkout\\.pci\\.shopifyinc\\.com$", "^deposit\\.[a-z0-9-]+\\.shopifycs\\.com$"], "encoding": "json", "passthroughHeaders": [/^shopify-identification-signature$/i] }, { "psp": "stripe", "match": /api\.stripe\.com\/v1\/(payment_methods|tokens|sources|confirmation_tokens|setup_intents\/seti_\w+\/confirm|payment_intents\/pi_\w+\/confirm|payment_pages\/cs_(?:test|live)_\w+\/confirm)/i, "hosts": ["^api\\.stripe\\.com$"], "encoding": "form", "passthroughHeaders": [/^authorization$/i, /^stripe-version$/i, /^x-stripe-client-user-agent$/i], "cardFields": ["card[number]", "payment_method_data[card][number]"], "passWithoutCard": "api\\.stripe\\.com/v1/(sources|confirmation_tokens|payment_pages/cs_(?:test|live)_\\w+/confirm)" }, { "psp": "braintree", "match": /payments(\.sandbox)?\.braintree-api\.com\/graphql/i, "hosts": ["^payments\\.braintree-api\\.com$", "^payments\\.sandbox\\.braintree-api\\.com$"], "encoding": "json", "passthroughHeaders": [/^authorization$/i, /^braintree-version$/i] }, { "psp": "checkout_com", "match": /(api|card-acquisition-gateway)(\.sandbox)?\.checkout\.com\/tokens/i, "hosts": ["^api\\.checkout\\.com$", "^api\\.sandbox\\.checkout\\.com$", "^card-acquisition-gateway\\.checkout\\.com$", "^card-acquisition-gateway\\.sandbox\\.checkout\\.com$"], "encoding": "json", "passthroughHeaders": [/^authorization$/i] }, { "psp": "adyen", "match": /(checkoutshopper-(test|live(-[a-z]+)?)\.adyen\.com|([a-z0-9-]+\.)*adyenpayments\.com)\/checkoutshopper\/v1\/sessions\/[A-Za-z0-9_-]+\/payments/i, "hosts": ["^checkoutshopper-(test|live(-[a-z]+)?)\\.adyen\\.com$", "^([a-z0-9-]+\\.)*adyenpayments\\.com$"], "encoding": "json", "passthroughHeaders": [], "clientSideEncrypted": true, "mode": "cse" }, { "psp": "tranzila", "match": /(direct\.tranzila\.com\/process\/n\/|directng\.tranzila\.com\/process\/?)/i, "hosts": ["^direct\\.tranzila\\.com$", "^directng\\.tranzila\\.com$"], "encoding": "form", "passthroughHeaders": [], "mode": "hosted_form" }, { "psp": "square", "match": /pci-connect\.squareup(?:sandbox)?\.com\/v2\/card-nonce/i, "hosts": ["^pci-connect\\.squareup\\.com$", "^pci-connect\\.squareupsandbox\\.com$"], "encoding": "json", "passthroughHeaders": [] }, { "psp": "authorize_net", "match": /(api2|apitest)\.authorize\.net\/xml\/v1\/request\.api/i, "hosts": ["^api2\\.authorize\\.net$", "^apitest\\.authorize\\.net$"], "encoding": "json", "passthroughHeaders": [] }, { "psp": "worldpay", "match": /(try\.)?access\.worldpay\.com\/(sessions\/card|verifiedTokens\/sessions)/i, "hosts": ["^access\\.worldpay\\.com$", "^try\\.access\\.worldpay\\.com$"], "encoding": "json", "passthroughHeaders": [/^accept$/i] }, { "psp": "nuvei", "match": /(secure|ppp-test)\.safecharge\.com\/ppp\/api\/v1\/(?:cardTokenization|clientPayment|websdk\/initPaymentWithCardTokenization)\.do/i, "hosts": ["^secure\\.safecharge\\.com$", "^ppp-test\\.safecharge\\.com$"], "encoding": "json", "passthroughHeaders": [] }, { "psp": "airwallex", "match": /(checkout(\.sandbox)?\.airwallex\.com|pci-api(\.sandbox)?\.airwallex\.com)\/api\/v1\/pa\/(payment_intents\/[^/?#]+\/confirm|payment_consents\/[^/?#]+\/verify|payment_methods\/create)(\?|$)/i, "hosts": ["^checkout\\.airwallex\\.com$", "^checkout\\.sandbox\\.airwallex\\.com$", "^pci-api\\.airwallex\\.com$", "^pci-api\\.sandbox\\.airwallex\\.com$"], "encoding": "json", "passthroughHeaders": [/^client-secret$/i, /^authorization$/i, /^x-auth-token$/i, /^x-on-behalf-of$/i, /^x-api-version$/i] }, { "psp": "rapyd", "match": /(api|sandboxapi)\.rapyd\.net\/v1\/(?:hosted\/collect\/card\/[^/?#]+\/payment_method|checkout\/checkout_[A-Za-z0-9]+)(?:[?#]|$)/i, "hosts": ["^api\\.rapyd\\.net$", "^sandboxapi\\.rapyd\\.net$"], "encoding": "json", "passthroughHeaders": [] }, { "psp": "dlocal", "match": /ppmcc(-sandbox)?\.dlocal\.com\/cvault\/credit-card\/temporal/i, "hosts": ["^ppmcc\\.dlocal\\.com$", "^ppmcc-sandbox\\.dlocal\\.com$"], "encoding": "json", "passthroughHeaders": [/^x-fields-api-key$/i, /^x-uow$/i, /^x-dlocal-infrav2$/i] }, { "psp": "ebanx", "match": /(?:(?:customer-frontier|customer|api-local-latam|api|sandbox-local-latam|sandbox)\.ebanx\.com|(?:api-diamond|api|sandbox)\.ebanxpay\.com)\/ws\/token/i, "hosts": ["^customer\\.ebanx\\.com$", "^customer-frontier\\.ebanx\\.com$", "^api\\.ebanx\\.com$", "^sandbox\\.ebanx\\.com$", "^api-local-latam\\.ebanx\\.com$", "^sandbox-local-latam\\.ebanx\\.com$", "^api-diamond\\.ebanxpay\\.com$", "^api\\.ebanxpay\\.com$", "^sandbox\\.ebanxpay\\.com$"], "encoding": "json", "passthroughHeaders": [] }, { "psp": "mercado_pago", "match": /api\.mercadopago\.com\/v1\/card_tokens(?![\w/-])/i, "hosts": ["^api\\.mercadopago\\.com$"], "encoding": "json", "passthroughHeaders": [/^x-product-id$/i] }, { "psp": "payu", "match": /(secure\.payu\.com|(merch-prod|secure)\.snd\.payu\.com)\/api\/front\/tokens/i, "hosts": ["^secure\\.payu\\.com$", "^(merch-prod|secure)\\.snd\\.payu\\.com$"], "encoding": "json", "passthroughHeaders": [/^authorization$/i] }, { "psp": "razorpay", "match": /api\.razorpay\.com\/v1\/(?:standard_checkout\/)?payments\/create\/(?:ajax|checkout|fees)/i, "hosts": ["^api\\.razorpay\\.com$"], "encoding": "form", "passthroughHeaders": [/^x-razorpay-sessionid$/i, /^x-customer-access-token$/i] }, { "psp": "mollie", "match": /api\.cc\.mollie\.com\/v1\/card-tokens/i, "hosts": ["^api\\.cc\\.mollie\\.com$"], "encoding": "json", "passthroughHeaders": [] }, { "psp": "paysafe", "match": /(?:api(\.test)?\.paysafe\.com\/(?:paymenthub\/v1\/singleusepaymenthandles|js\/api\/v1\/tokenize)|hosted(\.test)?\.paysafe\.com\/checkout\/api\/v1\/tokenize)(?![\w/-])/i, "hosts": ["^api\\.paysafe\\.com$", "^api\\.test\\.paysafe\\.com$", "^hosted\\.paysafe\\.com$", "^hosted\\.test\\.paysafe\\.com$"], "encoding": "json", "passthroughHeaders": [/^authorization$/i, /^x-paysafe-credentials$/i, /^correlationid$/i] }, { "psp": "recurly", "match": /api(\.eu)?\.recurly\.com\/js\/v1\/token(?![\w-])/i, "hosts": ["^api\\.recurly\\.com$", "^api\\.eu\\.recurly\\.com$"], "encoding": "form", "passthroughHeaders": [/^recurly-credential-checkout-hostname$/i] }, { "psp": "moneris", "match": /(www3|esqa|gateway|gatewayqa|gatewayt|gatewaydev)\.moneris\.com\/HPPtoken\/request\.php/i, "hosts": ["^www3\\.moneris\\.com$", "^esqa\\.moneris\\.com$", "^gateway\\.moneris\\.com$", "^gatewayqa\\.moneris\\.com$", "^gatewayt\\.moneris\\.com$", "^gatewaydev\\.moneris\\.com$"], "encoding": "form", "passthroughHeaders": [] }, { "psp": "bambora", "match": /(api\.na\.bambora\.com|api\.bam\.shift4api\.net)\/scripts\/tokenization\/tokens/i, "hosts": ["^api\\.na\\.bambora\\.com$", "^api\\.bam\\.shift4api\\.net$"], "encoding": "json", "passthroughHeaders": [] }, { "psp": "global_payments", "match": /(?:api\.heartlandportico\.com\/SecureSubmit\.v1\/api\/token|cert\.api2\.heartlandportico\.com\/Hps\.Exchange\.PosGateway\.Hpf\.v1\/api\/token|apis(?:\.sandbox)?(?:\.eu)?\.globalpay\.com\/ucp\/(?:merchants\/[^/]+\/)?payment-methods)/i, "hosts": ["^api\\.heartlandportico\\.com$", "^cert\\.api2\\.heartlandportico\\.com$", "^apis\\.globalpay\\.com$", "^apis\\.sandbox\\.globalpay\\.com$", "^apis\\.eu\\.globalpay\\.com$", "^apis\\.sandbox\\.eu\\.globalpay\\.com$"], "encoding": "json", "passthroughHeaders": [/^authorization$/i, /^x-gp-version$/i] }];

package/dist/card-fields.generated.d.ts

@@ -0,0 +1,3 @@
+declare function carriesCardFields(recognizer: any, body: any): boolean;
+declare function requestWithoutCard(recognizer: any, url: any, body: any): "continue" | "refuse" | null;
+export { carriesCardFields, requestWithoutCard };

package/dist/card-fields.generated.js

@@ -0,0 +1,46 @@
+// @ts-nocheck
+// Generated from @agent-cards/payment-core. Do not edit.
+// artifact-sha256: ac6967df3f29912d12c310418d06b6583529d5a4d5346c362ef0a7987fd4f2ab
+// src/card-fields.js
+function carriesCardFields(recognizer, body) {
+    const fields = recognizer && recognizer.cardFields;
+    if (!Array.isArray(fields) || fields.length === 0)
+        return true;
+    if (recognizer.encoding !== "form")
+        return true;
+    if (typeof body !== "string" || body === "")
+        return false;
+    for (const chunk of body.split("&")) {
+        const eq = chunk.indexOf("=");
+        if (eq <= 0 || eq === chunk.length - 1)
+            continue;
+        let key;
+        try {
+            key = decodeURIComponent(chunk.slice(0, eq).replace(/\+/g, " "));
+        }
+        catch {
+            continue;
+        }
+        if (fields.includes(key))
+            return true;
+    }
+    return false;
+}
+function requestWithoutCard(recognizer, url, body) {
+    if (carriesCardFields(recognizer, body))
+        return null;
+    const pass = recognizer && recognizer.passWithoutCard;
+    if (typeof pass === "string" && pass !== "") {
+        let parsed;
+        try {
+            parsed = new URL(url);
+        }
+        catch {
+            return "refuse";
+        }
+        if (new RegExp(`^(?:${pass})$`, "i").test(`${parsed.hostname.toLowerCase()}${parsed.pathname}`))
+            return "continue";
+    }
+    return "refuse";
+}
+export { carriesCardFields, requestWithoutCard };

package/dist/cdp.d.ts

@@ -109,6 +109,8 @@ export interface AttachOptions extends LifecycleOptions, ExecutionMetadata {
     vault: VaultClient;
     user: string;
     merchant: string;
+    /** Return the caller's `Date.now()` at the pay click; the SDK reads it when the card request pauses. */
+    payClickedAt?: () => number | null | undefined;
     /**
      * Your hint at the amount, an integer in the currency's smallest unit or a
      * decimal string in normal units, with its ISO 4217 code. See

package/dist/cdp.js

@@ -298,6 +298,17 @@ export function withCorsHeaders(headers, cors) {
 function headerEntries(headers) {
     return Object.entries(headers).map(([name, value]) => ({ name, value: String(value) }));
 }
+function readPayToInterceptMs(readClickedAt, approvalStartedAt) {
+    try {
+        const clickedAt = readClickedAt?.();
+        return typeof clickedAt === 'number' && Number.isFinite(clickedAt) && clickedAt <= approvalStartedAt
+            ? Math.round(approvalStartedAt - clickedAt)
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * The origin of the top-level document the payment form is on, read when a
  * card request pauses: the fact that names the merchant for the company's
@@ -406,6 +417,54 @@ function failureSummary(error) {
         return `${error.name}: ${error.code ?? `http_${error.status}`}`;
     return error instanceof Error ? error.name : 'CheckoutError';
 }
+const STRIPE_PAYMENT_INTENT_CONFIRM = /^\/v1\/payment_intents\/pi_[A-Za-z0-9]+\/confirm$/;
+/**
+ * A page that tokenized the card through an approval, then confirms the
+ * payment in the browser with the token it got back (confirmCardPayment with
+ * payment_method: 'pm_...', confirmPayment with a confirmation token). That
+ * confirmation carries no card, and the hold after a Stripe tokenization
+ * would refuse it. The API decides instead whether it is the payment the
+ * cardholder approved (the approved amount and currency, on the same Stripe
+ * account, paid with exactly the approved token).
+ *
+ * Synchronous on purpose: every paused request passes through here, and an
+ * await would reorder it against the attachment's own events. Returns the
+ * approval to check, with the lifecycle's one continuation claimed, or null
+ * when this is not such a confirmation and the ordinary rules apply.
+ */
+function claimStripeContinuation(opts, lifecycle, url, method, body) {
+    if (body == null || typeof opts.vault.checkStripeContinuation !== 'function' || !lifecycle.isBlocked()
+        || method.toUpperCase() !== 'POST')
+        return null;
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return null;
+    }
+    if (parsed.origin !== 'https://api.stripe.com' || !STRIPE_PAYMENT_INTENT_CONFIRM.test(parsed.pathname)
+        || opts.vault.withoutCard?.(url, body) !== 'refuse')
+        return null;
+    return lifecycle.claimStripeContinuation();
+}
+/** Ask the API about a claimed continuation and settle the claim. True: continue the page's request untouched. */
+async function checkStripeContinuation(opts, lifecycle, authorizationId, request) {
+    let paymentIntentId = null;
+    try {
+        paymentIntentId = (await opts.vault.checkStripeContinuation(authorizationId, request)).paymentIntentId;
+    }
+    catch (error) {
+        opts.onEvent?.({ type: 'blocked', detail: failureSummary(error) });
+    }
+    // The checkout may have been cancelled or reconciled while the API answered.
+    const proceed = lifecycle.stripeContinuationChecked(paymentIntentId !== null);
+    if (proceed)
+        opts.onEvent?.({ type: 'stripe_payment_continued', detail: { authorizationId, paymentIntentId } });
+    else if (paymentIntentId !== null)
+        opts.onEvent?.({ type: 'blocked', detail: 'stripe_continuation_superseded' });
+    return proceed;
+}
 /**
  * How long an approval waits, after the cardholder gives it, for the page to
  * issue the request it will answer.
@@ -1346,14 +1405,62 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 return;
             }
         }
+        // A request the catalog marks as routine without a card (a confirmation
+        // token for a saved method, a bank source, a Checkout Session confirm with
+        // the method hosted Checkout created) was never ours: it continues in
+        // every state, like a request the catalog does not recognize. One without
+        // a card anywhere else is judged after the holds below.
+        const continuationBody = pausedBody(request);
+        const withoutCard = stripeStep ? null : opts.vault.withoutCard?.(request.url, continuationBody) ?? null;
+        if (withoutCard === 'continue') {
+            if (preparation)
+                preparationGate.retireUnboundClaim();
+            await cdp.send('Fetch.continueRequest', { requestId }, sessionId).catch(() => { });
+            return;
+        }
+        // Not gated on awaitingApproval: the page can send this confirmation while
+        // the token's own delivery is still being acknowledged. The lifecycle
+        // opens the claim only once a Stripe tokenization is being handed over.
+        const continuationId = stripeStep || terminal ? null
+            : claimStripeContinuation(opts, lifecycle, request.url, request.method, continuationBody);
+        if (continuationId) {
+            if (preparation)
+                preparationGate.retireUnboundClaim();
+            if (await checkStripeContinuation(opts, lifecycle, continuationId, { url: request.url, method: request.method, headers: request.headers, body: continuationBody }) && !setupStop.signal.aborted) {
+                await cdp.send('Fetch.continueRequest', { requestId }, sessionId).catch(() => { });
+                return;
+            }
+            await cdp.send('Fetch.failRequest', { requestId, errorReason: 'Aborted' }, sessionId).catch(() => { });
+            return;
+        }
         // Same stop condition as the Playwright adapter: once a failure proves
         // retrying is pointless, fail the request without calling the API again.
         if (terminal || lifecycle.isBlocked() || awaitingApproval || Date.now() < quietUntil) {
+            let repeatedAuthorizationId = null;
+            if (lastSubmitted) {
+                const body = pausedBody(request);
+                if (body !== null && isRepeatOfSubmitted(lastSubmitted, request.url, body, repeatQuietMs)) {
+                    repeatedAuthorizationId = lastSubmitted.authorizationId;
+                }
+            }
             const why = terminal ?? (lifecycle.isBlocked() ? lifecycle.getState().status : awaitingApproval ? 'an approval is already outstanding' : 'awaiting approval cooldown');
             opts.onEvent?.({ type: 'blocked', detail: why instanceof Error ? failureSummary(why) : String(why) });
             if (preparation)
                 preparationGate.retireUnboundClaim();
             await cdp.send('Fetch.failRequest', { requestId, errorReason: 'Aborted' }, sessionId).catch(() => { });
+            if (repeatedAuthorizationId)
+                void opts.vault.reportDuplicateGuard?.(repeatedAuthorizationId);
+            return;
+        }
+        // A recognized request that carries no card is not a card request: a
+        // Stripe confirmation paying with a method the page created itself. It is
+        // judged only after the holds above, so a request that would reuse an
+        // approved token is still refused there (card-fields.js requestWithoutCard).
+        if (withoutCard === 'refuse') {
+            if (preparation)
+                preparationGate.retireUnboundClaim();
+            opts.onEvent?.({ type: 'blocked', detail: 'request_without_card' });
+            await cdp.send('Fetch.failRequest', { requestId, errorReason: 'Aborted' }, sessionId).catch(() => { });
             return;
         }
         // Reserve BEFORE the first await (the authorize call below yields), so two
@@ -1381,11 +1488,14 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             if (isRepeatOfSubmitted(lastSubmitted, request.url, body, repeatQuietMs)) {
                 opts.onEvent?.({ type: 'blocked', detail: HOSTED_FORM_REPEAT_REASON });
                 await cdp.send('Fetch.failRequest', { requestId, errorReason: 'Aborted' }, sessionId).catch(() => { });
+                if (lastSubmitted)
+                    void opts.vault.reportDuplicateGuard?.(lastSubmitted.authorizationId);
                 return;
             }
             opts.onEvent?.({ type: 'card_request_paused', detail: { url: redactUrl(request.url), ...(resourceType ? { resourceType } : {}) } });
             lifecycle.begin();
             const approvalStartedAt = Date.now();
+            const payToInterceptMs = readPayToInterceptMs(opts.payClickedAt, approvalStartedAt);
             if (typeof networkId !== 'string' || !networkId) {
                 attempt.stop();
                 attempt.assertLive();
@@ -1422,6 +1532,7 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 merchantOrigin,
                 pageOrigin,
                 pageAmount,
+                ...(payToInterceptMs !== undefined ? { payToInterceptMs } : {}),
                 preparation,
                 timeoutMs: opts.timeoutMs,
                 signal: lifecycle.abort.signal,
@@ -1480,7 +1591,7 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                     body: Buffer.from(page.body).toString('base64'),
                 }, deliverOn);
                 attempt.assertLive();
-                lastSubmitted = { url: deliverRequest.url, body: deliverBody, at: Date.now() };
+                lastSubmitted = { url: deliverRequest.url, body: deliverBody, at: Date.now(), authorizationId: replay.authorizationId };
                 // Named for what it is: a device-attested submission with no
                 // processor evidence, never an `authorized` event.
                 opts.onEvent?.({ type: 'submitted_on_device', detail: { authorizationId: replay.authorizationId, submittedAt: replay.submittedAt, outcome: replay.outcome } });
@@ -1833,16 +1944,55 @@ export async function attachToPlaywright(page, opts) {
                     return;
                 }
             }
+            // Same order as attachToCdp: a routine card-free request continues in every state.
+            const continuationBody = request.postData();
+            const withoutCard = stripeStep ? null : opts.vault.withoutCard?.(request.url(), continuationBody) ?? null;
+            if (withoutCard === 'continue') {
+                if (preparation)
+                    preparationGate.retireUnboundClaim();
+                return route.fallback();
+            }
+            const continuationId = stripeStep || terminal ? null
+                : claimStripeContinuation(opts, lifecycle, request.url(), request.method(), continuationBody);
+            if (continuationId) {
+                if (preparation)
+                    preparationGate.retireUnboundClaim();
+                if (await checkStripeContinuation(opts, lifecycle, continuationId, { url: request.url(), method: request.method(), headers: request.headers(), body: continuationBody }) && !setupStop.signal.aborted) {
+                    return route.fallback();
+                }
+                return route.abort('aborted');
+            }
             // Fail closed and stay quiet: no card may reach the PSP, but neither may
             // the page's retry loop turn into a stream of doomed API calls. Every
             // abort in this adapter is 'aborted' (ERR_ABORTED), the same code the
             // CDP adapter's Fetch.failRequest uses, so a refused navigation
             // resolves identically whichever adapter is attached.
             if (terminal || lifecycle.isBlocked() || awaitingApproval || Date.now() < quietUntil) {
+                let repeatedAuthorizationId = null;
+                if (lastSubmitted) {
+                    let body = null;
+                    try {
+                        body = request.postData() ?? '';
+                    }
+                    catch { /* The refusal still holds when the body cannot be read. */ }
+                    if (body !== null && isRepeatOfSubmitted(lastSubmitted, request.url(), body, repeatQuietMs)) {
+                        repeatedAuthorizationId = lastSubmitted.authorizationId;
+                    }
+                }
                 const why = terminal ?? (lifecycle.isBlocked() ? lifecycle.getState().status : awaitingApproval ? 'an approval is already outstanding' : 'awaiting approval cooldown');
                 opts.onEvent?.({ type: 'blocked', detail: why instanceof Error ? failureSummary(why) : String(why) });
                 if (preparation)
                     preparationGate.retireUnboundClaim();
+                const refused = await route.abort('aborted');
+                if (repeatedAuthorizationId)
+                    void opts.vault.reportDuplicateGuard?.(repeatedAuthorizationId);
+                return refused;
+            }
+            // Same judgement as attachToCdp, after the same holds.
+            if (withoutCard === 'refuse') {
+                if (preparation)
+                    preparationGate.retireUnboundClaim();
+                opts.onEvent?.({ type: 'blocked', detail: 'request_without_card' });
                 return route.abort('aborted');
             }
             // Reserved before anything that could yield, matching attachToCdp.
@@ -1879,11 +2029,15 @@ export async function attachToPlaywright(page, opts) {
                 const body = request.postData() ?? '';
                 if (isRepeatOfSubmitted(lastSubmitted, request.url(), body, repeatQuietMs)) {
                     opts.onEvent?.({ type: 'blocked', detail: HOSTED_FORM_REPEAT_REASON });
-                    return await route.abort('aborted');
+                    const refused = await route.abort('aborted');
+                    if (lastSubmitted)
+                        void opts.vault.reportDuplicateGuard?.(lastSubmitted.authorizationId);
+                    return refused;
                 }
                 opts.onEvent?.({ type: 'card_request_paused', detail: { url: redactUrl(request.url()) } });
                 lifecycle.begin();
                 const approvalStartedAt = Date.now();
+                const payToInterceptMs = readPayToInterceptMs(opts.payClickedAt, approvalStartedAt);
                 attempt.bind({ route, request, frames });
                 activeRequest = { request, frames, attempt,
                     identity: requestIdentity(opts, request.url(), request.method(), body, undefined, undefined) };
@@ -1914,6 +2068,7 @@ export async function attachToPlaywright(page, opts) {
                     merchantOrigin,
                     pageOrigin,
                     pageAmount,
+                    ...(payToInterceptMs !== undefined ? { payToInterceptMs } : {}),
                     preparation,
                     timeoutMs: opts.timeoutMs,
                     signal: lifecycle.abort.signal,
@@ -1957,7 +2112,7 @@ export async function attachToPlaywright(page, opts) {
                     // Inert on a navigation (never CORS-checked); one path for every fulfill.
                     await deliverTo.fulfill({ status: synthetic.status, headers: withCorsHeaders(synthetic.headers, corsHeadersFor(deliverRequest.url(), deliverRequest.headers())), body: synthetic.body });
                     assertRequestLive();
-                    lastSubmitted = { url: deliverRequest.url(), body: deliverBody, at: Date.now() };
+                    lastSubmitted = { url: deliverRequest.url(), body: deliverBody, at: Date.now(), authorizationId: replay.authorizationId };
                     opts.onEvent?.({ type: 'submitted_on_device', detail: { authorizationId: replay.authorizationId, submittedAt: replay.submittedAt, outcome: replay.outcome } });
                 }
                 else if (replay.mode === 'cse') {

package/dist/client.d.ts

@@ -15,6 +15,16 @@ export interface PausedRequest {
  * is never paused) and sent on every create.
  */
 export declare const SUPPORTED_MODES: readonly CheckoutMode[];
+/**
+ * Registry features this SDK honours, asked for on syncRegistry next to the
+ * modes. `card_fields`: it reads a recognizer's cardFields and claims only a
+ * request whose body carries the card, so the API may serve it recognizers
+ * whose endpoints also run without a card. `checkout_sessions`: it lets a
+ * request the recognizer marks as routine without a card (passWithoutCard)
+ * through ahead of its holds, so the API may serve Stripe's Checkout Session
+ * confirm, which hosted Checkout sends after an approval.
+ */
+export declare const SUPPORTED_REGISTRY_FEATURES: readonly string[];
 /**
  * What the amount on an authorization IS: held to a Stripe PaymentIntent
  * (read back at create and before the replay), the parked form's own sum
@@ -199,6 +209,8 @@ export interface AuthorizeInput extends ExecutionMetadata {
         amount: number;
         currency: string;
     };
+    /** Milliseconds from the caller's pay click until the SDK caught the card request, measured on one clock. */
+    payToInterceptMs?: number;
     /**
      * WHICH stored card should pay — a vault card id from
      * GET /api/v2/vault_cards. The approval page preselects it (the human can
@@ -459,6 +471,11 @@ export interface VaultClientOptions {
     /** Override the PSP registry (tests, or pinning). Defaults to the hosted list. */
     registry?: Recognizer[];
     fetchImpl?: typeof fetch;
+    /** Receives contained reporting failures that do not change checkout behavior. */
+    onEvent?: (event: {
+        type: string;
+        detail?: unknown;
+    }) => void;
     pollIntervalMs?: number;
     /**
      * Waits before retrying a create the API answered 502 `amount_unverifiable`
@@ -482,6 +499,16 @@ export declare class VaultClient {
     syncRegistry(): Promise<void>;
     /** True when this request is a card tokenization we can take over. */
     isCardRequest(url: string, method?: string): boolean;
+    /**
+     * What happens to a card request (by URL) whose body carries no card: null
+     * when it carries one, so it is a card request as usual; 'continue' when the
+     * recognizer marks the endpoint as one where such requests are routine and
+     * never ours; 'refuse' otherwise, such as a Stripe confirmation paying with
+     * a method this checkout never approved. The adapters ask only after their
+     * holds, so a request that would reuse an approved token is refused there
+     * first. A body that could not be read is not judged here.
+     */
+    withoutCard(url: string, body: string | null | undefined): 'continue' | 'refuse' | null;
     /**
      * How the card would reach the processor on this request (`token`, `cse`
      * or `hosted_form`; absent on the entry means `token`), or null when the
@@ -506,6 +533,8 @@ export declare class VaultClient {
     prepareCheckout(input: PrepareCheckoutInput): Promise<PreparedCheckout>;
     /** Cancel only an unconsumed preparation; a bound request is reconciled separately. */
     cancelPreparation(id: string): Promise<void>;
+    observePreparation(id: string, guidance: 'presented_not_filled' | 'not_presented', reason?: string): Promise<void>;
+    reportDuplicateGuard(authorizationId: string): Promise<void>;
     /**
      * Hand us a paused tokenization request. We ask the cardholder to approve,
      * their device supplies the card and calls the merchant, and you get back the
@@ -539,6 +568,26 @@ export declare class VaultClient {
         cancelled: true;
         processor_request_started: boolean;
     }>;
+    /**
+     * Ask whether the page may pay with the Stripe card token an approval
+     * produced: a PaymentIntent confirm that carries no card and pays with
+     * exactly the approved payment method, card token, confirmation token or
+     * source. The API reads the payment from Stripe and answers only for the
+     * approved amount and currency on the same Stripe account; any other answer
+     * rejects with a CheckoutApiError whose code says why (for example
+     * `continuation_not_bound`, `amount_mismatch`). Nothing is charged here:
+     * the adapters continue the page's own request once this resolves.
+     */
+    checkStripeContinuation(authorizationId: string, request: {
+        url: string;
+        method: string;
+        headers: Record<string, string>;
+        body: string;
+    }): Promise<{
+        paymentIntentId: string;
+        amount: number;
+        currency: string;
+    }>;
     /**
      * POST the create, with two typed twists: a 502 `amount_unverifiable`
      * (Stripe did not answer the read-back) is retried on a short backoff

package/dist/client.js

@@ -2,6 +2,7 @@ import { BUILTIN_REGISTRY, cardUrlPatterns as deriveCardUrlPatterns, findRecogni
 import { isMercadoTokenRequest, parseMercadoCheckoutContext, validateMercadoProcessorContext } from './mercado-checkout.generated.js';
 import { matchesPreparedRequest, preparationMode, validPreparationEnvironment } from './prepared-processor.js';
 import { hasOwnedShopMarker, parseOwnedShopOrder, parseOwnedShopReceipt } from './owned-shop.generated.js';
+import { requestWithoutCard } from './card-fields.generated.js';
 import { classifyStripeCheckoutRequest, encodeStripeCheckoutContext, hasStripeCheckoutMarker, parseStripeCheckoutContext, parseStripeCheckoutResponse, STRIPE_CHECKOUT_CONTEXT_HEADER, } from './stripe-checkout.generated.js';
 /**
  * The modes this SDK can finish. Asked for on syncRegistry (the API serves
@@ -9,6 +10,16 @@ import { classifyStripeCheckoutRequest, encodeStripeCheckoutContext, hasStripeCh
  * is never paused) and sent on every create.
  */
 export const SUPPORTED_MODES = ['token', 'cse', 'hosted_form'];
+/**
+ * Registry features this SDK honours, asked for on syncRegistry next to the
+ * modes. `card_fields`: it reads a recognizer's cardFields and claims only a
+ * request whose body carries the card, so the API may serve it recognizers
+ * whose endpoints also run without a card. `checkout_sessions`: it lets a
+ * request the recognizer marks as routine without a card (passWithoutCard)
+ * through ahead of its holds, so the API may serve Stripe's Checkout Session
+ * confirm, which hosted Checkout sends after an approval.
+ */
+export const SUPPORTED_REGISTRY_FEATURES = ['card_fields', 'checkout_sessions'];
 /** An integer in the smallest unit, or a decimal string in normal units with a point; nothing else. */
 export function validAmountInput(amount) {
     if (typeof amount === 'number')
@@ -395,7 +406,7 @@ export class VaultClient {
         // spread verbatim.
         let raw;
         try {
-            raw = await this.get(`/v2/checkout/recognizers?modes=${SUPPORTED_MODES.join(',')}`);
+            raw = await this.get(`/v2/checkout/recognizers?modes=${SUPPORTED_MODES.join(',')}&features=${SUPPORTED_REGISTRY_FEATURES.join(',')}`);
         }
         catch {
             return;
@@ -412,6 +423,21 @@ export class VaultClient {
     isCardRequest(url, method = 'POST') {
         return method.toUpperCase() === 'POST' && findRecognizer(url, this.registry) !== null;
     }
+    /**
+     * What happens to a card request (by URL) whose body carries no card: null
+     * when it carries one, so it is a card request as usual; 'continue' when the
+     * recognizer marks the endpoint as one where such requests are routine and
+     * never ours; 'refuse' otherwise, such as a Stripe confirmation paying with
+     * a method this checkout never approved. The adapters ask only after their
+     * holds, so a request that would reuse an approved token is refused there
+     * first. A body that could not be read is not judged here.
+     */
+    withoutCard(url, body) {
+        if (body == null)
+            return null;
+        const rec = findRecognizer(url, this.registry);
+        return rec ? requestWithoutCard(rec, url, body) : null;
+    }
     /**
      * How the card would reach the processor on this request (`token`, `cse`
      * or `hosted_form`; absent on the entry means `token`), or null when the
@@ -534,6 +560,26 @@ export class VaultClient {
         if (state?.id !== id || !['cancelled', 'expired'].includes(state.status))
             throw new CheckoutPreparationError(id, 'cancel_unconfirmed');
     }
+    async observePreparation(id, guidance, reason) {
+        try {
+            await this.post(`/v2/checkout/preparations/${id}/observe`, {
+                form_guidance: guidance, ...(reason ? { reason } : {}),
+            }, AbortSignal.timeout(5_000));
+        }
+        catch {
+            this.opts.onEvent?.({ type: 'telemetry_skipped', detail: 'form_guidance' });
+        }
+    }
+    async reportDuplicateGuard(authorizationId) {
+        try {
+            await this.post(`/v2/checkout/authorizations/${authorizationId}/duplicate-guard`, {
+                guard: 'hosted_form_repeat',
+            }, AbortSignal.timeout(5_000));
+        }
+        catch {
+            this.opts.onEvent?.({ type: 'telemetry_skipped', detail: 'duplicate_guard' });
+        }
+    }
     /**
      * Hand us a paused tokenization request. We ask the cardholder to approve,
      * their device supplies the card and calls the merchant, and you get back the
@@ -647,6 +693,9 @@ export class VaultClient {
             // snake_case on the wire; camelCase is this SDK's convention.
             ...(hasAmount ? { amount: input.amount, currency: input.currency } : {}),
             ...(input.pageAmount ? { page_amount: input.pageAmount.amount, page_currency: input.pageAmount.currency } : {}),
+            ...(Number.isInteger(input.payToInterceptMs) && input.payToInterceptMs >= 0
+                ? { pay_to_intercept_ms: input.payToInterceptMs }
+                : {}),
             psp: rec.psp,
             // The mode this request will be finished in. The API checks it against
             // the recognizer and refuses a disagreement before a row exists.
@@ -657,7 +706,7 @@ export class VaultClient {
             ...(input.merchantOrigin && !preparation ? { merchant_origin: input.merchantOrigin } : {}),
             // A prepared checkout already carries the page origin as merchant_origin.
             ...(preparation
-                ? { preparation_id: preparation.id, checkout_key: preparation.checkoutKey, merchant_origin: preparation.merchantOrigin }
+                ? { preparation_id: preparation.id, checkout_key: preparation.checkoutKey, merchant_origin: preparation.merchantOrigin, form_guidance: 'filled' }
                 : input.pageOrigin ? { checkout_origin: input.pageOrigin } : {}),
             request: {
                 url: input.request.url,
@@ -996,6 +1045,32 @@ export class VaultClient {
         return { id: authorizationId, status: 'declined', reason: recorded,
             cancelled: true, processor_request_started: result.processor_request_started };
     }
+    /**
+     * Ask whether the page may pay with the Stripe card token an approval
+     * produced: a PaymentIntent confirm that carries no card and pays with
+     * exactly the approved payment method, card token, confirmation token or
+     * source. The API reads the payment from Stripe and answers only for the
+     * approved amount and currency on the same Stripe account; any other answer
+     * rejects with a CheckoutApiError whose code says why (for example
+     * `continuation_not_bound`, `amount_mismatch`). Nothing is charged here:
+     * the adapters continue the page's own request once this resolves.
+     */
+    async checkStripeContinuation(authorizationId, request) {
+        if (!/^cauth_[A-Za-z0-9_-]{1,128}$/.test(authorizationId))
+            throw new Error('Invalid authorization ID.');
+        const rec = findRecognizer(request.url, this.registry);
+        if (rec?.psp !== 'stripe')
+            throw new Error('Only a Stripe request can continue an approved Stripe token.');
+        const result = await this.post(`/v2/checkout/authorizations/${authorizationId}/continuations`, {
+            request: { url: request.url, method: request.method, headers: pickHeaders(request.headers, rec.passthroughHeaders), body: request.body },
+        }, AbortSignal.timeout(15_000));
+        const pi = result?.payment_intent;
+        if (result?.object !== 'checkout_continuation' || result.continuation !== 'allowed' || result.authorization !== authorizationId
+            || !pi || typeof pi.id !== 'string' || !Number.isSafeInteger(pi.amount) || typeof pi.currency !== 'string') {
+            throw new Error('The continuation answer was not recognized.');
+        }
+        return { paymentIntentId: pi.id, amount: pi.amount, currency: pi.currency };
+    }
     /**
      * POST the create, with two typed twists: a 502 `amount_unverifiable`
      * (Stripe did not answer the read-back) is retried on a short backoff

package/dist/lifecycle.d.ts

@@ -61,6 +61,8 @@ export interface CheckoutController {
         status: 'failed';
     }): void;
 }
+/** How many times one approval's card-free Stripe confirmation may be checked before it is simply held. */
+export declare const MAX_STRIPE_CONTINUATION_CHECKS = 3;
 /** Shared by the raw CDP and Playwright transports. No browser ownership or payment execution lives here. */
 export declare class CheckoutLifecycle implements CheckoutController {
     private readonly options;
@@ -70,6 +72,9 @@ export declare class CheckoutLifecycle implements CheckoutController {
     private cancelled;
     private merchantAborted;
     private unboundStripeToken;
+    private stripeTokenPrepared;
+    private stripeContinuation;
+    private stripeContinuationChecks;
     private ownedShopOrderId;
     private reconciliation;
     private preparationHandler?;
@@ -121,6 +126,24 @@ export declare class CheckoutLifecycle implements CheckoutController {
     merchantNeverRetried(authorizationId: string | null): void;
     unsupported(): void;
     prepareHandoff(replay: ReplayResponse, requestUrl: string): void;
+    /**
+     * The approval a page's card-free Stripe confirmation may continue, or null.
+     * Only once a Stripe tokenization is being handed to the page, and while
+     * the checkout still awaits it (the page can send its confirmation before
+     * the browser acknowledges the delivery) or the merchant; for one check at
+     * a time and at most MAX_STRIPE_CONTINUATION_CHECKS checks. Reserves the check synchronously,
+     * so two confirmations can never both continue: the caller settles it with
+     * stripeContinuationChecked(). The hold stays on throughout.
+     */
+    claimStripeContinuation(): string | null;
+    /**
+     * Settle a claimed check. True only when the API allowed it and the checkout
+     * still awaits the merchant (nothing cancelled, aborted or reconciled it
+     * while the API answered): the page's confirmation continues, and no later
+     * one will.
+     */
+    stripeContinuationChecked(allowed: boolean): boolean;
+    private stripeContinuationOpen;
     handedOff(replay: ReplayResponse): void;
     failed(error: unknown, handoffStarted?: boolean): void;
     requestUserAction(reason: '3ds' | 'redirect' | 'other'): Promise<void>;

package/dist/lifecycle.js

@@ -1,5 +1,7 @@
 import { ApprovalDeclinedError, ApprovalTimeoutError, CheckoutCancelledError, CheckoutPreparationError, IntentNotConfirmableError, PaymentOutcomeUnknownError, ProcessorRefusedError } from './client.js';
 import { parseOwnedShopReceipt, OWNED_SHOP_SKU, OWNED_SHOP_AMOUNT_CENTS, OWNED_SHOP_CURRENCY } from './owned-shop.generated.js';
+/** How many times one approval's card-free Stripe confirmation may be checked before it is simply held. */
+export const MAX_STRIPE_CONTINUATION_CHECKS = 3;
 /** Shared by the raw CDP and Playwright transports. No browser ownership or payment execution lives here. */
 export class CheckoutLifecycle {
     options;
@@ -9,6 +11,10 @@ export class CheckoutLifecycle {
     cancelled = false;
     merchantAborted = false;
     unboundStripeToken = false;
+    // The page's own confirmation paying with that token: see claimStripeContinuation.
+    stripeTokenPrepared = false;
+    stripeContinuation = 'none';
+    stripeContinuationChecks = 0;
     ownedShopOrderId = null;
     reconciliation = null;
     preparationHandler;
@@ -141,16 +147,53 @@ export class CheckoutLifecycle {
         if (!replay.mode || replay.mode === 'token') {
             try {
                 const url = new URL(requestUrl);
-                if (url.origin === 'https://api.stripe.com' && ['/v1/payment_methods', '/v1/tokens'].includes(url.pathname)) {
+                if (url.origin === 'https://api.stripe.com' && ['/v1/payment_methods', '/v1/tokens', '/v1/sources', '/v1/confirmation_tokens'].includes(url.pathname)) {
                     // Set before delivery: a lost browser acknowledgement must not reset
                     // an already-issued token into a retryable authorization.
                     this.unboundStripeToken = true;
+                    this.stripeTokenPrepared = true;
                     this.held = true;
                 }
             }
             catch { /* unknown URL cannot establish a token binding */ }
         }
     }
+    /**
+     * The approval a page's card-free Stripe confirmation may continue, or null.
+     * Only once a Stripe tokenization is being handed to the page, and while
+     * the checkout still awaits it (the page can send its confirmation before
+     * the browser acknowledges the delivery) or the merchant; for one check at
+     * a time and at most MAX_STRIPE_CONTINUATION_CHECKS checks. Reserves the check synchronously,
+     * so two confirmations can never both continue: the caller settles it with
+     * stripeContinuationChecked(). The hold stays on throughout.
+     */
+    claimStripeContinuation() {
+        if (!this.stripeContinuationOpen() || this.stripeContinuation !== 'none'
+            || this.stripeContinuationChecks >= MAX_STRIPE_CONTINUATION_CHECKS)
+            return null;
+        this.stripeContinuation = 'checking';
+        this.stripeContinuationChecks++;
+        return this.state.authorizationId;
+    }
+    /**
+     * Settle a claimed check. True only when the API allowed it and the checkout
+     * still awaits the merchant (nothing cancelled, aborted or reconciled it
+     * while the API answered): the page's confirmation continues, and no later
+     * one will.
+     */
+    stripeContinuationChecked(allowed) {
+        if (this.stripeContinuation !== 'checking')
+            return false;
+        const proceed = allowed && this.stripeContinuationOpen();
+        this.stripeContinuation = proceed ? 'continued' : 'none';
+        if (proceed)
+            this.set({ ...this.state, reason: 'stripe_payment_continued' });
+        return proceed;
+    }
+    stripeContinuationOpen() {
+        return this.stripeTokenPrepared && !this.cancelled && !this.merchantAborted && !!this.state.authorizationId
+            && (this.state.status === 'awaiting_approval' || this.state.status === 'awaiting_merchant');
+    }
     handedOff(replay) {
         if (this.merchantAborted)
             return;
@@ -161,9 +204,13 @@ export class CheckoutLifecycle {
         }
         const mismatch = (!replay.mode || replay.mode === 'token') && replay.amountVerified === false;
         this.held = !!this.options.requireMerchantResult || replay.mode === 'hosted_form' || mismatch || this.unboundStripeToken;
+        if (mismatch)
+            this.stripeTokenPrepared = false;
         this.set({ status: 'awaiting_merchant', authorizationId: replay.authorizationId, mode: replay.mode ?? 'token',
             ...(this.state.preparationId ? { preparationId: this.state.preparationId } : {}),
-            ...(mismatch ? { reason: 'charged_amount_mismatch' } : this.unboundStripeToken ? { reason: 'stripe_tokenization_unbound' } : {}) });
+            ...(mismatch ? { reason: 'charged_amount_mismatch' }
+                : this.stripeContinuation === 'continued' ? { reason: 'stripe_payment_continued' }
+                    : this.unboundStripeToken ? { reason: 'stripe_tokenization_unbound' } : {}) });
     }
     failed(error, handoffStarted = false) {
         if (this.cancelled)

package/dist/preflight-capabilities.generated.d.ts

@@ -124,7 +124,7 @@ export declare const CHECKOUT_PREFLIGHT_CAPABILITIES: {
             readonly requires: "reviewed_final_payment_and_continuation_evidence";
         }, {
             readonly id: "stripe.tokenization";
-            readonly path_pattern: "^/v1/(?:payment_methods|tokens)$";
+            readonly path_pattern: "^/v1/(?:payment_methods|tokens|sources|confirmation_tokens)$";
             readonly effect: "token_or_method_creation";
             readonly amount_binding: "none";
             readonly psp: "stripe";

package/dist/preflight-capabilities.generated.js

@@ -188,7 +188,7 @@ export const CHECKOUT_PREFLIGHT_CAPABILITIES = {
                 },
                 {
                     "id": "stripe.tokenization",
-                    "path_pattern": "^/v1/(?:payment_methods|tokens)$",
+                    "path_pattern": "^/v1/(?:payment_methods|tokens|sources|confirmation_tokens)$",
                     "effect": "token_or_method_creation",
                     "amount_binding": "none",
                     "psp": "stripe",

package/dist/preflight-catalog.json

@@ -2640,7 +2640,7 @@
         },
         {
           "id": "stripe.tokenization",
-          "path_pattern": "^/v1/(?:payment_methods|tokens)$",
+          "path_pattern": "^/v1/(?:payment_methods|tokens|sources|confirmation_tokens)$",
           "effect": "token_or_method_creation",
           "amount_binding": "none",
           "psp": "stripe",

package/dist/preflight.generated.d.ts

@@ -271,7 +271,7 @@ export declare function getCheckoutPreflightCatalog(): {
             readonly requires: "reviewed_final_payment_and_continuation_evidence";
         }, {
             readonly id: "stripe.tokenization";
-            readonly path_pattern: "^/v1/(?:payment_methods|tokens)$";
+            readonly path_pattern: "^/v1/(?:payment_methods|tokens|sources|confirmation_tokens)$";
             readonly effect: "token_or_method_creation";
             readonly amount_binding: "none";
             readonly psp: "stripe";

package/dist/preparation.d.ts

@@ -22,4 +22,10 @@ export declare class PreparationGate {
     retireUnboundClaim(): void;
     /** A bound native request has its own cancellation/unknown-outcome machinery. */
     invalidate(reason: string): void;
+    /**
+     * Retire the server handle first, then report the form outcome. Neither
+     * call waits on the other: a stalled report cannot delay the cancel, and a
+     * stalled cancel cannot lose the report.
+     */
+    private cancelThenObserve;
 }

package/dist/preparation.js

@@ -69,7 +69,7 @@ export class PreparationGate {
             if (prepared.psp !== options.psp || prepared.environment !== options.environment)
                 throw new CheckoutPreparationError(prepared.id, 'checkout_changed');
             if (signal.aborted || this.state !== 'preparing') {
-                void this.opts.vault.cancelPreparation(prepared.id).catch(() => { });
+                void this.cancelThenObserve(prepared.id, 'cancelled');
                 throw new CheckoutPreparationError(prepared.id, 'cancelled');
             }
             await this.assertDocument();
@@ -135,7 +135,7 @@ export class PreparationGate {
     retireUnboundClaim() {
         if (this.state !== 'consumed' || !this.prepared || this.lifecycle.getState().authorizationId)
             return;
-        void this.opts.vault.cancelPreparation(this.prepared.id).catch(() => { });
+        void this.cancelThenObserve(this.prepared.id, 'request_not_bound');
         // No bound ID means the adapter must not leave a spent handle appearing ready.
         if (this.lifecycle.getState().status === 'ready_to_submit')
             this.lifecycle.preparationFailed(new CheckoutPreparationError(this.prepared.id, 'request_not_bound'));
@@ -148,7 +148,17 @@ export class PreparationGate {
         clearTimeout(this.expiryTimer);
         this.stop.abort();
         if (this.prepared)
-            void this.opts.vault.cancelPreparation(this.prepared.id).catch(() => { });
+            void this.cancelThenObserve(this.prepared.id, reason);
         this.lifecycle.preparationFailed(new CheckoutPreparationError(this.prepared?.id ?? null, reason));
     }
+    /**
+     * Retire the server handle first, then report the form outcome. Neither
+     * call waits on the other: a stalled report cannot delay the cancel, and a
+     * stalled cancel cannot lose the report.
+     */
+    async cancelThenObserve(id, reason) {
+        const cancellation = this.opts.vault.cancelPreparation(id).catch(() => { });
+        const observation = this.opts.vault.observePreparation?.(id, this.observedRequest ? 'presented_not_filled' : 'not_presented', reason);
+        await Promise.all([cancellation, observation?.catch(() => { })]);
+    }
 }

package/dist/registry.d.ts

@@ -40,6 +40,21 @@ export interface Recognizer {
      * the call (signatures, client tokens). Matched case-insensitively.
      */
     passthroughHeaders: RegExp[];
+    /**
+     * Form keys that carry the card number. When present, a request on this
+     * recognizer's endpoints is a card request only if its body carries one of
+     * them: a Stripe confirmation that pays with a method the page already
+     * created (`payment_method=pm_...`) carries none, so there is nothing for
+     * the cardholder to approve. Served by the API and carried through
+     * syncRegistry() verbatim.
+     */
+    cardFields?: string[];
+    /**
+     * With cardFields: the endpoints (regex source over hostname + pathname,
+     * anchored) where a request without a card is routine and never ours, so
+     * it continues untouched; a request without a card anywhere else is refused.
+     */
+    passWithoutCard?: string;
     /**
      * True when the card is encrypted inside the page before the request leaves.
      * A digit swap is useless here; the vault must re-run the PSP's client-side

package/dist/stripe-checkout.generated.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 // Generated from @agent-cards/payment-core. Do not edit.
-// artifact-sha256: 0d2e18239c2a0102d3a473e339c8921aac7777e640ad44a2743a922204f2edfc
+// artifact-sha256: 128bbf2359c38eda0d29a58c9b6f83123cf2d27d94365a5665e1569d605e9d2c
 // src/definitions.js
 function deepFreeze(value) {
     if (value && typeof value === "object" && !Object.isFrozen(value)) {
@@ -28,21 +28,42 @@ var PROCESSOR_DEFINITIONS = deepFreeze([
     },
     {
         psp: "stripe",
-        // FOUR PAN-bearing surfaces, not two. `payment_methods` and `tokens` are the
-        // LEGACY tokenizers. Modern Payment Element does not call either: it puts the
-        // card inline in the intent confirmation as
-        // `payment_method_data[card][number]`, so a merchant on the current SDK was
-        // never paused at all. Observed live on Anthropic's own billing page
-        // (platform.claude.com/settings/billing), which posts to
-        // /v1/setup_intents/{seti_...}/confirm — that is the "save a card" flow;
-        // /v1/payment_intents/{pi_...}/confirm is the same shape for "pay now".
-        // The id segment is matched narrowly (seti_/pi_ + word chars) rather than
-        // `.*` so the pattern cannot be widened by a crafted path.
-        match: "api\\.stripe\\.com/v1/(payment_methods|tokens|setup_intents/seti_\\w+/confirm|payment_intents/pi_\\w+/confirm)",
+        // Every endpoint Stripe.js sends a card to, read from its own controller
+        // bundle: `tokens` (createToken), `payment_methods` (createPaymentMethod),
+        // `sources` (createSource, the older API), `confirmation_tokens`
+        // (createConfirmationToken: the page collects the card and confirms on its
+        // own server), and the intent confirmations that carry the card inline as
+        // `payment_method_data[card][number]` (confirmPayment, confirmSetup). The
+        // modern Payment Element mostly confirms inline or through a confirmation
+        // token, so matching the tokenizers alone never paused it. Observed live on
+        // Anthropic's own billing page (platform.claude.com/settings/billing),
+        // which posts to /v1/setup_intents/{seti_...}/confirm, the "save a card"
+        // flow; /v1/payment_intents/{pi_...}/confirm is the same shape for "pay
+        // now". Stripe Checkout Sessions confirm at
+        // /v1/payment_pages/{cs_...}/confirm: Checkout Elements (initCheckout)
+        // sends the card there inline, while hosted and embedded Checkout send only
+        // the payment method they created first. The id segment is matched
+        // narrowly (seti_/pi_/cs_ + word chars) rather than `.*` so the pattern
+        // cannot be widened by a crafted path. A client that does not check
+        // cardFields is served the pattern it knew before sources, confirmation
+        // tokens and Checkout Sessions joined (recognition.js recognizersForClient).
+        match: "api\\.stripe\\.com/v1/(payment_methods|tokens|sources|confirmation_tokens|setup_intents/seti_\\w+/confirm|payment_intents/pi_\\w+/confirm|payment_pages/cs_(?:test|live)_\\w+/confirm)",
         hosts: ["^api\\.stripe\\.com$"],
         encoding: "form",
         // Elements' own surface markers; without these Stripe rejects the surface.
-        passthroughHeaders: ["^authorization$", "^stripe-version$", "^x-stripe-client-user-agent$"]
+        passthroughHeaders: ["^authorization$", "^stripe-version$", "^x-stripe-client-user-agent$"],
+        // The same confirmations also run WITHOUT a card: a page that created the
+        // method first confirms with `payment_method=pm_...`. Only a body that
+        // carries one of these fields is a card request (card-fields.js). Any
+        // other request on these endpoints has no card to approve, so it is
+        // refused (requestWithoutCard) instead of paused for the cardholder,
+        // unless passWithoutCard below names its endpoint.
+        cardFields: ["card[number]", "payment_method_data[card][number]"],
+        // A confirmation token that wraps a saved method, a source for a bank, or a
+        // Checkout Session confirm paying with the method hosted or embedded
+        // Checkout created first carries no card and was never ours: it continues
+        // untouched, as it did before these endpoints were recognized.
+        passWithoutCard: "api\\.stripe\\.com/v1/(sources|confirmation_tokens|payment_pages/cs_(?:test|live)_\\w+/confirm)"
     },
     {
         psp: "braintree",
@@ -498,6 +519,16 @@ function trustedClientRecognizer(pspOrEntry) {
         throw new Error("Refusing to pay: unknown payment processor.");
     return definition;
 }
+// src/recognition.js
+var PATTERN_WITHOUT_CARD_FIELDS = Object.freeze({
+    stripe: "api\\.stripe\\.com/v1/(payment_methods|tokens|setup_intents/seti_\\w+/confirm|payment_intents/pi_\\w+/confirm)"
+});
+var WITHOUT_CHECKOUT_SESSIONS = Object.freeze({
+    stripe: Object.freeze({
+        match: "api\\.stripe\\.com/v1/(payment_methods|tokens|sources|confirmation_tokens|setup_intents/seti_\\w+/confirm|payment_intents/pi_\\w+/confirm)",
+        passWithoutCard: "api\\.stripe\\.com/v1/(sources|confirmation_tokens)"
+    })
+});
 // src/request-policy.js
 var HEADER_NEVER_FORWARD = /^(cookie|set-cookie|authorization2|proxy-authorization|host|content-length|origin|referer)$/i;
 var ALLOWED_MEDIA_TYPES = {
@@ -591,7 +622,7 @@ function validateStripeCheckoutCard(card, environment = "test") {
             reject();
     }
     else {
-        if (!/^\d{13,19}(?![\s\S])/.test(card.number) || /^(\d)\1+(?![\s\S])/.test(card.number) || !/^\d{3,4}(?![\s\S])/.test(card.cvc) || SYNTHETIC_CARDS.includes(card.number))
+        if (!/^\d{12,19}(?![\s\S])/.test(card.number) || /^(\d)\1+(?![\s\S])/.test(card.number) || !/^\d{3,4}(?![\s\S])/.test(card.cvc) || SYNTHETIC_CARDS.includes(card.number))
             reject();
         let sum = 0, double = false;
         for (let i = card.number.length - 1; i >= 0; i--) {

package/examples/preflight/kernel-native/inventory.json

@@ -1,7 +1,7 @@
 {
   "schema_version": 1,
   "catalog_version": "2026-09-15.1",
-  "catalog_sha256": "e1bbae82b91134c8be5919fddd5d60ea56f6897b570f8ccb2f305cd5b0a1c085",
+  "catalog_sha256": "c605e3f370a2560e15d695e9ce80248f117076e4556f8dc7912ba1e54fb92315",
   "baseline_version": "kernel-native-docs-2026-09-11.1",
   "baseline_sha256": "d86722f49633d8223fccae54cd3d485df4375aee06aa156a273cc689b7c8507c",
   "native_build": null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-cards/checkout",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Let browser agents pay with the user's own card, without your infrastructure ever touching card data.",
   "type": "module",
   "main": "dist/index.js",