@agent-cards/checkout 0.17.0 → 0.19.0

package/dist/stripe-checkout.generated.js

@@ -1,7 +1,7 @@
 // @ts-nocheck
 // Generated from @agent-cards/payment-core. Do not edit.
-// artifact-sha256: 0d2e18239c2a0102d3a473e339c8921aac7777e640ad44a2743a922204f2edfc
-// src/definitions.js
+// artifact-sha256: 9edf78da59b3bdfe310b4422e06d333cd164497cdb4070db59ffed348492198a
+// src/deep-freeze.js
 function deepFreeze(value) {
     if (value && typeof value === "object" && !Object.isFrozen(value)) {
         for (const child of Object.values(value))
@@ -10,6 +10,7 @@ function deepFreeze(value) {
     }
     return value;
 }
+// src/definitions.js
 var PROCESSOR_DEFINITIONS = deepFreeze([
     {
         psp: "spreedly",
@@ -28,26 +29,48 @@ 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",
         match: "payments(\\.sandbox)?\\.braintree-api\\.com/graphql",
         hosts: ["^payments\\.braintree-api\\.com$", "^payments\\.sandbox\\.braintree-api\\.com$"],
+        sandboxHosts: ["^payments\\.sandbox\\.braintree-api\\.com$"],
         encoding: "json",
         passthroughHeaders: ["^authorization$", "^braintree-version$"]
     },
@@ -65,6 +88,7 @@ var PROCESSOR_DEFINITIONS = deepFreeze([
             "^card-acquisition-gateway\\.checkout\\.com$",
             "^card-acquisition-gateway\\.sandbox\\.checkout\\.com$"
         ],
+        sandboxHosts: ["^api\\.sandbox\\.checkout\\.com$", "^card-acquisition-gateway\\.sandbox\\.checkout\\.com$"],
         encoding: "json",
         passthroughHeaders: ["^authorization$"]
     },
@@ -93,6 +117,15 @@ var PROCESSOR_DEFINITIONS = deepFreeze([
         // merchants on them were silently never paused.
         match: "(checkoutshopper-(test|live(-[a-z]+)?)\\.adyen\\.com|([a-z0-9-]+\\.)*adyenpayments\\.com)/checkoutshopper/v1/sessions/[A-Za-z0-9_-]+/payments",
         hosts: ["^checkoutshopper-(test|live(-[a-z]+)?)\\.adyen\\.com$", "^([a-z0-9-]+\\.)*adyenpayments\\.com$"],
+        // The sandbox marker matches ONLY the TEST hostname, a subset of the first
+        // host source (which matches checkoutshopper-test and every checkoutshopper-live
+        // regional host). checkoutshopper-live* and *.adyenpayments.com are live.
+        // Load-bearing for Adyen although Adyen does not pin its environment: the
+        // Adyen TEST platform rule (backend.js adyenLivePlatform) reads this marker
+        // on the server's authorization create and cardholder legs
+        // (services/checkout-cse-adyen.ts in the backend), on the device and in the
+        // enclave. Dropping or widening it moves which payments count as Adyen TEST.
+        sandboxHosts: ["^checkoutshopper-test\\.adyen\\.com$"],
         encoding: "json",
         passthroughHeaders: [],
         clientSideEncrypted: true,
@@ -162,6 +195,7 @@ var PROCESSOR_DEFINITIONS = deepFreeze([
         // PAN@ card_data.number. POST /v2/card-nonce (URL always carries ?_=&version=).
         match: "pci-connect\\.squareup(?:sandbox)?\\.com/v2/card-nonce",
         hosts: ["^pci-connect\\.squareup\\.com$", "^pci-connect\\.squareupsandbox\\.com$"],
+        sandboxHosts: ["^pci-connect\\.squareupsandbox\\.com$"],
         encoding: "json",
         passthroughHeaders: []
         // auth = client_id in body; no auth header
@@ -182,6 +216,7 @@ var PROCESSOR_DEFINITIONS = deepFreeze([
         // request types on the same URL — the body, not the URL, is what distinguishes them.
         match: "(api2|apitest)\\.authorize\\.net/xml/v1/request\\.api",
         hosts: ["^api2\\.authorize\\.net$", "^apitest\\.authorize\\.net$"],
+        sandboxHosts: ["^apitest\\.authorize\\.net$"],
         encoding: "json",
         // JSON body; Content-Type is sometimes text/plain (preflight dodge), replayed as-is
         passthroughHeaders: []
@@ -192,6 +227,8 @@ var PROCESSOR_DEFINITIONS = deepFreeze([
         // the two paths need DIFFERENT vendor media types; `application/json` → HTTP 406.
         match: "(try\\.)?access\\.worldpay\\.com/(sessions/card|verifiedTokens/sessions)",
         hosts: ["^access\\.worldpay\\.com$", "^try\\.access\\.worldpay\\.com$"],
+        sandboxHosts: ["^try\\.access\\.worldpay\\.com$"],
+        // try.* is Worldpay's try/test host
         encoding: "json",
         passthroughHeaders: ["^accept$"]
     },
@@ -208,6 +245,7 @@ var PROCESSOR_DEFINITIONS = deepFreeze([
         // with no branch back to the covered path.
         match: "(secure|ppp-test)\\.safecharge\\.com/ppp/api/v1/(?:cardTokenization|clientPayment|websdk/initPaymentWithCardTokenization)\\.do",
         hosts: ["^secure\\.safecharge\\.com$", "^ppp-test\\.safecharge\\.com$"],
+        sandboxHosts: ["^ppp-test\\.safecharge\\.com$"],
         encoding: "json",
         passthroughHeaders: []
     },
@@ -242,6 +280,7 @@ var PROCESSOR_DEFINITIONS = deepFreeze([
             "^pci-api\\.airwallex\\.com$",
             "^pci-api\\.sandbox\\.airwallex\\.com$"
         ],
+        sandboxHosts: ["^checkout\\.sandbox\\.airwallex\\.com$", "^pci-api\\.sandbox\\.airwallex\\.com$"],
         encoding: "json",
         passthroughHeaders: ["^client-secret$", "^authorization$", "^x-auth-token$", "^x-on-behalf-of$", "^x-api-version$"]
     },
@@ -255,6 +294,7 @@ var PROCESSOR_DEFINITIONS = deepFreeze([
         // Checkout Page (signature-authed, server-to-server, no card) — the POST gate is what splits them.
         match: "(api|sandboxapi)\\.rapyd\\.net/v1/(?:hosted/collect/card/[^/?#]+/payment_method|checkout/checkout_[A-Za-z0-9]+)(?:[?#]|$)",
         hosts: ["^api\\.rapyd\\.net$", "^sandboxapi\\.rapyd\\.net$"],
+        sandboxHosts: ["^sandboxapi\\.rapyd\\.net$"],
         encoding: "json",
         passthroughHeaders: []
         // auth rides the opaque hosted-page / checkout token in the URL
@@ -266,6 +306,7 @@ var PROCESSOR_DEFINITIONS = deepFreeze([
         // multi-tenant surface: `ppmcc` is dlocal-operated, not merchant-registrable.
         match: "ppmcc(-sandbox)?\\.dlocal\\.com/cvault/credit-card/temporal",
         hosts: ["^ppmcc\\.dlocal\\.com$", "^ppmcc-sandbox\\.dlocal\\.com$"],
+        sandboxHosts: ["^ppmcc-sandbox\\.dlocal\\.com$"],
         encoding: "json",
         passthroughHeaders: ["^x-fields-api-key$", "^x-uow$", "^x-dlocal-infrav2$"]
     },
@@ -297,6 +338,7 @@ var PROCESSOR_DEFINITIONS = deepFreeze([
             "^api\\.ebanxpay\\.com$",
             "^sandbox\\.ebanxpay\\.com$"
         ],
+        sandboxHosts: ["^sandbox\\.ebanx\\.com$", "^sandbox-local-latam\\.ebanx\\.com$", "^sandbox\\.ebanxpay\\.com$"],
         encoding: "json",
         passthroughHeaders: []
     },
@@ -321,6 +363,8 @@ var PROCESSOR_DEFINITIONS = deepFreeze([
         // GPO Secure Forms. PAN@ card.number.
         match: "(secure\\.payu\\.com|(merch-prod|secure)\\.snd\\.payu\\.com)/api/front/tokens",
         hosts: ["^secure\\.payu\\.com$", "^(merch-prod|secure)\\.snd\\.payu\\.com$"],
+        sandboxHosts: ["^(merch-prod|secure)\\.snd\\.payu\\.com$"],
+        // .snd. is PayU's sandbox
         encoding: "json",
         // Native checkout attaches a bearer to tokenization; preserve it on replay.
         passthroughHeaders: ["^authorization$"]
@@ -382,6 +426,7 @@ var PROCESSOR_DEFINITIONS = deepFreeze([
         // card/tokenize uses a saved paymentToken, and 3DS-specific paths are unverified.
         match: "(?:api(\\.test)?\\.paysafe\\.com/(?:paymenthub/v1/singleusepaymenthandles|js/api/v1/tokenize)|hosted(\\.test)?\\.paysafe\\.com/checkout/api/v1/tokenize)(?![\\w/-])",
         hosts: ["^api\\.paysafe\\.com$", "^api\\.test\\.paysafe\\.com$", "^hosted\\.paysafe\\.com$", "^hosted\\.test\\.paysafe\\.com$"],
+        sandboxHosts: ["^api\\.test\\.paysafe\\.com$", "^hosted\\.test\\.paysafe\\.com$"],
         encoding: "json",
         passthroughHeaders: ["^authorization$", "^x-paysafe-credentials$", "^correlationid$"]
     },
@@ -425,6 +470,8 @@ var PROCESSOR_DEFINITIONS = deepFreeze([
             "^gatewayt\\.moneris\\.com$",
             "^gatewaydev\\.moneris\\.com$"
         ],
+        // Live: www3, gateway. Test/QA/dev: esqa, gatewayqa, gatewayt, gatewaydev.
+        sandboxHosts: ["^esqa\\.moneris\\.com$", "^gatewayqa\\.moneris\\.com$", "^gatewayt\\.moneris\\.com$", "^gatewaydev\\.moneris\\.com$"],
         encoding: "form",
         passthroughHeaders: []
     },
@@ -465,8 +512,66 @@ var PROCESSOR_DEFINITIONS = deepFreeze([
             "^apis\\.eu\\.globalpay\\.com$",
             "^apis\\.sandbox\\.eu\\.globalpay\\.com$"
         ],
+        // Heartland/Portico cert.* is the certification (sandbox) host; GP-API sandbox is apis.sandbox[.eu].
+        sandboxHosts: ["^cert\\.api2\\.heartlandportico\\.com$", "^apis\\.sandbox\\.globalpay\\.com$", "^apis\\.sandbox\\.eu\\.globalpay\\.com$"],
         encoding: "json",
         passthroughHeaders: ["^authorization$", "^x-gp-version$"]
+    },
+    // ── Encrypted on the device under a pinned key ────────────────────────────
+    {
+        psp: "fiserv",
+        // Fiserv Commerce Hub card capture from the Secure Data Capture (SDC) frame,
+        // the request Home Depot's OrangePay checkout sends (payment-fields.js and
+        // sdk-secure 3.8.14). The frame always encrypts: it seals the card with
+        // AES-256-GCM under a fresh key, wraps that key with RSA-OAEP-SHA256 under the
+        // public key the page passed it, and posts the envelope as
+        // source.encryptionData. It picks its endpoint by the page's auth type
+        // (iframe.js @85480): an AccessToken (Security Credentials) posts here, to
+        // card-capture; a Checkout Sessions JWT posts to /ch/checkouts/v1/payment-link
+        // instead. payment-link also carries the card, and it is left out on purpose:
+        // `match` names card-capture only, so a Sessions merchant's capture is never
+        // paused and fails as it does today. Fastlane (PaymentToken), ACH
+        // (PaymentCheck), gift and EBT captures share this URL, carry no Vault card,
+        // and the SDK continues them unpaused (fiserv.js isFiservPausableBody).
+        // The Wave 0 sandbox gate (2026-09-24, connect-cert, Fiserv simulator cards)
+        // settled the mode: card-capture refuses a plaintext source.card (400
+        // GATEWAY 302 "Missing or Invalid Encryption Data") and captures the frame's
+        // own envelope with no Origin, so the device builds that envelope under a
+        // key Agentcard pinned (fiserv-keys.js), the runtime writes its four members
+        // over the paused ones, and the capture continues from the agent's browser.
+        // The AccessToken the agent can read was refused on charges and tokens at
+        // Fiserv's edge in that sandbox. Every other Commerce Hub path is refused
+        // here: charges, tokens, security/keys, payment-link, and the non-production
+        // hosts (connect-dev, -qa, -uat, -test); resolveRecognizerForUrl also takes
+        // only the two endpoints written exactly (fiserv-environment.js). The
+        // envelope carries no timestamp or session binding, so it is approved by the
+        // cardholder every time: dark until an org is allowlisted, and autopilot
+        // refuses fiserv at all three gates.
+        capability: "fiserv_card_capture",
+        // A Fiserv card is sealed only for a capture the cardholder already approved
+        // through a prepare(): the backend refuses an unprepared create (409
+        // preparation_required), the internal buy loop never mints a Fiserv round,
+        // and the SDK refuses locally before it prompts.
+        preparationRequired: true,
+        match: "connect(?:-cert)?\\.fiservapis\\.com/ch/payments-vas/v1/card-capture(?![\\w/.-])",
+        hosts: ["^connect\\.fiservapis\\.com$", "^connect-cert\\.fiservapis\\.com$"],
+        sandboxHosts: ["^connect-cert\\.fiservapis\\.com$"],
+        // A live row reaches connect only and a test row connect-cert only, and
+        // connect-cert receives only documented test cards (device-replay.js).
+        hostEnvironmentPinned: true,
+        encoding: "json",
+        // The browser continues the capture with its own headers, so only the ones
+        // the backend checks against the body and the merchant are kept:
+        // Auth-Token-Type, the merchant and terminal ids, and the embedding frame's
+        // origin the SDC names (x-integration-origin, self-asserted). The
+        // AccessToken, the API key, Client-Request-Id and Timestamp are never stored.
+        passthroughHeaders: ["^auth-token-type$", "^x-integration-merchant-id$", "^x-integration-terminal-id$", "^x-integration-origin$"],
+        clientSideEncrypted: true,
+        mode: "cse",
+        cse: {
+            at: "source.encryptionData",
+            fields: ["keyId", "encryptedKey", "encryptionBlock", "aesIv"]
+        }
     }
 ]);
 var PSP_RECOGNIZERS = deepFreeze(PROCESSOR_DEFINITIONS.map(({ compose, encryptedCardFields, ...definition }) => definition));
@@ -476,17 +581,22 @@ var PSP_CLIENT_TABLE = deepFreeze(PROCESSOR_DEFINITIONS.map((definition) => ({
     hosts: definition.hosts.map((source) => new RegExp(source, "i")),
     encoding: definition.encoding,
     headers: definition.passthroughHeaders.map((source) => new RegExp(source, "i")),
+    ...definition.sandboxHosts ? { sandboxHosts: definition.sandboxHosts.map((source) => new RegExp(source, "i")) } : {},
+    ...definition.hostEnvironmentPinned ? { hostEnvironmentPinned: true } : {},
     ...definition.mode ? { mode: definition.mode } : {},
     ...definition.clientSideEncrypted ? { clientSideEncrypted: true } : {},
     ...definition.compose ? { compose: definition.compose } : {},
     ...definition.encryptedCardFields ? { cse: { fields: definition.encryptedCardFields } } : {},
     ...definition.hostedForm ? { form: definition.hostedForm.card } : {}
 })));
-var BUILTIN_REGISTRY = deepFreeze(PSP_RECOGNIZERS.map(({ cse, hostedForm, ...definition }) => ({
-    ...definition,
-    match: new RegExp(definition.match, "i"),
-    passthroughHeaders: definition.passthroughHeaders.map((source) => new RegExp(source, "i"))
-})));
+function buildBuiltinRegistry(recognizers) {
+    return recognizers.filter((definition) => !definition.capability).map(({ cse, hostedForm, ...definition }) => ({
+        ...definition,
+        match: new RegExp(definition.match, "i"),
+        passthroughHeaders: definition.passthroughHeaders.map((source) => new RegExp(source, "i"))
+    }));
+}
+var BUILTIN_REGISTRY = deepFreeze(buildBuiltinRegistry(PSP_RECOGNIZERS));
 var CHECKOUT_MODES = deepFreeze(["token", "cse", "hosted_form"]);
 function recognizerByPsp(psp) {
     return typeof psp === "string" ? PSP_CLIENT_TABLE.find((entry) => entry.psp === psp) ?? null : null;
@@ -498,6 +608,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 +711,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/dist/substitutions.generated.d.ts

@@ -7,4 +7,5 @@ declare var SubstitutionError: {
     };
 };
 declare function substituteEncryptedFields(body: any, sub: any): string;
-export { SubstitutionError, substituteEncryptedFields };
+declare function substituteMerchantHosted(body: any, sub: any, opts: any): string;
+export { SubstitutionError, substituteEncryptedFields, substituteMerchantHosted };