@agent-cards/sdk 0.23.21 → 0.23.23

package/dist/cdp.js

@@ -8,23 +8,28 @@ import { MERCADO_CHECKOUT_PATTERN } from './mercado-checkout.generated.js';
 import { JuspayCheckoutGate } from './juspay-gate.js';
 import { ACI_CHECKOUT_REUSED, AciGate, playwrightReplacesNavigationBody } from './aci.js';
 import { EprotectGate, classifyEprotectRequest, eprotectScriptAnswer } from './eprotect.js';
+import { SbpsGate, classifySbpsRequest, sbpsScriptAnswer } from './sbps.js';
 import { dispatchPreClaim, eventUrl, isArmedCreditguardCall, routesHipayVault } from './pre-claim.js';
 import { GMO_TOKEN_V1_PATTERNS, gmoRequestShop, isGmoTokenV1Request, recognizesGmo } from './gmo.js';
 import { isPaddleVgsCardsUrl } from './paddle-vgs.generated.js';
+import { isToastPaymentMethodsUrl, readToastBody } from './toast.generated.js';
 import { PADDLE_VGS_PAY_PATTERNS, PaddleVgsPayGate, isPaddleCheckoutService, recognizesPaddleVgs } from './paddle-vgs-pay.js';
 import { DatatransRepeats } from './datatrans.js';
 import { TokenexIframeRepeats, isArmedTokenexIframeUrl } from './tokenex-iframe.js';
+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 { isArmedEkashuUrl } from './ekashu.js';
-import { isArmedTransbankUrl } from './transbank.js';
+import { isArmedTransbankUrl, transbankMerchantReturn, transbankMerchantReturnAnswer } from './transbank.js';
 import { isArmedRedsysUrl } from './redsys.js';
 import { isArmedPrzelewy24Url } from './przelewy24.js';
 import { isArmedQuickpayUrl } from './quickpay.js';
 import { COMGATE_CARD_PATTERNS, isArmedComgateUrl, servesComgate } from './comgate.js';
+import { isArmedEximbayUrl } from './eximbay.js';
 import { PAYPAL_HOSTED_FIELDS_PATTERNS, isPaypalHostedFieldsConfirm } from './paypal-hosted-fields.js';
 import { EBANX_RESEND_PATTERNS, EbanxFollowUps, isEbanxResendUrl } from './ebanx.js';
+import { PayrexxFollowUps } from './payrexx.js';
 import { PAYPAL_CARD_FORM_PATTERNS, isPaypalCardFormUrl } from './paypal-card-forms.js';
 import { CYBERSOURCE_SECURE_ACCEPTANCE_PATTERNS, CYBERSOURCE_SECURE_ACCEPTANCE_RECIPIENT, SecureAcceptanceFollowUpWatch, isCybersourceSecureAcceptanceUrl, secureAcceptanceFollowUp, secureAcceptanceFrameAnswer, secureAcceptanceReplyLast4, } from './cybersource-secure-acceptance.js';
 import { CheckoutAttachmentError, attachmentDeadline, attachmentFailure, withinAttachmentDeadline } from './attachment.js';
@@ -1288,9 +1293,23 @@ function requestIdentity(opts, url, method, body, documentUrl, pageAmount, flexS
     // out, so the shop joins the identity: a retry that names another shop needs its own approval.
     const shop = gmoRequestShop(url, body);
     const identity = shop === undefined ? shaped.shape : `${shaped.shape};gmo_shop:${JSON.stringify(shop)}`;
-    return { url, method, documentUrl, pageAmount, body: `${identity}${paddleVgsRetryKey(url, body, headers)}`,
+    return { url, method, documentUrl, pageAmount, body: `${identity}${paddleVgsRetryKey(url, body, headers)}${toastRetryKey(url, body)}`,
         amountEvidence: opts.amount != null || pageAmount !== undefined || shaped.namesAmount };
 }
+/**
+ * What a Toast card request's retry must repeat, beyond its shape: the sealed card opens at any Toast
+ * restaurant whose payment intent names it, and the frame seals the ZIP inside it, so the payment session
+ * and the ZIP join the identity. A request under another session or with another ZIP never receives the
+ * card the cardholder approved for the first, while the frame's retry, its placeholder sealed afresh, still
+ * does. A body Toast's reader refuses joins whole, so it matches nothing but itself. Empty for every other
+ * request.
+ */
+function toastRetryKey(url, body) {
+    if (!isToastPaymentMethodsUrl(url))
+        return '';
+    const read = readToastBody(body);
+    return `;toast:${JSON.stringify(read.ok ? [read.sessionSecret, read.postalCode] : body)}`;
+}
 /**
  * What a Paddle VGS card request's retry must repeat byte for byte, beyond its shape: Paddle's frame
  * sends its second request with the same body under the same bearer, and the bearer names the
@@ -1624,6 +1643,22 @@ function eprotectResumedReplay(replay, request) {
         throw new PaymentOutcomeUnknownError(replay.authorizationId, 'eprotect_registration_unconfirmed');
     return { ...replay, status: answer.status, headers: answer.headers, body: answer.body };
 }
+/**
+ * SB Payment Service's token request, resumed by the business, on the same terms as eProtect's above. The read
+ * carries the token as the API stored it, which the paused <script> cannot run, so it gets the answer authorize()
+ * gives on the create path (client.ts): the token inside the callback the paused URL named, under a script type,
+ * and only a token payment-core's judge accepts for that URL. A read in any other mode never answers it either.
+ * The paused URL alone decides, whatever recognizer claimed it. Any other request's replay passes as it came, and
+ * a create's replay never comes here, so no answer is wrapped twice.
+ */
+function sbpsResumedReplay(replay, request) {
+    if (classifySbpsRequest(request.url, request.method)?.kind !== 'token_request')
+        return replay;
+    const answer = replay.mode === 'token' ? sbpsScriptAnswer(request.url, replay) : null;
+    if (replay.mode !== 'token' || !answer)
+        throw new PaymentOutcomeUnknownError(replay.authorizationId, 'sbps_token_unconfirmed');
+    return { ...replay, status: answer.status, headers: answer.headers, body: answer.body };
+}
 /** 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) {
     const read = opts.vault.recognizerOf;
@@ -1867,8 +1902,11 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
     const juspayCheckout = new JuspayCheckoutGate(opts.vault);
     // The approved EBANX token request on this attachment and the sends claimed under it (ebanx.ts).
     const ebanxFollowUps = new EbanxFollowUps();
+    // The approved Payrexx card request on this attachment and the 3-D Secure sends claimed under it (payrexx.ts).
+    const payrexxFollowUps = new PayrexxFollowUps();
     const aci = new AciGate(opts.vault);
     const eprotect = new EprotectGate(opts.vault);
+    const sbps = new SbpsGate(opts.vault);
     // The merchant's follow-up request after a delivered Secure Acceptance reply (cybersource-secure-acceptance.ts).
     const secureAcceptanceFollowUpWatch = new SecureAcceptanceFollowUpWatch(opts.onEvent);
     lifecycle.abort.signal.addEventListener('abort', () => secureAcceptanceFollowUpWatch.end(), { once: true });
@@ -2786,7 +2824,7 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             // headers and body are read lazily, inside the gate that needs them (see PreClaimContext.request).
             request: { url: request.url, method: request.method, get headers() { return request.headers; }, get body() { return pausedBody(request); },
                 navigation: resourceType === 'Document' },
-            vault: opts.vault, guards, mercado: mercadoCheckout, stripe: stripeCheckout, aci, eprotect,
+            vault: opts.vault, guards, mercado: mercadoCheckout, stripe: stripeCheckout, aci, eprotect, sbps,
             // This adapter drives Chromium, which sends the body Fetch.continueRequest replaces on a
             // navigation (the ACI browser test's classic case, design gate G3).
             replacesNavigationBody: async () => true,
@@ -2821,6 +2859,7 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             datatrans: datatransRepeats,
             tokenexIframe: tokenexIframeRepeats,
             ebanx: ebanxFollowUps,
+            payrexx: payrexxFollowUps,
             frame: typeof frameId === 'string' && frameId ? frameId : undefined,
             payrails,
             shijiSts: { companions: shijiCompanions, page: () => cdpShijiPage(sessionId, frameId) },
@@ -2934,8 +2973,9 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
         // A request that skipped the spent preparation's claim and was not bound as
         // its retry (the approval ended while it was judged) is refused as that
         // claim would refuse it, never asked as a new approval.
-        // An EBANX send still out (a confirm that may pay) holds the attachment too: a new card request the page sends
-        // meanwhile, a second tap on the hosted page's Pay among them, would start another payment over it.
+        // An EBANX or Payrexx send still out (a confirm that may pay, a 3-D Secure step whose answer names the token the
+        // page charges) holds the attachment too: a new card request the page sends meanwhile, a second tap on the hosted
+        // page's Pay among them, would start another payment over it.
         const followUpOut = lifecycle.followUpsInFlight();
         if (terminal || lifecycle.isBlocked() || awaitingApproval || followUpOut || preparedRetry || Date.now() < quietUntil) {
             let repeatedAuthorizationId = null;
@@ -2946,7 +2986,7 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 }
             }
             const why = terminal ?? (lifecycle.isBlocked() ? lifecycle.getState().status : awaitingApproval ? 'an approval is already outstanding'
-                : followUpOut ? 'an EBANX send is in flight' : preparedRetry ? 'CheckoutPreparationError' : 'awaiting approval cooldown');
+                : followUpOut ? 'a follow-up send is in flight' : preparedRetry ? 'CheckoutPreparationError' : 'awaiting approval cooldown');
             opts.onEvent?.({ type: 'blocked', detail: why instanceof Error ? failureSummary(why) : String(why) });
             if (preparation)
                 preparationGate.retireUnboundClaim();
@@ -2987,8 +3027,9 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
         // The approval the device gave, and whether it reached a browser request.
         let approvedId = null;
         let deliveryBegun = false;
-        // Whether this handoff kept an EBANX approval's follow-ups (ebanxFollowUps.remember), which a failed handoff stops.
-        let ebanxRemembered = false;
+        // Whether this handoff kept an approval's follow-ups (ebanxFollowUps.remember, payrexxFollowUps.remember), which a
+        // failed handoff stops.
+        let followUpsRemembered = false;
         // The business's pause, so resume resolves once the page has its answer.
         let businessPause = null;
         // Hold mode: the person's release, settled with what came of it.
@@ -3169,7 +3210,7 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 holdRelease.settle(outcome);
                 throw new HoldAnsweredError(outcome);
             }
-            const replay = pause ? eprotectResumedReplay(await pause.replay, request) : await authorization;
+            const replay = pause ? sbpsResumedReplay(eprotectResumedReplay(await pause.replay, request), request) : await authorization;
             attempt.assertLive();
             approvedId = replay.authorizationId;
             if (lifecycle.isCancelled())
@@ -3219,8 +3260,14 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 // answered the device. The paused NAVIGATION is fulfilled with a page
                 // that says exactly that (see hosted-form.ts for why not an abort and
                 // why not a fake result page), and the same form is refused if the
-                // page posts it again.
-                const page = hostedFormSubmittedPage({ authorizationId: replay.authorizationId, merchant: opts.merchant, submittedAt: replay.submittedAt });
+                // page posts it again. A Webpay entry whose reviewed shop names its
+                // return page goes to that page instead, with the token of the link
+                // the approval was created from, the one the phone paid, since Webpay
+                // tells the shop of a payment only through that return (transbank.ts
+                // transbankMerchantReturn).
+                const merchantReturn = transbankMerchantReturn(request.url, pageOrigin);
+                const page = merchantReturn ? transbankMerchantReturnAnswer(merchantReturn)
+                    : hostedFormSubmittedPage({ authorizationId: replay.authorizationId, merchant: opts.merchant, submittedAt: replay.submittedAt });
                 // A navigation response is never CORS-checked, so the CORS wrap is
                 // inert here; it is applied so every fulfill goes through one path.
                 await cdp.send('Fetch.fulfillRequest', {
@@ -3232,8 +3279,10 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 attempt.assertLive();
                 lastSubmitted = { url: deliverRequest.url, body: deliverBody, at: Date.now(), authorizationId: replay.authorizationId };
                 // Named for what it is: a device-attested submission with no
-                // processor evidence, never an `authorized` event.
-                opts.onEvent?.({ type: 'submitted_on_device', detail: { authorizationId: replay.authorizationId, submittedAt: replay.submittedAt, outcome: replay.outcome } });
+                // processor evidence, never an `authorized` event. A return names the
+                // shop's host, never the URL, which carries Webpay's token.
+                opts.onEvent?.({ type: 'submitted_on_device', detail: { authorizationId: replay.authorizationId, submittedAt: replay.submittedAt, outcome: replay.outcome,
+                        ...(merchantReturn ? { merchantReturn: { host: new URL(merchantReturn).hostname } } : {}) } });
             }
             else if (replay.mode === 'cse') {
                 // The device encrypted the card for the processor; the request itself
@@ -3322,12 +3371,14 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                     throw new PaymentOutcomeUnknownError(replay.authorizationId, 'paddle_vgs_card_facts_unavailable');
                 }
                 // An approved EBANX token request whose read names a window covers the 3-D Secure calls and the confirm the
-                // page sends next (ebanx.ts): kept as the API stored it, the request that raised the approval. Kept before the
-                // page has the answer, since the page may send its first 3-D Secure call the moment the answer lands; a
-                // handoff that then fails stops them (the catch below).
+                // page sends next (ebanx.ts), and an approved Payrexx card request whose answer started 3-D Secure covers the
+                // card frame's two 3-D Secure sends (payrexx.ts): kept as the API stored it, the request that raised the
+                // approval. Kept before the page has the answer, since the page may send its first 3-D Secure call the moment
+                // the answer lands; a handoff that then fails stops them (the catch below).
                 if (replay.mode !== 'device_encrypt') {
                     ebanxFollowUps.remember({ url: request.url, body }, replay);
-                    ebanxRemembered = true;
+                    payrexxFollowUps.remember({ url: request.url, body }, replay);
+                    followUpsRemembered = true;
                 }
                 await cdp.send('Fetch.fulfillRequest', {
                     requestId: deliverTo,
@@ -3365,10 +3416,12 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 authorizationId: approvedId ?? lifecycle.getState().authorizationId, detail: failureSummary(err) });
             // Ignore the failure event caused by our own safe decline/error abort.
             const dead = attempt.target ?? { requestId, sessionId };
-            // An EBANX token answer this handoff kept follow-ups for and did not finish handing over: nothing after it is
-            // claimed (ebanx.ts EbanxFollowUps.stop).
-            if (ebanxRemembered)
+            // An answer this handoff kept follow-ups for and did not finish handing over: nothing after it is claimed
+            // (ebanx.ts EbanxFollowUps.stop, payrexx.ts PayrexxFollowUps.stop).
+            if (followUpsRemembered) {
                 ebanxFollowUps.stop();
+                payrexxFollowUps.stop();
+            }
             // The business's resume settles once the request is answered: a terminal read is an answer (failed, nothing charged), a lost handoff is not.
             const settlePause = () => { if (businessPause) {
                 if (isApprovalOutcome(err))
@@ -3541,9 +3594,12 @@ export async function attachToPlaywright(page, opts) {
     const juspayCheckout = new JuspayCheckoutGate(opts.vault);
     // The approved EBANX token request on this attachment and the sends claimed under it (ebanx.ts).
     const ebanxFollowUps = new EbanxFollowUps();
+    // The approved Payrexx card request on this attachment and the 3-D Secure sends claimed under it (payrexx.ts).
+    const payrexxFollowUps = new PayrexxFollowUps();
     const aci = new AciGate(opts.vault);
     let navigationBodyReplaced;
     const eprotect = new EprotectGate(opts.vault);
+    const sbps = new SbpsGate(opts.vault);
     // The merchant's follow-up request after a delivered Secure Acceptance reply (cybersource-secure-acceptance.ts).
     const secureAcceptanceFollowUpWatch = new SecureAcceptanceFollowUpWatch(opts.onEvent);
     lifecycle.abort.signal.addEventListener('abort', () => secureAcceptanceFollowUpWatch.end(), { once: true });
@@ -3845,6 +3901,9 @@ export async function attachToPlaywright(page, opts) {
             || opts.vault.isCardRequest(url.toString(), 'GET')
             || guards.matches(url.toString()) || stripeCheckout.matches(url.toString()) || mercadoCheckout.matches(url.toString())
             || eprotect.matches(url.toString())
+            // SB Payment Service's token request is a GET too, so its family is routed by the SBPS gate (never
+            // its scripts or the 3-D Secure info request).
+            || sbps.matches(url.toString())
             // An armed merchant profile's endpoint or a sibling of it (merchant-hosted.ts), as attachToCdp arms it.
             || (typeof opts.vault.merchantProfileOf === 'function' && opts.vault.merchantProfileOf(url.toString()) !== null)
             // An armed Verifone merchant's origin (verifone.ts), as attachToCdp arms it.
@@ -3870,6 +3929,10 @@ export async function attachToPlaywright(page, opts) {
             // Every request to a Webpay host once its entry is served (transbank.ts), as attachToCdp arms the hosts: the
             // token's submit and Webpay's card steps reach the Webpay gate and fail, and the entry pauses.
             || isArmedTransbankUrl(opts.vault, url.toString())
+            // Every request to Paytrail's entry host and Payment Highway's card page host once Paytrail's entry is served
+            // (paytrail.ts), as attachToCdp arms the recognizer's host and its abort host: the loading page's post and the
+            // card page's card requests reach the Paytrail gate and fail.
+            || isArmedPaytrailUrl(opts.vault, url.toString())
             // A CreditGuard page's own calls beside its submit (its card lookup and its 3-D Secure calls), for an
             // org the API served CreditGuard to, as attachToCdp arms its hosts: the CreditGuard gate answers them
             // under a ready preparation and lets them go on with none (pre-claim.ts isArmedCreditguardCall).
@@ -3886,6 +3949,9 @@ export async function attachToPlaywright(page, opts) {
             // Every request on the TokenEx iframe's /iframe/v3 path once its entry is served (tokenex-iframe.ts), as attachToCdp
             // arms its hosts: a card post the recognizer's exact URL does not match reaches the TokenEx gate and fails.
             || isArmedTokenexIframeUrl(opts.vault, url.toString())
+            // Every request to an Eximbay host once its entry is served there (eximbay.ts), as attachToCdp arms the host: the
+            // step, the window's lookups and its card post reach the Eximbay gate and fail.
+            || isArmedEximbayUrl(opts.vault, url.toString())
             // PayPal's legacy Hosted Fields confirm, for every org, as attachToCdp arms it (paypal-hosted-fields.ts).
             || isPaypalHostedFieldsConfirm(url.toString())
             // PayPal's Card Fields confirm and GraphQL on www.paypal.com, for every org, as attachToCdp arms them (paypal-card-forms.ts).
@@ -3934,7 +4000,7 @@ export async function attachToPlaywright(page, opts) {
                     catch {
                         return false;
                     } } },
-                vault: opts.vault, guards, mercado: mercadoCheckout, stripe: stripeCheckout, aci, eprotect,
+                vault: opts.vault, guards, mercado: mercadoCheckout, stripe: stripeCheckout, aci, eprotect, sbps,
                 // Asked once, and only for ACI's classic-mode /payment: whether this page's engine sends
                 // the body route.continue replaces on a navigation (aci.ts playwrightReplacesNavigationBody).
                 replacesNavigationBody: () => (navigationBodyReplaced ??= playwrightReplacesNavigationBody(page)),
@@ -3993,6 +4059,7 @@ export async function attachToPlaywright(page, opts) {
                 datatrans: datatransRepeats,
                 tokenexIframe: tokenexIframeRepeats,
                 ebanx: ebanxFollowUps,
+                payrexx: payrexxFollowUps,
                 frame: frameOf(request),
                 payrails,
                 shijiSts: { companions: shijiCompanions, page: async () => (await playwrightShijiDocumentPage(request)) ?? `pw:none:${++playwrightShijiSeq}` },
@@ -4087,7 +4154,7 @@ export async function attachToPlaywright(page, opts) {
             // identically whichever adapter is attached. An Amadeus card request is
             // 'failed' (ERR_FAILED) in both too, see failsAsNetworkError (refusalFailure).
             // As in attachToCdp: an unbound request that skipped the spent preparation's claim is refused.
-            // As in attachToCdp: an EBANX send still out holds the attachment too.
+            // As in attachToCdp: an EBANX or Payrexx send still out holds the attachment too.
             const followUpOut = lifecycle.followUpsInFlight();
             if (terminal || lifecycle.isBlocked() || awaitingApproval || followUpOut || preparedRetry || Date.now() < quietUntil) {
                 let repeatedAuthorizationId = null;
@@ -4102,7 +4169,7 @@ export async function attachToPlaywright(page, opts) {
                     }
                 }
                 const why = terminal ?? (lifecycle.isBlocked() ? lifecycle.getState().status : awaitingApproval ? 'an approval is already outstanding'
-                    : followUpOut ? 'an EBANX send is in flight' : preparedRetry ? 'CheckoutPreparationError' : 'awaiting approval cooldown');
+                    : followUpOut ? 'a follow-up send is in flight' : preparedRetry ? 'CheckoutPreparationError' : 'awaiting approval cooldown');
                 opts.onEvent?.({ type: 'blocked', detail: why instanceof Error ? failureSummary(why) : String(why) });
                 if (preparation)
                     preparationGate.retireUnboundClaim();
@@ -4156,7 +4223,7 @@ export async function attachToPlaywright(page, opts) {
             let approvedId = null;
             let deliveryBegun = false;
             // See the same flag in attachToCdp.
-            let ebanxRemembered = false;
+            let followUpsRemembered = false;
             // A prepared Amadeus SDK add must be sent within its window (see amadeus.ts).
             let disarmSendWindow = null;
             try {
@@ -4291,13 +4358,17 @@ export async function attachToPlaywright(page, opts) {
                 }
                 else if (replay.mode === 'hosted_form') {
                     // Same as the CDP path: the paused navigation resolves to the
-                    // synthetic page, and a re-post of this form is refused.
-                    const synthetic = hostedFormSubmittedPage({ authorizationId: replay.authorizationId, merchant: opts.merchant, submittedAt: replay.submittedAt });
+                    // synthetic page, or a reviewed Webpay shop's return page, and a
+                    // re-post of this form is refused.
+                    const merchantReturn = transbankMerchantReturn(request.url(), pageOrigin);
+                    const synthetic = merchantReturn ? transbankMerchantReturnAnswer(merchantReturn)
+                        : hostedFormSubmittedPage({ authorizationId: replay.authorizationId, merchant: opts.merchant, submittedAt: replay.submittedAt });
                     // Inert on a navigation (never CORS-checked); one path for every fulfill.
                     await deliverTo.fulfill({ status: synthetic.status, headers: withCorsHeaders(synthetic.headers, corsHeadersFor(deliverRequest.url(), deliverRequest.headers())), body: synthetic.body });
                     assertRequestLive();
                     lastSubmitted = { url: deliverRequest.url(), body: deliverBody, at: Date.now(), authorizationId: replay.authorizationId };
-                    opts.onEvent?.({ type: 'submitted_on_device', detail: { authorizationId: replay.authorizationId, submittedAt: replay.submittedAt, outcome: replay.outcome } });
+                    opts.onEvent?.({ type: 'submitted_on_device', detail: { authorizationId: replay.authorizationId, submittedAt: replay.submittedAt, outcome: replay.outcome,
+                            ...(merchantReturn ? { merchantReturn: { host: new URL(merchantReturn).hostname } } : {}) } });
                 }
                 else if (replay.mode === 'cse') {
                     // Same as the CDP path: the request continues from this browser
@@ -4374,7 +4445,8 @@ export async function attachToPlaywright(page, opts) {
                     // See the same step in attachToCdp: kept before the page has the answer.
                     if (replay.mode !== 'device_encrypt') {
                         ebanxFollowUps.remember({ url: request.url(), body }, replay);
-                        ebanxRemembered = true;
+                        payrexxFollowUps.remember({ url: request.url(), body }, replay);
+                        followUpsRemembered = true;
                     }
                     await deliverTo.fulfill({ status: replay.status, headers: withCorsHeaders(replay.headers, cors.headers), body: replay.body });
                     datatransRepeats.remember(frameOf(deliverRequest), deliverRequest.url(), deliverBody, replay);
@@ -4393,8 +4465,10 @@ export async function attachToPlaywright(page, opts) {
             catch (err) {
                 const dead = attempt.target?.route ?? route;
                 // See the same step in attachToCdp.
-                if (ebanxRemembered)
+                if (followUpsRemembered) {
                     ebanxFollowUps.stop();
+                    payrexxFollowUps.stop();
+                }
                 if (activeRequest?.attempt === attempt)
                     activeRequest = null;
                 try {

package/dist/client.d.ts

@@ -211,6 +211,12 @@ export declare const SUPPORTED_REGISTRY_FEATURES: readonly string[];
  * never lets the agent's browser post to (pre-claim.ts, redsys.ts). Served on the same terms as NMI's: only
  * to a build that lists it, for a company Agentcard turned Redsys on for.
  *
+ * `paytrail_hosted_payment_page`: Paytrail's card method, whose card-free signed Visa and Mastercard
+ * entry this build pauses for the cardholder's device, and whose loading page post, card page posts and
+ * card-number lookup on Payment Highway's host this build never lets the agent's browser send
+ * (pre-claim.ts, paytrail.ts). Served on the same terms as NMI's and Redsys's: only to a build that lists
+ * it, for a company Agentcard turned Paytrail on for.
+ *
  * `paddle_vgs_cards`: the card request Paddle's checkout frame sends to its VGS card
  * vault (vault.paddle.com/cards) on a checkout that names VGS, only through a prepared
  * checkout: the frame aborts the request 10 seconds after Pay and sends it once more,
@@ -274,6 +280,22 @@ export declare const SUPPORTED_REGISTRY_FEATURES: readonly string[];
  * company until a reviewed change binds GoPay's payee and amount to the approval: the post names
  * neither. The API takes it only at a shop Agentcard reviewed.
  *
+ * `paygent_token`: the token request Paygent's own PaygentToken.js sends from a merchant's
+ * page (token.paygent.co.jp/n/token/request), only through a prepared checkout: the script
+ * abandons the request 35 seconds after the press that sends it, so the cardholder approves
+ * before the press. The cardholder's device sends the card itself and the page gets back
+ * Paygent's single-use token alone; the SDK refuses a second token request on the same approval.
+ * Served on the same terms: only to a build that lists it, for a company Agentcard turned
+ * Paygent on for.
+ *
+ * `payrexx_card_frame`: the card request Payrexx Pay's card frame sends to its own URL
+ * (checkout.payrexx.com/?pspId=44&lang=<xx>) on a Payrexx merchant's page. This build pauses only
+ * the frame's own one-time card request and answers it with Payrexx's answer as the API recorded
+ * it: the token the merchant's page then charges, or the start of 3-D Secure, whose two later sends
+ * of the card this build hands to the cardholder's device under the same approval (payrexx.ts,
+ * pre-claim.ts payrexxPreClaim). The cardholder's device sends the card through the checkout relay.
+ * Served only to a build that lists it, for a company Agentcard turned Payrexx on for.
+ *
  * `hipay_vault_token`: the token create HiPay's hosted fields send to HiPay's Secure Vault
  * (secure2-vault.hipay-tpp.com, stage-secure2-vault for a test row), only through a prepared
  * checkout: the merchant's page gives the frame 20 seconds after Pay. The cardholder's device
@@ -311,8 +333,8 @@ export declare const SUPPORTED_REGISTRY_FEATURES: readonly string[];
  * This build pauses only the form's own multipart body at that exact URL; the cardholder's
  * device sends the card through the checkout relay, and the frame gets the token answer
  * payment-core's judge rebuilt, with the CORS answer for the frame's own origin, null. The
- * request names no amount, so the agent's pair, above zero, is the one the cardholder approves
- * (PAY_NL_PSP below). Served on the same terms: only to a build that lists it, for a company
+ * request 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 Pay. on for.
  *
  * `paypal_card_fields`: PayPal Card Fields' confirm, the POST its v5 frame sends to
@@ -373,6 +395,74 @@ export declare const SUPPORTED_REGISTRY_FEATURES: readonly string[];
  * device sends the card itself, and the API holds the payment to a merchant Agentcard reviewed, at the
  * amount SumUp holds for the checkout. Served on the same terms: only to a build that lists it, for a
  * company Agentcard turned SumUp on for.
+ *
+ * `clover_card_token`: the card token request Clover's card frame (the hidden frame of
+ * checkout.clover.com that Clover's iframe mounts on a merchant's page) sends to
+ * token.clover.com/v1/tokens (token-sandbox.dev.clover.com for a test row), with the number
+ * encrypted under Clover's key. This build pauses only the frame's own body at that exact URL; the
+ * cardholder's device builds the request again with the real card under the key payment-core pins
+ * and sends it to Clover itself, and the frame gets the token answer payment-core's judge rebuilt.
+ * The request 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 Clover on for.
+ *
+ * `eximbay_hosted_payment_page`: Eximbay's payment window, whose card-free signed entry
+ * (a form post to /Gateway/BasicProcessor.krp on secureapi.eximbay.com, or its test host) this
+ * build pauses for the cardholder's device, in the page or in a window it opened once attachToCdp
+ * has armed that window (eximbay.ts names the entry that can leave first), and whose
+ * step, amount query, card lookup and card post this build never lets the agent's browser send
+ * (pre-claim.ts, eximbay.ts). Served on the same terms as NMI's and Redsys's: only to a build
+ * that lists it, for a company Agentcard turned Eximbay on for.
+ *
+ * `toast_pinned_key`: the card request Toast's payments frame sends to
+ * payments.toasttab.com/v1/payment-methods on a Toast online-ordering checkout, with
+ * the card sealed in card.cardData under one key every Toast restaurant shares. The
+ * cardholder's device seals the real card under that key, which payment-core pins, and
+ * this build writes it over the agent's placeholder and nothing else before it
+ * continues the request. Served on the same terms: only to a build that lists it, for
+ * a company Agentcard turned Toast on for.
+ *
+ * `xendit_card_token`: the card token request Xendit's hosted invoice checkout
+ * (checkout.xendit.co/web/<invoice id>, where Xendit's payment and donation links land) sends
+ * when the payer presses Pay Now: Xendit.js posts the card as JSON to
+ * https://api.xendit.co/v2/credit_card_tokens from the page itself, under the business's
+ * publishable key. This build pauses only the card form's single-use token body at that exact URL
+ * (payment-core xendit.js); a token that keeps the card on file, Xendit.js's code-only storeCVN post
+ * and any other body there fail in the browser before anything is created. The cardholder's device
+ * sends the request itself with the real card, and the page gets the token answer payment-core's
+ * judge rebuilt, after which the page runs 3-D Secure and charges the token without the card. The
+ * token names the invoice's amount and currency, so no agent pair is needed: the API reads the
+ * token's and holds an agent's pair to it. Served on the same terms: only to a build that lists it,
+ * for a company Agentcard turned Xendit on for.
+ *
+ * `omise_card_token`: the card token request every Omise card form sends, Omise.js's pay.html frame
+ * or a merchant's own page calling Omise.js or Omise's Node library: a JSON POST to
+ * https://vault.omise.co/tokens under the merchant's public key. This build pauses only the card
+ * form's token body at that exact URL (payment-core omise.js); a wallet's tokenization and any other
+ * body there fail in the browser before anything is created. The cardholder's device sends the
+ * request itself with the real card, and the page gets the token answer payment-core's judge
+ * rebuilt. The request names no amount, so the agent's pair, above zero, is the one the cardholder
+ * approves, and the API pays only a merchant payment-core pins for the checkout
+ * page the create names. Served on the same terms: only to a build that lists it, for a company
+ * Agentcard turned Omise on for.
+ *
+ * `sbps_token_jsonp`: SB Payment Service's card token request, the JSONP <script>
+ * GET its token script sends to /token/generateToken on token.sps-system.com. This
+ * build pauses it only as the browser writes it, aborts any other request on that
+ * path, and answers the paused script with the token as the API recorded it, in the
+ * request's own callback. The device rebuilds the card's ciphertext and sends it
+ * through the checkout relay. Served on the same terms: only to a build that lists
+ * it, for a company Agentcard turned SB Payment Service on for.
+ *
+ * `midtrans_card_token`: the card token Midtrans' Snap popup posts as one JSON request to
+ * api.midtrans.com/v2/token (api.sandbox.midtrans.com in test), under the business's
+ * publishable client key. The cardholder's device sends it and the page gets back Midtrans'
+ * token, which the merchant's own server charges afterwards, card free, running 3-D Secure
+ * there. The token names no amount, so authorize() needs the agent's pair.
+ * 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.
+ *
+ * The list itself is capabilities.json, sorted, one per line (scripts/generate-capabilities.mjs).
  */
 export declare const SUPPORTED_CAPABILITIES: readonly string[];
 /**
@@ -452,8 +542,9 @@ export interface TokenReplay extends ExecutionMetadata {
     amountAuthority?: AmountAuthority;
     /**
      * An EBANX token approval that covers the sends EBANX's page makes after it (its 3-D Secure calls and the hosted
-     * page's confirm), for a company Agentcard turned that on for: until when (ISO 8601) the adapters may ask the
-     * cardholder's device to send them (sendEbanxFollowUp). Absent on every other approval.
+     * page's confirm), for a company Agentcard turned that on for, or a Payrexx card request whose answer started 3-D
+     * Secure, which covers the card frame's two 3-D Secure sends: until when (ISO 8601) the adapters may ask the
+     * cardholder's device to send them (sendEbanxFollowUp, sendPayrexxFollowUp). Absent on every other approval.
      */
     followUpsUntil?: string;
 }
@@ -556,7 +647,10 @@ export interface VerifoneReplay extends ExecutionMetadata {
  * paused the navigation, so there is no response to replay and no outcome
  * here: resolve the paused navigation with hostedFormSubmittedPage() (the
  * adapters do), never resubmit the form, and confirm the order with the
- * merchant, which learns the outcome from the processor.
+ * merchant, which learns the outcome from the processor. Webpay's merchant
+ * learns it only from the buyer's browser, so the adapters send a paused
+ * Webpay entry whose reviewed shop names its return page to that page instead
+ * (transbankMerchantReturn).
  *
  * THIS IS NOT AN APPROVED PAYMENT. `kind` and `outcome` say so in words so
  * no caller mistakes it for one: the API finishes such an authorization as
@@ -1230,12 +1324,12 @@ export interface PresetRefusal {
 /** A decline reason only the company presets stamp (see PresetRefusedError). */
 export declare const PRESET_REFUSAL_REASONS: ReadonlySet<string>;
 /**
- * How often sendEbanxFollowUp reads a send back while the cardholder's device has it: every half second, whatever the
- * client's own `pollIntervalMs`. One send is out at a time per approval, so this is 120 reads a minute, inside the
- * API's 240 a minute per caller and authorization (routes/api/v2/checkout-follow-ups.ts).
+ * How often sendEbanxFollowUp and sendPayrexxFollowUp read a send back while the cardholder's device has it: every
+ * half second, whatever the client's own `pollIntervalMs`. One send is out at a time per approval, so this is 120
+ * reads a minute, inside the API's 240 a minute per caller and authorization (routes/api/v2/checkout-follow-ups.ts).
  */
 export declare const EBANX_FOLLOW_UP_READ_MS = 500;
-/** The longest sendEbanxFollowUp waits after reads the API refused as too many (429): 1, 2, 4, 8, then 15 seconds. */
+/** The longest a follow-up send waits after reads the API refused as too many (429): 1, 2, 4, 8, then 15 seconds. */
 export declare const EBANX_FOLLOW_UP_BACKOFF_MAX_MS = 15000;
 export declare class CheckoutApiError extends Error {
     status: number;
@@ -1318,6 +1412,11 @@ export declare class CheckoutAuthError extends Error {
  * https://pgw-ui.2c2p.com/payment/4.1/{token}.
  * On QuickPay's host the window's session reads `{session}`:
  * https://payment.quickpay.net/{session}/3ds_auth.
+ * On FastSpring's store hosts the session id reads `{session}`:
+ * https://daisydisk.onfastspring.com/session/{session}/payment.
+ * On PayU Latam's hosts the checkout session's key reads `{key}`:
+ * https://checkout.payulatam.com/ppp-web-gateway-payu/checkout/submit/co/credit_card/{key}.
+ * Each mask in src/url-masks/ says what it reads in its own file.
  * A string that is not a URL keeps the part before any `?` or `#`, with the
  * same segments masked for every processor whose host it names.
  * A URL is read by its host only when the parser finds one. Text before a URL
@@ -1708,6 +1807,28 @@ export declare class VaultClient {
         headers: Record<string, string>;
         body: string;
     }>;
+    /**
+     * Send one of Payrexx's 3-D Secure sends an approved Payrexx card request covers (payrexx.ts says which: the card
+     * frame's authentication after the ACS method and its post-authentication after the bank's challenge, bound to that
+     * approval) from the cardholder's device, and resolve with Payrexx's answer for the paused request, exactly as
+     * sendEbanxFollowUp does for EBANX: the same create, reads and clocks, and no prompt. Rejects with a
+     * PayrexxFollowUpError naming why there is no answer and whether the card may have reached Payrexx.
+     */
+    sendPayrexxFollowUp(authorizationId: string, request: {
+        url: string;
+        method: 'POST';
+        headers: Record<string, string>;
+        body: string;
+    }, options?: {
+        signal?: AbortSignal;
+        until?: number;
+    }): Promise<{
+        status: number;
+        headers: Record<string, string>;
+        body: string;
+    }>;
+    /** The send behind sendEbanxFollowUp and sendPayrexxFollowUp; `fail` builds the processor's error for a send with no answer. */
+    private sendFollowUp;
     /**
      * Create a merchant-session probe, the phase-0 read of the deterministic merchant total:
      * `user` is the org's connected user, who opens the returned Vault link and reads the