@agent-cards/sdk 0.23.12 → 0.23.13

package/CHANGELOG.md

@@ -4,6 +4,8 @@
 
 - Keep a Rapyd hosted page's id and a Stripe Checkout Session's id out of your events and error messages. Rapyd's checkout page sends the card to `/v1/checkout/checkout_<id>` on `api.rapyd.net` (a card page to `/v1/hosted/collect/card/hp_card_<id>/payment_method`) with no auth header, so the page's id is the only credential that request needs: anyone who holds it can read the page and post a card to it until it expires. Stripe Checkout confirms a session at `/v1/payment_pages/<session id>/confirm` with the merchant's publishable key, which is public, so the session id is what lets anyone confirm a payment on it. Earlier releases named both ids in the `card_request_paused` event and in the errors `authorize()` throws, so they reached your `onEvent` handler and every log that recorded the event or the error. `redactUrl`, every event and every error message now show them as `{token}` and `{session}`, as in `https://api.rapyd.net/v1/checkout/{token}` and `https://api.stripe.com/v1/payment_pages/{session}/confirm`. `redactUrl` also masks an ACI checkout id in the shapes it used to keep: a host with a trailing dot, an escaped or doubled slash, and a string that is not a URL. A PaymentIntent or SetupIntent id stays, since confirming one also needs its client_secret. No API or Vault release is needed.
 
+- Pay a store on Paysafe Checkout's current build, 1.16.1. The loader Paysafe tells merchants to include, `checkout/v1/latest`, now runs version 1.16.1, and that build sends the card to `api.paysafe.com/checkout/api/v1/tokenize` (`api.test.paysafe.com` in its test environment), where 1.8.0 sent it to `hosted.paysafe.com`. Earlier releases did not recognize that request, so it was never paused and the agent's placeholder card reached Paysafe. The SDK now pauses it and keeps the three headers the build sends beside its credential: `X-Internal-Correlation-Id`, `X-App-Version` and `X-TransactionSource`. Paysafe.js latest sends the same three, and its replay keeps them too. `prepare({ psp: 'paysafe' })` binds a request only to a Checkout build Agentcard read, by the version the request names: 1.8.0 on `hosted.paysafe.com`, or 1.16.1 on `api.paysafe.com`, each with its own headers. A request from any other build stops with `checkout_changed`, and nothing is sent. An SDK that syncs its registry pauses the 1.16.1 request once the API release deploys; a prepared 1.16.1 checkout needs this release. Both need a Vault release after 0.6.2.
+
 - Keep a Gravy checkout session out of your events and error messages. Gravy's Secure Fields send the card to `/checkout/sessions/<session id>/fields` on the merchant's Gravy host with no auth header, so the session id is the only credential that request needs: anyone who holds it can write card fields into the session until it expires. Earlier releases named the full URL in the `card_request_paused` event and in the error `authorize()` throws for a request in the wrong method, so the session id reached your `onEvent` handler and every log that recorded the event or the error. `redactUrl`, every event and every error message now show it as `{session}`, as in `https://api.<merchant>.gr4vy.app/checkout/sessions/{session}/fields`. No API or Vault release is needed.
 
 - Pay FlixBus's checkout on Payrails web SDK 6.7.0. FlixBus's page now loads web SDK 6.7.0 in place of 5.50.0, and 6.7.0's Pay now button sends the card-form payment without the `enrollInstrumentToNetworkOffers` member that 5.50.0 sent as `false`. 0.23.11 required that member and aborted every such payment as `unsupported_payrails_card_payment` before creating anything, so no FlixBus payment reached an approval. A payment that names no `enrollInstrumentToNetworkOffers` now pauses as 5.50.0's does: Payrails reads a missing flag as `false`, and 6.7.0 sends no other member in its place. A payment that sets the flag `true` or keeps the card (`storeInstrument: true`, or `meta.order.processingType` `CardOnFile` or `UnscheduledCardOnFile`) still aborts as `payrails_card_on_file_consent_required`, and the flag in another case, in another place or as anything but a boolean aborts as `unsupported_payrails_card_payment`. A payment also needs the matching API and Vault releases.
@@ -96,7 +98,7 @@
 
 - Read the card number on the D-EDGE card frame the way the frame groups each card network: 4-6-5 for an American Express number, 4-6-4 for a Diners Club number starting 36 or 300 to 305, and groups of four for any other. The SDK's copy of D-EDGE's rules read a grouped number only in groups of four, so an American Express or Diners Club placeholder as the frame groups it was not D-EDGE's reviewed card request, and the same number in groups of four, which the frame never posts, was. D-EDGE stays in `observe`, so its card post still gets the page that says Agentcard has not turned it on.
 
-- Pay a Paddle checkout that sends the card to Paddle's card vault, from Agentcard's own account only for now (dark launch): Agentcard turns it on for another company once it has confirmed that a card stored for one Paddle seller cannot pay another. On a checkout whose card method names VGS, Paddle's checkout frame on `buy.paddle.com` posts the card to `https://vault.paddle.com/cards` (`https://sandbox-vault.paddle.com/cards` in test) and sends that request once more when it gets no answer within 10 seconds, too soon for an approval after Pay. So the card is paid only through `prepare({ psp: 'paddle_vgs', environment: 'production' })` (`'sandbox'` for Paddle's sandbox) on an attachment whose `cardId` names the card whose `placeholderCard()` facts you typed into Paddle's form; without one, `prepare()` fails with `card_required`, and the approval is locked to that card. The sync now also asks for `capabilities=paddle_vgs_cards`. Once the cardholder approves, the frame's request pauses, the cardholder's device sends the card to Paddle's vault itself, and the frame receives the stored card's id and nothing else; the frame's second request after its 10-second timeout, the same body under the same bearer, gets the same answer, and any other request is refused. Paddle's request names no amount, so the cardholder approves the `amount` and `currency` you pass. The lane pays Visa, Mastercard and American Express cards: `prepare()` fails with `paddle_vgs_card_unsupported` for a card on another network, and the create fails with `paddle_vgs_card_mismatch` when the expiry or placeholder you typed is not the card's. On Paddle's live vault, Agentcard pays only a seller it has reviewed, at the checkout page it reviewed (Rectangle Pro at `https://rectangleapp.com` today), and the approval names that seller and says it can keep the card on file, because the card stays stored in Paddle's vault. Paddle's own `/pay` call, which follows the stored card's id, still carries the placeholder's first six and last four digits that you typed; whether Paddle accepts them beside the real card is not proven yet. A Paddle checkout that sends the card through TokenEx or Spreedly is not paid. No live payment has gone through this route yet. A payment also needs the matching API and Vault releases.
+- Pay a Paddle checkout that sends the card to Paddle's card vault, from Agentcard's own account only for now (dark launch): Agentcard turns it on for another company once it has confirmed that a card stored for one Paddle seller cannot pay another. On a checkout whose card method names VGS, Paddle's checkout frame on `buy.paddle.com` posts the card to `https://vault.paddle.com/cards` (`https://sandbox-vault.paddle.com/cards` in test) and sends that request once more when it gets no answer within 10 seconds, too soon for an approval after Pay. So the card is paid only through `prepare({ psp: 'paddle_vgs', environment: 'production' })` (`'sandbox'` for Paddle's sandbox) on an attachment whose `cardId` names the card whose `placeholderCard()` facts you typed into Paddle's form; without one, `prepare()` fails with `card_required`, and the approval is locked to that card. The sync now also asks for `capabilities=paddle_vgs_cards`. Once the cardholder approves, the frame's request pauses, the cardholder's device sends the card to Paddle's vault itself, and the frame receives the stored card's id and nothing else; the frame's second request after its 10-second timeout, the same body under the same bearer, gets the same answer, and any other request is refused. Paddle's request names no amount, so the cardholder approves the `amount` and `currency` you pass. The lane pays Visa, Mastercard and American Express cards: `prepare()` fails with `paddle_vgs_card_unsupported` for a card on another network, and the create fails with `paddle_vgs_card_mismatch` when the expiry or placeholder you typed is not the card's. On Paddle's live vault, Agentcard pays only a seller it has reviewed, at the checkout page it reviewed (Rectangle Pro at `https://rectangleapp.com` today), and the approval names that seller and says it can keep the card on file, because the card stays stored in Paddle's vault. Paddle's own `/pay` call, which follows the stored card's id, names the card it pays by its first six and last four digits, expiry and brand, and Paddle's form reads those from the placeholder you typed. The SDK writes the approved card's own over them, the details the cardholder's device read from the card, and changes nothing else in that call. A `/pay` that names another stored card, comes from another frame, comes more than a minute after the id reached the frame, or follows the first one is aborted, and Paddle charges nothing. A Paddle checkout that sends the card through TokenEx or Spreedly is not paid. No live payment has gone through this route yet. A payment also needs the matching API and Vault releases.
 
 ## 0.23.0
 

package/LICENSE

@@ -0,0 +1,38 @@
+Copyright (c) 2026 Agentcard Corporation. All rights reserved.
+
+This software, including its source, compiled and minified code, models,
+word lists, recognizers and data files (the "Software"), is proprietary to
+Agentcard Corporation and is licensed, not sold.
+
+You may install and run the Software only to use Agentcard's services, under
+the terms you accepted when you signed up for them. If you integrate
+Agentcard into an application, you may include the Software, unmodified and
+as Agentcard publishes it, in that application and distribute the application
+to your end users so they can use Agentcard's services through it; this
+license binds every copy you distribute that way. Otherwise you may not, and
+may not help or allow anyone else to:
+
+1. copy, modify, translate or create derivative works of the Software, except
+   for copies made automatically when installing and running it or included
+   in an application as the paragraph above allows;
+2. reverse engineer, decompile, disassemble, deobfuscate or otherwise try to
+   derive the source, models, thresholds, word lists, recognizers or data of
+   the Software, except to the extent applicable law expressly permits it
+   despite this restriction;
+3. extract, scrape or reuse the Software's data, including its merchant,
+   processor and passphrase data, in any other product or service;
+4. use the Software, or anything learned from studying it, to build, train,
+   tune or benchmark a product or service that competes with Agentcard, or to
+   defeat or imitate its security checks;
+5. redistribute, sublicense, sell, rent or publish the Software apart from an
+   application as the paragraph above allows, or remove this notice from it.
+
+Agentcard keeps dated fingerprints of the Software's data. A match in
+another product or data set is evidence that it was copied from the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED. IN NO EVENT SHALL AGENTCARD CORPORATION BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY ARISING FROM THE SOFTWARE OR ITS USE.
+
+Questions: legal@agentcard.sh

package/README.md

@@ -278,7 +278,7 @@ Coverage is specific to the processor request format, merchant setup, browser tr
 | WSPay Components (WSPay's build of Monri Components) | dark launch: the card frame's confirm of a new card, after `vault.syncRegistry()`, with `amount` and `currency`, and only for an org Agentcard has enabled; for any other org the SDK leaves WSPay's requests alone. The cardholder's device sends the card to WSPay and the frame receives WSPay's answer. A confirm that asks WSPay to keep the card on file, as Valamar's does on every booking, is paid only as a hotel's EUR 1.00 card guarantee with a card the cardholder stored. Validated in local Chromium against a model of the card frame; no WSPay sandbox run or live merchant purchase yet. See [Pay a WSPay Components checkout](#pay-a-wspay-components-checkout) |
 | Shiji STS (MyCheck Wallet V3; Wyndham's booking pages) | dark launch, mode `cse` under a pinned key, and only for an org Agentcard has enabled. The card token a hotel booking mints guarantees the stay, so the cardholder approves with a card they stored, under a line that says the hotel can keep it on file. See [Shiji STS](#shiji-sts-mycheck-wallet-v3) |
 | Amadeus Checkout (Air France, KLM) | dark: only for an org Agentcard enabled, and only through `prepare({ psp: 'amadeus_checkout', cardId })`. The Checkout Web SDK's card add pauses; every other action on its URL continues. Air France and KLM keep the expiry in their own form, so the agent types the stored card's real expiry there and the checkout pays only with that card. Every Data Collection Page store is refused as `amadeus_dcp_field_config_unreviewed`. No live purchase yet. See "Prepare an Amadeus Checkout card step" |
-| Paddle checkout (Paddle's card vault; Rectangle Pro) | dark launch: only in Agentcard's own account for now, after `vault.syncRegistry()`, and only through `prepare({ psp: 'paddle_vgs', environment: 'production' })` (`'sandbox'` for Paddle's sandbox) on an attachment whose `cardId` names the paying card; without one, `prepare()` fails with `card_required`. On a Paddle checkout whose card method names VGS, the frame's post to `vault.paddle.com/cards` pauses, the cardholder's device sends the card itself, and the frame receives the stored card's id; its second request after its 10-second timeout gets the same answer. Type `placeholderCard()`'s facts for that card into Paddle's form, and pass `amount` and `currency`, the total the cardholder approves. Only Visa, Mastercard and American Express cards are paid (`paddle_vgs_card_unsupported` otherwise), and a typed expiry or placeholder that is not the card's fails the create with `paddle_vgs_card_mismatch`. On the live vault only a reviewed seller at its reviewed page is paid (Rectangle Pro at `https://rectangleapp.com`), and the approval says that seller can keep the card on file. Paddle's `/pay` still carries the placeholder's first six and last four digits beside the stored card's id, and whether Paddle accepts them is not proven yet. A Paddle checkout that sends the card through TokenEx or Spreedly is not supported, and no live payment has gone through this route yet |
+| Paddle checkout (Paddle's card vault; Rectangle Pro) | dark launch: only in Agentcard's own account for now, after `vault.syncRegistry()`, and only through `prepare({ psp: 'paddle_vgs', environment: 'production' })` (`'sandbox'` for Paddle's sandbox) on an attachment whose `cardId` names the paying card; without one, `prepare()` fails with `card_required`. On a Paddle checkout whose card method names VGS, the frame's post to `vault.paddle.com/cards` pauses, the cardholder's device sends the card itself, and the frame receives the stored card's id; its second request after its 10-second timeout gets the same answer. Type `placeholderCard()`'s facts for that card into Paddle's form, and pass `amount` and `currency`, the total the cardholder approves. Only Visa, Mastercard and American Express cards are paid (`paddle_vgs_card_unsupported` otherwise), and a typed expiry or placeholder that is not the card's fails the create with `paddle_vgs_card_mismatch`. On the live vault only a reviewed seller at its reviewed page is paid (Rectangle Pro at `https://rectangleapp.com`), and the approval says that seller can keep the card on file. Paddle's `/pay` that follows names the approved card's first six and last four digits, expiry and brand: the SDK writes them over the ones Paddle's form read from the placeholder, and aborts a `/pay` that names another stored card or comes more than a minute later. A Paddle checkout that sends the card through TokenEx or Spreedly is not supported, and no live payment has gone through this route yet |
 
 The recognizer list, and the status of each reviewed Adyen merchant profile on
 your client, are fetched from the API at runtime (`agentcard.checkout.syncRegistry()`),

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|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$"], "sandboxHosts": ["^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$"], "sandboxHosts": ["^api\\.sandbox\\.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$"], "sandboxHosts": ["^checkoutshopper-test\\.adyen\\.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$"], "sandboxHosts": ["^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$"], "sandboxHosts": ["^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$"], "sandboxHosts": ["^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$"], "sandboxHosts": ["^ppp-test\\.safecharge\\.com$"], "encoding": "json", "passthroughHeaders": [], "jsonCardFields": [["paymentOption", "card", "cardNumber"], ["cardData", "cardNumber"]], "passWithoutCard": "(?:secure|ppp-test)\\.safecharge\\.com/ppp/api/v1/(?:clientPayment|websdk/initPaymentWithCardTokenization)\\.do" }, { "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$"], "sandboxHosts": ["^checkout\\.sandbox\\.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$"], "sandboxHosts": ["^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$"], "sandboxHosts": ["^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$"], "sandboxHosts": ["^sandbox\\.ebanx\\.com$", "^sandbox-local-latam\\.ebanx\\.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$"], "sandboxHosts": ["^(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$"], "sandboxHosts": ["^api\\.test\\.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": "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$"], "sandboxHosts": ["^cert\\.api2\\.heartlandportico\\.com$", "^apis\\.sandbox\\.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$"], "sandboxHosts": ["^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$"], "sandboxHosts": ["^api\\.sandbox\\.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$"], "sandboxHosts": ["^checkoutshopper-test\\.adyen\\.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$"], "sandboxHosts": ["^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$"], "sandboxHosts": ["^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$"], "sandboxHosts": ["^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$"], "sandboxHosts": ["^ppp-test\\.safecharge\\.com$"], "encoding": "json", "passthroughHeaders": [], "jsonCardFields": [["paymentOption", "card", "cardNumber"], ["cardData", "cardNumber"]], "passWithoutCard": "(?:secure|ppp-test)\\.safecharge\\.com/ppp/api/v1/(?:clientPayment|websdk/initPaymentWithCardTokenization)\\.do" }, { "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$"], "sandboxHosts": ["^checkout\\.sandbox\\.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$"], "sandboxHosts": ["^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$"], "sandboxHosts": ["^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$"], "sandboxHosts": ["^sandbox\\.ebanx\\.com$", "^sandbox-local-latam\\.ebanx\\.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$"], "sandboxHosts": ["^(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|checkout\/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$"], "sandboxHosts": ["^api\\.test\\.paysafe\\.com$", "^hosted\\.test\\.paysafe\\.com$"], "encoding": "json", "passthroughHeaders": [/^authorization$/i, /^x-paysafe-credentials$/i, /^correlationid$/i, /^x-internal-correlation-id$/i, /^x-app-version$/i, /^x-transactionsource$/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": "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$"], "sandboxHosts": ["^cert\\.api2\\.heartlandportico\\.com$", "^apis\\.sandbox\\.globalpay\\.com$", "^apis\\.sandbox\\.eu\\.globalpay\\.com$"], "encoding": "json", "passthroughHeaders": [/^authorization$/i, /^x-gp-version$/i] }];

package/dist/card-fields.generated.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 // Generated from @agent-cards/payment-core. Do not edit.
-// artifact-sha256: c8e0308b7790c3577c56ec0428577a42c308ccdbeff3eb041c6103d9e9b338a8
+// artifact-sha256: 5c2d8f5671c901ef8162e61e21996671a0e6e9ca235467ea7f6267274f5c3ee1
 // src/card-number-key.js
 var CARD_NUMBER_KEY = /^(number|card_number|cardnumber|cardNum|card_num|pan)$/i;
 // src/json-path.js
@@ -406,6 +406,8 @@ var pin2 = (fields) => Object.freeze({
 var PADDLE_VGS_MERCHANT_PINS = /* @__PURE__ */ Object.freeze([
     pin2({ id: "rectangle_pro", merchant: "Rectangle Pro", origins: ["https://rectangleapp.com"], sellerClaim: null })
 ]);
+var FACT_KEYS = /* @__PURE__ */ Object.freeze(["card_first_six", "card_last_four", "expiry_month", "expiry_year", "card_brand"]);
+var METADATA_KEYS = /* @__PURE__ */ Object.freeze(["cardholder_name", ...FACT_KEYS]);
 // src/card-fields.js
 function processorGate(recognizer, url, body) {
     if (recognizer && recognizer.psp === PADDLE_VGS_PSP) {

package/dist/cdp.js

@@ -11,6 +11,7 @@ import { EprotectGate } from './eprotect.js';
 import { dispatchPreClaim, eventUrl } from './pre-claim.js';
 import { GMO_TOKEN_V1_PATTERNS, gmoRequestShop, isGmoTokenV1Request, recognizesGmo } from './gmo.js';
 import { isPaddleVgsCardsUrl } from './paddle-vgs.generated.js';
+import { PADDLE_VGS_PAY_PATTERNS, PaddleVgsPayGate, isPaddleCheckoutService, recognizesPaddleVgs } from './paddle-vgs-pay.js';
 import { DatatransRepeats } from './datatrans.js';
 import { SHIJI_STS_COMPANION_WINDOW_MS, ShijiStsCompanions, ShijiStsError, isShijiStsHost, shijiStsTokenContinuation, } from './shiji-sts.js';
 import { isArmedEkashuUrl } from './ekashu.js';
@@ -1532,7 +1533,10 @@ function replayOf(result, timeoutMs) {
         || !response.headers || typeof response.headers !== 'object' || Array.isArray(response.headers)) {
         throw new Error('An approved token read resumes with response, the processor\'s answer (voice.awaitResult carries it once the purchase finished).');
     }
-    return { mode: 'token', authorizationId, status: response.status, headers: { ...response.headers }, body: response.body, amountVerified: null, ...execution };
+    // The read's processor_context rides as it came: a Paddle VGS answer is handed to the page only with the
+    // approved card's details its /pay names (paddle-vgs-pay.ts checks them before the hand-over).
+    return { mode: 'token', authorizationId, status: response.status, headers: { ...response.headers }, body: response.body, amountVerified: null,
+        ...(result.processor_context !== undefined ? { processorContext: result.processor_context } : {}), ...execution };
 }
 /** The recogniser that claimed a paused request, by processor name, so a caller never re-matches the URL; null on a duck-typed vault without the read. */
 function recognizerNameOf(opts, url, method) {
@@ -2019,6 +2023,10 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
     // committing a new document (Page.frameNavigated, at the top of the event handler).
     const shijiCompanions = new ShijiStsCompanions();
     lifecycle.abort.signal.addEventListener('abort', () => shijiCompanions.release(), { once: true });
+    // Paddle's /pay after the stored card's id this attachment handed a frame (paddle-vgs-pay.ts): its
+    // checkout services are held only when the synced registry serves Paddle VGS, and a cancel drops the binding.
+    const paddleVgsPay = new PaddleVgsPayGate(() => recognizesPaddleVgs(opts.vault));
+    lifecycle.abort.signal.addEventListener('abort', () => paddleVgsPay.release(), { once: true });
     const derived = typeof opts.vault?.cardUrlPatterns === 'function' ? opts.vault.cardUrlPatterns() : [];
     // The endpoint and siblings of every merchant profile this build reviewed
     // (merchant-hosted.ts), which a VaultClient arms from the start: a profile's card
@@ -2046,7 +2054,8 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
     const urlPatterns = [...new Set([...(derived.length > 0 ? derived : FALLBACK_CARD_PATTERNS), ...guards.patterns,
             ...(stripeCheckout.isEnabled() ? ['https://api.stripe.com/*'] : []), MERCADO_CHECKOUT_PATTERN, ...merchantPatterns,
             ...(recognizesGmo(opts.vault) ? GMO_TOKEN_V1_PATTERNS : []), ...juspayCheckout.urlPatterns(), ...cardEndpointPatterns(),
-            ...(payrails ? PAYRAILS_GUARD_PATTERNS : []), ...PAYPAL_HOSTED_FIELDS_PATTERNS, ...CYBERSOURCE_SECURE_ACCEPTANCE_PATTERNS])];
+            ...(payrails ? PAYRAILS_GUARD_PATTERNS : []), ...PAYPAL_HOSTED_FIELDS_PATTERNS, ...CYBERSOURCE_SECURE_ACCEPTANCE_PATTERNS,
+            ...(recognizesPaddleVgs(opts.vault) ? PADDLE_VGS_PAY_PATTERNS : [])])];
     const arm = async (sessionId, resume = false, worker = false) => {
         const key = sessionId ?? '__root__';
         if (armed.has(key))
@@ -2480,6 +2489,7 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             payrails,
             shijiSts: { companions: shijiCompanions, page: () => cdpShijiPage(sessionId, frameId) },
             worldlineMyCheckout: worldlineProducts,
+            paddleVgsPay,
         });
         const preClaim = preClaimResult instanceof Promise ? await preClaimResult : preClaimResult;
         if (preClaim.kind !== 'pause')
@@ -2901,6 +2911,15 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 // device_encrypt answer (Payrails' 201, which the device obtained) is
                 // handed over the same way.
                 const cors = corsDecision(deliverRequest.url, deliverRequest.headers);
+                // A Paddle card request's answer is the stored card's id: the frame's /pay that follows continues only
+                // with the approved card's details, bound to that frame before the id reaches it (paddle-vgs-pay.ts).
+                // An answer that came with no details is not handed over: its /pay could only name the placeholder.
+                try {
+                    paddleVgsPay.arm(activeRequest?.frameId || undefined, deliverRequest.url, replay);
+                }
+                catch {
+                    throw new PaymentOutcomeUnknownError(replay.authorizationId, 'paddle_vgs_card_facts_unavailable');
+                }
                 await cdp.send('Fetch.fulfillRequest', {
                     requestId: deliverTo,
                     responseCode: replay.status,
@@ -3131,6 +3150,9 @@ export async function attachToPlaywright(page, opts) {
     // a new document (the handlers below).
     const shijiCompanions = new ShijiStsCompanions();
     lifecycle.abort.signal.addEventListener('abort', () => shijiCompanions.release(), { once: true });
+    // Paddle's /pay after the stored card's id this attachment handed a frame, as attachToCdp binds it.
+    const paddleVgsPay = new PaddleVgsPayGate(() => recognizesPaddleVgs(opts.vault));
+    lifecycle.abort.signal.addEventListener('abort', () => paddleVgsPay.release(), { once: true });
     // An answer to a request the facts watch records began to arrive: the watch orders what the page sent after a
     // record by this moment, since Playwright reports the answer's end after the page's next request. Listened to only
     // once the page sent such a request, so a page that never meets a merchant with facts carries no extra listener.
@@ -3388,7 +3410,9 @@ export async function attachToPlaywright(page, opts) {
             // PayPal's legacy Hosted Fields confirm, for every org, as attachToCdp arms it (paypal-hosted-fields.ts).
             || isPaypalHostedFieldsConfirm(url.toString())
             // CyberSource Secure Acceptance's /silent/ paths, for every org, as attachToCdp arms them (cybersource-secure-acceptance.ts).
-            || isCybersourceSecureAcceptanceUrl(url.toString()), async (route) => {
+            || isCybersourceSecureAcceptanceUrl(url.toString())
+            // Paddle's checkout services, routed only for an org the API served Paddle VGS to (see attachToCdp).
+            || (isPaddleCheckoutService(url.toString()) && recognizesPaddleVgs(opts.vault)), async (route) => {
             const request = route.request();
             // When this request paused, and the page it came from: the merchant's total is read as of now.
             const pausedAt = Date.now();
@@ -3485,6 +3509,7 @@ export async function attachToPlaywright(page, opts) {
                 payrails,
                 shijiSts: { companions: shijiCompanions, page: async () => (await playwrightShijiDocumentPage(request)) ?? `pw:none:${++playwrightShijiSeq}` },
                 worldlineMyCheckout: worldlineProducts,
+                paddleVgsPay,
             });
             const preClaim = preClaimResult instanceof Promise ? await preClaimResult : preClaimResult;
             if (preClaim.kind !== 'pause')
@@ -3847,6 +3872,13 @@ export async function attachToPlaywright(page, opts) {
                     // none; written here anyway (replacing a stale value) so a
                     // cross-origin answer is the same whichever adapter ran.
                     const cors = corsDecision(deliverRequest.url(), deliverRequest.headers());
+                    // See the same step in attachToCdp: a Paddle stored card's id reaches its frame only with its /pay bound.
+                    try {
+                        paddleVgsPay.arm(frameOf(deliverRequest), deliverRequest.url(), replay);
+                    }
+                    catch {
+                        throw new PaymentOutcomeUnknownError(replay.authorizationId, 'paddle_vgs_card_facts_unavailable');
+                    }
                     await deliverTo.fulfill({ status: replay.status, headers: withCorsHeaders(replay.headers, cors.headers), body: replay.body });
                     datatransRepeats.remember(frameOf(deliverRequest), deliverRequest.url(), deliverBody, replay);
                     assertRequestLive();

package/dist/client.d.ts

@@ -251,7 +251,10 @@ export interface ExecutionMetadata {
  * this is the processor's answer to replay into the paused request.
  */
 export interface TokenReplay extends ExecutionMetadata {
-    /** Authenticated selected-card metadata; the processor response body stays unchanged. */
+    /**
+     * Authenticated selected-card metadata; the processor response body stays unchanged. Paddle VGS: the
+     * approved card's first six and last four digits, expiry and brand, which the frame's /pay names.
+     */
     processorContext?: unknown;
     /** Present only after validating the native TEST Checkout completion. */
     checkoutSessionId?: string;

package/dist/client.js

@@ -14,7 +14,7 @@ import { creditguardPageProcessUrl, creditguardPpDomainHost, creditguardPreparat
 import { CONVERGE_CAPABILITY } from './elavon-converge.js';
 import { SHIJI_STS_CAPABILITY, SHIJI_STS_PSP, isShijiStsServedCompanion, isShijiStsServedSubstitution } from './shiji-sts.js';
 import { AMADEUS_CHECKOUT_CAPABILITY, AMADEUS_CHECKOUT_PSP } from './amadeus-checkout.generated.js';
-import { PADDLE_VGS_CAPABILITY, PADDLE_VGS_PSP } from './paddle-vgs.generated.js';
+import { PADDLE_VGS_CAPABILITY, PADDLE_VGS_PSP, paddleVgsCardFactsOf } from './paddle-vgs.generated.js';
 import { classifyStripeCheckoutRequest, encodeStripeCheckoutContext, hasStripeCheckoutMarker, parseStripeCheckoutContext, parseStripeCheckoutResponse, STRIPE_CHECKOUT_CONTEXT_HEADER, } from './stripe-checkout.generated.js';
 import { VoiceModule } from './voice.js';
 import { BuyModule } from './buy.js';
@@ -2620,6 +2620,14 @@ export class VaultClient {
                             throw new PaymentOutcomeUnknownError(authorizationId, 'mercado_checkout_metadata_invalid');
                         }
                     }
+                    else if (rec?.psp === PADDLE_VGS_PSP) {
+                        // Paddle VGS: the approved card's details the phone read from the card it stored at VGS, which the
+                        // frame's /pay names in place of the placeholder's (paddle-vgs-pay.ts). Exactly those five, or the
+                        // stored card's id never reaches the frame.
+                        processorContext = paddleVgsCardFactsOf(s.processor_context) ?? undefined;
+                        if (!processorContext)
+                            throw new PaymentOutcomeUnknownError(authorizationId, 'paddle_vgs_card_facts_unavailable');
+                    }
                     else if (s.processor_context !== undefined)
                         throw new PaymentOutcomeUnknownError(authorizationId, 'unexpected_processor_context');
                     return {

package/dist/lifecycle.d.ts

@@ -4,6 +4,7 @@ import type { PayrailsUnsupportedReason } from './payrails.js';
 import type { Substitutions } from './substitute.js';
 import type { GmoUnsupportedReason } from './gmo.js';
 import type { ShijiStsUnsupportedReason } from './shiji-sts.js';
+import type { PaddleVgsPayRefusal } from './paddle-vgs-pay.js';
 /** The application's resolver confirmed the payment for this checkout authorization. */
 export interface MerchantPaymentConfirmation {
     kind: 'merchant_payment';
@@ -91,6 +92,11 @@ export interface ResumeResult {
         headers: Record<string, string>;
         body: string;
     };
+    /**
+     * The read's `processor_context`, as the API serves it. A Paddle VGS read carries the approved card's
+     * details here, which the frame's /pay names; without them the stored card's id is never handed to the page.
+     */
+    processor_context?: unknown;
     substitutions?: Substitutions;
     submitted_at?: string;
     execution_mode?: string;
@@ -239,9 +245,12 @@ export declare class CheckoutLifecycle implements CheckoutController {
      * over (unsupported_paypal_hosted_fields, paypal-hosted-fields.ts), or a card
      * a merchant's page posts to CyberSource Secure Acceptance's Silent Order
      * POST, which no Vault mode takes over either
-     * (unsupported_cybersource_secure_acceptance, cybersource-secure-acceptance.ts).
+     * (unsupported_cybersource_secure_acceptance, cybersource-secure-acceptance.ts), or a
+     * Paddle /pay naming a stored card that its binding does not continue (the
+     * paddle-vgs-pay.ts reasons): once an approval exists the state keeps it, and only the
+     * hold changes.
      */
-    unsupported(reason?: 'unrecognized_payment_endpoint' | 'merchant_profile_observe' | 'merchant_request_unsupported' | GmoUnsupportedReason | 'microform_unsupported' | 'juspay_request_unsupported' | 'merchant_card_endpoint_not_enabled' | 'merchant_card_endpoint_resend_refused' | 'creditguard_three_d_secure' | 'unsupported_primer_sdk' | 'unsupported_primer_request' | PayrailsUnsupportedReason | ShijiStsUnsupportedReason | 'processor_card_page' | 'unsupported_paypal_hosted_fields' | 'unsupported_cybersource_secure_acceptance'): void;
+    unsupported(reason?: 'unrecognized_payment_endpoint' | 'merchant_profile_observe' | 'merchant_request_unsupported' | GmoUnsupportedReason | 'microform_unsupported' | 'juspay_request_unsupported' | 'merchant_card_endpoint_not_enabled' | 'merchant_card_endpoint_resend_refused' | 'creditguard_three_d_secure' | 'unsupported_primer_sdk' | 'unsupported_primer_request' | PayrailsUnsupportedReason | ShijiStsUnsupportedReason | 'processor_card_page' | 'unsupported_paypal_hosted_fields' | 'unsupported_cybersource_secure_acceptance' | PaddleVgsPayRefusal): void;
     /**
      * A card request that only a prepared checkout pays (an Adyen merchant
      * profile's, or a Fiserv card capture) arrived with no preparation on this

package/dist/lifecycle.js

@@ -238,7 +238,10 @@ export class CheckoutLifecycle {
      * over (unsupported_paypal_hosted_fields, paypal-hosted-fields.ts), or a card
      * a merchant's page posts to CyberSource Secure Acceptance's Silent Order
      * POST, which no Vault mode takes over either
-     * (unsupported_cybersource_secure_acceptance, cybersource-secure-acceptance.ts).
+     * (unsupported_cybersource_secure_acceptance, cybersource-secure-acceptance.ts), or a
+     * Paddle /pay naming a stored card that its binding does not continue (the
+     * paddle-vgs-pay.ts reasons): once an approval exists the state keeps it, and only the
+     * hold changes.
      */
     unsupported(reason = 'unrecognized_payment_endpoint') {
         this.held = true;

package/dist/paddle-vgs-pay.d.ts

@@ -0,0 +1,55 @@
+import type { ReplayResponse } from './client.js';
+/**
+ * Why a /pay naming a stored card was aborted, reported as the `reason` of the `unsupported_checkout` event:
+ *   paddle_vgs_pay_unbound        this attachment handed no stored card's id to the frame that sent it
+ *   paddle_vgs_pay_expired        it came more than a minute after the id reached the frame
+ *   paddle_vgs_pay_used           the one /pay for that id already went
+ *   paddle_vgs_pay_card_mismatch  it names another stored card, or the other environment's checkout service
+ *   paddle_vgs_pay_unsupported    anything else payment-core's rule refuses: another shape, a card saved at
+ *                                 Paddle for later, a network the frame chose from the typed card
+ */
+export type PaddleVgsPayRefusal = 'paddle_vgs_pay_unbound' | 'paddle_vgs_pay_expired' | 'paddle_vgs_pay_used' | 'paddle_vgs_pay_card_mismatch' | 'paddle_vgs_pay_unsupported';
+/** The patterns attachToCdp holds Paddle's two checkout services under, only for an attachment the API served Paddle VGS to. */
+export declare const PADDLE_VGS_PAY_PATTERNS: readonly string[];
+/** Whether `url` is on one of Paddle's two checkout services: what attachToPlaywright routes, once served. */
+export declare function isPaddleCheckoutService(url: string): boolean;
+/** Whether the synced registry serves Paddle VGS's card request: an org Agentcard turned Paddle on for. */
+export declare function recognizesPaddleVgs(vault: {
+    isCardRequest?: (url: string, method?: string) => boolean;
+} | null | undefined): boolean;
+/** The URL an event names for a /pay: its origin and path, with the checkout's id as {checkout}. */
+export declare function paddleVgsPayEventUrl(url: string): string;
+/**
+ * One attachment's /pay binding: at most one, to the stored card's id it last handed a Paddle frame. `arm` runs
+ * right before the id is handed over, `release` when the attachment is cancelled, and `judge` for every request
+ * to Paddle's checkout services. `served` says whether the synced registry serves Paddle VGS; it is asked only
+ * about a POST to /pay, so no other request reads the registry here.
+ */
+export declare class PaddleVgsPayGate {
+    private readonly served;
+    private readonly now;
+    private bound;
+    constructor(served: () => boolean, now?: () => number);
+    /** Whether the gate judges this request: a POST to /pay, on an attachment the API served Paddle VGS to. */
+    holds(url: string, method: string): boolean;
+    /**
+     * Bind the next /pay of `frame`, the frame about to receive `replay` for its card request to `cardsUrl`, to the
+     * stored card's id in the replay and the approved card's facts the API served beside it. Does nothing for a
+     * request to anything but Paddle's card vault. Throws when the frame is unknown, or the replay carries no id or
+     * no facts payment-core reads: the id must then not reach the frame, since its /pay could only carry the
+     * placeholder's facts.
+     */
+    arm(frame: unknown, cardsUrl: string, replay: ReplayResponse): void;
+    /** Drop the binding: no /pay continues with these facts after this. */
+    release(): void;
+    /**
+     * What becomes of a request to Paddle's checkout services: null when it is not a /pay naming a stored card (it
+     * continues untouched), the body to continue it with (payment-core paddleVgsPayVerdict), or why it is aborted.
+     * The binding answers one /pay: the first one from its frame continues or is refused, and either way ends it.
+     */
+    judge(frame: unknown, url: string, method: string, body: string | null): {
+        body: string;
+    } | {
+        reason: PaddleVgsPayRefusal;
+    } | null;
+}

package/dist/paddle-vgs-pay.js

@@ -0,0 +1,115 @@
+// Paddle's /pay, the request that charges the card the cardholder's phone stored at VGS, as the SDK sees it
+// (payment-core paddle-vgs.js has the request's shape and the rule).
+//
+// Once the SDK hands the stored card's id to Paddle's checkout frame, the frame posts /pay to its checkout
+// service with that id beside card facts it read from the number typed into its own form: on this lane the
+// agent's placeholder, so the placeholder's first six, last four and brand. This build holds that /pay and
+// writes over those five values the approved card's own, which the phone read from the card it sent to VGS and
+// the API served with the id (payment-core paddleVgsPayVerdict). Every other byte goes as the frame wrote it.
+//
+// The binding: the frame that received the stored card's id, the id, the vault's environment and the approved
+// card's facts, for PADDLE_VGS_CARD_ID_WINDOW_MS after the hand-over, for one /pay. A /pay naming a stored card
+// is aborted, so Paddle charges nothing, when this attachment handed no id to that frame
+// (paddle_vgs_pay_unbound), after the window (paddle_vgs_pay_expired), after the one /pay already went
+// (paddle_vgs_pay_used), or when payment-core's rule refuses it: another stored card or environment
+// (paddle_vgs_pay_card_mismatch), or any other shape (paddle_vgs_pay_unsupported). A /pay naming no stored card
+// (PayPal, a wallet) carries none of the cardholder's cards and continues untouched.
+//
+// Nothing is decided without the registry: an attachment the API did not serve Paddle VGS to never holds
+// Paddle's checkout service, so its /pay continues untouched, exactly as before.
+import { PADDLE_VGS_CARD_ID_WINDOW_MS, PADDLE_VGS_CARDS_URLS, paddleVgsCardFactsOf, paddleVgsEnvironment, paddleVgsPayCarriesStoredCard, paddleVgsPayTarget, paddleVgsPayVerdict, } from './paddle-vgs.generated.js';
+const CHECKOUT_SERVICES = ['https://checkout-service.paddle.com', 'https://sandbox-checkout-service.paddle.com'];
+/** The patterns attachToCdp holds Paddle's two checkout services under, only for an attachment the API served Paddle VGS to. */
+export const PADDLE_VGS_PAY_PATTERNS = CHECKOUT_SERVICES.map((origin) => `${origin}/*`);
+/** Whether `url` is on one of Paddle's two checkout services: what attachToPlaywright routes, once served. */
+export function isPaddleCheckoutService(url) {
+    try {
+        return CHECKOUT_SERVICES.includes(new URL(url).origin);
+    }
+    catch {
+        return false;
+    }
+}
+/** Whether the synced registry serves Paddle VGS's card request: an org Agentcard turned Paddle on for. */
+export function recognizesPaddleVgs(vault) {
+    if (!vault || typeof vault.isCardRequest !== 'function')
+        return false;
+    try {
+        return vault.isCardRequest(PADDLE_VGS_CARDS_URLS.production, 'POST') || vault.isCardRequest(PADDLE_VGS_CARDS_URLS.sandbox, 'POST');
+    }
+    catch {
+        return false;
+    }
+}
+/** The URL an event names for a /pay: its origin and path, with the checkout's id as {checkout}. */
+export function paddleVgsPayEventUrl(url) {
+    return url.replace(/^(https:\/\/[^/]+\/(?:checkout|transaction-checkout)\/)[^/]+(\/pay)$/, '$1{checkout}$2');
+}
+const known = (frame) => frame !== undefined && frame !== null && frame !== '';
+/**
+ * One attachment's /pay binding: at most one, to the stored card's id it last handed a Paddle frame. `arm` runs
+ * right before the id is handed over, `release` when the attachment is cancelled, and `judge` for every request
+ * to Paddle's checkout services. `served` says whether the synced registry serves Paddle VGS; it is asked only
+ * about a POST to /pay, so no other request reads the registry here.
+ */
+export class PaddleVgsPayGate {
+    served;
+    now;
+    bound = null;
+    constructor(served, now = Date.now) {
+        this.served = served;
+        this.now = now;
+    }
+    /** Whether the gate judges this request: a POST to /pay, on an attachment the API served Paddle VGS to. */
+    holds(url, method) {
+        return String(method).toUpperCase() === 'POST' && paddleVgsPayTarget(url) !== null && this.served();
+    }
+    /**
+     * Bind the next /pay of `frame`, the frame about to receive `replay` for its card request to `cardsUrl`, to the
+     * stored card's id in the replay and the approved card's facts the API served beside it. Does nothing for a
+     * request to anything but Paddle's card vault. Throws when the frame is unknown, or the replay carries no id or
+     * no facts payment-core reads: the id must then not reach the frame, since its /pay could only carry the
+     * placeholder's facts.
+     */
+    arm(frame, cardsUrl, replay) {
+        const environment = paddleVgsEnvironment(cardsUrl);
+        if (environment === null)
+            return;
+        this.release();
+        const token = replay.mode === undefined || replay.mode === 'token' ? replay : null;
+        const facts = token ? paddleVgsCardFactsOf(token.processorContext) : null;
+        let cardId = null;
+        try {
+            cardId = token ? JSON.parse(token.body)?.data?.id : null;
+        }
+        catch {
+            cardId = null;
+        }
+        if (!known(frame) || !facts || typeof cardId !== 'string')
+            throw new Error('paddle_vgs_card_facts_unavailable');
+        this.bound = { frame, environment, cardId, facts, until: this.now() + PADDLE_VGS_CARD_ID_WINDOW_MS, used: false };
+    }
+    /** Drop the binding: no /pay continues with these facts after this. */
+    release() {
+        this.bound = null;
+    }
+    /**
+     * What becomes of a request to Paddle's checkout services: null when it is not a /pay naming a stored card (it
+     * continues untouched), the body to continue it with (payment-core paddleVgsPayVerdict), or why it is aborted.
+     * The binding answers one /pay: the first one from its frame continues or is refused, and either way ends it.
+     */
+    judge(frame, url, method, body) {
+        if (!this.holds(url, method) || !paddleVgsPayCarriesStoredCard(body))
+            return null;
+        const bound = this.bound;
+        if (!bound || !known(frame) || frame !== bound.frame)
+            return { reason: 'paddle_vgs_pay_unbound' };
+        if (bound.used)
+            return { reason: 'paddle_vgs_pay_used' };
+        bound.used = true;
+        if (this.now() > bound.until)
+            return { reason: 'paddle_vgs_pay_expired' };
+        const verdict = paddleVgsPayVerdict({ url, method, body }, { environment: bound.environment, cardId: bound.cardId, facts: bound.facts });
+        return verdict.verdict === 'continue' ? { body: verdict.body } : { reason: verdict.code };
+    }
+}

package/dist/paddle-vgs.generated.d.ts

@@ -47,4 +47,32 @@ declare function paddleVgsAnswerOutcome(status: any, text: any, card: any): {
     reason?: undefined;
     code?: undefined;
 };
-export { PADDLE_VGS_CAPABILITY, PADDLE_VGS_CARDS_URLS, PADDLE_VGS_CARD_NETWORKS, PADDLE_VGS_CONTENT_TYPE, PADDLE_VGS_MERCHANT_PINS, PADDLE_VGS_OPERATION, PADDLE_VGS_PSP, PADDLE_VGS_REFUSAL_CODES, injectPaddleVgsCard, isPaddleVgsCardsUrl, isPreparedPaddleVgsRequest, paddleVgsAnswerOutcome, paddleVgsBodyVerdict, paddleVgsCardRefusal, paddleVgsEnvironment, paddleVgsMerchantPin, paddleVgsMerchantRefusal, paddleVgsRefusalCode, paddleVgsRefusalMessage, paddleVgsRequestRefusal, paddleVgsSellerClaimsPinned, paddleVgsStoredCardRefusal, paddleVgsTypedCardRefusal };
+declare var PADDLE_VGS_CARD_ID_WINDOW_MS: number;
+declare function paddleVgsPayTarget(url: any): Readonly<{
+    environment: "production" | "sandbox";
+    line: "classic" | "billing";
+}> | null;
+declare function paddleVgsPayCarriesStoredCard(body: any): boolean;
+declare function paddleVgsCardFacts(card: any): Readonly<{
+    card_first_six: string;
+    card_last_four: string;
+    expiry_month: number;
+    expiry_year: number;
+    card_brand: "visa" | "master" | "american_express";
+}>;
+declare function paddleVgsCardFactsOf(value: any): Readonly<{
+    card_first_six: any;
+    card_last_four: string;
+    expiry_month: any;
+    expiry_year: any;
+    card_brand: any;
+}> | null;
+declare function paddleVgsCardFactsAgree(facts: any, stored: any): boolean;
+declare function paddleVgsPayVerdict(request: any, approved: any): Readonly<{
+    verdict: "refuse";
+    code: any;
+}> | Readonly<{
+    verdict: "continue";
+    body: string;
+}>;
+export { PADDLE_VGS_CAPABILITY, PADDLE_VGS_CARDS_URLS, PADDLE_VGS_CARD_ID_WINDOW_MS, PADDLE_VGS_CARD_NETWORKS, PADDLE_VGS_CONTENT_TYPE, PADDLE_VGS_MERCHANT_PINS, PADDLE_VGS_OPERATION, PADDLE_VGS_PSP, PADDLE_VGS_REFUSAL_CODES, injectPaddleVgsCard, isPaddleVgsCardsUrl, isPreparedPaddleVgsRequest, paddleVgsAnswerOutcome, paddleVgsBodyVerdict, paddleVgsCardFacts, paddleVgsCardFactsAgree, paddleVgsCardFactsOf, paddleVgsCardRefusal, paddleVgsEnvironment, paddleVgsMerchantPin, paddleVgsMerchantRefusal, paddleVgsPayCarriesStoredCard, paddleVgsPayTarget, paddleVgsPayVerdict, paddleVgsRefusalCode, paddleVgsRefusalMessage, paddleVgsRequestRefusal, paddleVgsSellerClaimsPinned, paddleVgsStoredCardRefusal, paddleVgsTypedCardRefusal };

package/dist/paddle-vgs.generated.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 // Generated from @agent-cards/payment-core. Do not edit.
-// artifact-sha256: b33914c3bb882b868a28a7d7abb91d6cca450c0145dca0aa338474400b6f923e
+// artifact-sha256: f3437a15e11b72b9958179cc9610fdafb411cc5db76be536af62c08360a45575
 // src/paddle-vgs.js
 var PADDLE_VGS_PSP = "paddle_vgs";
 var PADDLE_VGS_CAPABILITY = "paddle_vgs_cards";
@@ -254,12 +254,12 @@ function readAnswer(text) {
         return null;
     }
 }
+var isStoredCardId = (id) => typeof id === "string" && STORED_CARD_ID.test(id) && /[A-Za-z]/.test(id) && !PAN_LIKE.test(id);
 function storedCardId(answer) {
     const data = answer && answer.data;
-    if (!record(data) || data.type !== "cards" || typeof data.id !== "string")
+    if (!record(data) || data.type !== "cards")
         return null;
-    const id = data.id;
-    return STORED_CARD_ID.test(id) && /[A-Za-z]/.test(id) && !PAN_LIKE.test(id) ? id : null;
+    return isStoredCardId(data.id) ? data.id : null;
 }
 var boundedCode = (value) => typeof value === "string" && REFUSAL_CODE.test(value) && (value.match(/[0-9]/g) ?? []).length <= MAX_CODE_DIGITS ? value : null;
 function paddleVgsRefusalCode(text) {
@@ -286,4 +286,123 @@ function paddleVgsAnswerOutcome(status, text, card) {
         return { outcome: "unknown", reason: "paddle_vgs_unsafe_response" };
     return { outcome: "approved", body: JSON.stringify({ data: { type: "cards", id } }) };
 }
-export { PADDLE_VGS_CAPABILITY, PADDLE_VGS_CARDS_URLS, PADDLE_VGS_CARD_NETWORKS, PADDLE_VGS_CONTENT_TYPE, PADDLE_VGS_MERCHANT_PINS, PADDLE_VGS_OPERATION, PADDLE_VGS_PSP, PADDLE_VGS_REFUSAL_CODES, injectPaddleVgsCard, isPaddleVgsCardsUrl, isPreparedPaddleVgsRequest, paddleVgsAnswerOutcome, paddleVgsBodyVerdict, paddleVgsCardRefusal, paddleVgsEnvironment, paddleVgsMerchantPin, paddleVgsMerchantRefusal, paddleVgsRefusalCode, paddleVgsRefusalMessage, paddleVgsRequestRefusal, paddleVgsSellerClaimsPinned, paddleVgsStoredCardRefusal, paddleVgsTypedCardRefusal };
+var PADDLE_VGS_CARD_ID_WINDOW_MS = 6e4;
+var PAY_URL = /^https:\/\/(sandbox-)?checkout-service\.paddle\.com\/(checkout|transaction-checkout)\/[A-Za-z0-9_-]{1,64}\/pay$/;
+function paddleVgsPayTarget(url) {
+    const match = typeof url === "string" ? PAY_URL.exec(url) : null;
+    return match ? Object.freeze({ environment: match[1] ? "sandbox" : "production", line: match[2] === "checkout" ? "classic" : "billing" }) : null;
+}
+function paddleVgsPayCarriesStoredCard(body) {
+    if (typeof body !== "string")
+        return true;
+    try {
+        return JSON.stringify(JSON.parse(body)).includes('"vgs_card"');
+    }
+    catch {
+        return true;
+    }
+}
+var FRAME_BRANDS = /* @__PURE__ */ Object.freeze(["visa", "master", "american_express", "discover", "diners_club", "jcb", "maestro", "dankort", "unionpay", "unknown"]);
+var PAY_BRANDS = /* @__PURE__ */ Object.freeze({ visa: "visa", mastercard: "master", amex: "american_express" });
+var FACT_KEYS = /* @__PURE__ */ Object.freeze(["card_first_six", "card_last_four", "expiry_month", "expiry_year", "card_brand"]);
+var FIRST_SIX = /^[0-9]{6}$/;
+var LAST_FOUR = /^[0-9]{4}$/;
+var fullYear = (year) => {
+    const value = Number(year);
+    return Number.isInteger(value) && value >= 0 && value <= 99 ? 2e3 + value : value;
+};
+var expiryMonth = (month) => Number.isInteger(month) && month >= 1 && month <= 12;
+var expiryYear = (year) => Number.isInteger(year) && year >= 2e3 && year <= 2099;
+function paddleVgsCardFacts(card) {
+    const number = card ? String(card.number) : "";
+    const network = cardNetwork(number);
+    const month = card ? Number(card.month) : NaN;
+    const year = card ? fullYear(card.year) : NaN;
+    if (network === null || !expiryMonth(month) || !expiryYear(year))
+        throw new Error("Could not read this card's details for Paddle. Nothing was sent.");
+    return Object.freeze({ card_first_six: number.slice(0, 6), card_last_four: number.slice(-4), expiry_month: month, expiry_year: year, card_brand: PAY_BRANDS[network] });
+}
+function paddleVgsCardFactsOf(value) {
+    if (!record(value))
+        return null;
+    const keys = Object.keys(value);
+    if (keys.length !== FACT_KEYS.length || !FACT_KEYS.every((key) => keys.includes(key)))
+        return null;
+    const { card_first_six: firstSix, card_last_four: lastFour, expiry_month: month, expiry_year: year, card_brand: brand } = value;
+    const network = typeof firstSix === "string" && FIRST_SIX.test(firstSix) ? cardNetwork(`${firstSix}000000`) : null;
+    if (network === null || PAY_BRANDS[network] !== brand || typeof lastFour !== "string" || !LAST_FOUR.test(lastFour) || !expiryMonth(month) || !expiryYear(year))
+        return null;
+    return Object.freeze({ card_first_six: firstSix, card_last_four: lastFour, expiry_month: month, expiry_year: year, card_brand: brand });
+}
+function paddleVgsCardFactsAgree(facts, stored) {
+    const read = paddleVgsCardFactsOf(facts);
+    if (!read)
+        return false;
+    const card = record(stored) ? stored : {};
+    const network = Object.keys(PAY_BRANDS).find((name) => PAY_BRANDS[name] === read.card_brand);
+    const brand = storedBrand(card.brand);
+    return !(typeof card.last4 === "string" && LAST_FOUR.test(card.last4) && card.last4 !== read.card_last_four) && (brand === null || brand === network) && !(Number.isInteger(card.expiryMonth) && card.expiryMonth !== read.expiry_month) && !(Number.isInteger(card.expiryYear) && card.expiryYear % 100 !== read.expiry_year % 100);
+}
+var PAY_BODY_LIMIT = 16384;
+var PAY_DATA_KEYS = /* @__PURE__ */ Object.freeze(["payment_method_type", "payment_method_data"]);
+var PAY_CARD_KEYS = /* @__PURE__ */ Object.freeze(["metadata", "three_d_s", "vgs_card"]);
+var METADATA_KEYS = /* @__PURE__ */ Object.freeze(["cardholder_name", ...FACT_KEYS]);
+var BROWSER_INFO = /^[A-Za-z0-9+/]{1,4096}={0,2}$/;
+var RADAR_TOKEN = /^[\x21-\x7e]{1,512}$/;
+var COUNTRY_CODE = /^[A-Za-z]{2}$/;
+var FRONTEND_HOST = /^https:\/\/[\x21-\x7e]{1,1024}$/;
+var radarKeys = (value) => sameKeys(value, ["token", "country_code"]) || sameKeys(value, ["country_code", "token"]);
+function readPay(body, line) {
+    if (typeof body !== "string" || body === "" || body.length > PAY_BODY_LIMIT)
+        return null;
+    let value;
+    try {
+        value = JSON.parse(body);
+        if (!record(value) || JSON.stringify(value) !== body)
+            return null;
+    }
+    catch {
+        return null;
+    }
+    const data = value.data;
+    if (!sameKeys(value, ["data"]) || !record(data) || !(sameKeys(data, PAY_DATA_KEYS) || sameKeys(data, [...PAY_DATA_KEYS, "checkout"])) || data.payment_method_type !== (line === "classic" ? "CARD" : "card"))
+        return null;
+    if (data.checkout !== void 0 && !(record(data.checkout) && sameKeys(data.checkout, ["frontend_host"]) && typeof data.checkout.frontend_host === "string" && FRONTEND_HOST.test(data.checkout.frontend_host)))
+        return null;
+    const method = data.payment_method_data;
+    const card = record(method) && sameKeys(method, ["card"]) ? method.card : null;
+    if (!record(card) || !(sameKeys(card, PAY_CARD_KEYS) || sameKeys(card, [...PAY_CARD_KEYS, "session_tracking"])))
+        return null;
+    const metadata = card.metadata;
+    if (!record(metadata) || !sameKeys(metadata, METADATA_KEYS) || typeof metadata.cardholder_name !== "string" || metadata.cardholder_name.length > NAME_LIMIT || CONTROL.test(metadata.cardholder_name) || cardLikeName(metadata.cardholder_name) || typeof metadata.card_first_six !== "string" || !FIRST_SIX.test(metadata.card_first_six) || typeof metadata.card_last_four !== "string" || !LAST_FOUR.test(metadata.card_last_four) || !expiryMonth(metadata.expiry_month) || !expiryYear(metadata.expiry_year) || !FRAME_BRANDS.includes(metadata.card_brand))
+        return null;
+    const details = card.three_d_s;
+    if (!record(details) || !sameKeys(details, ["browser_info"]) || typeof details.browser_info !== "string" || !BROWSER_INFO.test(details.browser_info))
+        return null;
+    if (!record(card.vgs_card) || !sameKeys(card.vgs_card, ["card_id"]) || !isStoredCardId(card.vgs_card.card_id))
+        return null;
+    if (card.session_tracking !== void 0) {
+        const tracking = card.session_tracking;
+        const radar = record(tracking) && sameKeys(tracking, ["stripe_radar"]) ? tracking.stripe_radar : null;
+        if (!record(radar) || !radarKeys(radar) || typeof radar.token !== "string" || !RADAR_TOKEN.test(radar.token) || typeof radar.country_code !== "string" || !COUNTRY_CODE.test(radar.country_code))
+            return null;
+    }
+    return value;
+}
+function paddleVgsPayVerdict(request, approved) {
+    const facts = record(approved) ? paddleVgsCardFactsOf(approved.facts) : null;
+    if (!facts || !isStoredCardId(approved.cardId) || approved.environment !== "production" && approved.environment !== "sandbox") {
+        return refuse("paddle_vgs_pay_unbound");
+    }
+    const target = record(request) && typeof request.method === "string" && request.method.toUpperCase() === "POST" ? paddleVgsPayTarget(request.url) : null;
+    const value = target ? readPay(request.body, target.line) : null;
+    if (!value)
+        return refuse("paddle_vgs_pay_unsupported");
+    const card = value.data.payment_method_data.card;
+    if (target.environment !== approved.environment || card.vgs_card.card_id !== approved.cardId)
+        return refuse("paddle_vgs_pay_card_mismatch");
+    for (const key of FACT_KEYS)
+        card.metadata[key] = facts[key];
+    return Object.freeze({ verdict: "continue", body: JSON.stringify(value) });
+}
+export { PADDLE_VGS_CAPABILITY, PADDLE_VGS_CARDS_URLS, PADDLE_VGS_CARD_ID_WINDOW_MS, PADDLE_VGS_CARD_NETWORKS, PADDLE_VGS_CONTENT_TYPE, PADDLE_VGS_MERCHANT_PINS, PADDLE_VGS_OPERATION, PADDLE_VGS_PSP, PADDLE_VGS_REFUSAL_CODES, injectPaddleVgsCard, isPaddleVgsCardsUrl, isPreparedPaddleVgsRequest, paddleVgsAnswerOutcome, paddleVgsBodyVerdict, paddleVgsCardFacts, paddleVgsCardFactsAgree, paddleVgsCardFactsOf, paddleVgsCardRefusal, paddleVgsEnvironment, paddleVgsMerchantPin, paddleVgsMerchantRefusal, paddleVgsPayCarriesStoredCard, paddleVgsPayTarget, paddleVgsPayVerdict, paddleVgsRefusalCode, paddleVgsRefusalMessage, paddleVgsRequestRefusal, paddleVgsSellerClaimsPinned, paddleVgsStoredCardRefusal, paddleVgsTypedCardRefusal };

package/dist/paysafe.generated.d.ts

@@ -1,12 +1,10 @@
 export type PaysafePreparationEnvironment = 'production' | 'sandbox';
 export declare function paysafePreparationUrl(environment: string): string;
-/** Exact strings refuse credentials, queries, fragments and URL normalization. */
+/** The environment of a reviewed build's card URL. Exact strings refuse credentials, queries, fragments and URL normalization. */
 export declare function paysafeEnvironment(url: string): PaysafePreparationEnvironment | undefined;
-/** Checkout 1.8.0 starts a 40-second XHR when Pay is pressed. Prior approval may
- * consume only its new-card request, including native clientInfo and headers.
- * Saved cards, alternate APIs and 3DS-only requests require separate review.
- * Source: hosted.paysafe.com/checkout/1.8.0/main.bundle.js, SHA-256
- * e9e111ff03073cc936a47674e8e7c5db4a6d1050e1b65bf5e20723116fd5080c.
- * The guard checks original bytes and never changes the request.
+/** A reviewed Checkout build (BUILDS) starts a 40-second XHR when Pay is pressed. Prior approval may
+ * consume only its new-card request, including native clientInfo and headers, on the card URL that
+ * build sends to in the approved environment. Saved cards, alternate APIs and 3DS-only requests
+ * require separate review. The guard checks original bytes and never changes the request.
  */
 export declare function isPreparedPaysafeRequest(url: string, method: string, body: string | null, environment: string, headers?: Record<string, string>): boolean;

package/dist/paysafe.generated.js

@@ -1,10 +1,34 @@
 // Generated from @agent-cards/payment-core. Do not edit.
-// source-sha256: 24c7940ae8974c0d24e5a365144c1b07ccc46863ae3094eb92b3c54c8307e837
+// source-sha256: afa00cd57246e51361474c66c5ab4282bd5b39f0297fdf68616e164e19ed1741
 import { readTokenizationJson } from './braintree.js';
+/** The card URL a preparation names: Checkout 1.8.0's. The bind takes the exact URL of the build the request names (BUILDS). */
 const ENDPOINTS = {
     production: 'https://hosted.paysafe.com/checkout/api/v1/tokenize',
     sandbox: 'https://hosted.test.paysafe.com/checkout/api/v1/tokenize',
 };
+/**
+ * The Paysafe Checkout builds whose new-card request a prior approval may consume, each read from
+ * Paysafe's public bundle. A request binds only to the build its own clientInfo.version names, on
+ * that build's URL and headers, so a build Paysafe ships later is refused, and nothing is sent,
+ * until it is read and listed here. The request moved inside 1.x: 1.8.0 to 1.12.0 post to
+ * hosted.paysafe.com with a correlationId header, 1.16.1 to api.paysafe.com with three other
+ * headers, so a version range would hold one build's request to another build's rules.
+ *
+ * 1.8.0: hosted.paysafe.com/checkout/1.8.0/main.bundle.js, SHA-256
+ * e9e111ff03073cc936a47674e8e7c5db4a6d1050e1b65bf5e20723116fd5080c; LIVE/TEST select hosted[.test].
+ * 1.16.1: the checkout/v1/latest loader (SHA-256 5fac65c4f7a74b45388ad3ce7c02282f05e832226792bebc417cd9ff191be4f0)
+ * names it and frames checkout/v1/latest/index.html. Its main.js (SHA-256
+ * 328c6443da930f3648826248afa3c342cdd07d04e49a78b0878dda187772bf80) posts to environment +
+ * "checkout/api/v1/tokenize", and its vendor.js (SHA-256 7348275bd07256e295f4b83b292c7fe5115dd7ac35d1b1fe3d26eda3c37d2835)
+ * maps LIVE/TEST to api[.test].paysafe.com and sets X-Internal-Correlation-Id, X-Paysafe-Credentials,
+ * X-App-Version (the clientInfo version) and X-TransactionSource (CheckoutV1 for paysafe.checkout).
+ * The TEST host serves the same bytes (read 2026-10-15).
+ */
+const BUILDS = [
+    { version: '1.8.0', endpoints: ENDPOINTS, correlation: 'correlationid', fixed: {} },
+    { version: '1.16.1', correlation: 'x-internal-correlation-id', fixed: { 'x-app-version': '1.16.1', 'x-transactionsource': 'CheckoutV1' },
+        endpoints: { production: 'https://api.paysafe.com/checkout/api/v1/tokenize', sandbox: 'https://api.test.paysafe.com/checkout/api/v1/tokenize' } },
+];
 const record = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
 const keys = (value, allowed) => record(value) && Object.keys(value).every(key => allowed.includes(key));
 const exact = (pattern, value) => typeof value === 'string' && pattern.exec(value)?.[0] === value;
@@ -16,27 +40,31 @@ export function paysafePreparationUrl(environment) {
         throw new Error('unsupported_preparation_environment');
     return ENDPOINTS[environment];
 }
-/** Exact strings refuse credentials, queries, fragments and URL normalization. */
+/** The environment of a reviewed build's card URL. Exact strings refuse credentials, queries, fragments and URL normalization. */
 export function paysafeEnvironment(url) {
-    return url === ENDPOINTS.production ? 'production' : url === ENDPOINTS.sandbox ? 'sandbox' : undefined;
+    const build = BUILDS.find(candidate => url === candidate.endpoints.production || url === candidate.endpoints.sandbox);
+    return !build ? undefined : url === build.endpoints.production ? 'production' : 'sandbox';
 }
 const ADDRESS_FIELDS = ['city', 'country', 'zip', 'street', 'street2', 'state'];
 function billing(value) {
     return keys(value, ADDRESS_FIELDS) && Object.values(value).every(value => text(value))
         && (!own(value, 'country') || exact(/^[A-Z]{2}$/, value.country));
 }
-function freshCard(value) {
+/** The reviewed build whose new-card body this is: never a saved card, a 3-D Secure request or another app's body. */
+function freshCardBuild(value) {
     if (!keys(value, ['card', 'clientInfo', 'billingAddress']) || !keys(value.card, ['cardNum', 'cardExpiry', 'cvv', 'holderName']))
-        return false;
+        return undefined;
     const card = value.card;
     if (!exact(/^[0-9]{12,19}$/, card.cardNum) || !exact(/^[0-9]{3,4}$/, card.cvv)
         || !keys(card.cardExpiry, ['month', 'year']) || !exact(/^(?:0[1-9]|1[0-2])$/, card.cardExpiry.month)
         || !exact(/^20[0-9]{2}$/, card.cardExpiry.year) || own(card, 'holderName') && !text(card.holderName)
         || own(value, 'billingAddress') && !billing(value.billingAddress))
-        return false;
+        return undefined;
     const info = value.clientInfo;
-    return keys(info, ['correlationId', 'invocationId', 'version', 'appName'])
-        && uuid(info.correlationId) && uuid(info.invocationId) && info.version === '1.8.0' && info.appName === 'paysafe.checkout';
+    if (!keys(info, ['correlationId', 'invocationId', 'version', 'appName'])
+        || !uuid(info.correlationId) || !uuid(info.invocationId) || info.appName !== 'paysafe.checkout')
+        return undefined;
+    return BUILDS.find(build => build.version === info.version);
 }
 const BROWSER_HEADERS = new Set(['accept', 'accept-language', 'accept-encoding', 'content-length', 'origin', 'referer',
     'user-agent', 'host', 'connection', 'cache-control', 'pragma', 'priority', 'dnt',
@@ -53,9 +81,11 @@ function singleUseCredential(value) {
         return false;
     }
 }
-function nativeHeaders(headers, correlationId) {
+/** The build's own headers, each once with its native value, and only headers a browser adds beside them. */
+function nativeHeaders(headers, correlationId, build) {
     if (!record(headers))
         return false;
+    const native = ['content-type', 'x-paysafe-credentials', build.correlation, ...Object.keys(build.fixed)];
     const parsed = new Map();
     let bytes = 0;
     for (const [name, value] of Object.entries(headers)) {
@@ -63,25 +93,27 @@ function nativeHeaders(headers, correlationId) {
         if (parsed.size >= 64 || parsed.has(lower) || !exact(/^[A-Za-z0-9-]+$/, name) || !text(value, 8192)
             || (bytes += name.length + value.length) > 32768)
             return false;
-        if (!['content-type', 'correlationid', 'x-paysafe-credentials'].includes(lower) && !BROWSER_HEADERS.has(lower)
+        if (!native.includes(lower) && !BROWSER_HEADERS.has(lower)
             && !exact(/^sec-ch-ua(?:-[a-z0-9-]+)?$/, lower))
             return false;
         parsed.set(lower, value);
     }
     return exact(/^application\/json(?:;\s*charset=utf-8)?$/i, parsed.get('content-type'))
-        && parsed.get('correlationid') === correlationId && singleUseCredential(parsed.get('x-paysafe-credentials'));
+        && parsed.get(build.correlation) === correlationId && singleUseCredential(parsed.get('x-paysafe-credentials'))
+        && Object.entries(build.fixed).every(([name, value]) => parsed.get(name) === value);
 }
-/** Checkout 1.8.0 starts a 40-second XHR when Pay is pressed. Prior approval may
- * consume only its new-card request, including native clientInfo and headers.
- * Saved cards, alternate APIs and 3DS-only requests require separate review.
- * Source: hosted.paysafe.com/checkout/1.8.0/main.bundle.js, SHA-256
- * e9e111ff03073cc936a47674e8e7c5db4a6d1050e1b65bf5e20723116fd5080c.
- * The guard checks original bytes and never changes the request.
+/** A reviewed Checkout build (BUILDS) starts a 40-second XHR when Pay is pressed. Prior approval may
+ * consume only its new-card request, including native clientInfo and headers, on the card URL that
+ * build sends to in the approved environment. Saved cards, alternate APIs and 3DS-only requests
+ * require separate review. The guard checks original bytes and never changes the request.
  */
 export function isPreparedPaysafeRequest(url, method, body, environment, headers) {
     if (method !== 'POST' || (environment !== 'production' && environment !== 'sandbox')
         || paysafeEnvironment(url) !== environment)
         return false;
     const value = readTokenizationJson(body);
-    return freshCard(value) && record(value.clientInfo) && nativeHeaders(headers, value.clientInfo.correlationId);
+    if (!value || !record(value.clientInfo))
+        return false;
+    const build = freshCardBuild(value);
+    return !!build && url === build.endpoints[environment] && nativeHeaders(headers, value.clientInfo.correlationId, build);
 }

package/dist/pre-claim.d.ts

@@ -13,6 +13,7 @@ import { type CardEndpointProfile } from './card-endpoint.js';
 import { type PayrailsSessionCapture, type PayrailsSidecar } from './payrails.js';
 import { type VerifoneProfile } from './verifone.js';
 import { type WorldlineMyCheckoutProducts } from './worldline-mycheckout.js';
+import { type PaddleVgsPayGate } from './paddle-vgs-pay.js';
 /** The native Stripe step the gate claimed, or null when none was: exactly what StripeCheckoutGate.claim returns. */
 type StripeStep = ReturnType<StripeCheckoutGate['claim']>;
 /** A synthetic response a gate fulfills locally. The effect applies CORS and encoding. */
@@ -189,6 +190,12 @@ export interface PreClaimContext {
      * Absent, no MyCheckout card submit is held to a product here.
      */
     worldlineMyCheckout?: WorldlineMyCheckoutProducts;
+    /**
+     * The attachment's binding of Paddle's /pay to the stored card's id it handed a frame (paddle-vgs-pay.ts),
+     * judged by the request's frame (`frame`). Absent, or for an org the API did not serve Paddle VGS to, Paddle's
+     * checkout services are not this gate's.
+     */
+    paddleVgsPay?: PaddleVgsPayGate;
 }
 /**
  * The URL an event may name for a request. For an armed merchant profile's
@@ -211,6 +218,7 @@ export declare const ekashuPreClaim: PreClaimGate;
 export declare const paypalHostedFieldsPreClaim: PreClaimGate;
 export declare const cybersourceSecureAcceptancePreClaim: PreClaimGate;
 export declare const worldlineMyCheckoutPreClaim: PreClaimGate;
+export declare const paddleVgsPayPreClaim: PreClaimGate;
 /** The processor gates, in order. A new family adds one entry here; the terminal
  * arbiter runs after all of them and is not part of this list. A gate appended
  * after Stripe is never offered a step Stripe claimed: Stripe answers, aborts or

package/dist/pre-claim.js

@@ -79,6 +79,7 @@ import { ekashuEntryUrl, isEkashuEntry, isEkashuHost } from './ekashu.js';
 import { PAYPAL_HOSTED_FIELDS_REASON, isPaypalHostedFieldsConfirm, paypalHostedFieldsBody } from './paypal-hosted-fields.js';
 import { CYBERSOURCE_SECURE_ACCEPTANCE_REASON, CYBERSOURCE_SECURE_ACCEPTANCE_RECIPIENT, cybersourceSecureAcceptanceRequest, isCybersourceSecureAcceptanceUrl, isSecureAcceptanceFramePost, } from './cybersource-secure-acceptance.js';
 import { isWorldlineMyCheckoutEndpoint } from './worldline-mycheckout.js';
+import { paddleVgsPayEventUrl } from './paddle-vgs-pay.js';
 /**
  * The URL an event may name for a request. For an armed merchant profile's
  * endpoint or a sibling of it: the endpoint origin, the path TEMPLATE and the
@@ -1737,6 +1738,52 @@ async function worldlineMyCheckoutBlock(ctx, reason) {
     await ctx.effects.abort();
     return { kind: 'abort' };
 }
+// Paddle's /pay (paddle-vgs-pay.ts), held only on an attachment the API served Paddle VGS to: a POST to /pay
+// that names a stored card continues with the approved card's first six, last four, expiry and brand written
+// over the ones the frame read from the agent's placeholder, when this attachment handed that frame the stored
+// card's id within the minute and this is its first /pay; otherwise it aborts as an unsupported checkout, with
+// the gate's reason, so Paddle never receives the real card's id beside the placeholder's facts. Anything else
+// on Paddle's checkout services (its create, the buyer's first step, 3-D Secure's follow-up, a PayPal or wallet
+// /pay naming no stored card) defers, and the terminal arbiter continues it untouched. Synchronous until the
+// continue or the abort.
+export const paddleVgsPayPreClaim = (ctx) => {
+    const { url, method } = ctx.request;
+    if (!ctx.paddleVgsPay?.holds(url, method))
+        return undefined;
+    let body;
+    // A reader that throws (Playwright's postData() can) proves nothing: judged as a body that is not the frame's.
+    try {
+        body = ctx.request.body;
+    }
+    catch {
+        body = null;
+    }
+    const judged = ctx.paddleVgsPay.judge(ctx.frame, url, method, body);
+    if (judged === null)
+        return undefined;
+    return 'reason' in judged ? paddleVgsPayRefused(ctx, judged.reason) : paddleVgsPayContinued(ctx, judged.body);
+};
+async function paddleVgsPayRefused(ctx, reason) {
+    const { url, method } = ctx.request;
+    ctx.preparationGate.invalidate('unsupported_checkout');
+    ctx.lifecycle.unsupported(reason);
+    ctx.onEvent?.({ type: 'unsupported_checkout', detail: { url: paddleVgsPayEventUrl(url), method, reason } });
+    await ctx.effects.abort();
+    return { kind: 'abort' };
+}
+async function paddleVgsPayContinued(ctx, body) {
+    try {
+        await ctx.effects.continueRequest(body);
+    }
+    catch (error) {
+        ctx.onEvent?.({ type: 'failed', detail: ctx.failureSummary(error) });
+        await ctx.effects.abort().catch(() => { });
+        return { kind: 'abort' };
+    }
+    ctx.onEvent?.({ type: 'companion_continued', detail: { url: paddleVgsPayEventUrl(ctx.request.url), psp: 'paddle_vgs',
+            fields: ['card_first_six', 'card_last_four', 'expiry_month', 'expiry_year', 'card_brand'] } });
+    return { kind: 'continue' };
+}
 // The terminal arbiter, always last. A request that no gate claimed and that is
 // neither a native Stripe step nor a recognized card request continues, unless
 // it matches a declared payment endpoint we do not support (then it aborts as an
@@ -1771,7 +1818,7 @@ async function unsupportedContinue(ctx) {
  * after Stripe is never offered a step Stripe claimed: Stripe answers, aborts or
  * pauses each one itself. */
 export const PSP_PRE_CLAIM_GATES = [cardEndpointResendPreClaim, cardEndpointPreClaim, mercadoPreClaim, juspayPreClaim, braintreePreClaim, stripePreClaim, merchantHostedPreClaim, verifonePreClaim, fiservPreClaim, gmoPreClaim, cybersourceFlexPreClaim, datatransPreClaim, pelecardPreClaim, aciPreClaim, creditguardPreClaim, primerPreClaim, payrailsPreClaim, convergePreClaim, eprotectPreClaim, wspayPreClaim, shijiStsPreClaim, ekashuPreClaim, paypalHostedFieldsPreClaim,
-    cybersourceSecureAcceptancePreClaim, worldlineMyCheckoutPreClaim];
+    cybersourceSecureAcceptancePreClaim, worldlineMyCheckoutPreClaim, paddleVgsPayPreClaim];
 /** Run each gate in order; the first to return a decision wins. If none does,
  * the terminal arbiter decides between continue, abort (unsupported) and pause.
  * Returns synchronously while every gate defers synchronously (an ordinary card

package/dist/primer.generated.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 // Generated from @agent-cards/payment-core. Do not edit.
-// artifact-sha256: b3391e7d6137e269555a23062ce848aa7a7f6f02e626fd568b1e9597c02e5ce6
+// artifact-sha256: 80af165492668e00d651e9a039d3f24fe336bc3601dd5d2ab937a4b79bbb7ad8
 // src/card-number-key.js
 var CARD_NUMBER_KEY = /^(number|card_number|cardnumber|cardNum|card_num|pan)$/i;
 // src/json-path.js
@@ -414,6 +414,8 @@ var pin2 = (fields) => Object.freeze({
 var PADDLE_VGS_MERCHANT_PINS = /* @__PURE__ */ Object.freeze([
     pin2({ id: "rectangle_pro", merchant: "Rectangle Pro", origins: ["https://rectangleapp.com"], sellerClaim: null })
 ]);
+var FACT_KEYS = /* @__PURE__ */ Object.freeze(["card_first_six", "card_last_four", "expiry_month", "expiry_year", "card_brand"]);
+var METADATA_KEYS = /* @__PURE__ */ Object.freeze(["cardholder_name", ...FACT_KEYS]);
 // src/card-fields.js
 function processorGate(recognizer, url, body) {
     if (recognizer && recognizer.psp === PADDLE_VGS_PSP) {

package/dist/stripe-checkout.generated.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 // Generated from @agent-cards/payment-core. Do not edit.
-// artifact-sha256: dd47d4d2d97c39acb2385272d1a2bf3e647741839234283b848b67fd5ce5c114
+// artifact-sha256: 7e7a9b515128df56d149df50e0c275c7f6e8e522945ed818ca714ccac7eb1cd7
 // src/deep-freeze.js
 function deepFreeze(value) {
     if (value && typeof value === "object" && !Object.isFrozen(value)) {
@@ -583,13 +583,26 @@ var PROCESSOR_DEFINITIONS = deepFreeze([
         // Verified from https://hosted.test.paysafe.com/checkout/1.8.0/main.bundle.js
         // and its byte-identical production sibling (SHA-256 e9e111ff03073cc936a47674e8e7c5db4a6d1050e1b65bf5e20723116fd5080c).
         // Its native LIVE/TEST environment map selects exactly hosted[.test].paysafe.com.
+        // Checkout v1 latest (loader version 1.16.1; checkout/v1/latest/main.js SHA-256
+        // 328c6443da930f3648826248afa3c342cdd07d04e49a78b0878dda187772bf80) posts the same body to
+        // checkout/api/v1/tokenize on api[.test].paysafe.com, the hosts its vendor.js maps LIVE/TEST to.
+        // It and Paysafe.js latest set X-Internal-Correlation-Id, X-App-Version and X-TransactionSource
+        // on every card request, and Paysafe's CORS answer on all three API card paths allows them for
+        // any origin (2026-10-15), so a replay keeps them as the native request sends them.
         // Keep host/path pairs separate: details/log are not card requests;
         // 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/-])",
+        match: "(?:api(\\.test)?\\.paysafe\\.com/(?:paymenthub/v1/singleusepaymenthandles|js/api/v1/tokenize|checkout/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$"]
+        passthroughHeaders: [
+            "^authorization$",
+            "^x-paysafe-credentials$",
+            "^correlationid$",
+            "^x-internal-correlation-id$",
+            "^x-app-version$",
+            "^x-transactionsource$"
+        ]
     },
     {
         psp: "recurly",
@@ -1556,6 +1569,8 @@ var pin2 = (fields) => Object.freeze({
 var PADDLE_VGS_MERCHANT_PINS = /* @__PURE__ */ Object.freeze([
     pin2({ id: "rectangle_pro", merchant: "Rectangle Pro", origins: ["https://rectangleapp.com"], sellerClaim: null })
 ]);
+var FACT_KEYS = /* @__PURE__ */ Object.freeze(["card_first_six", "card_last_four", "expiry_month", "expiry_year", "card_brand"]);
+var METADATA_KEYS = /* @__PURE__ */ Object.freeze(["cardholder_name", ...FACT_KEYS]);
 // src/cybersource-secure-acceptance.js
 var SA_BODY_LIMIT = 32 * 1024;
 var SA_REPLY_LIMIT = 64 * 1024;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-cards/sdk",
-  "version": "0.23.12",
+  "version": "0.23.13",
   "description": "Agentcard's SDK: one client, Agentcard, with two modules. checkout pauses a browser purchase and pays it with the person's own card; voice connects a person to your product once and approves a purchase by voice inside it. Card data never enters your process.",
   "type": "module",
   "main": "dist/index.js",
@@ -49,5 +49,5 @@
   "engines": {
     "node": ">=22"
   },
-  "license": "UNLICENSED"
+  "license": "SEE LICENSE IN LICENSE"
 }