@agent-cards/sdk 0.23.20 → 0.23.22

package/dist/client.js

@@ -2,7 +2,12 @@ import { BUILTIN_REGISTRY, cardUrlPatterns as deriveCardUrlPatterns, LOOPBACK_UR
 import { armServedProfiles, classifyProfileRequest, declareSandboxMerchant, merchantProfileEnvironment, merchantProfileFor, merchantProfileUrlPatterns, } from './merchant-hosted.js';
 import { merchantAmountExchanges, merchantAmountFromResponses, merchantProfilePricedBySource, merchantTotalWire, MerchantTotalWait, } from './merchant-total.js';
 import { ACI_CAPABILITY, ACI_PSP, aciCardLegAnswer } from './aci.js';
+import { PRZELEWY24_CAPABILITY, PRZELEWY24_PSP } from './przelewy24.js';
 import { EPROTECT_CAPABILITY, EPROTECT_PSP, eprotectCheckoutRefusal, eprotectScriptAnswer, isEprotectRegistration } from './eprotect.js';
+import { COMGATE_CAPABILITY, COMGATE_PSP } from './comgate.js';
+import { EXIMBAY_CAPABILITY } from './eximbay.js';
+import { isHostedGetEntry } from './hosted-entry.js';
+import { TRANSBANK_CAPABILITY, TRANSBANK_PSP } from './transbank.js';
 import { isMercadoTokenRequest, parseMercadoCheckoutContext, validateMercadoProcessorContext } from './mercado-checkout.generated.js';
 import { matchesPreparation, preparationMode, validPreparationEnvironment } from './prepared-processor.js';
 import { fiservKeyPinById, isFiservSubstitution, requiresFiservPreparation } from './fiserv.js';
@@ -15,10 +20,12 @@ 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, paddleVgsCardFactsOf } from './paddle-vgs.generated.js';
+import { PAYGENT_CAPABILITY, PAYGENT_PSP, paygentAnswerOutcome } from './paygent.generated.js';
 import { PADDLE_TOKENEX_CAPABILITY, PADDLE_TOKENEX_PSP, isPaddleTokenexServedFacts, isPaddleTokenexServedSubstitution } from './paddle-tokenex.js';
 import { TWOC2P_CAPABILITY, TWOC2P_PSP } from './twoc2p.js';
 import { WIX_PAYMENTS_CAPABILITY, WIX_PAYMENTS_PSP } from './wix-payments.generated.js';
 import { HIPAY_CAPABILITY, HIPAY_PSP } from './hipay.generated.js';
+import { TOAST_CAPABILITY, TOAST_PSP, isToastCiphertext } from './toast.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';
@@ -32,11 +39,13 @@ import { JUSPAY_CAPABILITY, JUSPAY_PSP, juspayPageAnswer } from './juspay-gate.j
 import { CARD_ENDPOINT_MODE, CARD_ENDPOINT_PSP, CardEndpointRefusedError, cardEndpointById, cardEndpointLive, cardEndpointSessionRefusal, } from './card-endpoint.js';
 import { merchantCardEndpointFactsRefusal as sharedFactsRefusal, readMerchantCardEndpointFacts as sharedReadFacts, } from './merchant-card-endpoints.generated.js';
 import { DATATRANS_CAPABILITY } from './datatrans.js';
+import { TOKENEX_IFRAME_CAPABILITY, TOKENEX_IFRAME_PSP, tokenexIframePageAnswer, tokenexIframePlaceholderFits } from './tokenex-iframe.js';
 import { PELECARD_CAPABILITY, PELECARD_PSP } from './pelecard.js';
 import { PRIMER_CAPABILITY, PRIMER_PSP, primerTokenAnswer } from './primer.js';
 import { PAYRAILS_CAPABILITY, isPayrailsPaymentUrl, payrailsAnswer } from './payrails.js';
 import { WSPAY_CAPABILITY, WSPAY_PSP } from './wspay.js';
 import { EbanxFollowUpError } from './ebanx.js';
+import { PAYREXX_CAPABILITY, PAYREXX_PSP, PayrexxFollowUpError } from './payrexx.js';
 import { SECURE_ACCEPTANCE_CAPABILITY, SECURE_ACCEPTANCE_FAST_POLL_MS, SECURE_ACCEPTANCE_PSP, SECURE_ACCEPTANCE_REPLY_WINDOW_MS, secureAcceptanceCheckoutProfile, secureAcceptanceCheckoutRefusal, secureAcceptanceFrameAnswer, } from './cybersource-secure-acceptance.js';
 /**
  * The modes this SDK can finish. Asked for on syncRegistry (the API serves
@@ -228,6 +237,13 @@ export const SUPPORTED_REGISTRY_FEATURES = ['card_fields', 'checkout_sessions'];
  * checkout relay. Served on the same terms: only to a build that lists it, for a company
  * Agentcard turned Payfast on for.
  *
+ * `przelewy24_hosted_payment_page`: Przelewy24's pay wall, whose card-free link
+ * (secure.przelewy24.pl/trnRequest/<token>, 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 card method post, card form post and Saferpay resolver this build never lets the
+ * agent's browser send (pre-claim.ts, przelewy24.ts). Served on the same terms as NMI's and
+ * Redsys's: only to a build that lists it, for a company Agentcard turned Przelewy24 on for.
+ *
  * `wix_payments_tokenize`: the card request Wix Cashier's card frame sends to Wix's
  * tokenizer (cashier-pci.wixapps.net), only through a prepared checkout: Wix's payment
  * widget fails the payment 30 seconds after it asks the frame for a token. The
@@ -244,6 +260,31 @@ export const SUPPORTED_REGISTRY_FEATURES = ['card_fields', 'checkout_sessions'];
  * the checkout relay. Served on the same terms: only to a build that lists it, for a company
  * Agentcard turned PayMongo on for.
  *
+ * `gopay_card_form`: the card post GoPay's card frame sends to its own URL
+ * (secure.gopay.com/gp-card-comm/h/<token>) inside the GoPay gateway a shop opens. This build pauses
+ * only the frame's own card post and answers it with GoPay's answer as the API recorded it, the
+ * empty JSON object the frame reads; the gateway then reads the payment's end from GoPay and runs
+ * 3-D Secure in the agent's browser when the bank asks for it. The cardholder's device sends the card
+ * through the checkout relay. Served only to a build that lists it, and only for Agentcard's proof
+ * 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
@@ -265,9 +306,117 @@ export const SUPPORTED_REGISTRY_FEATURES = ['card_fields', 'checkout_sessions'];
  * Secure step and card lookup this build never lets the agent's browser send (pre-claim.ts,
  * quickpay.ts). Served on the same terms as NMI's and Redsys's: only to a build that lists it, for a
  * company Agentcard turned QuickPay on for.
+ *
+ * `revolut_card_field`: the card payment Revolut Business's card field or card popup sends from
+ * its frame to /api/public/orders/<order token>/payments on merchant.revolut.com, on a merchant's
+ * own page or Revolut's hosted checkout. This build pauses only the frame's card payment and
+ * answers it with Revolut's answer as the API recorded it: the payment Revolut created, which the
+ * frame then follows, through any 3-D Secure step, in the agent's browser. A payment by Apple Pay,
+ * Google Pay or Revolut Pay on the same URL carries no card and continues untouched. Revolut's
+ * host answers the Vault's origin, so the cardholder's device sends the card itself, with no relay.
+ * Served on the same terms: only to a build that lists it, for a company Agentcard turned Revolut
+ * on for.
+ *
+ * `pay_nl_card_token`: the card token request a shop's card form sends to Pay. (pay.nl),
+ * Weeztix's sandboxed frame posting its FormData to payment.pay.nl/v1/Payment/getCardToken/json.
+ * 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
+ * Agentcard turned Pay. on for.
+ *
+ * `paypal_card_fields`: PayPal Card Fields' confirm, the POST its v5 frame sends to
+ * www.paypal.com and its v6 frame to api-m.paypal.com. This build pauses it only in
+ * the frames' own shape, refuses one that asks PayPal to keep the card or forces
+ * 3-D Secure in the browser with a `blocked` event, and answers the frame with the
+ * order's id and status as the API recorded them. The device sends a v5 confirm
+ * through the checkout relay and a v6 one directly. Served on the same terms: only
+ * to a build that lists it, for a company Agentcard turned PayPal Card Fields on
+ * for. Every other company keeps the checkout guard's refusal (paypal-card-forms.ts).
+ *
+ * `comgate_hosted_payment_page`: ComGate's payment gateway, whose card-free gateway link
+ * (payN.comgate.cz/init?id=<transaction id>, a plain GET) this build pauses for the
+ * cardholder's device by its exact link (hosted-entry.ts), in the page, in a frame of it or
+ * in a window it opened, and whose card hosts this build never lets the agent's browser post
+ * to (pre-claim.ts, comgate.ts). Served on the same terms as NMI's and Redsys's: only to a
+ * build that lists it, for a company Agentcard turned ComGate on for.
+ *
+ * `makecommerce_card_frame`: the card post MakeCommerce's card frame sends to its own card endpoint
+ * (cc.maksekeskus.ee/card-payment) under the shop's publishable key. This build pauses only the
+ * frame's own one-time card payment and answers it with MakeCommerce's answer as the API recorded
+ * it: the URL of MakeCommerce's 3-D Secure page, which the frame then opens in the agent's browser.
+ * The cardholder's device sends the card through the checkout relay. Served on the same terms: only
+ * to a build that lists it, for a company Agentcard turned MakeCommerce on for.
+ *
+ * `poynt_collect_nonce`: GoDaddy Payments' card request, the POST Poynt Collect's
+ * card frame sends to a store's generate-nonce on services.poynt.net. This build
+ * pauses it only as the frame writes it, refuses a body that asks Poynt to keep the
+ * card in the browser with a `blocked` event, and answers the frame with the nonce as
+ * the API recorded it. The device sends the card through the checkout relay. Served
+ * on the same terms: only to a build that lists it, for a company Agentcard turned
+ * GoDaddy Payments on for.
+ *
+ * `tokenex_iframe_tokenize`: the card post TokenEx's hosted iframe v3 sends from its card-number frame
+ * to its own document URL on htp.tokenex.com (JetBlue's card form). This build pauses only the PCI frame's
+ * own card post with its CVV frame, refuses in the browser every other post on that path that carries a
+ * card (tokenex-iframe.ts), answers it with TokenEx's token as the API recorded it, rebuilt from
+ * payment-core's allow-list, and answers the same frame's byte-identical repeat from that answer while the
+ * approval is being handed off. Served on the same terms: only to a build that lists it, for a company
+ * Agentcard turned the TokenEx iframe on for.
+ *
+ * `transbank_webpay_hosted_payment_page`: Transbank's Webpay Plus, whose card-free entry
+ * (webpay3g.transbank.cl/webpayserver/initTransaction?token_ws=<token>, the merchant's
+ * redirect, a plain GET) this build pauses for the cardholder's device by its exact link
+ * (hosted-entry.ts) in the page or a frame of it, and with attachToCdp also in a window the
+ * page opened, and whose hosts this build never lets the agent's browser post to (pre-claim.ts,
+ * transbank.ts), so the token is never spent there. attachToPlaywright covers the page it is
+ * attached to and that page's frames only, and pauses only a direct or scripted navigation to
+ * the entry: its page.route sees no HTTP redirect hop, so a merchant's redirect needs attachToCdp.
+ * Served on the same terms as NMI's and Redsys's: only to a build that lists it, for a company
+ * Agentcard turned Webpay on for.
+ *
+ * `sumup_checkout_process`: the card request SumUp's Payment Widget sends from its hidden form frame
+ * on gateway.sumup.com, a PUT to https://api.sumup.com/v0.2/checkouts/<checkout id>. This build pauses
+ * that PUT as it pauses Gravy's, so only the CDP and Playwright adapters see it (the form frame is
+ * cross-origin to the page), and answers the frame with SumUp's own answer as the API recorded it: the
+ * paid checkout, or the 3-D Secure step the widget then runs in the agent's browser. The cardholder's
+ * 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
+ * (CLOVER_PSP below). 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.
  */
 export const SUPPORTED_CAPABILITIES = ['fiserv_card_capture', GMO_CAPABILITY, CYBERSOURCE_FLEX_CAPABILITY, JUSPAY_CAPABILITY, DATATRANS_CAPABILITY, 'authorize_net_dpm_form', PELECARD_CAPABILITY, ACI_CAPABILITY, 'creditguard_pps_process', PRIMER_CAPABILITY, PAYRAILS_CAPABILITY, CONVERGE_CAPABILITY, EPROTECT_CAPABILITY, WSPAY_CAPABILITY, SHIJI_STS_CAPABILITY, AMADEUS_CHECKOUT_CAPABILITY, 'worldline_mycheckout_form', 'verifone_card_capture', 'ekashu_hosted_payment_page', SECURE_ACCEPTANCE_CAPABILITY, 'gravy_session_fields_put', 'moneris_hosted_tokenization', PADDLE_VGS_CAPABILITY, PADDLE_TOKENEX_CAPABILITY,
-    'redsys_hosted_payment_page', 'lyra_krypton_payment', 'payfast_card_pay', WIX_PAYMENTS_CAPABILITY, 'paymongo_checkout_pay', HIPAY_CAPABILITY, TWOC2P_CAPABILITY, 'quickpay_hosted_payment_page'];
+    'redsys_hosted_payment_page', 'lyra_krypton_payment', 'payfast_card_pay', WIX_PAYMENTS_CAPABILITY, 'paymongo_checkout_pay', PAYGENT_CAPABILITY, 'pay_nl_card_token', HIPAY_CAPABILITY, TWOC2P_CAPABILITY, 'quickpay_hosted_payment_page', 'revolut_card_field', 'paypal_card_fields', 'gopay_card_form', PAYREXX_CAPABILITY, COMGATE_CAPABILITY, PRZELEWY24_CAPABILITY, 'makecommerce_card_frame', 'poynt_collect_nonce',
+    TOKENEX_IFRAME_CAPABILITY, TRANSBANK_CAPABILITY,
+    'sumup_checkout_process',
+    'clover_card_token',
+    EXIMBAY_CAPABILITY, TOAST_CAPABILITY];
 /**
  * Processors whose paused request names no amount at all, so the pair the
  * agent passes is the amount the cardholder approves: authorize() refuses one
@@ -295,24 +444,86 @@ export const SUPPORTED_CAPABILITIES = ['fiserv_card_capture', GMO_CAPABILITY, CY
  * so the agent sends the total Payfast's page shows, above zero (PAYFAST_PSP below),
  * and the API holds it to the payment Payfast itself reports. Wix's tokenize request
  * carries none either: the merchant's page charges Wix's token for its own order, so the
- * agent's pair, which the prepared checkout carries, is the total the cardholder approves.
+ * agent's pair, which the prepared checkout carries, is the total the cardholder approves. Toast's
+ * card request carries none either: the page's card-free confirm of its payment intent
+ * charges whatever the intent says, so the agent's pair, above zero (as Moneris's), is
+ * the one figure the approval shows.
  * PayMongo's card attach carries none either: the merchant bound the total, always in
  * Philippine pesos, to the checkout session when it created it, so the agent sends that
  * total, above zero (PAYMONGO_PSP below), and the API holds it to the session PayMongo's
- * own page shows. 2C2P's Payment carries none either: the merchant bound the total to the
+ * own page shows. GoPay's card post carries none either: the shop's server set the amount
+ * when it created the payment at GoPay, and GoPay's gateway shows it only inside its own
+ * session, so the agent sends the total the gateway shows, above zero (GOPAY_PSP below).
+ * Paygent's token request carries none either: the merchant's server charges the token later, so
+ * the agent's pair, which the prepared checkout carries, is the total the cardholder approves.
+ * Payrexx's card request names the page's total, but it only mints a token: the merchant's page
+ * charges its own total later, at its validateForm, so the agent sends the total that page shows,
+ * above zero (PAYREXX_PSP), and the API holds it to the frame's figure exactly.
+ * 2C2P's Payment carries none either: the merchant bound the total to the
  * payment token when it created it, so the agent sends the total 2C2P's page shows, above
  * zero (TWOC2P_PSP), and the API holds it to the amount 2C2P's own PaymentOption answer names.
+ * Przelewy24's pay wall link carries none either: the merchant's server registered the amount
+ * with Przelewy24 under the link's token, so the agent sends the amount the pay wall shows, above
+ * zero (PRZELEWY24_PSP below), and the cardholder's device holds the pay wall to it.
  * HiPay's token create carries none either: the merchant's server charges
  * HiPay's token for its own order, so the agent's pair, which the prepared checkout carries,
- * is the total the cardholder approves, above zero as Moneris's is.
+ * is the total the cardholder approves, above zero as Moneris's is. Revolut's card payment
+ * names the order's amount in minor units but not its currency, which only the order holds,
+ * so the number alone is no price the cardholder can approve: the agent sends the pair, above
+ * zero (REVOLUT_PSP below), and the API holds its amount to the body's and its currency to
+ * one that Revolut and the API both count in hundredths.
+ * Pay.'s card token request carries none either: the shop's server charges the token later for
+ * its own order total, so the agent's pair, above zero (PAY_NL_PSP below), is the one figure the
+ * approval shows.
+ * PayPal Card Fields' confirm carries none either: the merchant's server fixed the
+ * amount when it created the order, so the agent's pair, above zero (PAYPAL_PSP
+ * below), is the one figure the approval shows.
+ * ComGate's gateway link carries none either: the merchant's server set
+ * the amount when it created the payment at ComGate, so the agent's pair, above zero
+ * (COMGATE_PSP below), is the figure the cardholder approves, and the cardholder's device
+ * holds ComGate's own figure to it before any card leaves.
+ * MakeCommerce's card post carries none either: MakeCommerce's transaction holds the total, in
+ * euros, so the agent sends the total the shop's order page shows, above zero (MAKECOMMERCE_PSP
+ * below), and the API refuses any other currency.
+ * GoDaddy Payments' generate-nonce carries none either: GoDaddy's server charges
+ * the nonce later, so its pair must be above zero too (POYNT_PSP below).
+ * The TokenEx iframe's card post carries none either: it mints a token into the merchant's TokenEx
+ * vault, which the merchant's server charges later for its own order, so the agent sends the total
+ * the merchant's page shows, above zero (TOKENEX_IFRAME_PSP), and the API refuses a create without it.
+ * Webpay's entry carries none either: the merchant's server bound the total, in Chilean pesos,
+ * to the transaction when it created it, so the agent's pair, above zero (TRANSBANK_PSP below),
+ * is the figure the cardholder approves, and the cardholder's device holds Webpay's own
+ * transaction to it before any card leaves.
+ * SumUp's card request carries none either: the merchant's server bound the
+ * total and its currency to the checkout when it created it, so the agent sends the total the
+ * payment page shows, above zero (SUMUP_PSP below), and the API holds it to the checkout SumUp
+ * itself reports.
+ * Clover's card token request carries none either: the merchant's server charges the token
+ * later for its own order, so the agent's pair, above zero (CLOVER_PSP below), is the one figure
+ * the approval shows.
  */
 const MONERIS_PSP = 'moneris';
 const PAYFAST_PSP = 'payfast';
 const PAYMONGO_PSP = 'paymongo';
-const AGENT_AMOUNT_PROCESSORS = [GMO_PSP, PELECARD_PSP, WSPAY_PSP, SECURE_ACCEPTANCE_PSP, MONERIS_PSP, PADDLE_VGS_PSP, PAYFAST_PSP, WIX_PAYMENTS_PSP, PAYMONGO_PSP, HIPAY_PSP, TWOC2P_PSP];
+const REVOLUT_PSP = 'revolut';
+const PAY_NL_PSP = 'pay_nl';
+const PAYPAL_PSP = 'paypal';
+const GOPAY_PSP = 'gopay';
+const MAKECOMMERCE_PSP = 'makecommerce';
+const POYNT_PSP = 'poynt';
+const SUMUP_PSP = 'sumup';
+const CLOVER_PSP = 'clover';
+const AGENT_AMOUNT_PROCESSORS = [GMO_PSP, PELECARD_PSP, WSPAY_PSP, SECURE_ACCEPTANCE_PSP, MONERIS_PSP, PADDLE_VGS_PSP, PAYFAST_PSP, WIX_PAYMENTS_PSP, PAYMONGO_PSP, PAYGENT_PSP, PAY_NL_PSP, HIPAY_PSP, TWOC2P_PSP, REVOLUT_PSP, PAYPAL_PSP, GOPAY_PSP, PAYREXX_PSP, COMGATE_PSP,
+    PRZELEWY24_PSP, MAKECOMMERCE_PSP, POYNT_PSP, TOKENEX_IFRAME_PSP, TRANSBANK_PSP, SUMUP_PSP,
+    CLOVER_PSP, TOAST_PSP];
 /** How AmountRequiredError names a processor. */
 const PROCESSOR_NAMES = { [GMO_PSP]: 'GMO', [PELECARD_PSP]: 'Pelecard', [WSPAY_PSP]: 'WSPay',
-    [SECURE_ACCEPTANCE_PSP]: 'CyberSource Secure Acceptance', [MONERIS_PSP]: 'Moneris', [PADDLE_VGS_PSP]: 'Paddle', [PAYFAST_PSP]: 'Payfast', [WIX_PAYMENTS_PSP]: 'Wix', [PAYMONGO_PSP]: 'PayMongo', [HIPAY_PSP]: 'HiPay', [TWOC2P_PSP]: '2C2P' };
+    [SECURE_ACCEPTANCE_PSP]: 'CyberSource Secure Acceptance', [MONERIS_PSP]: 'Moneris', [PADDLE_VGS_PSP]: 'Paddle', [PAYFAST_PSP]: 'Payfast', [WIX_PAYMENTS_PSP]: 'Wix', [PAYMONGO_PSP]: 'PayMongo', [PAYGENT_PSP]: 'Paygent', [PAY_NL_PSP]: 'Pay.', [HIPAY_PSP]: 'HiPay', [TWOC2P_PSP]: '2C2P',
+    [REVOLUT_PSP]: 'Revolut', [PAYPAL_PSP]: 'PayPal', [GOPAY_PSP]: 'GoPay', [PAYREXX_PSP]: 'Payrexx',
+    [COMGATE_PSP]: 'ComGate', [PRZELEWY24_PSP]: 'Przelewy24',
+    [MAKECOMMERCE_PSP]: 'MakeCommerce', [POYNT_PSP]: 'GoDaddy Payments', [TOKENEX_IFRAME_PSP]: 'TokenEx', [TRANSBANK_PSP]: 'Webpay',
+    [SUMUP_PSP]: 'SumUp',
+    [CLOVER_PSP]: 'Clover', [TOAST_PSP]: 'Toast' };
 /**
  * Processors whose request and answer name no amount at all, so the total the
  * payment page shows (`pageAmount`) is the one figure that ties the agent's pair
@@ -543,13 +754,18 @@ const PROCESSOR_PLACEHOLDER_NUMBERS = Object.freeze({});
 /**
  * The placeholder number for a network (lowercase, as GET /api/v2/vault_cards names it) on a
  * processor's page: the processor's own number for that network when `overrides` names one, else
- * the network's default, else undefined for a network with no placeholder.
+ * the network's default, else undefined for a network with no placeholder. On a TokenEx iframe
+ * (`tokenex_iframe`) the number must also be one TokenEx's frame reads as that network, since the frame
+ * names the brand to the page from the typed digits and the cardholder's device refuses a mismatch: the
+ * frame's table takes Visa, Mastercard and American Express, so every other network gets undefined.
  */
 export function placeholderNumber(brand, psp, overrides = PROCESSOR_PLACEHOLDER_NUMBERS) {
     const own = psp !== undefined && Object.prototype.hasOwnProperty.call(overrides, psp) ? overrides[psp] : undefined;
-    if (own && Object.prototype.hasOwnProperty.call(own, brand))
-        return own[brand];
-    return Object.prototype.hasOwnProperty.call(PLACEHOLDER_NUMBERS, brand) ? PLACEHOLDER_NUMBERS[brand] : undefined;
+    const number = own && Object.prototype.hasOwnProperty.call(own, brand) ? own[brand]
+        : Object.prototype.hasOwnProperty.call(PLACEHOLDER_NUMBERS, brand) ? PLACEHOLDER_NUMBERS[brand] : undefined;
+    if (number !== undefined && psp === TOKENEX_IFRAME_PSP && !tokenexIframePlaceholderFits(brand, number))
+        return undefined;
+    return number;
 }
 /**
  * The recognizer says this processor is preparation-required, and no preparation
@@ -575,7 +791,9 @@ export class PreparationRequiredError extends Error {
  * when the merchant's server created the payment), so the `amount` and
  * `currency` you pass are what the cardholder approves, and for WSPay the
  * figure the API compares with WSPay's answer when that answer names one (a
- * 3-D Secure step names none). Thrown locally before any create or
+ * 3-D Secure step names none). A Revolut card payment names the order's
+ * amount but not its currency, so it takes the same pair, above zero.
+ * Thrown locally before any create or
  * prompt, and terminal: the same request without an amount fails the same
  * way. The API answers 400 amount_required for the same case. A page total
  * (`pageAmount`) does not count.
@@ -585,7 +803,10 @@ export class AmountRequiredError extends Error {
     code = 'amount_required';
     constructor(psp) {
         const processor = PROCESSOR_NAMES[psp] ?? psp;
-        super(`A ${processor} payment request names no amount, so pass amount and currency: that is the amount the cardholder approves. Nothing was created and nothing was charged.`);
+        // A Payrexx card request names the frame's total, but the merchant's page charges its own total after the token.
+        const lacks = psp === REVOLUT_PSP ? 'names its amount but not its currency'
+            : psp === PAYREXX_PSP ? "only mints a token the merchant's page charges later" : 'names no amount';
+        super(`A ${processor} payment request ${lacks}, so pass amount and currency: that is the amount the cardholder approves. Nothing was created and nothing was charged.`);
         this.psp = psp;
         this.name = 'AmountRequiredError';
     }
@@ -929,12 +1150,12 @@ function refusalsOf(v) {
     return out;
 }
 /**
- * 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 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 const EBANX_FOLLOW_UP_BACKOFF_MAX_MS = 15_000;
 export class CheckoutApiError extends Error {
     status;
@@ -1183,12 +1404,19 @@ function maskPaymongoSession(path) {
  * https://secure.gopay.com/gp-card-comm/h/<hex token>?lang=..&ver=..&SG=<64 hex> (payment-core gopay.js). The
  * token names that payment's card form, and with the SG, which redactUrl drops with the query, anyone who holds
  * the URL can open the form and post a card to it. On GoPay's two card frame hosts the segment after /h/, in any
- * case or after an escaped slash, reads {token}: https://secure.gopay.com/gp-card-comm/h/{token}.
+ * case or after an escaped slash, reads {token}: https://secure.gopay.com/gp-card-comm/h/{token}. Then every run of
+ * 16 or more hex digits left reads {token} too, so a token after a path the frame never writes (an escaped h, a
+ * path parameter) is masked as well; the token is 16 hex digits or more, and no other path the card frame uses holds
+ * such a run. The pattern reads a percent escape as one unit: an escaped hex digit (%61, %2561) counts toward a run,
+ * so escaping some of a token's digits never splits it into runs that show, and any other escape (%2F, %252F, %68)
+ * is kept whole, so its own hex digits never start a run and leave part of a token showing.
  */
 const GOPAY_CARD_FORM_HOST = /^secure(?:\.sandbox)?\.gopay\.com\.?$/i;
 const GOPAY_CARD_FORM_TOKEN = new RegExp(`(${SLASH}h${SLASH}+)[^/?#]*`, 'gi');
+const GOPAY_TOKEN_RUN = /(?:[0-9a-f]|%(?:25)*(?:3[0-9]|[46][1-6])){16,}|%(?:25)*[0-9a-f]{2}/gi;
+const GOPAY_LONE_ESCAPE = /^%(?:25)*[0-9a-f]{2}$/i;
 function maskGopayToken(path) {
-    return path.replace(GOPAY_CARD_FORM_TOKEN, '$1{token}');
+    return path.replace(GOPAY_CARD_FORM_TOKEN, '$1{token}').replace(GOPAY_TOKEN_RUN, (run) => (GOPAY_LONE_ESCAPE.test(run) ? run : '{token}'));
 }
 /**
  * KOMOJU's Hosted Fields frame pays a session with POST /api/v1/sessions/<id>/pay on komoju.com under
@@ -1220,6 +1448,18 @@ const SUMUP_CHECKOUT = new RegExp(`(${SLASH}checkouts${SLASH}+)[^/]*`, 'gi');
 function maskSumupCheckout(path) {
     return maskUuids(path.replace(SUMUP_CHECKOUT, '$1{checkout}'), '{checkout}');
 }
+/**
+ * FastSpring's checkout posts its card payment to <store>.onfastspring.com[/popup-<name>]/session/<id>/payment
+ * (payment-core fastspring.js), and the session id in that path is a credential: the session's own document,
+ * which anyone holding the id can read with no cookie, carries the order and the session's token. On every
+ * host under onfastspring.com the segment after /session/, in any case or after an escaped slash, reads
+ * {session}.
+ */
+const FASTSPRING_HOST = /(?:^|\.)onfastspring\.com\.?$/i;
+const FASTSPRING_SESSION = /(\/session(?:\/|%2f))[^/]*/gi;
+function maskFastspringSession(path) {
+    return path.replace(FASTSPRING_SESSION, '$1{session}');
+}
 /**
  * The processors whose card request carries its own credential in the URL path, with the hosts
  * that send it, the text that names those hosts anywhere else (a string that is not a URL, or a
@@ -1273,6 +1513,18 @@ const REVOLUT_HOST = /^(?:sandbox-)?(?:merchant|checkout|merchant-mgmt)\.revolut
 function maskRevolutToken(path) {
     return maskUuids(path, '{token}');
 }
+/**
+ * ComGate's gateway pages name the payment by its transaction id in their paths (pay1.comgate.cz/<id>,
+ * /specify/card2/<id>, payment-core processors/comgate.js), and the id alone opens that payment's gateway page, its
+ * amount and its merchant. Its entry link names the id in the query, which redactUrl drops. On every host ComGate
+ * owns, any id of its shape, in any case and with each hyphen in any spelling HYPHEN reads, reads {payment}. The
+ * pattern reads a percent escape as one unit and keeps it, as maskUuids does.
+ */
+const COMGATE_HOST = /(?:^|\.)comgate\.cz\.?$/i;
+const COMGATE_ID = new RegExp(`%(?:25)*[0-9a-f]{2}|[a-z0-9]{4}${HYPHEN}[a-z0-9]{4}${HYPHEN}[a-z0-9]{4}`, 'gi');
+function maskComgateId(path) {
+    return path.replace(COMGATE_ID, (token) => (token.startsWith('%') ? token : '{payment}'));
+}
 /**
  * Paytrail names its payment in the path of every route of its card method
  * (/payments/<transaction>/click-to-pay/loading-and-redirect, and its success and cancel routes), and the same id
@@ -1377,10 +1629,12 @@ const PATH_CREDENTIALS = [
     { host: PRZELEWY24_HOST, named: /przelewy24\.pl/i, mask: maskPrzelewy24Token },
     { host: REVOLUT_HOST, named: /(?:merchant|checkout|merchant-mgmt)\.revolut\.com/i, mask: maskRevolutToken },
     { host: SUMUP_API_HOST, named: /api\.sumup\.com/i, mask: maskSumupCheckout },
+    { host: COMGATE_HOST, named: /comgate\.cz/i, mask: maskComgateId },
     { host: PAYTRAIL_HOST, named: /paytrail\.com/i, mask: maskPaytrailTransaction },
     { host: PAYMENT_HIGHWAY_HOST, named: /(?:paymenthighway\.io|sph-test-solinor\.com)/i, mask: maskPaymentHighwaySession },
     { host: TWOC2P_PAGE_HOST, named: /pgw-ui\.2c2p\.com/i, mask: maskTwoC2pToken, pathMask: maskTwoC2pPath },
     { host: QUICKPAY_HOST, named: /quickpay\.net/i, mask: maskQuickpaySession },
+    { host: FASTSPRING_HOST, named: /onfastspring\.com/i, mask: maskFastspringSession },
 ];
 /**
  * A URL as it may appear in an error message: origin + path only. A paused
@@ -1418,6 +1672,8 @@ const PATH_CREDENTIALS = [
  * 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.
  * 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
@@ -1526,6 +1782,18 @@ const PADDLE_VGS_PREPARATION_REFUSALS = [
  * `unsupported_checkout`, which PREPARATION_REFUSALS names for every checkout. Only for a Wix checkout.
  */
 const WIX_PAYMENTS_PREPARATION_REFUSALS = ['processor_unavailable', 'live_host_on_sandbox_row', 'merchant_profile_mismatch'];
+/**
+ * The API's refusals of a Paygent preparation, before any preparation exists, that prepareCheckout passes on
+ * by name: Paygent is off for the company (`processor_unavailable`), the environment is not the client's test
+ * or live mode, a live checkout's currency is not the one the reviewed merchant charges in
+ * (`unsupported_currency`), and the price is zero (`amount_required`): Paygent's token request names no
+ * amount, so the price the agent sends is the one the cardholder approves. A page and name no reviewed pin
+ * lists answers `unsupported_checkout`, which PREPARATION_REFUSALS names for every checkout. The API holds the
+ * pins, not this build, so a merchant a later release reviews needs no new SDK. Only for a Paygent checkout.
+ */
+const PAYGENT_PREPARATION_REFUSALS = [
+    'processor_unavailable', 'sandbox_host_on_live_row', 'live_host_on_sandbox_row', 'unsupported_currency', 'amount_required',
+];
 /**
  * The API's refusals of a HiPay preparation, before any preparation exists, that prepareCheckout surfaces by name:
  * the company is not turned on for HiPay (`processor_unavailable`), the environment is not the caller's key mode's
@@ -1754,7 +2022,7 @@ export class VaultClient {
         // cybersource_sa_token_create, gravy_session_fields_put,
         // moneris_hosted_tokenization, paddle_vgs_cards, paddle_tokenex_pay,
         // redsys_hosted_payment_page, lyra_krypton_payment, payfast_card_pay,
-        // quickpay_hosted_payment_page) and
+        // quickpay_hosted_payment_page, tokenex_iframe_tokenize, among others) and
         // the caller's company is one Agentcard turned that processor on for, so this
         // build arms Fiserv's card capture, GMO's getToken, CyberSource Flex's card
         // fields, Juspay's card flow, Datatrans's Secure Fields card post, the
@@ -1948,7 +2216,9 @@ export class VaultClient {
      * The facts hold only while the cardholder pays with that card. `psp` names the processor
      * whose card form the agent types into (the recognizer's name, `worldline_mycheckout`): a
      * processor that needs its own number for the card's network gets it, and every other gets the
-     * network's default. Throws PlaceholderCardError when there is no such card, its network has no
+     * network's default. On a TokenEx iframe (`tokenex_iframe`, JetBlue) the number is one TokenEx's frame
+     * reads as the card's own network, Visa, Mastercard or American Express, and any other network has no
+     * placeholder there. Throws PlaceholderCardError when there is no such card, its network has no
      * placeholder, or it carries no expiry.
      */
     async placeholderCard(input) {
@@ -2114,6 +2384,8 @@ export class VaultClient {
             throw fail(secureAcceptanceRefusal);
         const secureAcceptanceProfileId = secureAcceptance ? secureAcceptanceCheckoutProfile({ environment: input.environment,
             profileId: input.secureAcceptanceProfileId, merchantOrigin: input.merchantOrigin }) : null;
+        // A live Paygent checkout's merchant is the API's to judge against the reviewed pins it holds, before anyone is
+        // asked to approve (PAYGENT_PREPARATION_REFUSALS); test mode needs no pin.
         const timeoutMs = input.timeoutMs ?? 15 * 60_000;
         if (!Number.isInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2_147_483_647)
             throw fail('timeout_invalid');
@@ -2233,6 +2505,7 @@ export class VaultClient {
                     || (input.psp === EPROTECT_PSP && EPROTECT_PREPARATION_REFUSALS.includes(error.code))
                     || (input.psp === PADDLE_VGS_PSP && PADDLE_VGS_PREPARATION_REFUSALS.includes(error.code))
                     || (input.psp === WIX_PAYMENTS_PSP && WIX_PAYMENTS_PREPARATION_REFUSALS.includes(error.code))
+                    || (input.psp === PAYGENT_PSP && PAYGENT_PREPARATION_REFUSALS.includes(error.code))
                     || (input.psp === HIPAY_PSP && HIPAY_PREPARATION_REFUSALS.includes(error.code))
                     || (!!flexContext && CYBERSOURCE_FLEX_PREPARATION_REFUSALS.includes(error.code))))
                     || (input.psp === 'fiserv' && error.status === 502 && error.code === 'cse_key_unavailable')))
@@ -2488,10 +2761,14 @@ export class VaultClient {
                     : `checkout authorization is POST-only; got ${method} for ${redactUrl(input.request.url)}. ` +
                         'A non-POST tokenizer needs recognizer support before it can be intercepted.');
         }
-        // A GET card request is its URL alone. This build completes one: Worldpay
-        // eProtect's registration exactly as payment-core admits it, with no body.
+        // A GET card request is its URL alone. This build completes two kinds: Worldpay
+        // eProtect's registration exactly as payment-core admits it, with no body, and a
+        // hosted page's entry link exactly as its rule admits it (hosted-entry.ts), with no
+        // body, which the cardholder's device takes over.
         const eprotect = rec?.psp === EPROTECT_PSP;
-        if (cardMethod === 'GET' && !(eprotect && isEprotectRegistration(input.request))) {
+        const hostedGetEntry = mode === 'hosted_form' && !!rec && isHostedGetEntry(rec.psp, input.request.url)
+            && (input.request.body === undefined || input.request.body === null || input.request.body === '');
+        if (cardMethod === 'GET' && !(eprotect && isEprotectRegistration(input.request)) && !hostedGetEntry) {
             throw new Error(`this ${rec?.psp} GET is not a card registration this version of @agent-cards/checkout can complete: ${redactUrl(input.request.url)}.`);
         }
         // A CyberSource Secure Acceptance token create (always prepared: its recognizer requires it). The
@@ -2517,11 +2794,30 @@ export class VaultClient {
         // amount_required.
         if (!hasAmount && rec && AGENT_AMOUNT_PROCESSORS.includes(rec.psp))
             throw new AmountRequiredError(rec.psp);
-        // A Moneris or a HiPay token is charged later for whatever the merchant's server decides, and a Payfast pay, a
-        // PayMongo attach or a 2C2P Payment charges the total its payment, checkout session or payment token
-        // already holds, so a zero pair would show the cardholder no price at all: it is refused like a missing one.
-        if (hasAmount && rec && (rec.psp === MONERIS_PSP || rec.psp === PAYFAST_PSP || rec.psp === PAYMONGO_PSP || rec.psp === HIPAY_PSP || rec.psp === TWOC2P_PSP)
-            && Number(input.amount) <= 0)
+        // A Przelewy24 pay wall charges the amount the merchant's server registered with Przelewy24 under the link's
+        // token, so a zero pair would show the cardholder no price at all: it is refused like a missing one.
+        // A Moneris, a HiPay or a Pay. token, or a GoDaddy Payments nonce, is charged later for whatever the merchant's
+        // server decides, a Payfast pay, a PayMongo attach, a 2C2P Payment, a Revolut card payment or a SumUp card request
+        // charges the total its payment, checkout session, payment token, order or checkout already holds, and a PayPal
+        // order's amount was fixed by the merchant's server and never shown in the confirm, and a GoPay card post charges
+        // the total GoPay's payment already holds, so a zero pair would show the cardholder no price at all: it is refused
+        // like a missing one.
+        // A ComGate payment charges the total ComGate already holds for it, the same way, and a Webpay transaction the
+        // total the merchant's server bound to it, and a Payrexx page charges its own
+        // total after the frame's token.
+        // A Moneris token is charged later for whatever the merchant's server decides, and a Payfast pay, a
+        // PayMongo attach or a MakeCommerce card post charges the total its payment, checkout session or
+        // transaction already holds, so a zero pair would show the cardholder no price at all: it is refused
+        // like a missing one. So is a TokenEx iframe token, which the merchant's server charges later for its own order.
+        // A Clover token is charged later for whatever the merchant's server decides, as a Moneris one is.
+        // A Toast payment method is charged by the page's own confirm for whatever its intent says, the same way.
+        if (hasAmount && rec && rec.psp === PRZELEWY24_PSP && Number(input.amount) <= 0)
+            throw new AmountRequiredError(rec.psp);
+        if (hasAmount && rec && (rec.psp === MONERIS_PSP || rec.psp === PAYFAST_PSP || rec.psp === PAYMONGO_PSP || rec.psp === HIPAY_PSP || rec.psp === TWOC2P_PSP
+            || rec.psp === REVOLUT_PSP || rec.psp === PAY_NL_PSP || rec.psp === PAYPAL_PSP
+            || rec.psp === GOPAY_PSP || rec.psp === COMGATE_PSP || rec.psp === MAKECOMMERCE_PSP
+            || rec.psp === POYNT_PSP || rec.psp === TOKENEX_IFRAME_PSP || rec.psp === TRANSBANK_PSP || rec.psp === SUMUP_PSP
+            || rec.psp === CLOVER_PSP || rec.psp === PAYREXX_PSP || rec.psp === TOAST_PSP) && Number(input.amount) <= 0)
             throw new AmountRequiredError(rec.psp);
         // Nor is the agent's pair tied to the page by anything but the total the
         // page shows: without it the cardholder could approve one figure while the
@@ -2857,6 +3153,10 @@ export class VaultClient {
                         // source.encryptionData and removes nothing (fiserv.ts); any other shape is not one to act on.
                         if (rec.psp === 'fiserv' && !isFiservSubstitution(sub))
                             throw new PaymentOutcomeUnknownError(authorizationId, 'cse_substitutions_malformed');
+                        // A Toast approval carries exactly one sealed card, cardData at `card`, and removes nothing
+                        // (payment-core toast-seal.js substituteToastCardData checks the rest at the swap).
+                        if (rec.psp === TOAST_PSP && !isToastSubstitution(sub))
+                            throw new PaymentOutcomeUnknownError(authorizationId, 'cse_substitutions_malformed');
                         // `remove`: sibling keys the API says to drop with the swap (Adyen's
                         // `brand`, stamped by adyen-web from the agent's dummy digits). Absent
                         // on an older API; anything but a list of names is refused, since a
@@ -3027,6 +3327,18 @@ export class VaultClient {
                         response.headers = answer.headers;
                         response.body = answer.body;
                     }
+                    if (rec?.psp === PAYGENT_PSP) {
+                        // Paygent's answer enters the page only as payment-core rebuilds an approved token from its members
+                        // (paygent.js paygentAnswerOutcome: HTTP 200, result 0000 and a token in shape), under a JSON content
+                        // type. Anything else, a refusal Paygent answers inside HTTP 200 included, is never handed over as an
+                        // approval; the card may have left the device, so the outcome is unknown rather than declined.
+                        const judged = paygentAnswerOutcome(response.status, response.body, null);
+                        if (judged.outcome !== 'approved' || typeof judged.body !== 'string')
+                            throw new PaymentOutcomeUnknownError(authorizationId, 'paygent_token_unconfirmed');
+                        response.status = 200;
+                        response.headers = { 'content-type': 'application/json' };
+                        response.body = judged.body;
+                    }
                     if (rec?.psp === PRIMER_PSP) {
                         // Primer's answer enters the page only as one single-use card token rebuilt from
                         // payment-core's allow-list, under a JSON content type (primer.ts primerTokenAnswer).
@@ -3039,6 +3351,18 @@ export class VaultClient {
                         response.headers = answer.headers;
                         response.body = answer.body;
                     }
+                    if (rec?.psp === TOKENEX_IFRAME_PSP) {
+                        // TokenEx's answer enters the frame only as TokenEx's 200 with a sound token, rebuilt from payment-core's
+                        // allow-list under a JSON content type (tokenex-iframe.ts tokenexIframePageAnswer); the frame adds its own
+                        // cardType. Anything else is never handed over: the device may already have sent the card, so the
+                        // outcome is unknown rather than declined.
+                        const answer = tokenexIframePageAnswer(response.status, response.body);
+                        if (!answer)
+                            throw new PaymentOutcomeUnknownError(authorizationId, 'tokenex_iframe_token_unconfirmed');
+                        response.status = answer.status;
+                        response.headers = answer.headers;
+                        response.body = answer.body;
+                    }
                     let processorContext;
                     if (mercadoContext) {
                         try {
@@ -3069,8 +3393,9 @@ export class VaultClient {
                         chargedAmount: typeof s.charged_amount === 'number' ? s.charged_amount : null,
                         chargedCurrency: typeof s.charged_currency === 'string' ? s.charged_currency : null,
                         chargedKind: s.charged_kind === 'captured' || s.charged_kind === 'authorized' || s.charged_kind === 'none' ? s.charged_kind : null,
-                        // An EBANX token approval that covers the sends after it names until when (ebanx.ts EbanxFollowUps).
-                        ...(rec?.psp === 'ebanx' && typeof s.follow_ups?.until === 'string' && Number.isFinite(Date.parse(s.follow_ups.until))
+                        // An EBANX token approval, or a Payrexx card request whose answer started 3-D Secure, that covers the sends
+                        // after it names until when (ebanx.ts EbanxFollowUps, payrexx.ts PayrexxFollowUps).
+                        ...((rec?.psp === 'ebanx' || rec?.psp === PAYREXX_PSP) && typeof s.follow_ups?.until === 'string' && Number.isFinite(Date.parse(s.follow_ups.until))
                             ? { followUpsUntil: s.follow_ups.until } : {}),
                         ...amountAuthority,
                         ...execution,
@@ -3283,6 +3608,20 @@ export class VaultClient {
      * an answer that carried the card, or `options.until` (the approval's window, plus the API's own clocks) passed.
      */
     async sendEbanxFollowUp(authorizationId, request, options = {}) {
+        return this.sendFollowUp(authorizationId, request, options, (reason, cardSent) => new EbanxFollowUpError(reason, cardSent, authorizationId));
+    }
+    /**
+     * 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.
+     */
+    async sendPayrexxFollowUp(authorizationId, request, options = {}) {
+        return this.sendFollowUp(authorizationId, request, options, (reason, cardSent) => new PayrexxFollowUpError(reason, cardSent, authorizationId));
+    }
+    /** The send behind sendEbanxFollowUp and sendPayrexxFollowUp; `fail` builds the processor's error for a send with no answer. */
+    async sendFollowUp(authorizationId, request, options, fail) {
         if (!/^cauth_[A-Za-z0-9_-]{1,128}$/.test(authorizationId))
             throw new Error('Invalid authorization ID.');
         const base = `/v2/checkout/authorizations/${authorizationId}/follow_ups`;
@@ -3296,16 +3635,16 @@ export class VaultClient {
         catch (error) {
             // A refusal (a 4xx answer) stored no send, so nothing left. Any other failure (a 5xx, a timeout, a dropped
             // connection, an unreadable 201) may have come after the API stored the send, which the device then sends:
-            // the card may reach EBANX, and for a confirm that is a payment whose outcome is unknown.
+            // the card may reach the processor, and for an EBANX confirm that is a payment whose outcome is unknown.
             const refused = error instanceof CheckoutApiError && error.status >= 400 && error.status < 500;
             const reason = error instanceof CheckoutApiError
                 ? (typeof error.details.reason === 'string' && /^[a-z_]{1,64}$/.test(error.details.reason) ? error.details.reason : error.code ?? `http_${error.status}`)
                 : 'follow_up_unavailable';
-            throw new EbanxFollowUpError(reason, !refused, authorizationId);
+            throw fail(reason, !refused);
         }
         const id = created?.id;
         if (typeof id !== 'string' || !/^cfu_[0-9a-f]{24}$/.test(id) || created.authorization !== authorizationId) {
-            throw new EbanxFollowUpError('follow_up_unrecognized', true, authorizationId);
+            throw fail('follow_up_unrecognized', true);
         }
         // Reads the API refused in a row as too many (429): each waits twice as long as the last before the next read.
         let limited = 0;
@@ -3317,14 +3656,14 @@ export class VaultClient {
             }
             catch (error) {
                 if (signal.aborted)
-                    throw new EbanxFollowUpError('answer_late', true, authorizationId);
+                    throw fail('answer_late', true);
                 if (error instanceof CheckoutApiError && error.status === 429)
                     limited += 1;
             }
             if (read?.status === 'answered') {
                 const r = read.response;
                 if (!r || !Number.isInteger(r.status) || r.status < 200 || r.status > 599 || typeof r.body !== 'string' || !r.headers || typeof r.headers !== 'object') {
-                    throw new EbanxFollowUpError('follow_up_unrecognized', true, authorizationId);
+                    throw fail('follow_up_unrecognized', true);
                 }
                 const headers = {};
                 for (const [name, value] of Object.entries(r.headers))
@@ -3334,10 +3673,10 @@ export class VaultClient {
             }
             if (read?.status === 'failed' || read?.status === 'expired') {
                 const reason = typeof read.failure_reason === 'string' && /^[a-z_]{1,64}$/.test(read.failure_reason) ? read.failure_reason : read.status;
-                throw new EbanxFollowUpError(reason, read.card_sent !== false, authorizationId);
+                throw fail(reason, read.card_sent !== false);
             }
             if (signal.aborted || Date.now() >= deadline)
-                throw new EbanxFollowUpError('answer_late', true, authorizationId);
+                throw fail('answer_late', true);
             const wait = limited === 0 ? EBANX_FOLLOW_UP_READ_MS : Math.min(EBANX_FOLLOW_UP_BACKOFF_MAX_MS, 1000 * 2 ** (limited - 1));
             await interruptibleSleep(Math.max(1, Math.min(wait, deadline - Date.now())), signal);
         }
@@ -3898,3 +4237,14 @@ function interruptibleSleep(ms, signal) {
         signal?.addEventListener('abort', done, { once: true });
     });
 }
+/** A served Toast set: exactly { cardData } at `card`, a 256-byte base64 value, with nothing to remove. */
+function isToastSubstitution(sub) {
+    if (!sub || typeof sub !== 'object')
+        return false;
+    const { at, fields, remove } = sub;
+    if (at !== 'card' || !fields || typeof fields !== 'object' || Array.isArray(fields))
+        return false;
+    const keys = Object.keys(fields);
+    return keys.length === 1 && keys[0] === 'cardData' && isToastCiphertext(fields.cardData)
+        && (remove === undefined || (Array.isArray(remove) && remove.length === 0));
+}