@agent-cards/sdk 0.23.22 → 0.23.24

package/dist/client.js

@@ -1,13 +1,10 @@
 import { BUILTIN_REGISTRY, cardUrlPatterns as deriveCardUrlPatterns, LOOPBACK_URL_PATTERNS, findRecognizer, isRecognizerRequest, recognizerRequestMethod, recognizerRequiresPreparation, urlsOnProcessorHosts, } from './registry.js';
 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 { ACI_PSP, aciCardLegAnswer } from './aci.js';
+import { EPROTECT_PSP, eprotectCheckoutRefusal, eprotectScriptAnswer, isEprotectRegistration } from './eprotect.js';
 import { isHostedGetEntry } from './hosted-entry.js';
-import { TRANSBANK_CAPABILITY, TRANSBANK_PSP } from './transbank.js';
+import { SBPS_PSP, isSbpsTokenGet, sbpsScriptAnswer } from './sbps.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';
@@ -16,37 +13,39 @@ import { hasOwnedShopMarker, parseOwnedShopOrder, parseOwnedShopReceipt } from '
 import { requestWithoutCard } from './card-fields.generated.js';
 import { merchantSessionCapture } from './merchant-session-probe.js';
 import { creditguardPageProcessUrl, creditguardPpDomainHost, creditguardPreparationEnvironment, creditguardProcessTxId, sanitizeCreditguardResponse, } from './creditguard.generated.js';
-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 { SHIJI_STS_PSP, isShijiStsServedCompanion, isShijiStsServedSubstitution } from './shiji-sts.js';
+import { AMADEUS_CHECKOUT_PSP } from './amadeus-checkout.generated.js';
+import { PADDLE_VGS_PSP, paddleVgsCardFactsOf } from './paddle-vgs.generated.js';
+import { PAYGENT_PSP, paygentAnswerOutcome } from './paygent.generated.js';
+import { PADDLE_TOKENEX_PSP, isPaddleTokenexServedFacts, isPaddleTokenexServedSubstitution } from './paddle-tokenex.js';
+import { TAP_PAYMENTS_PSP, isTapPaymentsServedSubstitution } from './tap-payments.js';
+import { WIX_PAYMENTS_PSP } from './wix-payments.generated.js';
+import { HIPAY_PSP } from './hipay.generated.js';
+import { OPENPAY_PSP, openpayAnswerOutcome } from './openpay.generated.js';
+import { 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';
 import { Languages } from './languages.js';
 import { RequestRegistry } from './requests.js';
 import { AgentcardError } from './voice-types.js';
-import { GMO_CAPABILITY, GMO_PSP, gmoTokenAnswer } from './gmo.js';
+import { HYPHEN, SLASH, maskUuids } from './url-mask-parts.js';
+import { URL_MASKS } from './url-masks.generated.js';
+import { DECLARED_CAPABILITIES } from './capabilities.generated.js';
+import { AGENT_AMOUNT } from './agent-amount.generated.js';
+import { GMO_PSP, gmoTokenAnswer } from './gmo.js';
 import { admitCybersourceFlexPreparation, isCybersourceFlexTokenShape, sameCybersourceFlexPreparation } from './cybersource-flex.generated.js';
-import { CYBERSOURCE_FLEX_CAPABILITY, CYBERSOURCE_FLEX_PSP, validCybersourceFlexSidecar, } from './cybersource-flex.js';
-import { JUSPAY_CAPABILITY, JUSPAY_PSP, juspayPageAnswer } from './juspay-gate.js';
+import { CYBERSOURCE_FLEX_PSP, validCybersourceFlexSidecar, } from './cybersource-flex.js';
+import { JUSPAY_PSP, juspayPageAnswer } from './juspay-gate.js';
 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 { TOKENEX_IFRAME_PSP, tokenexIframePageAnswer, tokenexIframePlaceholderFits } from './tokenex-iframe.js';
+import { APS_PSP, apsNavigationAnswer } from './amazon-payment-services.js';
+import { PRIMER_PSP, primerTokenAnswer } from './primer.js';
+import { isPayrailsPaymentUrl, payrailsAnswer } from './payrails.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';
+import { PAYREXX_PSP, PayrexxFollowUpError } from './payrexx.js';
+import { 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
  * only recognizers in these modes, so a request this build cannot complete
@@ -206,6 +205,12 @@ export const SUPPORTED_REGISTRY_FEATURES = ['card_fields', 'checkout_sessions'];
  * 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,
@@ -322,8 +327,8 @@ export const SUPPORTED_REGISTRY_FEATURES = ['card_fields', 'checkout_sessions'];
  * 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
@@ -391,8 +396,8 @@ export const SUPPORTED_REGISTRY_FEATURES = ['card_fields', 'checkout_sessions'];
  * 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
+ * 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
@@ -410,13 +415,86 @@ export const SUPPORTED_REGISTRY_FEATURES = ['card_fields', 'checkout_sessions'];
  * 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.
+ *
+ * `tap_card_sdk_token`: the token request Tap Payments' card frame sends to sdk.tap.company, carrying
+ * the card only as one ciphertext the frame writes under the merchant's own RSA key. This build pauses
+ * it and writes over the placeholder's ciphertext the one the cardholder's device wrote under the key
+ * payment-core pins for the request's publishable key (tap-payments.ts), into that request alone; 3-D
+ * Secure and the merchant's charge then run in the agent's browser. Served on the same terms: only to
+ * a build that lists it, for a company Agentcard turned Tap on for.
+ *
+ * `fastspring_card_payment`: the card payment FastSpring's checkout posts, on every store's own
+ * host, to <store>.onfastspring.com[/popup-<name>]/session/<id>/payment under the session's
+ * X-Session-Token. This build pauses only the checkout's own card body at that exact URL (a card
+ * FastSpring saved, a renewal, a gift, a tax id's second card send and a CAPTCHA answer are refused
+ * at the pause, and another method's payment with no card continues); the cardholder's device writes
+ * the real card into the paused body and sends it through the checkout relay, and the checkout gets
+ * FastSpring's answer as payment-core's judge rebuilt it. The request names no amount, so the agent's
+ * pair, above zero, is the total the checkout shows. Served on the same terms:
+ * only to a build that lists it, for a company Agentcard turned FastSpring on for.
+ *
+ * `openpay_tokenizer`: the token create openpay.js sends from a merchant's own page to
+ * api.openpay.mx/v1/<merchant id>/tokens (api.openpay.co, api.openpay.pe; sandbox-api for a test
+ * row), only through a prepared checkout: openpay.js abandons the request 40 seconds after Pay, so
+ * the cardholder approves before Pay. The token URL names the merchant, so the claim binds the
+ * request by its host's environment and its shape, never by the prepared URL. The cardholder's
+ * device sends the card to Openpay itself and the page gets back Openpay's token alone, rebuilt by
+ * payment-core's judge. The request names no amount, so the agent's pair, above zero
+ * (agent-amount-processors.json), is the one the cardholder approves. Served on the same terms: only
+ * to a build that lists it, for a company Agentcard turned Openpay on for.
+ *
+ * `aps_custom_merchant_page`: Amazon Payment Services' custom merchant page, whose own card form
+ * posts top-level to /FortAPI/paymentPage on checkout.payfort.com (sbcheckout.payfort.com on APS's
+ * sandbox) with service_command=TOKENIZATION. This build pauses that navigation; the cardholder's
+ * phone sends the form with the real card through the checkout relay, and the paused navigation
+ * gets APS's own answer, its page or its redirect to the form's return page, only as payment-core's
+ * judge reads it for that form (amazon-payment-services.ts apsNavigationAnswer). The form names no
+ * amount, so the agent's pair, above zero, is the one the cardholder approves.
+ * Served on the same terms: only to a build that lists it, for a company Agentcard turned APS on for.
+ *
+ * The list itself is capabilities.json, sorted, one per line (scripts/generate-capabilities.mjs).
  */
-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', 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];
+export const SUPPORTED_CAPABILITIES = DECLARED_CAPABILITIES;
 /**
  * Processors whose paused request names no amount at all, so the pair the
  * agent passes is the amount the cardholder approves: authorize() refuses one
@@ -436,12 +514,12 @@ export const SUPPORTED_CAPABILITIES = ['fiserv_card_capture', GMO_CAPABILITY, CY
  * carries, is the total the cardholder approves, and the card that pays can spend
  * no more than that (the API's card rule). Moneris Hosted Tokenization's
  * request.php carries the card and no price: the merchant's server charges the
- * token later, so the agent's pair, above zero (MONERIS_PSP below), is the one
+ * token later, so the agent's pair, above zero (`moneris` in the table), is the one
  * figure the approval shows. Paddle VGS's card request carries none either: Paddle
  * charges the stored card at /pay for what the checkout says, so the agent's pair,
  * which the prepared checkout carries, is the total the cardholder approves. Payfast's
  * card pay carries none either: the merchant's entry bound the total to the payment,
- * so the agent sends the total Payfast's page shows, above zero (PAYFAST_PSP below),
+ * so the agent sends the total Payfast's page shows, above zero (`payfast` in the table),
  * 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. Toast's
@@ -450,88 +528,87 @@ export const SUPPORTED_CAPABILITIES = ['fiserv_card_capture', GMO_CAPABILITY, CY
  * 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
+ * total, above zero (`paymongo` in the table), and the API holds it to the session PayMongo's
  * 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).
+ * session, so the agent sends the total the gateway shows, above zero (`gopay` in the table).
  * 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.
+ * above zero (`payrexx` in the table), 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.
+ * zero (`twoc2p` in the table), 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.
+ * zero (`przelewy24` in the table), 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. 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
+ * zero (`revolut` in the table), 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
+ * its own order total, so the agent's pair, above zero (`pay_nl` in the table), 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.
+ * amount when it created the order, so the agent's pair, above zero (`paypal` in
+ * the table), 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
+ * (`comgate` in the table), 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.
+ * euros, so the agent sends the total the shop's order page shows, above zero (`makecommerce` in
+ * the table), 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 nonce later, so its pair must be above zero too (`poynt` in the table).
  * 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.
+ * the merchant's page shows, above zero (`tokenex_iframe` in the table), 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),
+ * to the transaction when it created it, so the agent's pair, above zero (`transbank_webpay` in the table),
  * 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
+ * payment page shows, above zero (`sumup` in the table), 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
+ * later for its own order, so the agent's pair, above zero (`clover` in the table), is the one figure
  * the approval shows.
+ * Omise's card token request carries none either, for the same reason: the merchant's server
+ * charges the token afterwards for its own order (`omise` in the table).
+ * Paytrail's card method entry carries none either: the merchant's server fixed the amount, in
+ * euros, when it created the payment, so the agent sends that amount (`paytrail` in the table), and
+ * the cardholder's device holds Payment Highway's card page to it.
+ * SB Payment Service's token request carries none either: the merchant's server
+ * charges the token later, so its pair must be above zero too (`sb_payment_service` in the table), and
+ * agree with the page's order total (PAGE_AMOUNT_PROCESSORS).
+ * Midtrans' Snap card token carries none either: the merchant's server charges the token
+ * afterwards, so the agent's pair, above zero (`midtrans` in the table), is the one figure the
+ * approval shows.
+ * The table itself is agent-amount-processors.json, sorted, one processor per line
+ * (scripts/generate-agent-amount.mjs). A processor added there states its reason in the API
+ * create route's refusal, not in this comment.
  */
-const MONERIS_PSP = 'moneris';
-const PAYFAST_PSP = 'payfast';
-const PAYMONGO_PSP = 'paymongo';
 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];
+const AGENT_AMOUNT_PROCESSORS = AGENT_AMOUNT.processors;
+/** The ones a zero amount is refused for, like a missing one (authorize()). */
+const ABOVE_ZERO_PROCESSORS = AGENT_AMOUNT.aboveZero;
 /** 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', [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' };
+const PROCESSOR_NAMES = AGENT_AMOUNT.names;
 /**
  * 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
  * to what the page charges: authorize() refuses one without it
  * (PageAmountRequiredError), and the API answers 400 page_amount_required for the
- * same case. Pelecard only.
+ * same case. Pelecard, and SB Payment Service, whose token request and answer
+ * name no amount either.
  */
-const PAGE_AMOUNT_PROCESSORS = [PELECARD_PSP];
+const PAGE_AMOUNT_PROCESSORS = AGENT_AMOUNT.pageAmount;
 /** An integer in the smallest unit, or a decimal string in normal units with a point; nothing else. */
 export function validAmountInput(amount) {
     if (typeof amount === 'number')
@@ -805,8 +882,11 @@ export class AmountRequiredError extends Error {
         const processor = PROCESSOR_NAMES[psp] ?? psp;
         // 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.`);
+            : psp === PAYREXX_PSP ? "only mints a token the merchant's page charges later"
+                : psp === TAP_PAYMENTS_PSP ? 'does not decide the amount charged' : 'names no amount';
+        // "An Omise payment request", "A Clover payment request": the article follows the name's first letter.
+        const article = /^[AEIOU]/.test(processor) ? 'An' : 'A';
+        super(`${article} ${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';
     }
@@ -824,7 +904,7 @@ export class PageAmountRequiredError extends Error {
     psp;
     code = 'page_amount_required';
     constructor(psp) {
-        const processor = psp === PELECARD_PSP ? 'Pelecard' : psp;
+        const processor = PROCESSOR_NAMES[psp] ?? psp;
         super(`A ${processor} payment request names no amount, so pass the total its payment page shows as pageAmount beside amount and currency. Nothing was created and nothing was charged.`);
         this.psp = psp;
         this.name = 'PageAmountRequiredError';
@@ -1263,23 +1343,7 @@ function parseErrorEnvelope(bodyText) {
     }
     return { code: null, details: {} };
 }
-/**
- * A slash as the masks below read one: plain, or escaped once or more in either case (%2F, %2f, %252F). A path keeps
- * an escape as it was written, and the id behind it is the same id, so every slash a mask names reads in any of these
- * spellings. The slashes right before an id read as a run, and a doubled slash hides nothing either.
- */
-const SLASH = '(?:/|%(?:25)*2f)';
-/** A hyphen inside an id: plain, or escaped once or more in either case (%2D, %252d). */
-const HYPHEN = '(?:-|%(?:25)*2d)';
-/**
- * The masks that find a uuid by its shape take it in any case, with or without its hyphens, each hyphen in any
- * spelling HYPHEN reads. The pattern reads a percent escape as one unit and keeps it, so the hex digits of an escaped
- * separator before the id (%2F, %252F, %3D) never start a match and leave the id's last digits showing.
- */
-const UUID_OR_ESCAPE = new RegExp(`%(?:25)*[0-9a-f]{2}|[0-9a-f]{8}${HYPHEN}?[0-9a-f]{4}${HYPHEN}?[0-9a-f]{4}${HYPHEN}?[0-9a-f]{4}${HYPHEN}?[0-9a-f]{12}`, 'gi');
-function maskUuids(path, label) {
-    return path.replace(UUID_OR_ESCAPE, (token) => (token.startsWith('%') ? token : label));
-}
+// SLASH, HYPHEN and maskUuids, which every mask below reads, live in url-mask-parts.ts with the UrlMask shape.
 const CREDITGUARD_HOST = /(?:^|\.)creditguard\.co\.il\.?$/i;
 const CREDITGUARD_TXN = new RegExp(`(${SLASH}txn${SLASH}+)[^/]+`, 'gi');
 function maskCreditguardTxId(path) {
@@ -1452,14 +1516,28 @@ function maskSumupCheckout(path) {
  * 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}.
+ * host under onfastspring.com the segment after /session/, in any case and in any spelling of the slashes around
+ * /session/ that SLASH reads, reads {session}.
  */
 const FASTSPRING_HOST = /(?:^|\.)onfastspring\.com\.?$/i;
-const FASTSPRING_SESSION = /(\/session(?:\/|%2f))[^/]*/gi;
+const FASTSPRING_SESSION = new RegExp(`(${SLASH}session${SLASH}+)[^/]*`, 'gi');
 function maskFastspringSession(path) {
     return path.replace(FASTSPRING_SESSION, '$1{session}');
 }
+/**
+ * PayU Latam's WebCheckout sends the card to /ppp-web-gateway-payu/checkout/submit/<country>/credit_card/<key>
+ * on its own host (payment-core payu-latam.js), and the key, 32 hex characters, is the checkout session's
+ * only credential: the page's card-free routes answer it with no cookie, the order, the payer and the
+ * merchant among them. Every route of the page carries the same key, so on every host under
+ * payulatam.com any run of 32 or more hex characters, in any case or after an escaped slash, reads {key}. A hex
+ * character escaped once or more (%66 or %2566 for f, in either case) counts as that character, since PayU's server
+ * reads the same key, so an escape inside the key cannot split it into two runs too short to mask.
+ */
+const PAYU_LATAM_HOST = /(?:^|\.)payulatam\.com\.?$/i;
+const PAYU_LATAM_KEY = /(?:[0-9a-f]|%(?:25)*(?:3[0-9]|4[1-6]|6[1-6])){32,}/gi;
+function maskPayuLatamKey(path) {
+    return path.replace(PAYU_LATAM_KEY, '{key}');
+}
 /**
  * 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
@@ -1607,10 +1685,7 @@ const QUICKPAY_SESSION = /(\/|%2f)[0-9a-f]{32,}/gi;
 function maskQuickpaySession(path) {
     return path.replace(QUICKPAY_SESSION, '$1{session}');
 }
-/**
- * `mask` reads a text that names the processor's host; `pathMask`, where a processor has one, reads the path of a
- * URL already parsed on that host, which `mask` reads otherwise.
- */
+/** Today's masks here; each later processor's in its own src/url-masks/<psp>.ts (URL_MASKS). */
 const PATH_CREDENTIALS = [
     { host: PATH_SECRET_HOST, named: /(?:wspay\.biz|monri\.com)/i, mask: maskPathSecret },
     { host: CREDITGUARD_HOST, named: /creditguard\.co\.il/i, mask: maskCreditguardTxId },
@@ -1635,6 +1710,8 @@ const PATH_CREDENTIALS = [
     { 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 },
+    { host: PAYU_LATAM_HOST, named: /payulatam\.com/i, mask: maskPayuLatamKey },
+    ...URL_MASKS,
 ];
 /**
  * A URL as it may appear in an error message: origin + path only. A paused
@@ -1674,6 +1751,9 @@ const PATH_CREDENTIALS = [
  * 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
@@ -1804,19 +1884,33 @@ const PAYGENT_PREPARATION_REFUSALS = [
  */
 const HIPAY_PREPARATION_REFUSALS = ['processor_unavailable', 'live_host_on_sandbox_row', 'sandbox_host_on_live_row', 'merchant_profile_mismatch',
     'amount_required'];
+/**
+ * The API's refusals of an Openpay preparation, before any preparation exists, that prepareCheckout passes on by
+ * name: the company is not turned on for Openpay (`processor_unavailable`), the environment is not the caller's key
+ * mode's (`live_host_on_sandbox_row`, `sandbox_host_on_live_row`), a live checkout's merchant is not the name the
+ * reviewed pin for its origin carries (`merchant_profile_mismatch`), and the price is zero (`amount_required`), since
+ * the token create names no amount. An origin 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 an Openpay checkout.
+ */
+const OPENPAY_PREPARATION_REFUSALS = ['processor_unavailable', 'live_host_on_sandbox_row', 'sandbox_host_on_live_row',
+    'merchant_profile_mismatch', 'amount_required'];
 /**
  * The reason the cardholder's device declines a bound prepared row with, per processor, when its own
  * send boundary passed before the card left it (the Vault's sendWindow, 12 seconds after it last saw
  * the checkout unbound): a prepared Amadeus SDK add, a prepared Secure Acceptance token create and a
  * prepared Wix tokenize request. It names the same known non-payment the adapters' own send window
  * closes on (amadeus.ts), which can close later, so authorize() ends the attempt the way that window
- * does, as a CheckoutPreparationError with that reason, and never as the cardholder's "no".
+ * does, as a CheckoutPreparationError with that reason, and never as the cardholder's "no". A prepared
+ * HiPay token create too, and a prepared Openpay token create, whose device sends the card at most 25
+ * seconds after it last saw the checkout unbound, inside the adapters' 30.
  */
 const PREPARED_SEND_WINDOW_DECLINES = Object.freeze({
     amadeus_checkout: 'amadeus_send_window_closed',
     [SECURE_ACCEPTANCE_PSP]: 'secure_acceptance_send_window_closed',
     [WIX_PAYMENTS_PSP]: 'wix_payments_send_window_closed',
     [HIPAY_PSP]: 'hipay_send_window_closed',
+    [OPENPAY_PSP]: 'openpay_send_window_closed',
 });
 /**
  * Refusals a CyberSource Flex preparation that tokenizes before Pay answers (4xx) before any
@@ -2140,9 +2234,10 @@ export class VaultClient {
      * capability (syncRegistry does), so before a sync, or against an API that
      * withheld it, the adapters leave that processor's traffic exactly as they
      * found it. prepare() asks this for ACI, whose card-number request names a
-     * checkout id the merchant mints only at Pay time, and for a processor whose
-     * card request is a GET (Worldpay eProtect), since that request is recognized
-     * by a query the page has not written yet.
+     * checkout id the merchant mints only at Pay time, for Openpay, whose token
+     * URL names the merchant's own id, and for a processor whose card request is
+     * a GET (Worldpay eProtect), since that request is recognized by a query the
+     * page has not written yet.
      */
     recognizesProcessor(psp) {
         return this.registry.some((rec) => rec.psp === psp);
@@ -2385,7 +2480,8 @@ export class VaultClient {
         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.
+        // asked to approve (PAYGENT_PREPARATION_REFUSALS); test mode needs no pin. So is a live Openpay checkout's
+        // origin and merchant (OPENPAY_PREPARATION_REFUSALS); Openpay's sandbox needs no pin either.
         const timeoutMs = input.timeoutMs ?? 15 * 60_000;
         if (!Number.isInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2_147_483_647)
             throw fail('timeout_invalid');
@@ -2507,6 +2603,7 @@ export class VaultClient {
                     || (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))
+                    || (input.psp === OPENPAY_PSP && OPENPAY_PREPARATION_REFUSALS.includes(error.code))
                     || (!!flexContext && CYBERSOURCE_FLEX_PREPARATION_REFUSALS.includes(error.code))))
                     || (input.psp === 'fiserv' && error.status === 502 && error.code === 'cse_key_unavailable')))
                 throw fail(error.code);
@@ -2761,14 +2858,15 @@ 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 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.
+        // A GET card request is its URL alone. This build completes three kinds: Worldpay
+        // eProtect's registration and SB Payment Service's token request, each 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;
         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) {
+        const sbps = rec?.psp === SBPS_PSP;
+        if (cardMethod === 'GET' && !(eprotect && isEprotectRegistration(input.request)) && !hostedGetEntry && !(sbps && isSbpsTokenGet(input.request))) {
             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
@@ -2804,20 +2902,18 @@ export class VaultClient {
         // 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.
+        // total after the frame's token. The charge that follows a Tap token charges the order the merchant's session
+        // holds, the same way.
         // 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)
+        // An Omise token is charged later for whatever the merchant's server decides, as a Clover one is.
+        // An SB Payment Service token is charged later the same way.
+        // An Openpay token is charged later for whatever the merchant's server decides, as a HiPay one is.
+        if (hasAmount && rec && ABOVE_ZERO_PROCESSORS.includes(rec.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
@@ -2883,6 +2979,12 @@ export class VaultClient {
             // Only the profile's id: the API takes the leg, the key and its environment from the
             // profile Agentcard reviewed, never from the caller.
             ...(verifoneProfile ? { verifone: { profile: verifoneProfile.id } } : {}),
+            // Paddle TokenEx only: Paddle's checkout answers this browser recorded before the /pay paused, which the API
+            // holds `amount` to (paddle-checkout-watch.ts). Any other processor's create would be refused with them.
+            ...(rec?.psp === PADDLE_TOKENEX_PSP && input.paddleCheckout?.answers.length ? { paddle_checkout: {
+                    paused_at: input.paddleCheckout.pausedAt,
+                    answers: input.paddleCheckout.answers.map((answer) => ({ method: answer.method, url: answer.url, status: answer.status, completed_at: answer.completedAt, body: answer.body })),
+                } } : {}),
             // A prepared checkout already carries the page origin as merchant_origin.
             ...(preparation
                 ? { preparation_id: preparation.id, checkout_key: preparation.checkoutKey, merchant_origin: preparation.merchantOrigin, form_guidance: 'filled' }
@@ -2966,10 +3068,14 @@ export class VaultClient {
         // A prepared HiPay token create too, for 20 seconds: HiPay's hosted fields give it 20 seconds from Pay, so
         // an answer the cardholder's device records late in that span still reaches the frame before it gives up,
         // and the API names 500 ms as such a row's poll interval.
+        // A prepared Openpay token create too, for 40 seconds: openpay.js gives it 40 seconds from Pay, so the token
+        // reaches the page within half a second of the device's answer, and the API names 500 ms as such a row's poll
+        // interval.
         const preparedFastPollUntil = preparation?.psp === 'mercado_pago' ? Date.now() + 10_000
             : preparation?.psp === PADDLE_VGS_PSP || preparation?.psp === HIPAY_PSP ? Date.now() + 20_000
-                : preparation?.psp === EPROTECT_PSP ? Date.now() + 15_000
-                    : preparation?.psp === SECURE_ACCEPTANCE_PSP ? Date.now() + SECURE_ACCEPTANCE_FAST_POLL_MS : 0;
+                : preparation?.psp === OPENPAY_PSP ? Date.now() + 40_000
+                    : preparation?.psp === EPROTECT_PSP ? Date.now() + 15_000
+                        : preparation?.psp === SECURE_ACCEPTANCE_PSP ? Date.now() + SECURE_ACCEPTANCE_FAST_POLL_MS : 0;
         // A preparation that tokenized before Pay: the cardholder's device already holds CyberSource's
         // token and approves as soon as this bind reaches it, while the page may give createToken only
         // seconds (Alaska Airlines' flight checkout gives it three). Poll every 100 ms for 10 seconds,
@@ -3142,11 +3248,14 @@ export class VaultClient {
                         // Paddle TokenEx carries the two ciphertexts at tokenex_card and the five facts beside them in
                         // `paddle_tokenex_facts` (the expiry parts are numbers, so they cannot ride `fields`).
                         const paddleTokenex = rec?.psp === PADDLE_TOKENEX_PSP;
+                        // Tap carries its one ciphertext at the body root too (`at` is ''), and nothing to remove (tap-payments.ts).
+                        const tap = rec?.psp === TAP_PAYMENTS_PSP;
                         const fieldsOk = shiji ? isShijiStsServedSubstitution(sub) && isShijiStsServedCompanion(s.shiji_sts_companion)
                             : paddleTokenex ? isPaddleTokenexServedSubstitution(sub) && isPaddleTokenexServedFacts(s.paddle_tokenex_facts)
-                                : sub && typeof sub === 'object' && sub.encoding === 'json' && typeof sub.at === 'string' && sub.at
-                                    && sub.fields && typeof sub.fields === 'object' && !Array.isArray(sub.fields)
-                                    && Object.values(sub.fields).every((v) => typeof v === 'string' && v.length > 0);
+                                : tap ? isTapPaymentsServedSubstitution(sub)
+                                    : sub && typeof sub === 'object' && sub.encoding === 'json' && typeof sub.at === 'string' && sub.at
+                                        && sub.fields && typeof sub.fields === 'object' && !Array.isArray(sub.fields)
+                                        && Object.values(sub.fields).every((v) => typeof v === 'string' && v.length > 0);
                         if (!fieldsOk)
                             throw new PaymentOutcomeUnknownError(authorizationId, 'cse_substitutions_malformed');
                         // A Fiserv approval carries exactly its envelope's four members at
@@ -3255,6 +3364,18 @@ export class VaultClient {
                         response.headers = answer.headers;
                         response.body = answer.body;
                     }
+                    if (sbps) {
+                        // SB Payment Service: the paused <script> is answered the way SBPS answers it,
+                        // `<callback>({"tokenRes": ...})` under a script type, with the callback the paused URL named
+                        // and only a token payment-core's judge accepts for that URL. Anything else is not an answer to
+                        // hand the page, and the device may already have sent the card to SBPS.
+                        const answer = sbpsScriptAnswer(input.request.url, response);
+                        if (!answer)
+                            throw new PaymentOutcomeUnknownError(authorizationId, 'sbps_token_unconfirmed');
+                        response.status = answer.status;
+                        response.headers = answer.headers;
+                        response.body = answer.body;
+                    }
                     if (secureAcceptance) {
                         // CyberSource Secure Acceptance: the paused frame navigation is answered with CyberSource's own
                         // reply page, byte for byte, with status 200 and its one content type, and only a page
@@ -3339,6 +3460,19 @@ export class VaultClient {
                         response.headers = { 'content-type': 'application/json' };
                         response.body = judged.body;
                     }
+                    if (rec?.psp === OPENPAY_PSP) {
+                        // Openpay's answer enters the page only as payment-core rebuilds an approved token from its id, masked number,
+                        // brand and points flag (openpay.js openpayAnswerOutcome: HTTP 200 or 201 and a token in shape), under its
+                        // approved status and a JSON content type. openpay.js hands any 2xx to the page's success callback, so
+                        // anything else, an error object Openpay answers inside a 2xx 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 = openpayAnswerOutcome(response.status, response.body, null);
+                        if (judged.outcome !== 'approved' || typeof judged.body !== 'string')
+                            throw new PaymentOutcomeUnknownError(authorizationId, 'openpay_token_unconfirmed');
+                        response.status = response.status === 201 ? 201 : 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).
@@ -3363,6 +3497,21 @@ export class VaultClient {
                         response.headers = answer.headers;
                         response.body = answer.body;
                     }
+                    if (rec?.psp === APS_PSP) {
+                        // Amazon Payment Services: the paused top-level navigation is answered with APS's own page under its HTML
+                        // type, or with APS's redirect to the paused form's return page, and only with a token payment-core's judge
+                        // reads for that form (amazon-payment-services.ts apsNavigationAnswer). Anything else is not an answer to
+                        // hand the browser: the card has already reached APS. No autopilot run sends an APS form (payment-core, the
+                        // authority and the API refuse it), so an approval the API reports as unattended is not handed over either.
+                        if (execution.executionMode === 'autopilot')
+                            throw new PaymentOutcomeUnknownError(authorizationId, 'autopilot_submission_mode_invalid');
+                        const answer = apsNavigationAnswer(input.request, response);
+                        if (!answer)
+                            throw new PaymentOutcomeUnknownError(authorizationId, 'aps_answer_unconfirmed');
+                        response.status = answer.status;
+                        response.headers = answer.headers;
+                        response.body = answer.body;
+                    }
                     let processorContext;
                     if (mercadoContext) {
                         try {