@agent-cards/sdk 0.23.23 → 0.23.25

package/dist/amazon-payment-services.js

@@ -0,0 +1,53 @@
+// Amazon Payment Services (formerly PayFort; psp `amazon_payment_services`), its custom merchant page: the merchant's own
+// card form posts top-level, as a document navigation, to /FortAPI/paymentPage on checkout.payfort.com (its sandbox,
+// sbcheckout.payfort.com), form encoded, with service_command=TOKENIZATION and the merchant's signed fields beside the
+// card. APS answers the post with a page whose script posts APS's fields to the form's return_url, or with a redirect
+// to that return_url carrying them in its query, and the merchant charges the token in those fields later, from its own
+// server. The rules are payment-core's (amazon-payment-services.generated.ts): the API applies them at create and at the
+// approve, and the cardholder's phone again before it sends the form through the checkout relay.
+//
+// The processor ships dark. The API serves the amazon_payment_services recognizer only to a build that declares the
+// `aps_custom_merchant_page` capability (client.ts SUPPORTED_CAPABILITIES), and only to an org Agentcard enabled for it,
+// so an SDK the API never served it leaves every APS form alone. This module holds the last check before an approval's
+// answer reaches the paused navigation.
+import { APS_CAPABILITY as CORE_CAPABILITY, APS_PAGE_CONTENT_TYPE, APS_PSP as CORE_PSP, apsAnswerOutcome } from './amazon-payment-services.generated.js';
+export const APS_PSP = CORE_PSP;
+export const APS_CAPABILITY = CORE_CAPABILITY;
+/**
+ * The answer the paused APS form navigation is fulfilled with, or null. The API stores APS's answer only once
+ * payment-core's judge reads it as a token for the paused form (apsAnswerOutcome), and this reads the stored answer
+ * again, against the paused request, before the agent's browser gets it:
+ *   page      status 200 under APS's HTML type alone, APS's page byte for byte, whose one form posts APS's fields to
+ *             the paused form's own return_url;
+ *   redirect  status 302 or 303 with one Location alone: the paused form's return_url, then APS's fields in the query.
+ * Anything else is null: a refusal, an unknown answer, another merchant's or another return page's answer, a card
+ * number anywhere in it, or a header beside the one each shape carries. A navigation reads no CORS header, so none is
+ * added. Autopilot never sends an APS form (payment-core autopilot.js), so the caller refuses an unattended answer.
+ */
+export function apsNavigationAnswer(request, response) {
+    try {
+        const headers = {};
+        for (const [name, value] of Object.entries(response.headers ?? {})) {
+            const lower = name.toLowerCase();
+            if (typeof value !== 'string' || Object.prototype.hasOwnProperty.call(headers, lower))
+                return null;
+            headers[lower] = value;
+        }
+        const names = Object.keys(headers);
+        // No card is in hand here: the judge reads the answer for any card number, with no card of its own to search for.
+        const verdict = apsAnswerOutcome({ status: response.status, headers, bodyText: response.body }, { url: request.url, body: request.body ?? '' }, undefined, undefined);
+        if (verdict.outcome !== 'token' || typeof verdict.body !== 'string')
+            return null;
+        if (verdict.shape === 'page') {
+            if (names.length !== 1 || headers['content-type'] !== APS_PAGE_CONTENT_TYPE)
+                return null;
+            return { status: 200, headers: { 'content-type': APS_PAGE_CONTENT_TYPE }, body: verdict.body };
+        }
+        if (names.length !== 1 || typeof verdict.location !== 'string' || response.body !== '')
+            return null;
+        return { status: response.status, headers: { location: verdict.location }, body: '' };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/barion.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Barion's Smart Gateway (secure.barion.com, where Hungarian, Czech and Slovak shops send a buyer who pays by card), as
+ * this SDK reads it.
+ *
+ * The merchant's server starts the payment with Barion and sends the buyer's browser to the gateway URL Barion answered
+ * with, https://secure.barion.com/Pay?Id=<payment id>, by a redirect or by setting the page's location. That GET carries
+ * no card, no amount and no merchant, and it is the one request a build that declares Barion's capability pauses
+ * (hosted-entry.ts): the cardholder's device repeats it over the end-to-end TLS relay and makes the gateway's own posts
+ * in the session Barion opens (payment-core processors/barion.js). Every post the agent's browser would send the gateway
+ * to pay follows that entry and leads to a card: the email check, the card's 3-D Secure version post, the 3-D Secure
+ * post and the charge post (/Pay/CheckEmailAddress, /Pay/PrepareCardPaymentForGuest, /ThreeDs/Authenticate,
+ * /Pay/CompletePaymentAsGuestWithCard). A build that declares Barion aborts every one of them (pre-claim.ts), so a
+ * placeholder card never reaches Barion.
+ *
+ * BARION_HOSTS is payment-core's BARION_HOSTS, and isBarionEntryUrl is payment-core's isBarionEntryUrl; barion.test.mjs
+ * pins both to payment-core on every case payment-core's own tests list.
+ */
+export declare const BARION_PSP = "barion";
+/** The dark-launch capability the API serves Barion's recognizer behind (payment-core definitions.js). */
+export declare const BARION_CAPABILITY = "barion_hosted_payment_page";
+/** The gateway's two hosts: live, and Barion's test gateway, which runs the same gateway for Barion's test shops. */
+export declare const BARION_HOSTS: readonly string[];
+/**
+ * Whether a URL is the gateway URL exactly as the merchant's redirect writes it: https, one of the two gateway hosts in
+ * lowercase, the default port, no credentials or fragment, the path /Pay, and one query parameter, Id or id, holding the
+ * payment's id. The gateway acts on other parameters (its script starts a bank transfer by itself for a DefaultBankId),
+ * so a URL carrying any is not the entry, and neither is any other page or post of the gateway's host.
+ */
+export declare function isBarionEntryUrl(raw: unknown): boolean;
+/**
+ * Whether a request on the gateway's hosts is a step toward paying there: any POST (the email check, the card's two
+ * posts, the 3-D Secure post, and any other form the gateway posts). The gateway's own pages, scripts and images, its
+ * 3-D Secure frames among them, are GETs of no card and are not one.
+ */
+export declare function isBarionPayStep(url: string, method: string): boolean;
+/**
+ * Whether an adapter must hand this request to the pre-claim gates: it is on a gateway host and this build's registry
+ * serves Barion's entry there. The gateway's posts are not the entry, so the registry's card-request test does not name
+ * them; the CDP adapter still pauses them through the recognizer's host pattern, and attachToPlaywright's route
+ * predicate asks this, so both adapters show the gates every request to the gateway once Barion is armed.
+ */
+export declare function isArmedBarionUrl(vault: {
+    isCardRequest(url: string, method?: string): boolean;
+} | undefined, url: string): boolean;

package/dist/barion.js

@@ -0,0 +1,84 @@
+/**
+ * Barion's Smart Gateway (secure.barion.com, where Hungarian, Czech and Slovak shops send a buyer who pays by card), as
+ * this SDK reads it.
+ *
+ * The merchant's server starts the payment with Barion and sends the buyer's browser to the gateway URL Barion answered
+ * with, https://secure.barion.com/Pay?Id=<payment id>, by a redirect or by setting the page's location. That GET carries
+ * no card, no amount and no merchant, and it is the one request a build that declares Barion's capability pauses
+ * (hosted-entry.ts): the cardholder's device repeats it over the end-to-end TLS relay and makes the gateway's own posts
+ * in the session Barion opens (payment-core processors/barion.js). Every post the agent's browser would send the gateway
+ * to pay follows that entry and leads to a card: the email check, the card's 3-D Secure version post, the 3-D Secure
+ * post and the charge post (/Pay/CheckEmailAddress, /Pay/PrepareCardPaymentForGuest, /ThreeDs/Authenticate,
+ * /Pay/CompletePaymentAsGuestWithCard). A build that declares Barion aborts every one of them (pre-claim.ts), so a
+ * placeholder card never reaches Barion.
+ *
+ * BARION_HOSTS is payment-core's BARION_HOSTS, and isBarionEntryUrl is payment-core's isBarionEntryUrl; barion.test.mjs
+ * pins both to payment-core on every case payment-core's own tests list.
+ */
+export const BARION_PSP = 'barion';
+/** The dark-launch capability the API serves Barion's recognizer behind (payment-core definitions.js). */
+export const BARION_CAPABILITY = 'barion_hosted_payment_page';
+/** The gateway's two hosts: live, and Barion's test gateway, which runs the same gateway for Barion's test shops. */
+export const BARION_HOSTS = Object.freeze(['secure.barion.com', 'secure.test.barion.com']);
+const ENTRY_PATH = '/Pay';
+// The payment's id, a GUID: 32 hexadecimal digits as the gateway URL writes it, or with its four dashes as Barion's PHP
+// library writes it, in either letter case.
+const PAYMENT_ID = /^(?:[0-9a-f]{32}|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i;
+// The entry's whole query: the one parameter Barion's GatewayUrl names (Id) or its PHP library names (id).
+const ENTRY_QUERY = /^\?(?:Id|id)=([^&=]{1,64})$/;
+// An id of that shape, for asking whether this build's registry serves the entry on a host.
+const PROBE_ID = '00000000000000000000000000000000';
+/**
+ * Whether a URL is the gateway URL exactly as the merchant's redirect writes it: https, one of the two gateway hosts in
+ * lowercase, the default port, no credentials or fragment, the path /Pay, and one query parameter, Id or id, holding the
+ * payment's id. The gateway acts on other parameters (its script starts a bank transfer by itself for a DefaultBankId),
+ * so a URL carrying any is not the entry, and neither is any other page or post of the gateway's host.
+ */
+export function isBarionEntryUrl(raw) {
+    if (typeof raw !== 'string' || raw.length > 256)
+        return false;
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        return false;
+    }
+    if (url.protocol !== 'https:' || !BARION_HOSTS.includes(url.hostname) || url.pathname !== ENTRY_PATH
+        || url.port || url.username || url.password || url.href !== raw || raw.includes('#'))
+        return false;
+    const match = ENTRY_QUERY.exec(url.search);
+    return !!match && PAYMENT_ID.test(match[1]);
+}
+/** The gateway host a URL is on (https, no credentials, any port, any letter case, a trailing dot or not), or null. */
+function barionHost(raw) {
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        return null;
+    }
+    if (url.protocol !== 'https:' || url.username || url.password)
+        return null;
+    const host = url.hostname.toLowerCase().replace(/\.$/, '');
+    return BARION_HOSTS.includes(host) ? host : null;
+}
+/**
+ * Whether a request on the gateway's hosts is a step toward paying there: any POST (the email check, the card's two
+ * posts, the 3-D Secure post, and any other form the gateway posts). The gateway's own pages, scripts and images, its
+ * 3-D Secure frames among them, are GETs of no card and are not one.
+ */
+export function isBarionPayStep(url, method) {
+    return barionHost(url) !== null && String(method).toUpperCase() === 'POST';
+}
+/**
+ * Whether an adapter must hand this request to the pre-claim gates: it is on a gateway host and this build's registry
+ * serves Barion's entry there. The gateway's posts are not the entry, so the registry's card-request test does not name
+ * them; the CDP adapter still pauses them through the recognizer's host pattern, and attachToPlaywright's route
+ * predicate asks this, so both adapters show the gates every request to the gateway once Barion is armed.
+ */
+export function isArmedBarionUrl(vault, url) {
+    const host = barionHost(url);
+    return host !== null && typeof vault?.isCardRequest === 'function' && vault.isCardRequest(`https://${host}${ENTRY_PATH}?Id=${PROBE_ID}`, 'GET');
+}

package/dist/capabilities.generated.js

@@ -1,3 +1,3 @@
 // Written by scripts/generate-capabilities.mjs from capabilities.json. Do not edit; git ignores it.
 /** capabilities.json's list, sorted; client.ts exports it as SUPPORTED_CAPABILITIES. */
-export const DECLARED_CAPABILITIES = ["aci_split_card.v1", "amadeus_checkout_actions.v1", "authorize_net_dpm_form", "capture_context", "clover_card_token", "comgate_hosted_payment_page", "converge_hpp_process", "creditguard_pps_process", "cybersource_sa_token_create", "datatrans_secure_fields_tokenize", "ekashu_hosted_payment_page", "eximbay_hosted_payment_page", "fiserv_card_capture", "gmo_shared_pk", "gopay_card_form", "gravy_session_fields_put", "hipay_vault_token", "juspay_txns.v1", "lyra_krypton_payment", "makecommerce_card_frame", "midtrans_card_token", "moneris_hosted_tokenization", "omise_card_token", "paddle_tokenex_pay", "paddle_vgs_cards", "pay_nl_card_token", "payfast_card_pay", "paygent_token", "paymongo_checkout_pay", "paypal_card_fields", "payrails_device_encrypt", "payrexx_card_frame", "paytrail_hosted_payment_page", "pelecard_transaction", "poynt_collect_nonce", "primer_payment_instruments", "przelewy24_hosted_payment_page", "quickpay_hosted_payment_page", "redsys_hosted_payment_page", "revolut_card_field", "sbps_token_jsonp", "shiji_sts_pinned_key", "sumup_checkout_process", "toast_pinned_key", "tokenex_iframe_tokenize", "transbank_webpay_hosted_payment_page", "twoc2p_secure_pay", "verifone_card_capture", "wix_payments_tokenize", "worldline_mycheckout_form", "worldpay_eprotect_jsonp", "wspay_confirm", "xendit_card_token"];
+export const DECLARED_CAPABILITIES = ["aci_split_card.v1", "amadeus_checkout_actions.v1", "aps_custom_merchant_page", "authorize_net_dpm_form", "barion_hosted_payment_page", "capture_context", "clover_card_token", "comgate_hosted_payment_page", "converge_hpp_process", "creditguard_pps_process", "cybersource_sa_token_create", "datatrans_secure_fields_tokenize", "ekashu_hosted_payment_page", "eximbay_hosted_payment_page", "fastspring_card_payment", "fiserv_card_capture", "gmo_shared_pk", "gopay_card_form", "gravy_session_fields_put", "hipay_vault_token", "juspay_txns.v1", "lyra_krypton_payment", "makecommerce_card_frame", "midtrans_card_token", "moneris_hosted_tokenization", "omise_card_token", "openpay_tokenizer", "paddle_tokenex_pay", "paddle_vgs_cards", "pay_nl_card_token", "payfast_card_pay", "paygent_token", "paymongo_checkout_pay", "paypal_card_fields", "payrails_device_encrypt", "payrexx_card_frame", "paytrail_hosted_payment_page", "pelecard_transaction", "poynt_collect_nonce", "primer_payment_instruments", "przelewy24_hosted_payment_page", "quickpay_hosted_payment_page", "redsys_hosted_payment_page", "revolut_card_field", "sbps_token_jsonp", "shiji_sts_pinned_key", "sumup_checkout_process", "tap_card_sdk_token", "toast_pinned_key", "tokenex_iframe_tokenize", "transbank_webpay_hosted_payment_page", "twoc2p_secure_pay", "verifone_card_capture", "wix_payments_tokenize", "worldline_mycheckout_form", "worldpay_eprotect_jsonp", "wspay_confirm", "xendit_card_token"];

package/dist/card-fields.generated.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 // Generated from @agent-cards/payment-core. Do not edit.
-// artifact-sha256: d1aac0b870ff4b5f9d63a43d1c2bb0eef03841846206282b5aeca4f540f0e73d
+// artifact-sha256: e6f7697efcf41d051189ca331d0d99f5a701e50cb0b7d3a3f967178bf87d7df1
 // src/card-number-key.js
 var CARD_NUMBER_KEY = /^(number|card_number|cardnumber|cardNum|card_num|pan)$/i;
 // src/json-path.js
@@ -3561,11 +3561,11 @@ var TOKENEX_IFRAME_BODY_KEYS = Object.freeze([
 ]);
 var TOKENEX_IFRAME_TOKEN_SCHEMES = Object.freeze(["sixTOKENfour"]);
 var TOKENEX_IFRAME_REVIEWED_ACCOUNTS = Object.freeze({
-    "htp.tokenex.com": Object.freeze({}),
+    "htp.tokenex.com": Object.freeze({ "9014311640612780": "https://www.jetblue.com" }),
     "test-htp.tokenex.com": Object.freeze({})
 });
 var TOKENEX_IFRAME_ACCOUNT_NAMES = Object.freeze({
-    "htp.tokenex.com": Object.freeze({}),
+    "htp.tokenex.com": Object.freeze({ "9014311640612780": "JetBlue" }),
     "test-htp.tokenex.com": Object.freeze({})
 });
 var BODY_LIMIT22 = 8192;
@@ -4615,7 +4615,8 @@ function toastBodyVerdict(body) {
 // src/fastspring.js
 var FASTSPRING_PSP = "fastspring";
 var FASTSPRING_STORE_PINS = /* @__PURE__ */ Object.freeze([
-    Object.freeze({ environment: "production", store: "daisydisk", storefront: "", merchant: "DaisyDisk" })
+    Object.freeze({ environment: "production", store: "daisydisk", storefront: "", merchant: "DaisyDisk" }),
+    Object.freeze({ environment: "production", store: "stardock", storefront: "/popup-store", merchant: "Stardock" })
 ]);
 var URL_LIMIT11 = 256;
 var BODY_LIMIT28 = 32768;

package/dist/cdp.js

@@ -20,10 +20,12 @@ import { isArmedPaytrailUrl } from './paytrail.js';
 import { SHIJI_STS_COMPANION_WINDOW_MS, ShijiStsCompanions, ShijiStsError, isShijiStsHost, shijiStsTokenContinuation, } from './shiji-sts.js';
 import { paddleTokenexTokenContinuation } from './paddle-tokenex.js';
 import { twoC2pContinuation, twoC2pRetire } from './twoc2p.js';
+import { tapPaymentsContinuation } from './tap-payments.js';
 import { isArmedEkashuUrl } from './ekashu.js';
 import { isArmedTransbankUrl, transbankMerchantReturn, transbankMerchantReturnAnswer } from './transbank.js';
 import { isArmedRedsysUrl } from './redsys.js';
 import { isArmedPrzelewy24Url } from './przelewy24.js';
+import { isArmedBarionUrl } from './barion.js';
 import { isArmedQuickpayUrl } from './quickpay.js';
 import { COMGATE_CARD_PATTERNS, isArmedComgateUrl, servesComgate } from './comgate.js';
 import { isArmedEximbayUrl } from './eximbay.js';
@@ -39,6 +41,7 @@ import { replayTemplatedUrl, reviewedMerchantProfileUrlPatterns } from './mercha
 import { verifoneTemplatedUrl } from './verifone.js';
 import { MerchantHandoffWatch } from './merchant-handoff.js';
 import { MERCHANT_PAGE_WAIT_MS, MerchantTotalWatch } from './merchant-total-watch.js';
+import { PaddleCheckoutWatch } from './paddle-checkout-watch.js';
 import { hostedFormSubmittedPage } from './hosted-form.js';
 import { armSendWindow, failsAsNetworkError, preparedSendWindowMs, sendWindowProcessor } from './amadeus.js';
 import { HoldAnsweredError, HoldEndedError, HoldGate, HoldRefusedError, matchHoldOnlyRule } from './hold.js';
@@ -365,7 +368,7 @@ function cseAuthorizedDetail(replay, url, shijiCvv = null) {
  * processor takes cseContinuationBody (cse-body.ts cseBody), and `shijiCvv` and
  * `shijiCvvKeySequenceSha256` are null.
  */
-function cseContinuation(opts, url, body, replay, approved, preparation) {
+function cseContinuation(opts, url, body, replay, approved, preparation, headers) {
     const shiji = shijiStsTokenContinuation(url, body, replay.substitutions, approved, replay.kind === 'merchant_hosted' || replay.kind === 'verifone' ? undefined : replay.shijiStsCompanion);
     if (shiji)
         return { body: shiji.body, shijiCvv: shiji.cvv, shijiCvvKeySequenceSha256: shiji.cvvKeySequenceSha256 };
@@ -384,6 +387,13 @@ function cseContinuation(opts, url, body, replay, approved, preparation) {
         : null;
     if (twoc2p)
         return { body: twoc2p.body, shijiCvv: null, shijiCvvKeySequenceSha256: null };
+    // Tap writes one RSA ciphertext at the body root under the merchant's pinned key, which the generic Adyen swap refuses
+    // as no JWE, so it is dispatched by the token URL to substituteTapPayments (tap-payments.ts), only into the one request
+    // the approval was made for, and only while the request that continues names the merchant's publishable key the
+    // approved one named: the browser sends that request's own headers.
+    const tap = replay.kind === undefined ? tapPaymentsContinuation(url, body, headers, replay.substitutions, approved) : null;
+    if (tap)
+        return { body: tap.body, shijiCvv: null, shijiCvvKeySequenceSha256: null };
     return { body: cseContinuationBody(opts, body, replay, url, preparation), shijiCvv: null, shijiCvvKeySequenceSha256: null };
 }
 /**
@@ -1436,7 +1446,7 @@ function merchantAttempt(lifecycle, survives) {
     // known non-payment, so the prepared checkout ends failed with that reason, and a fresh attachment can
     // prepare again. Every other stop leaves the outcome unknown.
     const error = () => reason === 'amadeus_send_window_closed' || reason === 'secure_acceptance_send_window_closed'
-        || reason === 'wix_payments_send_window_closed' || reason === 'hipay_send_window_closed'
+        || reason === 'wix_payments_send_window_closed' || reason === 'hipay_send_window_closed' || reason === 'openpay_send_window_closed'
         ? new CheckoutPreparationError(lifecycle.getState().preparationId ?? null, reason)
         : new PaymentOutcomeUnknownError(lifecycle.getState().authorizationId, reason);
     const attempt = {
@@ -2016,6 +2026,8 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
     // The merchant's own total (merchant-total-watch.ts): its checkout responses, recorded
     // read-only from attach on, and the approval a hand-off answers, for the charge report.
     const merchantTotal = new MerchantTotalWatch(opts.onEvent, opts.vault);
+    // Paddle's own checkout answers (paddle-checkout-watch.ts), recorded read-only from attach on for a TokenEx /pay.
+    const paddleCheckout = new PaddleCheckoutWatch();
     // A reviewed card endpoint merchant's own record of the order (card-endpoint-facts.ts).
     const cardEndpointRecord = new CardEndpointFactsWatch();
     let handoffReplay = null;
@@ -2525,6 +2537,7 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 merchantTotal.sent(key, { method: params.request.method, url: params.request.url,
                     ...(typeof params.request.postData === 'string' ? { requestBody: params.request.postData } : {}),
                     ...(typeof params.loaderId === 'string' && params.loaderId ? { page: `${owner}:${params.loaderId}` } : {}) });
+                paddleCheckout.sent(key, { method: params.request.method, url: params.request.url });
                 cardEndpointRecord.sent(key, { method: params.request.method, url: params.request.url, resourceType: params.type ?? null, networkId: params.requestId });
             }
             if (matchesActive) {
@@ -2564,6 +2577,14 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 cdp.send('Network.getResponseBody', { requestId: params.requestId }, sessionId).then((read) => merchantTotal.log.read(key, typeof read?.body === 'string'
                     ? (read.base64Encoded ? Buffer.from(read.body, 'base64').toString('utf8') : read.body) : null, completedAt), () => merchantTotal.log.read(key, null, completedAt));
             }
+            if (paddleCheckout.tracks(key)) {
+                // One of Paddle's checkout answers: stamped finished at once, so a /pay's pause waits for its text, then read
+                // and cut to the terms by the watch.
+                const completedAt = Date.now();
+                paddleCheckout.finished(key, completedAt);
+                cdp.send('Network.getResponseBody', { requestId: params.requestId }, sessionId).then((read) => paddleCheckout.read(key, typeof read?.body === 'string'
+                    ? (read.base64Encoded ? Buffer.from(read.body, 'base64').toString('utf8') : read.body) : null, completedAt), () => paddleCheckout.read(key, null, completedAt));
+            }
             if (payrails && payrailsAnswers.delete(requestKey(sessionId, params.requestId))
                 && !(Number(params.encodedDataLength) > PAYRAILS_INIT_BODY_LIMIT)) {
                 payrails.reading(cdp.send('Network.getResponseBody', { requestId: params.requestId }, sessionId).then((answer) => {
@@ -2578,6 +2599,7 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
         }
         if (method === 'Network.responseReceived') {
             merchantTotal.log.answered(requestKey(sessionId, params.requestId), params.response?.status);
+            paddleCheckout.answered(requestKey(sessionId, params.requestId), params.response?.status);
             const recordKey = cardEndpointRecord.keyFor(requestKey(sessionId, params.requestId), params.requestId);
             if (recordKey)
                 cardEndpointRecord.answered(recordKey, params.response?.status);
@@ -2606,6 +2628,7 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 || (activeRequest && activeRequest.networkId === params.requestId && activeRequest.sourceSessionId === sessionId)))
                 holdGate.lost();
             merchantTotal.log.failed(requestKey(sessionId, params.requestId));
+            paddleCheckout.failed(requestKey(sessionId, params.requestId));
             const recordKey = cardEndpointRecord.keyFor(requestKey(sessionId, params.requestId), params.requestId);
             if (recordKey)
                 cardEndpointRecord.failed(recordKey);
@@ -3124,6 +3147,10 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             // The merchant's own record of the order, as of the pause, for a profile that reads one.
             const cardRecord = cardEndpoint ? await cardEndpointFacts(cardEndpointRecord, cardEndpoint, request.url, pausedAt, attempt.signal) : null;
             attempt.assertLive();
+            // Paddle's own checkout answers as of the pause, once the texts of those that finished before it are read
+            // (a Billing /pay only; sent only with a Paddle TokenEx create, which a pause-only business makes itself).
+            const paddleAnswers = opts.pauseOnly ? undefined : await paddleCheckout.capture(pausedAt, request.url, attempt.signal);
+            attempt.assertLive();
             // Hold mode: nothing is created until the person's total releases the request (hold.ts).
             if (holdGate) {
                 if (holdGate.state !== 'watching') {
@@ -3179,6 +3206,8 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 // What the merchant's own checkout said its total was, as this browser recorded it
                 // (read only for a reviewed profile priced by it): the page is the card request's.
                 merchantTotal: merchantTotal.capture(pausedAt, cardPage),
+                // Paddle's own checkout answers, as this browser recorded them (sent only with a Paddle TokenEx create).
+                paddleCheckout: paddleAnswers,
                 onAuthorizationCreated: (id) => {
                     lifecycle.approvalCreated(id);
                     if (holdSandbox && !holdRequestFailed) {
@@ -3299,7 +3328,7 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 // companion cannot arrive first, and dropped if the continue fails.
                 // Both go only to the request the approval was created from, from the
                 // frame that sent it (cseContinuation refuses any other body).
-                const continuation = cseContinuation(opts, deliverRequest.url, deliverBody, replay, { url: request.url, body }, preparation);
+                const continuation = cseContinuation(opts, deliverRequest.url, deliverBody, replay, { url: request.url, body, headers: request.headers }, preparation, deliverRequest.headers);
                 const postData = Buffer.from(continuation.body).toString('base64');
                 if (continuation.shijiCvv !== null) {
                     shijiCompanions.bind({ url: request.url, method: request.method, body }, cdpShijiPage(sessionId, frameId), continuation.shijiCvv, continuation.shijiCvvKeySequenceSha256 ?? []);
@@ -3629,6 +3658,8 @@ export async function attachToPlaywright(page, opts) {
     // but sends no document request, so it keeps the page id, as CDP's loaderId does. Nor does
     // a document request that commits nothing: one that failed, or one answered 204 or 205.
     const merchantTotal = new MerchantTotalWatch(opts.onEvent, opts.vault);
+    // Paddle's own checkout answers, as attachToCdp records them (paddle-checkout-watch.ts).
+    const paddleCheckout = new PaddleCheckoutWatch();
     // A reviewed card endpoint merchant's own record of the order (card-endpoint-facts.ts).
     const cardEndpointRecord = new CardEndpointFactsWatch();
     let documentSerial = 1;
@@ -3690,6 +3721,10 @@ export async function attachToPlaywright(page, opts) {
                 ...(typeof body === 'string' ? { requestBody: body } : {}), page: `doc:${documentSerial}` });
         }
         catch { /* a request the page already dropped */ }
+        try {
+            paddleCheckout.sent(keyOf(request), { method: request.method(), url: request.url() });
+        }
+        catch { /* a request the page already dropped */ }
         try {
             cardEndpointRecord.sent(keyOf(request), { method: request.method(), url: request.url(),
                 resourceType: typeof request.resourceType === 'function' ? request.resourceType() : null });
@@ -3731,6 +3766,28 @@ export async function attachToPlaywright(page, opts) {
                 cardEndpointRecord.read(key, text, finishedAt);
             }).catch(() => cardEndpointRecord.failed(key));
         }
+        if (paddleCheckout.tracks(key)) {
+            // One of Paddle's checkout answers: stamped finished at once, so a /pay's pause waits for its text, then its
+            // status and its text, cut to the terms by the watch.
+            const answeredAt = Date.now();
+            paddleCheckout.finished(key, answeredAt);
+            Promise.resolve().then(async () => {
+                const response = await request.response();
+                if (!response) {
+                    paddleCheckout.failed(key);
+                    return;
+                }
+                paddleCheckout.answered(key, response.status());
+                let text = null;
+                try {
+                    text = await response.text();
+                }
+                catch {
+                    text = null;
+                }
+                paddleCheckout.read(key, text, answeredAt);
+            }).catch(() => paddleCheckout.failed(key));
+        }
         if (!merchantTotal.log.tracks(key))
             return;
         const completedAt = Date.now();
@@ -3800,6 +3857,7 @@ export async function attachToPlaywright(page, opts) {
         if (request === documentRequest)
             documentRequest = null;
         merchantTotal.log.failed(keyOf(request));
+        paddleCheckout.failed(keyOf(request));
         cardEndpointRecord.failed(keyOf(request));
         if (activeRequest && activeRequest.request === request && activeRequest.attempt.lose()) {
             // The page's own script gave up on its request; the cardholder's
@@ -3923,6 +3981,9 @@ export async function attachToPlaywright(page, opts) {
             // the hosts: the card method's post, the card form's post and the Saferpay resolver reach the Przelewy24
             // gate and fail.
             || isArmedPrzelewy24Url(opts.vault, url.toString())
+            // Every request to Barion's gateway hosts once its entry is served (barion.ts), as attachToCdp arms the hosts:
+            // the gateway's email check, card posts and 3-D Secure post reach the Barion gate and fail.
+            || isArmedBarionUrl(opts.vault, url.toString())
             // Every request to an NMI host whose entry is served (ekashu.ts), as attachToCdp arms the
             // host: the card page's post and its 3-D Secure calls reach the NMI gate and fail.
             || isArmedEkashuUrl(opts.vault, url.toString())
@@ -4292,6 +4353,9 @@ export async function attachToPlaywright(page, opts) {
                 // The merchant's own record of the order, as of the pause (see attachToCdp).
                 const cardRecord = cardEndpoint ? await cardEndpointFacts(cardEndpointRecord, cardEndpoint, request.url(), pausedAt, attempt.signal) : null;
                 assertRequestLive();
+                // Paddle's own checkout answers as of the pause, once their texts are read (see attachToCdp).
+                const paddleAnswers = await paddleCheckout.capture(pausedAt, request.url(), attempt.signal);
+                assertRequestLive();
                 const replay = await opts.vault.authorize({
                     user: opts.user,
                     merchant: opts.merchant,
@@ -4311,6 +4375,8 @@ export async function attachToPlaywright(page, opts) {
                     merchantSignal: attempt.signal,
                     // Same as the CDP path: the merchant's total as this browser recorded it.
                     merchantTotal: merchantTotal.capture(pausedAt, pausedPage),
+                    // And Paddle's own checkout answers, as this browser recorded them.
+                    paddleCheckout: paddleAnswers,
                     onAuthorizationCreated: (id) => lifecycle.approvalCreated(id),
                     onApprovalUrl: (url) => { if (!preparation && !attempt.signal.aborted) {
                         lifecycle.approvalUrl(url);
@@ -4381,7 +4447,7 @@ export async function attachToPlaywright(page, opts) {
                     // A Shiji STS getTokenId binds the device's cvv to its companion
                     // first, exactly as in attachToCdp: only for the request the
                     // approval was created from, and its frame.
-                    const continuation = cseContinuation(opts, deliverRequest.url(), deliverBody, replay, { url: request.url(), body }, preparation);
+                    const continuation = cseContinuation(opts, deliverRequest.url(), deliverBody, replay, { url: request.url(), body, headers: request.headers() }, preparation, deliverRequest.headers());
                     if (continuation.shijiCvv !== null) {
                         // The document the getTokenId paused in. One that cannot be read leaves the CVV nowhere to
                         // go, so the card is not tokenized either.

package/dist/client.d.ts

@@ -6,6 +6,7 @@ import { type PreparationMode, type PreparationProcessor } from './prepared-proc
 import { type VerifoneProfile, type VerifoneSubstitutions } from './verifone.js';
 import { type MerchantSessionCapture } from './merchant-session-probe.js';
 import { type PaddleTokenexServedFacts } from './paddle-tokenex.js';
+import type { PaddleCheckoutCapture } from './paddle-checkout-watch.js';
 import { VoiceModule, type VoiceOptions } from './voice.js';
 import { BuyModule } from './buy.js';
 import { RequestRegistry } from './requests.js';
@@ -462,6 +463,49 @@ export declare const SUPPORTED_REGISTRY_FEATURES: readonly string[];
  * Served on the same terms, and the API holds the lane to Agentcard's own company
  * until a reviewed change binds the client key to the merchant.
  *
+ * `tap_card_sdk_token`: the token request Tap Payments' card frame sends to sdk.tap.company, carrying
+ * the card only as one ciphertext the frame writes under the merchant's own RSA key. This build pauses
+ * it and writes over the placeholder's ciphertext the one the cardholder's device wrote under the key
+ * payment-core pins for the request's publishable key (tap-payments.ts), into that request alone; 3-D
+ * Secure and the merchant's charge then run in the agent's browser. Served on the same terms: only to
+ * a build that lists it, for a company Agentcard turned Tap on for.
+ *
+ * `fastspring_card_payment`: the card payment FastSpring's checkout posts, on every store's own
+ * host, to <store>.onfastspring.com[/popup-<name>]/session/<id>/payment under the session's
+ * X-Session-Token. This build pauses only the checkout's own card body at that exact URL (a card
+ * FastSpring saved, a renewal, a gift, a tax id's second card send and a CAPTCHA answer are refused
+ * at the pause, and another method's payment with no card continues); the cardholder's device writes
+ * the real card into the paused body and sends it through the checkout relay, and the checkout gets
+ * FastSpring's answer as payment-core's judge rebuilt it. The request names no amount, so the agent's
+ * pair, above zero, is the total the checkout shows. Served on the same terms:
+ * only to a build that lists it, for a company Agentcard turned FastSpring on for.
+ *
+ * `openpay_tokenizer`: the token create openpay.js sends from a merchant's own page to
+ * api.openpay.mx/v1/<merchant id>/tokens (api.openpay.co, api.openpay.pe; sandbox-api for a test
+ * row), only through a prepared checkout: openpay.js abandons the request 40 seconds after Pay, so
+ * the cardholder approves before Pay. The token URL names the merchant, so the claim binds the
+ * request by its host's environment and its shape, never by the prepared URL. The cardholder's
+ * device sends the card to Openpay itself and the page gets back Openpay's token alone, rebuilt by
+ * payment-core's judge. The request names no amount, so the agent's pair, above zero
+ * (agent-amount-processors.json), is the one the cardholder approves. Served on the same terms: only
+ * to a build that lists it, for a company Agentcard turned Openpay on for.
+ *
+ * `aps_custom_merchant_page`: Amazon Payment Services' custom merchant page, whose own card form
+ * posts top-level to /FortAPI/paymentPage on checkout.payfort.com (sbcheckout.payfort.com on APS's
+ * sandbox) with service_command=TOKENIZATION. This build pauses that navigation; the cardholder's
+ * phone sends the form with the real card through the checkout relay, and the paused navigation
+ * gets APS's own answer, its page or its redirect to the form's return page, only as payment-core's
+ * judge reads it for that form (amazon-payment-services.ts apsNavigationAnswer). The form names no
+ * amount, so the agent's pair, above zero, is the one the cardholder approves.
+ * Served on the same terms: only to a build that lists it, for a company Agentcard turned APS on for.
+ *
+ * `barion_hosted_payment_page`: Barion's Smart Gateway, whose card-free link
+ * (secure.barion.com/Pay?Id=<payment id>, a plain GET the merchant's redirect or script sends
+ * the buyer to) this build pauses for the cardholder's device by its exact link (hosted-entry.ts),
+ * and whose email check, card posts and 3-D Secure post this build never lets the agent's browser
+ * send (pre-claim.ts, barion.ts). Served on the same terms as Przelewy24's: only to a build that
+ * lists it, for a company Agentcard turned Barion on for.
+ *
  * The list itself is capabilities.json, sorted, one per line (scripts/generate-capabilities.mjs).
  */
 export declare const SUPPORTED_CAPABILITIES: readonly string[];
@@ -964,6 +1008,13 @@ export interface AuthorizeInput extends ExecutionMetadata {
      * one from its network events, or the payment is refused before any create.
      */
     merchantTotal?: MerchantTotalCapture;
+    /**
+     * For a Paddle TokenEx /pay: when it paused and the answers Paddle's checkout service gave the frame before it,
+     * as this browser recorded them (see paddle-checkout-watch.ts). The adapters pass it, and it rides the create only
+     * for that processor. The API holds `amount` to the total they state for today, and admits a free trial's $0.00
+     * only on them; without them a $0.00 Paddle create is refused as before.
+     */
+    paddleCheckout?: PaddleCheckoutCapture;
 }
 export declare class CardEncryptedError extends Error {
     psp: string;
@@ -1625,9 +1676,10 @@ export declare class VaultClient {
      * capability (syncRegistry does), so before a sync, or against an API that
      * withheld it, the adapters leave that processor's traffic exactly as they
      * found it. prepare() asks this for ACI, whose card-number request names a
-     * checkout id the merchant mints only at Pay time, and for a processor whose
-     * card request is a GET (Worldpay eProtect), since that request is recognized
-     * by a query the page has not written yet.
+     * checkout id the merchant mints only at Pay time, for Openpay, whose token
+     * URL names the merchant's own id, and for a processor whose card request is
+     * a GET (Worldpay eProtect), since that request is recognized by a query the
+     * page has not written yet.
      */
     recognizesProcessor(psp: string): boolean;
     /**