@agent-cards/sdk 0.21.0 → 0.23.0

package/dist/client.js

@@ -1,11 +1,19 @@
-import { BUILTIN_REGISTRY, cardUrlPatterns as deriveCardUrlPatterns, LOOPBACK_URL_PATTERNS, findRecognizer, recognizerRequiresPreparation, } from './registry.js';
+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, redactAciCheckoutId } from './aci.js';
+import { EPROTECT_CAPABILITY, EPROTECT_PSP, eprotectCheckoutRefusal, eprotectScriptAnswer, isEprotectRegistration } from './eprotect.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';
+import { armServedVerifoneProfiles, classifyVerifoneProfileRequest, isVerifoneProfileEntry, isVerifoneSubstitution, verifoneProfileFor, verifoneProfileUrlPatterns, } from './verifone.js';
 import { hasOwnedShopMarker, parseOwnedShopOrder, parseOwnedShopReceipt } from './owned-shop.generated.js';
 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 } from './amadeus-checkout.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';
@@ -13,14 +21,24 @@ 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 { isCybersourceFlexTokenShape } from './cybersource-flex.generated.js';
-import { CYBERSOURCE_FLEX_CAPABILITY, CYBERSOURCE_FLEX_PSP, validCybersourceFlexSidecar } from './cybersource-flex.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 { 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 { PELECARD_CAPABILITY, PELECARD_PSP } from './pelecard.js';
+import { PRIMER_CAPABILITY, PRIMER_PSP, primerTokenAnswer } from './primer.js';
+import { PAYRAILS_CAPABILITY, payrailsSaveAnswer } from './payrails.js';
+import { WSPAY_CAPABILITY, WSPAY_PSP } from './wspay.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
- * is never paused) and sent on every create.
+ * is never paused) and sent on every create. `device_encrypt`: the adapters
+ * capture the Payrails session key the page's init payload names (payrails.ts),
+ * and the cardholder's device encrypts and sends the save.
  */
-export const SUPPORTED_MODES = ['token', 'cse', 'hosted_form'];
+export const SUPPORTED_MODES = ['token', 'cse', 'hosted_form', 'device_encrypt'];
 /**
  * Registry features this SDK honours, asked for on syncRegistry next to the
  * modes. `card_fields`: it reads a recognizer's cardFields and claims only a
@@ -50,35 +68,243 @@ export const SUPPORTED_REGISTRY_FEATURES = ['card_fields', 'checkout_sessions'];
  * serves Flex's recognizer the same way, only for a company Agentcard turned it on for.
  * A gated recognizer is never in BUILTIN_REGISTRY, so a build reaches it only through a
  * sync that declares its capability.
+ * `juspay_txns.v1`: Juspay's card flow (juspay-gate.ts), whose page tokenize
+ * this build answers locally and whose /txns it pauses, served and refused by
+ * the same rule. A gated recognizer is never in BUILTIN_REGISTRY, so a build
+ * reaches it only through a sync that declares its capability.
+ * `datatrans_secure_fields_tokenize`: Datatrans Secure Fields' TOKENIZE card
+ * post, which this build judges before it pauses, under the card-on-file
+ * policy served with the entry, and answers again for a repeat of the same
+ * form (datatrans.ts). A gated recognizer never sits in BUILTIN_REGISTRY, so
+ * it is paused only after a sync.
+ * `authorize_net_dpm_form`: the Authorize.Net Direct Post Method and SIM card
+ * form, one form navigation to transact.dll that the cardholder's device submits
+ * itself (hosted_form). This build finishes it with the hosted_form flow it
+ * already speaks, holds the bare endpoint the entry names (bareEndpoint in
+ * findRecognizer), and reads the form's keys without regard to case
+ * (card-fields.js). The API serves it, like Fiserv's, only to an org Agentcard
+ * enabled for that processor; every other org is served the ungated catalog.
+ * `pelecard_transaction`: Pelecard's card submission, which this build judges
+ * before it pauses (pelecard.ts) and pays only for the amount the agent passes.
+ * Declaring it is not enough: the API serves a gated recognizer only to an org
+ * Agentcard has enabled for that processor, so for every other org this build
+ * syncs the same catalog as one that declares nothing and leaves the processor's
+ * requests alone. A gated recognizer never sits in BUILTIN_REGISTRY, so it is
+ * paused only after a sync.
+ * `aci_split_card.v1`: ACI's COPYandPAY widget, whose card reaches ACI as
+ * several requests to one checkout. This build pauses the card-number request
+ * for a prepared checkout, holds the page's own CVC and expiry requests and
+ * answers them with that request's answer, and continues the page's /payment
+ * submission once, with the placeholder expiry removed (aci.ts). A gated
+ * recognizer is never in BUILTIN_REGISTRY, so a build reaches it only through a
+ * sync that declares its capability, and whether an org may pay through it
+ * stays the API's decision.
+ * `creditguard_pps_process`: CreditGuard's hosted payment page (Hyp PPS), whose
+ * card submit this build pays only under a prepared checkout that names the
+ * framed page (prepare({ psp: 'creditguard', environment, paymentPageUrl })). The
+ * API serves CreditGuard's recognizer on the same terms as Fiserv's.
+ * `primer_payment_instruments`: Primer's card tokenization, which this build
+ * judges before it pauses (primer.ts) and hands back to the page only as a
+ * single-use token. A merchant's client session can save the card after the
+ * payment with no sign in that request, so the API creates a Primer
+ * authorization only for a test-mode client and refuses a live one (400
+ * invalid_primer_request, live_keep_on_file) until the cardholder can consent
+ * to that save; this build then aborts the paused request with nothing sent. A
+ * gated recognizer never sits in BUILTIN_REGISTRY, so it is paused only after a
+ * sync.
+ * `payrails_device_encrypt`: Payrails' card-form save, which this build pauses
+ * only once it has bound the save to a captured session (payrails.ts). A gated
+ * recognizer never sits in BUILTIN_REGISTRY, so it is paused only after a sync.
+ * `converge_hpp_process`: Elavon Converge's Hosted Payment Page card request
+ * (elavon-converge.ts), paused in token mode and judged by the pre-claim gate.
+ * A gated recognizer never sits in BUILTIN_REGISTRY, so it is paused only after a
+ * sync, and the API also refuses a Converge payment for every company the
+ * processor is off for.
+ * `worldpay_eprotect_jsonp`: Worldpay eProtect, whose card rides in the query of
+ * a JSONP <script> GET that this build pauses, binds to a prepared checkout and
+ * answers with the registration in the script's own callback (eprotect.ts). A
+ * gated recognizer is never in BUILTIN_REGISTRY, so a build reaches either only
+ * through a sync that declares its capability, and the API serves it on that
+ * sync only for a company it has turned the processor on for.
+ * `wspay_confirm`: WSPay Components' card confirm, which this build judges
+ * before it pauses (wspay.ts) and pays only for the amount the agent passes.
+ * The API serves a gated recognizer only to a build that lists its capability
+ * and only for a company Agentcard turned that processor on for, so an older
+ * SDK never pauses a request it cannot finish and no SDK pauses one for a
+ * company the processor is off for; the API also refuses that processor's
+ * payment for every such company. A gated recognizer never sits in
+ * BUILTIN_REGISTRY, so it is paused only after a sync.
+ * `shiji_sts_pinned_key`: this build swaps Shiji STS's ciphertexts at the body
+ * root under the pinned key, binds the getCvvId companion to the getTokenId it
+ * continued, and refuses every other Shiji request in the browser (shiji-sts.ts).
+ * The API serves it on the same terms, only for a company Agentcard turned Shiji
+ * STS on for.
+ * `amadeus_checkout_actions.v1`: Amadeus Checkout (the Checkout Web SDK add and
+ * the Data Collection Page store), served on the same terms. This build lets every
+ * other action on those URLs through without claiming a preparation, so the page's
+ * own `load` never spends or blocks one, takes the card request only through a
+ * prepared checkout bound to the approved page's host, and fails a paused SDK add
+ * the device has not started 20 seconds after the pause (AMADEUS_SEND_WINDOW_MS).
+ * `worldline_mycheckout_form`: Worldline MyCheckout's card form (DHL Express),
+ * a top-level form POST this build holds like Tranzila's (mode hosted_form) and
+ * answers with the submission notice once the cardholder's device submitted the
+ * form itself. The page's cancel and its other payment methods on the same URL
+ * carry no card and continue untouched. The API serves the recognizer only to a
+ * build that lists it and only for a company Agentcard turned it on for.
+ * `verifone_card_capture`: a reviewed Verifone merchant's own card request (a
+ * verifone.js blob sent to the merchant's server), which this build pauses and pays
+ * only through a prepared checkout (verifone.ts); the API serves the Verifone
+ * profiles only to a build that lists it, for a company Agentcard turned Verifone on for.
+ * `ekashu_hosted_payment_page`: NMI's hosted payment page, whose card-free entry this
+ * build pauses for the cardholder's device and whose card page this build never lets
+ * the agent's browser post to (pre-claim.ts, ekashu.ts); served on the same terms.
  */
-export const SUPPORTED_CAPABILITIES = ['fiserv_card_capture', GMO_CAPABILITY, CYBERSOURCE_FLEX_CAPABILITY];
+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'];
 /**
  * Processors whose paused request names no amount at all, so the pair the
  * agent passes is the amount the cardholder approves: authorize() refuses one
  * without it (AmountRequiredError), and the API answers 400 amount_required
  * for the same case. GMO's card token request carries none: the merchant's
- * server charges the token later, for the amount it decides.
+ * server charges the token later, for the amount it decides. Pelecard's card
+ * submission carries none either: the merchant's server bound the total, the
+ * currency and the action type to the payment page when it created it, and no
+ * Pelecard answer states them. WSPay's confirm carries none either: WSPay fixed
+ * the amount when the merchant's server created the payment, so the agent's
+ * pair is also the figure the API compares with WSPay's answer when that
+ * answer names one. A WSPay 3-D Secure step answers with no amount, so on that
+ * path nothing Agentcard sees confirms what WSPay charges once the challenge
+ * completes.
  */
-const AGENT_AMOUNT_PROCESSORS = [GMO_PSP];
+const AGENT_AMOUNT_PROCESSORS = [GMO_PSP, PELECARD_PSP, WSPAY_PSP];
 /** How AmountRequiredError names a processor. */
-const PROCESSOR_NAMES = { [GMO_PSP]: 'GMO' };
+const PROCESSOR_NAMES = { [GMO_PSP]: 'GMO', [PELECARD_PSP]: 'Pelecard', [WSPAY_PSP]: 'WSPay' };
+/**
+ * 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.
+ */
+const PAGE_AMOUNT_PROCESSORS = [PELECARD_PSP];
 /** 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')
         return Number.isSafeInteger(amount) && amount >= 0;
     return typeof amount === 'string' && /^\d{1,15}\.\d{1,3}$/.test(amount.trim());
 }
+// The API reads an amount with Stripe's decimal places, which are not always ISO 4217's: MGA has
+// none, IQD and LYD have two. Kept equal to payment-core's stripeMinorUnitDigits by a test.
+const ZERO_DECIMAL_CURRENCIES = ['BIF', 'CLP', 'DJF', 'GNF', 'JPY', 'KMF', 'KRW', 'MGA', 'PYG', 'RWF', 'VND', 'VUV', 'XAF', 'XOF', 'XPF'];
+const THREE_DECIMAL_CURRENCIES = ['BHD', 'JOD', 'KWD', 'OMR', 'TND'];
+/** Digits after the point when the API reads an amount in `currency`. */
+export function amountDigits(currency) {
+    const code = currency.trim().toUpperCase();
+    return ZERO_DECIMAL_CURRENCIES.includes(code) ? 0 : THREE_DECIMAL_CURRENCIES.includes(code) ? 3 : 2;
+}
+/** `minor` in the forms the API accepts, labelled with the amount it means; null when the API refuses it. */
+function amountOption(minor, currency) {
+    const digits = amountDigits(currency);
+    // A three-decimal amount ends in 0 in the smallest unit (5120 for 5.120 KWD), as the API requires.
+    if (!Number.isSafeInteger(minor) || minor < 0 || (digits === 3 && minor % 10 !== 0))
+        return null;
+    const code = currency.trim().toUpperCase();
+    if (digits === 0)
+        return `For ${minor} ${code}, send the number ${minor}.`;
+    const padded = String(minor).padStart(digits + 1, '0');
+    const decimal = `${padded.slice(0, -digits)}.${padded.slice(-digits)}`;
+    return `For ${decimal} ${code}, send the number ${minor} or the string "${decimal}".`;
+}
+/** Every amount `figure` can mean in `currency`, each in the forms the API accepts. */
+function amountOptions(figure, currency) {
+    const digits = amountDigits(currency);
+    const whole = /^\d{1,15}$/.test(figure);
+    const decimal = /^(\d{1,15})\.(\d{1,3})$/.exec(figure);
+    // Digits alone can mean the smallest unit or normal units, so both readings are offered, each
+    // labelled with the amount it means, and the agent picks the one it intended.
+    const readings = whole ? (digits === 0 ? [Number(figure)] : [Number(figure), Number(figure) * 10 ** digits])
+        // More digits after the point than the currency has (23.065 dollars) is no amount at all.
+        : decimal && (decimal[2].length <= digits || Number(decimal[2].slice(digits)) === 0)
+            ? [Number(decimal[1] + decimal[2].padEnd(digits, '0').slice(0, digits))] : [];
+    return readings.map(minor => amountOption(minor, currency)).filter((option) => option !== null);
+}
+/**
+ * Why an amount is refused, worded for the agent that sent it: the rule, the value it passed, and
+ * each amount that value can mean, in the forms the API accepts. An agent told only the rule sends
+ * the same value again, and a tool harness that serializes every argument as text turns 2667 into
+ * "2667" on each try. A value that does not read as a price (long, or more digits than any amount)
+ * is described and never echoed, so a card number typed into the wrong field cannot reach a log
+ * line. A value below zero is named as such and never offered back as a positive amount.
+ */
+export function amountRefusal(amount, currency) {
+    const rule = 'amount is an integer in the currency\'s smallest unit (2306 for $23.06), or a decimal string in normal units ("23.06").';
+    // Ten digits is $99,999,999.99 in cents, and no more of a card number than its first six and last four.
+    const readable = typeof amount === 'string' ? amount.length <= 24 && (amount.match(/\d/g)?.length ?? 0) <= 10
+        : typeof amount === 'number' && Number.isFinite(amount) && Math.abs(amount) < 1e10;
+    if (!readable) {
+        const kind = typeof amount === 'string' ? 'a string' : typeof amount === 'number' ? 'a number' : amount === null ? 'null' : `a value of type ${typeof amount}`;
+        return `${rule} You passed ${kind}${typeof amount === 'string' || typeof amount === 'number' ? ' that does not read as an amount' : ''}.`;
+    }
+    const got = typeof amount === 'string' ? `the string ${JSON.stringify(amount)}` : `the number ${amount}`;
+    const code = typeof currency === 'string' && /^[a-z]{3}$/i.test(currency.trim()) ? currency.trim() : null;
+    // The figure inside a display string: "$23.06", "USD 23.06" and "23.06 usd" read as 23.06.
+    let figure = String(amount).trim().replace(/^[$€£¥₹]\s*/, '');
+    if (code)
+        figure = figure.replace(new RegExp(`^${code}\\s*|\\s*${code}$`, 'gi'), '');
+    if (figure.startsWith('-'))
+        return `${rule} You passed ${got}, which is below zero.`;
+    const options = code ? amountOptions(figure, code) : [];
+    return `${rule} You passed ${got}.${options.length ? ` ${options.join(' ')}` : ''}`;
+}
 const AMOUNT_AUTHORITIES = ['processor', 'agent', 'page', 'none'];
 export class CheckoutPreparationError extends Error {
     preparationId;
     reason;
-    constructor(preparationId, reason) {
-        super(`Checkout preparation unavailable: ${reason}`);
+    /**
+     * The API's own reason code under `reason`, when it gave one: a CreditGuard
+     * transaction refused as `creditguard_transaction_refused` names what the
+     * Vault cannot finish here (`three_d_secure`, `otp`, `installments`, ...).
+     */
+    detail;
+    /** `explanation` follows the reason in the message: what the caller passed and what to send instead. */
+    constructor(preparationId, reason, detail, explanation) {
+        super(`Checkout preparation unavailable: ${reason}${detail ? ` (${detail})` : ''}${explanation ? `. ${explanation}` : ''}`);
         this.preparationId = preparationId;
         this.reason = reason;
         this.name = 'CheckoutPreparationError';
+        if (detail)
+            this.detail = detail;
     }
 }
+/**
+ * Why a preparation's payment page is refused before any request, or null. CreditGuard needs the page
+ * the checkout framed, on a host of the preparation's environment (payment-core's own reading of it,
+ * the one the API applies); no other processor takes one.
+ */
+function paymentPageRefusal(input) {
+    if (input.psp !== 'creditguard')
+        return input.paymentPageUrl === undefined ? null : 'payment_page_unsupported';
+    if (input.paymentPageUrl === undefined)
+        return 'payment_page_required';
+    const processUrl = creditguardPageProcessUrl(input.paymentPageUrl);
+    if (processUrl === null)
+        return 'unsupported_payment_page';
+    return creditguardPreparationEnvironment(new URL(processUrl).hostname) === input.environment ? null : 'payment_page_environment_mismatch';
+}
+/**
+ * The API's refusals of a CreditGuard preparation, answered before any row or prompt: each names
+ * something the caller can act on (a page the Vault cannot finish, an amount CreditGuard does not
+ * hold, a company not enabled), so it is reported as its own reason rather than as an unconfirmed
+ * preparation. A transaction refusal carries CreditGuard's reason as `detail`.
+ */
+const CREDITGUARD_PREPARATION_REFUSALS = ['payment_page_required', 'unsupported_payment_page',
+    'sandbox_host_on_live_row', 'live_host_on_sandbox_row', 'creditguard_transaction_refused', 'creditguard_transaction_unavailable',
+    'amount_mismatch', 'processor_unavailable'];
+function creditguardPreparationRefusal(error) {
+    if (!(error instanceof CheckoutApiError) || error.code === null || !CREDITGUARD_PREPARATION_REFUSALS.includes(error.code))
+        return null;
+    const reason = error.details.reason;
+    return new CheckoutPreparationError(null, error.code, typeof reason === 'string' && /^[a-z0-9_]{1,64}$/.test(reason) ? reason : undefined);
+}
 export class CardEncryptedError extends Error {
     psp;
     constructor(psp) {
@@ -164,10 +390,15 @@ export class PreparationRequiredError extends Error {
 /**
  * The paused request names no amount and none was passed. A GMO card token
  * request carries no amount (the merchant's server charges the token later),
- * so the `amount` and `currency` you pass are what the cardholder approves.
- * 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.
+ * and neither does a Pelecard card submission (the merchant's server bound it
+ * to the payment page when it created it) or a WSPay confirm (WSPay fixed it
+ * 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
+ * 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.
  */
 export class AmountRequiredError extends Error {
     psp;
@@ -179,6 +410,25 @@ export class AmountRequiredError extends Error {
         this.name = 'AmountRequiredError';
     }
 }
+/**
+ * The paused request names no amount, and the total its payment page shows
+ * (`pageAmount`) was not passed. Pelecard's merchant bound the total to the
+ * payment page when it created it, and no Pelecard request or answer states
+ * it, so the page's total is the one figure that ties the `amount` the
+ * cardholder approves to what the page charges. Thrown locally before any
+ * create or prompt; the API answers 400 page_amount_required for the same
+ * case. Not terminal: the page's next submission reads the total again.
+ */
+export class PageAmountRequiredError extends Error {
+    psp;
+    code = 'page_amount_required';
+    constructor(psp) {
+        const processor = psp === PELECARD_PSP ? 'Pelecard' : 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';
+    }
+}
 export class ApprovalTimeoutError extends Error {
     constructor(ms) { super(`user did not approve within ${ms}ms`); this.name = 'ApprovalTimeoutError'; }
 }
@@ -190,6 +440,15 @@ export const RUNTIME_CANCEL_REASONS = ['merchant_request_aborted', 'merchant_nev
 export class PaymentOutcomeUnknownError extends Error {
     authorizationId;
     reason;
+    /**
+     * False when the API confirmed it retired this authorization before any processor
+     * request started: authorize() cancels an authorization it could not finish (a card
+     * endpoint, a prepared or a native checkout, or a request the page abandoned), and the
+     * cancel came back with `processor_request_started: false`, so nothing reached the
+     * processor or the merchant. Null when that is not known. The controller still reads
+     * `outcome_unknown`; a card form navigation's page reads this to say nothing was sent.
+     */
+    processorRequestStarted = null;
     constructor(authorizationId, reason) {
         super(`payment outcome unknown${authorizationId ? ` for ${authorizationId}` : ''}: ${reason}; check the merchant order before retrying`);
         this.authorizationId = authorizationId;
@@ -522,10 +781,13 @@ export class CheckoutApiError extends Error {
      * already has, or already answered, the prompt for this submission, and
      * once that prior authorization is declined or expired the same form is a
      * new question. The adapters quiet the page's re-post the way they quiet a
-     * decline instead of latching the attachment.
+     * decline instead of latching the attachment. NOT a stale form fingerprint
+     * either (isStaleFingerprint): the bytes of that form are refused for good,
+     * but the merchant's page renders a fresh fingerprint on reload, so the
+     * page's next form is a new question and is quieted the same way.
      */
     get permanent() {
-        if (this.code === 'amount_mismatch' || this.code === 'duplicate_submission')
+        if (this.code === 'amount_mismatch' || this.code === 'duplicate_submission' || this.isStaleFingerprint)
             return false;
         // Nor a refusal by the company preset (a 403 carrying `preset` in the
         // envelope): the company's rules refused THIS purchase, at this merchant,
@@ -535,6 +797,16 @@ export class CheckoutApiError extends Error {
             return false;
         return this.status >= 400 && this.status < 500 && this.status !== 429;
     }
+    /**
+     * True for a 400 `hosted_form_field_refused` whose reason is
+     * `stale_fingerprint`: an Authorize.Net DPM or SIM form signed more than 40
+     * minutes before the create, or ahead of the API's clock. Authorize.Net
+     * would refuse that fingerprint itself, and the page renders a fresh one
+     * when it reloads, so the refusal holds for this form only.
+     */
+    get isStaleFingerprint() {
+        return this.status === 400 && this.code === 'hosted_form_field_refused' && this.details.reason === 'stale_fingerprint';
+    }
 }
 /** The client-credentials exchange was refused: the RFC 6749 error, with the status the token endpoint answered. */
 export class CheckoutAuthError extends Error {
@@ -582,18 +854,46 @@ function parseErrorEnvelope(bodyText) {
     }
     return { code: null, details: {} };
 }
+const CREDITGUARD_HOST = /(?:^|\.)creditguard\.co\.il\.?$/i;
+function maskCreditguardTxId(path) {
+    return path.replace(/(\/txn\/)[^/]+/gi, '$1{txId}')
+        .replace(/[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}/gi, '{txId}');
+}
+/**
+ * Hosts that put a per-payment secret in the PATH: Monri Components and
+ * WSPay's build of it name the payment's client_secret in
+ * /v2/payment/{client_secret}/confirm (and /show, /status), and with the page's
+ * public token that secret confirms the payment and reads its status.
+ */
+const PATH_SECRET_HOSTS = ['proxy.wspay.biz', 'proxy-test.wspay.biz', 'ipg.monri.com', 'ipgtest.monri.com'];
+/** The segment after a `payment` segment, in any case (the WSPay proxy is IIS) or after an escaped slash. */
+const PATH_SECRET = /(\/payment(?:\/|%2f))[^/]*/gi;
 /**
  * A URL as it may appear in an error message: origin + path only. A paused
  * request's URL can carry a client secret in its query string, and error
  * messages travel further than anyone intends (onEvent, logs, crash reports).
+ * CreditGuard puts one in the path: on its hosts the transaction id after
+ * /txn/ is that transaction's only credential (payment-core's creditguard.js),
+ * so it reads {txId}, as does any other id-shaped segment there.
+ * On the Monri and WSPay hosts the secret is a path segment, so it is replaced
+ * with `{client_secret}`: https://proxy.wspay.biz/v2/payment/{client_secret}/confirm.
+ * A string that is not a URL keeps the part before any `?` or `#`, with the
+ * same segment masked.
  */
 export function redactUrl(raw) {
+    // An ACI checkout id is that checkout's only capability; it never rides on an event.
+    const aci = redactAciCheckoutId(raw);
+    if (aci !== null)
+        return aci;
     try {
         const u = new URL(raw);
-        return `${u.origin}${u.pathname}`;
+        // A trailing dot names the same host, so it cannot let the secret through.
+        const path = PATH_SECRET_HOSTS.includes(u.hostname.replace(/\.$/, '')) ? u.pathname.replace(PATH_SECRET, '$1{client_secret}') : u.pathname;
+        return `${u.origin}${CREDITGUARD_HOST.test(u.hostname) ? maskCreditguardTxId(path) : path}`;
     }
     catch {
-        return raw.split(/[?#]/)[0];
+        const bare = raw.split(/[?#]/)[0].replace(PATH_SECRET, '$1{client_secret}');
+        return /creditguard\.co\.il/i.test(bare) ? maskCreditguardTxId(bare) : bare;
     }
 }
 /**
@@ -625,6 +925,33 @@ const FISERV_PREPARATION_REFUSALS = [
     'processor_unavailable', 'unsupported_checkout', 'merchant_profile_required', 'unknown_merchant_profile',
     'merchant_profile_key_changed', 'fiserv_key_refused', 'sandbox_host_on_live_row', 'live_host_on_sandbox_row',
 ];
+/**
+ * The API's refusals of a Worldpay eProtect preparation, before any preparation exists, that
+ * prepareCheckout surfaces by name: a live checkout's merchant is not the name the reviewed pin for
+ * its paypageId carries (`merchant_profile_mismatch`, which this build also refuses itself when it
+ * holds that pin). Only for an eProtect checkout.
+ */
+const EPROTECT_PREPARATION_REFUSALS = ['merchant_profile_mismatch'];
+/**
+ * Refusals a CyberSource Flex preparation that tokenizes before Pay answers (4xx) before any
+ * preparation exists, surfaced as the CheckoutPreparationError reason: the processor is off for
+ * this company (`processor_unavailable`), the environment is not the client's mode, or the capture
+ * context or fields read from the page cannot be verified or rebuilt. Only for such a preparation;
+ * a Flex preparation without a capture context keeps `preparation_unconfirmed`, as before.
+ */
+const CYBERSOURCE_FLEX_PREPARATION_REFUSALS = [
+    'processor_unavailable', 'sandbox_host_on_live_row', 'live_host_on_sandbox_row', 'capture_context_invalid', 'microform_unsupported',
+    'cybersource_environment_mismatch',
+];
+/** Why payment-core refused a Flex preparation's capture context or fields, as a CheckoutPreparationError reason. */
+function cybersourceFlexPreparationRefusal(error) {
+    const reason = error?.reason;
+    if (reason === 'microform_version' || reason === 'fields')
+        return 'microform_unsupported';
+    if (reason === 'environment_mismatch')
+        return 'cybersource_environment_mismatch';
+    return 'capture_context_invalid';
+}
 /** Default backoff for a 502 amount_unverifiable at create: two retries, then give up. */
 const UNVERIFIABLE_RETRY_DELAYS_MS = [500, 1500];
 const PREPARATION_READ_RETRY_DELAYS_MS = [250, 500];
@@ -638,6 +965,20 @@ function transientReadNetworkError(error) {
     const code = error.cause?.code ?? error.code;
     return typeof code === 'string' && TRANSIENT_READ_NETWORK_CODES.has(code);
 }
+/**
+ * Processors whose payment without a card can spend a token the processor
+ * minted from the approved card. Nuvei answers a card it is handed (Fields
+ * getToken, or either leg of createPayment) with a ccTempToken, and can save
+ * it for a userPaymentOptionId; a clientPayment.do carrying only one of those
+ * pays with the approved card, and nothing binds it to the approved amount.
+ * So once the attachment has handed Nuvei the card, such a payment is refused
+ * (after the holds) instead of continuing. Before that, the token was issued
+ * elsewhere (Air France's server issues it, behind Amadeus) and it continues.
+ * Stripe is not listed: a card-free PaymentIntent confirm is bound by the API
+ * (checkStripeContinuation), and the confirmations its passWithoutCard names
+ * continue by design (payment-core definitions.js).
+ */
+const CARD_FREE_AFTER_HANDOFF_REFUSED = new Set(['nuvei']);
 export class VaultClient {
     opts;
     baseUrl;
@@ -653,6 +994,12 @@ export class VaultClient {
      * in 'observe' until a sync reads that the API enabled it (armServedProfiles).
      */
     merchantProfiles = armServedProfiles();
+    /**
+     * The reviewed Verifone profiles this client arms: only the ones the API served on the
+     * last sync, which it serves only to a company Agentcard turned Verifone on for
+     * (armServedVerifoneProfiles). None before a sync.
+     */
+    verifoneProfiles = [];
     /** This client's own sandbox declarations (sandboxMerchants), armed at construction, one per profile. */
     declaredProfiles;
     preparations = new WeakSet();
@@ -756,9 +1103,14 @@ export class VaultClient {
     mergedRegistry() {
         return this.extraRecognizers.length ? [...this.extraRecognizers, ...this.registry] : this.registry;
     }
-    /** The recogniser that claims a card request (`POST` to a recognised endpoint), or null; what a paused request names as `recognizer`. */
+    /**
+     * The recogniser that claims a card request, or null; what a paused request names as
+     * `recognizer`. A POST to a recognised endpoint, or for a recognizer whose card request is a
+     * GET (Worldpay eProtect) that exact GET, query included.
+     */
     recognizerOf(url, method = 'POST') {
-        return method.toUpperCase() === 'POST' ? findRecognizer(url, this.mergedRegistry(), { sandbox: this.sandbox }) : null;
+        const rec = findRecognizer(url, this.mergedRegistry(), { sandbox: this.sandbox });
+        return rec !== null && isRecognizerRequest(rec, url, method) ? rec : null;
     }
     /** Refresh recognizers from the API so new PSPs work without a redeploy. */
     async syncRegistry() {
@@ -774,13 +1126,30 @@ export class VaultClient {
         // ?capabilities= is the dark-launch half of the same negotiation: a
         // processor gated behind a capability is served only when this build lists
         // it (SUPPORTED_CAPABILITIES: fiserv_card_capture, gmo_shared_pk,
-        // capture_context) and the caller's company is one Agentcard turned that
-        // processor on for, so this build arms Fiserv's card capture, GMO's getToken
-        // and CyberSource Flex's card fields only for such a company, and an older
-        // build never receives a recognizer it cannot judge. Every other org's
-        // registry never recognizes a Flex host, so its Microform requests go
-        // through untouched; the create checks the org again (403
-        // processor_unavailable).
+        // capture_context, juspay_txns.v1, datatrans_secure_fields_tokenize,
+        // authorize_net_dpm_form, pelecard_transaction, aci_split_card.v1,
+        // creditguard_pps_process, primer_payment_instruments,
+        // payrails_device_encrypt, converge_hpp_process, worldpay_eprotect_jsonp,
+        // wspay_confirm, shiji_sts_pinned_key, amadeus_checkout_actions.v1,
+        // worldline_mycheckout_form, verifone_card_capture) 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
+        // Authorize.Net DPM or SIM form, Pelecard's card submission, ACI's split card,
+        // CreditGuard's hosted page submit, Primer's card tokenization, Payrails' card
+        // save, Converge's payment page, Worldpay eProtect's registration, WSPay's
+        // card confirm, Shiji STS's card leg, Amadeus Checkout's card add and
+        // Worldline MyCheckout's card form only for
+        // such a company, and an older build never receives a recognizer it cannot
+        // judge. Every other org's registry never recognizes a Flex, Juspay, Datatrans,
+        // Pelecard, ACI, CreditGuard, Primer, Payrails, Converge, eProtect, WSPay, Shiji STS, Amadeus or
+        // MyCheckout host or the
+        // transact.dll form, so its Microform, Juspay, Datatrans, Authorize.Net DPM or
+        // SIM, Pelecard, ACI, CreditGuard, Primer, Payrails, Converge, eProtect, WSPay,
+        // Shiji STS, Amadeus and MyCheckout requests go through untouched; the create checks the org again (403
+        // processor_unavailable), and the SDK refuses ACI's card-number request,
+        // CreditGuard's submit, an eProtect registration and an Amadeus card add locally
+        // without a prepared checkout.
         const capabilities = SUPPORTED_CAPABILITIES.length ? `&capabilities=${SUPPORTED_CAPABILITIES.join(',')}` : '';
         // merchant_profiles=1 asks for the reviewed Adyen merchant profiles too, each
         // as a `{ merchant_profile }` entry after the recognizers; an API that
@@ -797,12 +1166,31 @@ export class VaultClient {
         if (!Array.isArray(raw))
             return;
         const isProfile = (e) => !!e && typeof e === 'object' && 'merchant_profile' in e;
-        this.registry = raw.filter((e) => !isProfile(e)).map((e) => ({
+        this.registry = raw.filter((e) => !isProfile(e) && !isVerifoneProfileEntry(e)).map((e) => ({
             ...e,
             match: new RegExp(e.match, 'i'),
             passthroughHeaders: e.passthroughHeaders.map((h) => new RegExp(h, 'i')),
         }));
         this.merchantProfiles = armServedProfiles(raw.filter(isProfile));
+        this.verifoneProfiles = armServedVerifoneProfiles(raw.filter(isVerifoneProfileEntry));
+    }
+    /**
+     * The armed Verifone profile whose endpoint origin this URL is on, with its status on
+     * this client; null for any other URL, and for every URL before a sync served one. The
+     * adapters pause every request to that origin and judge it with
+     * classifyVerifoneProfileRequest. A raw runtime that pauses one must never continue a
+     * body carrying a verifone.js blob there unless authorize() paid it.
+     */
+    verifoneProfileOf(url) {
+        return verifoneProfileFor(this.verifoneProfiles, url);
+    }
+    /** The armed Verifone profile with this id, or null. */
+    verifoneProfile(id) {
+        return this.verifoneProfiles.find((profile) => profile.id === id) ?? null;
+    }
+    /** Fetch.enable globs for every armed Verifone profile's endpoint origins; none before a sync served one. */
+    verifoneProfileUrlPatterns() {
+        return verifoneProfileUrlPatterns(this.verifoneProfiles);
     }
     /**
      * The reviewed Adyen merchant profile whose card endpoint (or a sibling of it,
@@ -830,28 +1218,73 @@ export class VaultClient {
     merchantProfileUrlPatterns() {
         return merchantProfileUrlPatterns([...this.declaredProfiles, ...this.merchantProfiles]);
     }
-    /** True when this request is a card tokenization we can take over. */
+    /**
+     * The card-on-file policy the API served with the recognizer for this
+     * request (Recognizer.cardOnFile), or null when no recognizer matches or
+     * its entry names none. The Datatrans gate refuses a post that asks to keep
+     * the card on file only while this is `refuse` or a value it does not know.
+     */
+    cardOnFilePolicy(url, method = 'POST') {
+        if (method.toUpperCase() !== 'POST')
+            return null;
+        const rec = findRecognizer(url, this.registry);
+        return rec && typeof rec.cardOnFile === 'string' ? rec.cardOnFile : null;
+    }
+    /**
+     * True when this request is a card tokenization we can take over: a POST to
+     * a recognized endpoint, or for a recognizer whose card request is a GET
+     * (Worldpay eProtect) that exact GET, query included.
+     */
     isCardRequest(url, method = 'POST') {
         return this.recognizerOf(url, method) !== null;
     }
+    /**
+     * Whether the current registry holds this processor's recognizer. A
+     * processor that ships dark is served only to a build that declares its
+     * 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.
+     */
+    recognizesProcessor(psp) {
+        return this.registry.some((rec) => rec.psp === psp);
+    }
     /**
      * What happens to a card request (by URL) whose body carries no card: null
      * when it carries one, so it is a card request as usual; 'continue' when the
      * recognizer marks the endpoint as one where such requests are routine and
      * never ours; 'refuse' otherwise, such as a Stripe confirmation paying with
-     * a method this checkout never approved. The adapters ask only after their
-     * holds, so a request that would reuse an approved token is refused there
-     * first. A body that could not be read is not judged here.
+     * a method this checkout never approved. The adapters continue a 'continue'
+     * in every state and judge a 'refuse' after their holds. A body that could
+     * not be read is not judged here.
+     *
+     * `handedTo` lists the requests the attachment has already handed the card
+     * to (CheckoutLifecycle.cardHandoffs). Once one of them went to the same
+     * processor, a processor in CARD_FREE_AFTER_HANDOFF_REFUSED answers 'refuse'
+     * where it would have answered 'continue'.
+     *
+     * A sandbox client's loopback fixture is judged on the processor's own
+     * hosts, as it is recognised (urlsOnProcessorHosts), so a card-free request
+     * the catalog lets through there continues on the fixture too.
      */
-    withoutCard(url, body) {
+    withoutCard(url, body, handedTo = []) {
         if (body == null)
             return null;
-        const rec = findRecognizer(url, this.mergedRegistry(), { sandbox: this.sandbox });
-        return rec ? requestWithoutCard(rec, url, body) : null;
+        const registry = this.mergedRegistry();
+        const rec = findRecognizer(url, registry, { sandbox: this.sandbox });
+        if (!rec)
+            return null;
+        const answers = urlsOnProcessorHosts(url, rec, { sandbox: this.sandbox }).map((judged) => requestWithoutCard(rec, judged, body));
+        const answer = answers.includes(null) ? null : answers.includes('continue') ? 'continue' : 'refuse';
+        if (answer !== 'continue' || !CARD_FREE_AFTER_HANDOFF_REFUSED.has(rec.psp))
+            return answer;
+        return handedTo.some((handed) => findRecognizer(handed, registry, { sandbox: this.sandbox })?.psp === rec.psp) ? 'refuse' : 'continue';
     }
     /**
-     * How the card would reach the processor on this request (`token`, `cse`
-     * or `hosted_form`; absent on the entry means `token`), or null when the
+     * How the card would reach the processor on this request (`token`, `cse`,
+     * `hosted_form` or `device_encrypt`; absent on the entry means `token`), or null when the
      * registry does not recognize it. The adapters read it to decide whether an
      * approval outlives the page's own request: a hosted form is a navigation
      * and cannot.
@@ -915,6 +1348,9 @@ export class VaultClient {
         const fail = (reason, id = null) => new CheckoutPreparationError(id, reason);
         if (!validPreparationEnvironment(input.psp, input.environment))
             throw fail('unsupported_processor');
+        const pageRefusal = paymentPageRefusal(input);
+        if (pageRefusal)
+            throw fail(pageRefusal);
         // A merchant-hosted preparation pays one reviewed profile's card request: the
         // profile must be armed here, enabled, and paid in its own environment.
         // A Fiserv checkout names the key Agentcard pinned for its merchant, in that key's own
@@ -922,7 +1358,21 @@ export class VaultClient {
         // this preparation pays must carry an envelope under that key (matchesPreparation).
         let profile = null;
         let fiservPin = null;
-        if (input.psp === 'fiserv') {
+        // A Verifone checkout names the reviewed profile of the merchant, armed and enabled here, in
+        // that profile's own environment; the API then names that profile's merchant on the approval.
+        let verifone = null;
+        if (input.psp === 'verifone') {
+            if (input.merchantProfile === undefined)
+                throw fail('merchant_profile_required');
+            verifone = typeof input.merchantProfile === 'string' ? this.verifoneProfile(input.merchantProfile) : null;
+            if (!verifone)
+                throw fail('processor_interception_unavailable');
+            if (verifone.status !== 'enabled')
+                throw fail('unsupported_checkout');
+            if (verifone.environment !== input.environment)
+                throw fail('unsupported_processor');
+        }
+        else if (input.psp === 'fiserv') {
             if (input.merchantProfile === undefined)
                 throw fail('merchant_profile_required');
             fiservPin = fiservKeyPinById(input.merchantProfile);
@@ -944,11 +1394,44 @@ export class VaultClient {
                 throw fail('unsupported_processor');
         }
         const declaration = profile?.sandboxDeclaration;
-        if (!validAmountInput(input.amount) || typeof input.currency !== 'string' || !/^[a-z]{3}$/i.test(input.currency))
-            throw fail('amount_required');
+        // Worldpay eProtect: the preparation names the Worldpay merchant its registration may name
+        // (paypageId) and the paying card, whose expiry the agent types at the merchant because
+        // Worldpay never receives one. The API refuses either missing, and a paypageId on any other
+        // processor; refusing here asks nobody to approve a preparation that could never bind.
+        const eprotect = input.psp === EPROTECT_PSP;
+        if (eprotect ? typeof input.paypageId !== 'string' || !/^[A-Za-z0-9]{1,64}$/.test(input.paypageId) : input.paypageId !== undefined)
+            throw fail('paypage_id_invalid');
+        if (eprotect && !input.cardId)
+            throw fail('card_required');
+        // CyberSource Flex, tokenized before Pay: the loaded card field's capture context and fields,
+        // verified here against the keys payment-core pins before anything is created (the API and the
+        // cardholder's device verify them again).
+        if (input.tokenizeBeforePay !== undefined && typeof input.tokenizeBeforePay !== 'boolean')
+            throw fail('tokenize_before_pay_invalid');
+        const flexContext = input.cybersourceFlex;
+        if (input.tokenizeBeforePay === true && !flexContext)
+            throw fail('microform_not_loaded');
+        if (flexContext) {
+            if (input.psp !== CYBERSOURCE_FLEX_PSP)
+                throw fail('unsupported_processor');
+            try {
+                await admitCybersourceFlexPreparation({ capture_context: flexContext.captureContext,
+                    microform: { version: flexContext.microform.version, fields: [...flexContext.microform.fields] }, environment: input.environment }, { crypto: globalThis.crypto });
+            }
+            catch (error) {
+                throw fail(cybersourceFlexPreparationRefusal(error));
+            }
+        }
+        if (!validAmountInput(input.amount) || typeof input.currency !== 'string' || !/^[a-z]{3}$/i.test(input.currency)) {
+            throw new CheckoutPreparationError(null, 'amount_required', undefined, input.amount != null && !validAmountInput(input.amount) ? amountRefusal(input.amount, input.currency) : undefined);
+        }
         const origin = new URL(input.merchantOrigin);
         if (!(origin.protocol === 'https:' || (origin.protocol === 'http:' && origin.hostname === 'localhost')) || origin.origin !== input.merchantOrigin)
             throw fail('merchant_origin_invalid');
+        // CreditGuard's submit names the page that frames it (ppDomain), and only an HTTPS page under a
+        // dotted hostname can be bound to it, so the API would refuse any other merchant page.
+        if (input.psp === 'creditguard' && (origin.protocol !== 'https:' || creditguardPpDomainHost(btoa(origin.hostname)) !== origin.hostname))
+            throw fail('merchant_origin_invalid');
         if (!input.checkoutKey || !input.user || !input.merchant)
             throw fail('checkout_context_required');
         // The cardholder approves a payment to the merchant the key pin belongs to, so a Fiserv
@@ -956,6 +1439,15 @@ export class VaultClient {
         // authorization it pays then name one merchant, never a label the caller chose.
         if (fiservPin && input.merchant !== fiservPin.merchant)
             throw fail('merchant_profile_mismatch');
+        // A live Worldpay eProtect checkout whose paypageId this build pins for the merchant origin names
+        // that pin's merchant, the one the API shows on the approval (eprotectCheckoutRefusal): the
+        // approval, the handle this returns and every authorization it pays then name one merchant, and no
+        // approval is retired over a label. The API refuses a paypageId with no pin (unsupported_checkout);
+        // test mode needs no pin.
+        const eprotectRefusal = eprotect ? eprotectCheckoutRefusal({ environment: input.environment, paypageId: input.paypageId,
+            merchantOrigin: input.merchantOrigin, merchant: input.merchant }) : null;
+        if (eprotectRefusal)
+            throw fail(eprotectRefusal);
         const timeoutMs = input.timeoutMs ?? 15 * 60_000;
         if (!Number.isInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2_147_483_647)
             throw fail('timeout_invalid');
@@ -973,7 +1465,12 @@ export class VaultClient {
                 environment: input.environment, checkout_key: input.checkoutKey, merchant_origin: input.merchantOrigin,
                 ...(profile ? { merchant_profile: profile.id } : {}),
                 ...(fiservPin ? { merchant_profile: fiservPin.id } : {}),
+                ...(verifone ? { merchant_profile: verifone.id } : {}),
                 ...(declaration ? { sandbox_declaration: { endpoint: declaration.endpoint, client_key: declaration.clientKey, environment: 'test' } } : {}),
+                ...(input.psp === 'creditguard' ? { payment_page_url: input.paymentPageUrl } : {}),
+                ...(eprotect ? { paypage_id: input.paypageId } : {}),
+                ...(flexContext ? { capture_context: flexContext.captureContext,
+                    microform: { version: flexContext.microform.version, fields: [...flexContext.microform.fields] } } : {}),
             }, AbortSignal.timeout(30_000), signal);
             if (!created || typeof created.id !== 'string' || !/^cprep_[A-Za-z0-9_-]{1,128}$/.test(created.id))
                 throw fail('create_unconfirmed');
@@ -1004,12 +1501,18 @@ export class VaultClient {
                         // A merchant-hosted preparation names the merchant its reviewed profile names, and
                         // a declared test endpoint names its host (declareSandboxMerchant), never the caller's label.
                         // A Fiserv preparation names the merchant its key pin belongs to (input.merchant, checked above), and that pin.
-                        || state.user !== input.user || state.merchant !== (profile ? profile.merchant : input.merchant) || state.merchant_origin !== input.merchantOrigin
-                        || state.merchant_profile !== (profile ? profile.id : fiservPin ? fiservPin.id : undefined)
+                        // A Verifone preparation names the merchant its reviewed profile names, as a merchant-hosted one.
+                        || state.user !== input.user || state.merchant !== (profile ? profile.merchant : verifone ? verifone.merchant : input.merchant)
+                        || state.merchant_origin !== input.merchantOrigin
+                        || state.merchant_profile !== (profile ? profile.id : fiservPin ? fiservPin.id : verifone ? verifone.id : undefined)
                         || !servesDeclaration(state.sandbox_declaration, declaration)
                         || !Number.isSafeInteger(state.amount) || (typeof input.amount === 'number' && state.amount !== input.amount) || state.currency !== input.currency.toLowerCase()
                         || state.psp !== input.psp || state.mode !== preparationMode(input.psp) || state.environment !== input.environment
-                        || state.checkout_key !== input.checkoutKey)
+                        || state.checkout_key !== input.checkoutKey
+                        // eProtect: the merchant and the card the cardholder approved are the ones asked for.
+                        || (eprotect && (state.paypage_id !== input.paypageId || state.card_id !== input.cardId))
+                        // The API says a preparation tokenizes before Pay exactly when this one carried a capture context.
+                        || (state.tokenize_before_pay === true) !== !!flexContext)
                         throw fail('ready_unconfirmed', id);
                     const prepared = Object.freeze({
                         id: preparationId, status: 'ready', psp: input.psp, environment: input.environment, mode: preparationMode(input.psp), expiresAt: state.ready_expires_at,
@@ -1019,7 +1522,12 @@ export class VaultClient {
                         paymentStatus: 'not_started', amountAuthority: 'agent',
                         ...(profile ? { merchantProfile: profile.id } : {}),
                         ...(fiservPin ? { merchantProfile: fiservPin.id } : {}),
+                        ...(verifone ? { merchantProfile: verifone.id } : {}),
                         ...(declaration ? { sandboxDeclaration: declaration } : {}),
+                        ...(input.psp === 'creditguard' ? { paymentPageUrl: input.paymentPageUrl } : {}),
+                        ...(eprotect ? { paypageId: input.paypageId } : {}),
+                        ...(flexContext ? { cybersourceFlex: Object.freeze({ captureContext: flexContext.captureContext,
+                                microform: Object.freeze({ version: flexContext.microform.version, fields: Object.freeze([...flexContext.microform.fields]) }) }) } : {}),
                     });
                     this.preparations.add(prepared);
                     ready = true;
@@ -1034,13 +1542,18 @@ export class VaultClient {
         catch (error) {
             if (error instanceof CheckoutPreparationError)
                 throw error;
+            const refusal = input.psp === 'creditguard' && id === null ? creditguardPreparationRefusal(error) : null;
+            if (refusal)
+                throw refusal;
             // A refusal the API answered before any preparation existed names its rule: one
             // PREPARATION_REFUSALS names for any checkout, and, for a Fiserv checkout only, one
             // FISERV_PREPARATION_REFUSALS names or a 502 cse_key_unavailable. Every other
             // processor's other refusals stay preparation_unconfirmed, as before.
             if (!id && !signal.aborted && error instanceof CheckoutApiError && error.code
                 && ((error.status >= 400 && error.status < 500 && (PREPARATION_REFUSALS.includes(error.code)
-                    || (input.psp === 'fiserv' && FISERV_PREPARATION_REFUSALS.includes(error.code))))
+                    || (input.psp === 'fiserv' && FISERV_PREPARATION_REFUSALS.includes(error.code))
+                    || (input.psp === EPROTECT_PSP && EPROTECT_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);
             throw fail(signal.aborted ? 'cancelled' : 'preparation_unconfirmed', id);
@@ -1058,6 +1571,30 @@ export class VaultClient {
         if (state?.id !== id || !['cancelled', 'expired'].includes(state.status))
             throw new CheckoutPreparationError(id, 'cancel_unconfirmed');
     }
+    /**
+     * Retire a ready preparation whose authorization create has not answered, and name the request
+     * that already holds it. Resolves null once the API confirms no merchant request can bind the
+     * preparation any more (cancelled or expired: the API takes a cancel and a create's bind under one
+     * lock), or the ID of the authorization it is already bound to, which the caller retires like any
+     * other (cancelAuthorization). Rejects when the API confirms neither. The Amadeus send window uses
+     * it (amadeus.ts).
+     */
+    async retirePreparation(id) {
+        if (!/^cprep_[A-Za-z0-9_-]{1,128}$/.test(id))
+            throw new CheckoutPreparationError(null, 'id_invalid');
+        try {
+            await this.cancelPreparation(id);
+            return null;
+        }
+        catch { /* bound, or unanswered: read it */ }
+        const state = await this.get(`/v2/checkout/preparations/${id}`, AbortSignal.timeout(3_000));
+        if (state?.id === id && (state.status === 'cancelled' || state.status === 'expired'))
+            return null;
+        if (state?.id === id && state.status === 'bound' && typeof state.authorization_id === 'string'
+            && /^cauth_[A-Za-z0-9_-]{1,128}$/.test(state.authorization_id))
+            return state.authorization_id;
+        throw new CheckoutPreparationError(id, 'cancel_unconfirmed');
+    }
     async observePreparation(id, guidance, reason) {
         try {
             await this.post(`/v2/checkout/preparations/${id}/observe`, {
@@ -1084,6 +1621,9 @@ export class VaultClient {
      * response to replay into the browser. Your process never sees a card.
      */
     async authorize(input) {
+        // A reviewed merchant's own card endpoint is checked whole before anything else
+        // (admitCardEndpoint): the profile, the approval, the amount and the session.
+        const cardEndpoint = input.request.merchant_card_endpoint === undefined ? null : admitCardEndpoint(input);
         const mercadoContext = input.request.mercado_checkout === undefined ? undefined : parseMercadoCheckoutContext(input.request.mercado_checkout);
         if (mercadoContext && (!isMercadoTokenRequest(input.request.url, input.request.method)
             || input.executionMode === 'autopilot' || input.grantId))
@@ -1144,14 +1684,16 @@ export class VaultClient {
             throw new PaymentOutcomeUnknownError(null, 'merchant_request_aborted');
         // An armed merchant profile's endpoint (merchant-hosted.ts): the reviewed
         // merchant's own server, never a processor host, so no recognizer matches it.
-        const merchantProfile = nativeCheckout || ownedShop || mercadoContext ? null : this.merchantProfileOf(input.request.url);
+        const merchantProfile = cardEndpoint || nativeCheckout || ownedShop || mercadoContext ? null : this.merchantProfileOf(input.request.url);
+        // An armed Verifone profile's origin (verifone.ts): the reviewed merchant's own server.
+        const verifoneProfile = cardEndpoint || nativeCheckout || ownedShop || mercadoContext || merchantProfile ? null : this.verifoneProfileOf(input.request.url);
         // A preparation pays the profile it was made for and nothing else: a
         // merchant-hosted one never a processor's request or another profile's (two
         // profiles could share an endpoint), and a processor-hosted one never a
         // merchant's own endpoint. Checked here, not left to the matcher above, so the
         // create below can only ever name the profile the cardholder prepared. A Fiserv
         // preparation names a key pin, not a reviewed profile (matchesPreparation binds it).
-        if (preparation && (((preparation.psp === 'fiserv' ? null : preparation.merchantProfile) ?? null) !== (merchantProfile?.id ?? null)
+        if (preparation && (((preparation.psp === 'fiserv' || preparation.psp === 'verifone' ? null : preparation.merchantProfile) ?? null) !== (merchantProfile?.id ?? null)
             || (preparation.sandboxDeclaration?.endpoint ?? null) !== (merchantProfile?.sandboxDeclaration?.endpoint ?? null))) {
             throw new CheckoutPreparationError(preparation.id, 'checkout_changed');
         }
@@ -1161,46 +1703,64 @@ export class VaultClient {
         }
         if (merchantProfile)
             assertMerchantHostedRequest(input, merchantProfile);
-        const rec = merchantProfile ? MERCHANT_HOSTED_RECOGNIZER : nativeCheckout ? this.registry.find(entry => entry.psp === 'stripe' && (entry.mode ?? 'token') === 'token')
+        // A Verifone preparation pays only its profile's reviewed leg (matchesPreparation, above);
+        // here a request at an armed Verifone merchant is held to that profile's own rules.
+        if (verifoneProfile)
+            assertVerifoneRequest(input, verifoneProfile);
+        // A card endpoint is no processor: its profile, never the registry, says where it goes.
+        const rec = cardEndpoint ? null : merchantProfile ? MERCHANT_HOSTED_RECOGNIZER : verifoneProfile ? VERIFONE_RECOGNIZER : nativeCheckout ? this.registry.find(entry => entry.psp === 'stripe' && (entry.mode ?? 'token') === 'token')
             : findRecognizer(input.request.url, this.registry, { sandbox: this.sandbox });
-        if (!rec)
+        if (!cardEndpoint && !rec)
             throw new Error(`not a known tokenization endpoint: ${redactUrl(input.request.url)}`);
         // A client-side-encrypted processor is only takeable when its entry says
         // the vault produces that ciphertext itself (mode cse); a bare
         // clientSideEncrypted entry (an older registry, a hand-built one) still
         // refuses here, exactly as before.
-        const mode = rec.mode ?? 'token';
-        if (preparation && (rec.psp !== preparation.psp || mode !== preparationMode(preparation.psp)))
-            throw new CheckoutPreparationError(preparation.id, 'checkout_changed');
-        // A preparation-required processor may not be taken over on an ordinary
-        // authorization: the cardholder must have approved a prepare() first. Refuse
-        // locally, before any create or prompt, when none is active, through the
-        // same strict rule the API applies (recognizerRequiresPreparation). Fiserv
-        // sets it; the API serves Fiserv only on a sync that declares its capability,
-        // and only to a company Agentcard turned Fiserv on for. This build carries
-        // Fiserv's own rules, so it also requires the preparation for a Fiserv
-        // request whatever the served entry says (requiresFiservPreparation): a
-        // registry that dropped the flag never opens an ordinary Fiserv authorization.
-        if ((recognizerRequiresPreparation(rec) || requiresFiservPreparation(rec.psp, input.request.url)) && !preparation)
-            throw new PreparationRequiredError(rec.psp);
-        // The merchant's server picks what it charges Adyen, so the agent's amount is
-        // what the API holds the body's own amount to: a merchant-hosted payment names one.
-        if (merchantProfile && input.amount == null) {
-            throw new Error(`A payment to ${merchantProfile.merchant} names its amount: pass amount and currency, the amount the cardholder approves.`);
+        const mode = rec ? rec.mode ?? 'token' : CARD_ENDPOINT_MODE;
+        // The transaction a CreditGuard submit pays; its approved answer is rebuilt for it alone.
+        const creditguardTxId = rec?.psp === 'creditguard' ? creditguardProcessTxId(input.request.url) : null;
+        if (rec) {
+            if (preparation && (rec.psp !== preparation.psp || mode !== preparationMode(preparation.psp)))
+                throw new CheckoutPreparationError(preparation.id, 'checkout_changed');
+            // A preparation-required processor may not be taken over on an ordinary
+            // authorization: the cardholder must have approved a prepare() first. Refuse
+            // locally, before any create or prompt, when none is active, through the
+            // same strict rule the API applies (recognizerRequiresPreparation). Fiserv,
+            // aci, CreditGuard and amadeus_checkout set it (a CreditGuard submit is the
+            // sale and names no amount); the API serves each only on a sync that declares
+            // its capability,
+            // and only to a company Agentcard turned it on for. This build carries
+            // Fiserv's own rules, so it also requires the preparation for a Fiserv
+            // request whatever the served entry says (requiresFiservPreparation): a
+            // registry that dropped the flag never opens an ordinary Fiserv authorization.
+            if ((recognizerRequiresPreparation(rec) || requiresFiservPreparation(rec.psp, input.request.url)) && !preparation)
+                throw new PreparationRequiredError(rec.psp);
+            // The merchant's server picks what it charges Adyen, so the agent's amount is
+            // what the API holds the body's own amount to: a merchant-hosted payment names one.
+            if (merchantProfile && input.amount == null) {
+                throw new Error(`A payment to ${merchantProfile.merchant} names its amount: pass amount and currency, the amount the cardholder approves.`);
+            }
+            if (verifoneProfile && input.amount == null) {
+                throw new Error(`A payment to ${verifoneProfile.merchant} names its amount: pass amount and currency, the amount the cardholder approves.`);
+            }
+            // device_encrypt (Payrails) also encrypts in-page; the device rebuilds that
+            // ciphertext under the session key the request carries.
+            if (rec.clientSideEncrypted && mode !== 'cse' && mode !== 'device_encrypt')
+                throw new CardEncryptedError(rec.psp);
+            if (rec.psp === 'creditguard' && creditguardTxId === null)
+                throw new Error(`not a CreditGuard card submit: ${redactUrl(input.request.url)}`);
+            if (mode === CARD_ENDPOINT_MODE || !SUPPORTED_MODES.includes(mode))
+                throw new UnsupportedModeError(mode);
         }
-        if (rec.clientSideEncrypted && mode !== 'cse')
-            throw new CardEncryptedError(rec.psp);
-        if (!SUPPORTED_MODES.includes(mode))
-            throw new UnsupportedModeError(mode);
         // A dark-launch recognizer names the capability its create needs. A build that does not
         // declare it cannot send what that create carries, so it refuses here, before any create;
         // a registry the API served never holds such an entry.
-        if (rec.capability !== undefined && !SUPPORTED_CAPABILITIES.includes(rec.capability))
+        if (rec && rec.capability !== undefined && !SUPPORTED_CAPABILITIES.includes(rec.capability))
             throw new UnsupportedCapabilityError(rec.capability);
         // CyberSource Flex: the capture context and the Microform fields ride on the request (the
         // adapters read both from the card field iframe) and the API verifies them before anything
         // exists. They belong to a Flex request and nothing else, as the API holds them.
-        const flex = rec.psp === CYBERSOURCE_FLEX_PSP;
+        const flex = rec?.psp === CYBERSOURCE_FLEX_PSP;
         if (!flex && (input.request.capture_context !== undefined || input.request.microform !== undefined)) {
             throw new Error('request.capture_context and request.microform belong to a CyberSource Flex card request.');
         }
@@ -1208,15 +1768,39 @@ export class VaultClient {
             throw new Error('A CyberSource Flex card request carries the capture context its card field iframe was loaded with (request.capture_context) '
                 + 'and the Microform fields that loaded (request.microform); attachToCdp and attachToPlaywright read both.');
         }
-        // Say no rather than coerce. isCardRequest only ever pauses a POST, and the
-        // service stores the replay template with method 'POST' hardcoded — so a
-        // caller handing in a PUT or GET would get it silently rewritten and the
-        // cardholder's device would replay something the caller never asked for.
-        // A direct caller deserves to be told, not surprised.
+        // The session key is not in a device_encrypt request: without the one the
+        // page's init payload named, the device has nothing to encrypt under.
+        // Refused before any create or prompt, the way the API refuses
+        // payrails_session_key_required.
+        const sidecar = input.request.payrails;
+        if (mode === 'device_encrypt' && (!sidecar || typeof sidecar.encryption_public_key !== 'string' || !sidecar.encryption_public_key)) {
+            throw new Error('A Payrails card save needs request.payrails.encryption_public_key, the session key from the checkout\'s Payrails init payload (the adapters capture it). Nothing was created.');
+        }
+        // A preparation that tokenized before Pay pays only a field request loaded under the capture
+        // context and fields its cardholder approved: the device holds CyberSource's token for that context.
+        if (preparation?.cybersourceFlex && !(flex && sameCybersourceFlexPreparation({ capture_context: preparation.cybersourceFlex.captureContext, microform: preparation.cybersourceFlex.microform }, { capture_context: input.request.capture_context, microform: input.request.microform }))) {
+            throw new CheckoutPreparationError(preparation.id, 'checkout_changed');
+        }
+        // Say no rather than coerce. Each recognizer's card request has exactly one
+        // method (recognizerRequestMethod): a POST body, or for Worldpay eProtect the
+        // GET whose query carries the card. The service stores the replay template
+        // with that method, so a caller handing in another one would get it
+        // silently rewritten and the cardholder's device would replay something the
+        // caller never asked for. A direct caller deserves to be told, not surprised.
         const method = (input.request.method ?? 'POST').toUpperCase();
-        if (method !== 'POST') {
-            throw new Error(`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 card endpoint has no recognizer: its card request is a POST, as every recognizer's is but eProtect's.
+        const cardMethod = rec ? recognizerRequestMethod(rec) : 'POST';
+        if (method !== cardMethod) {
+            throw new Error(cardMethod === 'GET'
+                ? `a ${rec?.psp} card registration is a GET; got ${method} for ${redactUrl(input.request.url)}.`
+                : `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.
+        const eprotect = rec?.psp === EPROTECT_PSP;
+        if (cardMethod === 'GET' && !(eprotect && isEprotectRegistration(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)}.`);
         }
         // The amount is a hint: a pair or nothing. Refuse half a pair here, before
         // a network call: the API would too, and a retry loop cannot fix a
@@ -1226,15 +1810,27 @@ export class VaultClient {
         if (hasAmount !== hasCurrency) {
             throw new Error('amount and currency go together: pass both or neither.');
         }
-        if (hasAmount && !validAmountInput(input.amount)) {
-            throw new Error('amount is an integer in the currency\'s smallest unit (2306 for $23.06), or a decimal string in normal units ("23.06").');
-        }
+        if (hasAmount && !validAmountInput(input.amount))
+            throw new Error(amountRefusal(input.amount, input.currency));
         // A processor whose request names no amount (AGENT_AMOUNT_PROCESSORS) is
-        // paid only for the pair passed here: it is all the approval can show.
+        // paid only for the pair passed here: it is all the approval can show and,
+        // for WSPay, the only figure the processor's answer is checked against.
         // Refused before any create or prompt; the API refuses the same create as
         // amount_required.
-        if (!hasAmount && AGENT_AMOUNT_PROCESSORS.includes(rec.psp))
+        if (!hasAmount && rec && AGENT_AMOUNT_PROCESSORS.includes(rec.psp))
             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
+        // page charges another. The API refuses the same create as page_amount_required.
+        if (!input.pageAmount && rec && PAGE_AMOUNT_PROCESSORS.includes(rec.psp))
+            throw new PageAmountRequiredError(rec.psp);
+        // A Payrails save names no amount (the merchant charges the saved card
+        // later, under another session), so the price the cardholder approves is
+        // the one sent here: the agent's pair or else the page total. Refused
+        // before any create or prompt, the way the API refuses amount_required.
+        if (mode === 'device_encrypt' && !hasAmount && !input.pageAmount) {
+            throw new Error('A Payrails card save names no amount, so pass amount and currency (or let the adapter read the page total): that is the amount the cardholder approves. Nothing was created and nothing was charged.');
+        }
         const timeoutMs = input.timeoutMs ?? 15 * 60_000;
         if (!Number.isInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2_147_483_647)
             throw new Error('timeoutMs must be a positive integer no larger than 2147483647.');
@@ -1246,7 +1842,21 @@ export class VaultClient {
         const priced = merchantProfile && merchantProfilePricedBySource(merchantProfile.id)
             ? await this.readMerchantTotal(input, merchantProfile, preparation, operationSignal) : null;
         let created;
-        const payload = {
+        const payload = cardEndpoint ? {
+            // A card endpoint's request travels only in merchant_card_endpoint: `request`
+            // names its URL and nothing else, and the agent's amount is the only authority.
+            user: input.user,
+            merchant: input.merchant,
+            amount: input.amount,
+            currency: input.currency,
+            psp: CARD_ENDPOINT_PSP,
+            mode,
+            ...(input.cardId ? { cardId: input.cardId } : {}),
+            execution_mode: 'user_approval',
+            checkout_origin: cardEndpoint.session.page_origin,
+            request: { url: cardEndpoint.session.url, method: 'POST', headers: {}, body: '' },
+            merchant_card_endpoint: { profile: cardEndpoint.profile, session: cardEndpoint.session, ...(cardEndpoint.facts ? { facts: cardEndpoint.facts } : {}) },
+        } : {
             user: input.user,
             merchant: input.merchant,
             // snake_case on the wire; camelCase is this SDK's convention.
@@ -1269,11 +1879,16 @@ export class VaultClient {
                             endpoint: merchantProfile.sandboxDeclaration.endpoint, client_key: merchantProfile.sandboxDeclaration.clientKey, environment: 'test'
                         } } : {}),
                     ...(priced ? { merchant_total: priced.wire } : {}) } } : {}),
+            // 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 } } : {}),
             // 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' }
                 : input.pageOrigin ? { checkout_origin: input.pageOrigin } : {}),
-            request: {
+            // A GET card request (Worldpay eProtect) is its URL alone: no body, and no
+            // header the page sent, which the API would neither store nor replay.
+            request: cardMethod === 'GET' ? { url: input.request.url, method: 'GET', headers: {}, body: '' } : {
                 url: input.request.url,
                 method: input.request.method,
                 headers: { ...pickHeaders(input.request.headers, rec.passthroughHeaders),
@@ -1285,6 +1900,8 @@ export class VaultClient {
                     microform: { version: input.request.microform.version, fields: [...input.request.microform.fields],
                         ...(input.request.microform.trigger ? { trigger: input.request.microform.trigger } : {}) },
                 } : {}),
+                // Only the key: the token already rides in the passthrough authorization header.
+                ...(mode === 'device_encrypt' && sidecar ? { payrails: { encryption_public_key: sidecar.encryption_public_key } } : {}),
             },
         };
         try {
@@ -1324,7 +1941,18 @@ export class VaultClient {
         // 10 seconds has at most 20 reads instead of 5 (15 additional reads).
         // Then restore the caller's interval. Human approval waiting, cancellation,
         // merchant deadlines, and the single processor request remain unchanged.
-        const preparedMercadoPollUntil = preparation?.psp === 'mercado_pago' ? Date.now() + 10_000 : 0;
+        // A prepared Worldpay eProtect registration too, for 15 seconds: its
+        // merchants give up on the paused script 10 to 15 seconds after Pay, so a
+        // registration is read every 500 ms instead of waiting out 2 seconds.
+        const preparedFastPollUntil = preparation?.psp === 'mercado_pago' ? Date.now() + 10_000
+            : preparation?.psp === EPROTECT_PSP ? Date.now() + 15_000 : 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,
+        // then at the caller's interval; at the default 2 seconds the first read alone would miss it.
+        // The API's bind names 100 ms as such a row's poll interval, so slow_down admits these reads
+        // (as an eProtect row names the 500 ms read above).
+        const preparedFlexPollUntil = preparation?.cybersourceFlex ? Date.now() + 10_000 : 0;
         let execution = {};
         let approvalDelivered = false;
         const deliverApproval = (state) => {
@@ -1340,6 +1968,8 @@ export class VaultClient {
             catch { /* observer only */ }
         };
         let failed = false;
+        // What this attempt throws, once it fails: a confirmed retirement below is written onto it.
+        let failure = null;
         let actionRequired = false;
         const checkAutopilotAction = (state) => {
             if (state.autopilot_status !== 'action_required')
@@ -1370,7 +2000,8 @@ export class VaultClient {
             while (Date.now() < deadline) {
                 if (stopSignal?.aborted)
                     throw new PaymentOutcomeUnknownError(authorizationId, input.merchantSignal?.aborted ? 'merchant_request_aborted' : 'local_cancel');
-                const pollInterval = Date.now() < preparedMercadoPollUntil ? Math.min(this.pollIntervalMs, 500) : this.pollIntervalMs;
+                const pollInterval = Date.now() < preparedFastPollUntil ? Math.min(this.pollIntervalMs, 500)
+                    : Date.now() < preparedFlexPollUntil ? Math.min(this.pollIntervalMs, 100) : this.pollIntervalMs;
                 await interruptibleSleep(Math.min(pollInterval, Math.max(0, deadline - Date.now())), stopSignal);
                 if (stopSignal?.aborted)
                     throw new PaymentOutcomeUnknownError(authorizationId, input.merchantSignal?.aborted ? 'merchant_request_aborted' : 'local_cancel');
@@ -1405,7 +2036,7 @@ export class VaultClient {
                 // database forces these rows to cse. A finished read in any other mode
                 // (token, a missing mode, a hosted form) is not one to act on, and never
                 // reaches the code that would answer the merchant's paused request with it.
-                if (merchantProfile && (s.status === 'approved' || s.status === 'submitted_on_device') && s.mode !== 'cse') {
+                if ((merchantProfile || verifoneProfile) && (s.status === 'approved' || s.status === 'submitted_on_device') && s.mode !== 'cse') {
                     throw new PaymentOutcomeUnknownError(authorizationId, 'merchant_hosted_mode_invalid');
                 }
                 if (s.status === 'submitted_on_device') {
@@ -1426,6 +2057,13 @@ export class VaultClient {
                 }
                 if (s.status === 'approved') {
                     const approvedMode = typeof s.mode === 'string' ? s.mode : 'token';
+                    if (cardEndpoint || approvedMode === CARD_ENDPOINT_MODE) {
+                        // Only a card endpoint request is answered from a merchant's own answer, and
+                        // it is answered from nothing else.
+                        if (!cardEndpoint || approvedMode !== CARD_ENDPOINT_MODE)
+                            throw new PaymentOutcomeUnknownError(authorizationId, 'approved_mode_unsupported');
+                        return cardEndpointReplay(s, authorizationId, cardEndpoint.profile, { ...amountAuthority, ...execution });
+                    }
                     if (approvedMode === 'hosted_form') {
                         // Never: the API finishes a hosted form as submitted_on_device, and
                         // its database refuses `approved` on that mode. An answer that says
@@ -1437,19 +2075,30 @@ export class VaultClient {
                             throw new PaymentOutcomeUnknownError(authorizationId, 'autopilot_submission_mode_invalid');
                         // A merchant-hosted create reads back only a merchant-hosted approval,
                         // and a processor-hosted one never does.
+                        // A Verifone create reads back only a Verifone approval, and no other create ever does.
+                        if (verifoneProfile || (s.substitutions && typeof s.substitutions === 'object' && s.substitutions.kind === 'verifone')) {
+                            return { ...verifoneApproval(s, authorizationId, verifoneProfile), ...amountAuthority, ...execution };
+                        }
                         if (merchantProfile || (s.substitutions && typeof s.substitutions === 'object' && 'kind' in s.substitutions)) {
                             return { ...merchantHostedApproval(s, authorizationId, merchantProfile), ...(priced ? { merchantTotal: priced.approved } : {}),
                                 ...amountAuthority, ...execution };
                         }
-                        // The API serves a Fiserv envelope only briefly after the approval (it carries
-                        // no timestamp, so whoever holds it could resubmit it). A read after that
-                        // window says so instead of serving it; the capture was never continued here.
+                        // The API serves a Fiserv envelope, or a Shiji STS set, only briefly after the
+                        // approval (neither is bound to a session, so whoever holds it could resubmit
+                        // it). A read after that window says so instead of serving it; the request was
+                        // never continued here, and nothing here can pay with it.
                         if (s.substitutions_expired === true)
                             throw new PaymentOutcomeUnknownError(authorizationId, 'cse_substitutions_expired');
                         const sub = s.substitutions;
-                        const fieldsOk = 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);
+                        // Shiji STS carries its fields at the body root (`at` is ''), and
+                        // exactly pan, expires and cvv, each a 128-byte ciphertext, beside
+                        // the page's reviewed getCvvId keys (no keys, no continuation);
+                        // every other processor names a holder path, as before.
+                        const shiji = rec?.psp === SHIJI_STS_PSP;
+                        const fieldsOk = shiji ? isShijiStsServedSubstitution(sub) && isShijiStsServedCompanion(s.shiji_sts_companion)
+                            : 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
@@ -1473,12 +2122,39 @@ export class VaultClient {
                                 fields: { ...sub.fields },
                                 ...(removeRaw ? { remove: [...removeRaw] } : {}),
                             },
+                            ...(shiji ? { shijiStsCompanion: Object.freeze({ keySequences: Object.freeze([...s.shiji_sts_companion.key_sequences]) }) } : {}),
                             ...amountAuthority,
                             ...execution,
                         };
                     }
-                    if (approvedMode !== 'token')
+                    if (approvedMode === 'device_encrypt') {
+                        // The device sent the card to Payrails itself; this is Payrails' answer to it. It
+                        // enters the page only as a 201 for a card instrument, rebuilt from payment-core's
+                        // allow-list under a JSON content type (payrails.ts payrailsSaveAnswer). Anything else
+                        // is never handed over: the card may be saved, so the outcome is unknown, not declined.
+                        // Autopilot never runs this mode, so an autopilot answer is not one to act on either.
+                        if (execution.executionMode === 'autopilot')
+                            throw new PaymentOutcomeUnknownError(authorizationId, 'autopilot_submission_mode_invalid');
+                        if (mode !== 'device_encrypt')
+                            throw new PaymentOutcomeUnknownError(authorizationId, 'approved_mode_unsupported');
+                        const saved = s.response;
+                        const answer = saved && typeof saved === 'object' && Number.isInteger(saved.status) && typeof saved.body === 'string'
+                            ? payrailsSaveAnswer(saved.status, saved.body) : null;
+                        if (!answer)
+                            throw new PaymentOutcomeUnknownError(authorizationId, 'payrails_answer_unconfirmed');
+                        if (s.processor_context !== undefined)
+                            throw new PaymentOutcomeUnknownError(authorizationId, 'unexpected_processor_context');
+                        return { mode: 'device_encrypt', authorizationId, ...answer, ...amountAuthority, ...execution };
+                    }
+                    // A save created as device_encrypt is answered only as one: Payrails' raw answer never
+                    // passes through the token path below.
+                    if (approvedMode !== 'token' || mode === 'device_encrypt')
                         throw new PaymentOutcomeUnknownError(authorizationId, 'approved_mode_unsupported');
+                    // The API serves an approved answer whose landing url carries a processor's card token
+                    // (CreditGuard's) only for a window after the approval, this SDK's default timeoutMs; one it
+                    // no longer serves is an unknown outcome, never a page to continue.
+                    if (s.response_expired === true)
+                        throw new PaymentOutcomeUnknownError(authorizationId, 'response_expired');
                     const response = s.response;
                     if (!response || !Number.isInteger(response.status) || response.status < 100 || response.status > 599
                         || typeof response.body !== 'string' || !response.headers || typeof response.headers !== 'object' || Array.isArray(response.headers)) {
@@ -1490,6 +2166,41 @@ export class VaultClient {
                     if (flex && (response.status < 200 || response.status > 299 || !isCybersourceFlexTokenShape(response.body))) {
                         throw new PaymentOutcomeUnknownError(authorizationId, 'cybersource_flex_token_unconfirmed');
                     }
+                    if (rec?.psp === JUSPAY_PSP) {
+                        // The page receives only the allowlisted /txns answer for the paused
+                        // order, re-serialized here from the stored one (juspayPageAnswer),
+                        // with a JSON content type as its one header. Anything else is not an
+                        // answer to hand the page: the device may already have sent the payment.
+                        const answer = juspayPageAnswer(response.status, response.body, input.request);
+                        if (answer === null)
+                            throw new PaymentOutcomeUnknownError(authorizationId, 'juspay_response_unconfirmed');
+                        response.body = answer;
+                        response.headers = { 'content-type': 'application/json' };
+                    }
+                    if (rec?.psp === ACI_PSP) {
+                        // ACI: the paused card-number request, and the page's CVC and expiry requests the
+                        // adapters answer with the same bytes, get exactly ACI's rebuilt success answer under
+                        // JSON. Anything else is not an answer to hand the page, and the device may already have
+                        // put the real card on the checkout.
+                        const answer = aciCardLegAnswer(response);
+                        if (!answer)
+                            throw new PaymentOutcomeUnknownError(authorizationId, 'aci_answer_unconfirmed');
+                        response.status = answer.status;
+                        response.headers = answer.headers;
+                        response.body = answer.body;
+                    }
+                    if (eprotect) {
+                        // Worldpay eProtect: the paused <script> is answered the way Worldpay answers it,
+                        // `<callback>(<registration>)` under its script type, with the callback the paused URL
+                        // named and only a registration payment-core's judge accepts for that URL. Anything else
+                        // is not an answer to hand the page, and the device may already have registered the card.
+                        const answer = eprotectScriptAnswer(input.request.url, response);
+                        if (!answer)
+                            throw new PaymentOutcomeUnknownError(authorizationId, 'eprotect_registration_unconfirmed');
+                        response.status = answer.status;
+                        response.headers = answer.headers;
+                        response.body = answer.body;
+                    }
                     if (shopOrder) {
                         let receipt;
                         try {
@@ -1502,6 +2213,26 @@ export class VaultClient {
                         response.body = JSON.stringify(receipt);
                         response.headers = { 'content-type': 'application/json' };
                     }
+                    if (creditguardTxId !== null) {
+                        // A CreditGuard payment is always prepared and approved by the cardholder, and no
+                        // autopilot run sends one (payment-core and the autopilot authority refuse it), so an
+                        // approval the API reports as unattended is not handed to the page.
+                        if (execution.executionMode === 'autopilot')
+                            throw new PaymentOutcomeUnknownError(authorizationId, 'autopilot_submission_mode_invalid');
+                        // CreditGuard's answer to the device's submit reaches the page only as payment-core
+                        // rebuilds it from its allow-list, for the paused transaction, as JSON: an answer that
+                        // is not an approval of this txId is an unknown outcome, never handed to the page.
+                        let rebuilt;
+                        try {
+                            if (response.status === 200)
+                                rebuilt = sanitizeCreditguardResponse(response.body, { txId: creditguardTxId });
+                        }
+                        catch { /* Never return an unvalidated processor body to the page. */ }
+                        if (rebuilt === undefined)
+                            throw new PaymentOutcomeUnknownError(authorizationId, 'creditguard_response_unconfirmed');
+                        response.body = rebuilt;
+                        response.headers = { 'content-type': 'application/json' };
+                    }
                     if (checkoutContext) {
                         let receipt;
                         try {
@@ -1514,7 +2245,7 @@ export class VaultClient {
                         response.body = JSON.stringify(receipt);
                         response.headers = { 'content-type': 'application/json' };
                     }
-                    if (rec.psp === GMO_PSP) {
+                    if (rec?.psp === GMO_PSP) {
                         // GMO's answer enters the page only as one clean single-use token under a JSON
                         // content type (gmo.ts gmoTokenAnswer). Anything else is never handed over; the
                         // card may have left the device, so the outcome is unknown rather than declined.
@@ -1525,6 +2256,18 @@ export class VaultClient {
                         response.headers = answer.headers;
                         response.body = answer.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).
+                        // Anything else, a multi-use token or vaultData included, is never handed over; the card
+                        // may have left the device, so the outcome is unknown rather than declined.
+                        const answer = primerTokenAnswer(response.status, response.body);
+                        if (!answer)
+                            throw new PaymentOutcomeUnknownError(authorizationId, 'primer_token_unconfirmed');
+                        response.status = answer.status;
+                        response.headers = answer.headers;
+                        response.body = answer.body;
+                    }
                     let processorContext;
                     if (mercadoContext) {
                         try {
@@ -1588,19 +2331,25 @@ export class VaultClient {
         }
         catch (error) {
             failed = true;
-            if (input.merchantSignal?.aborted)
-                throw new PaymentOutcomeUnknownError(authorizationId, 'merchant_request_aborted');
-            throw error;
+            failure = input.merchantSignal?.aborted ? new PaymentOutcomeUnknownError(authorizationId, 'merchant_request_aborted') : error;
+            throw failure;
         }
         finally {
             // An attested action-required result retains its claim and reservation.
             // Reporting that state must not request cancellation of the same attempt.
-            if (!actionRequired && (input.merchantSignal?.aborted || ((preparation || nativeCheckout) && failed))) {
+            // A card endpoint request that failed here has no page request left to answer, so
+            // it is retired too: the device must not send the card for an answer nobody reads.
+            if (!actionRequired && (input.merchantSignal?.aborted || ((preparation || nativeCheckout || cardEndpoint) && failed))) {
                 // Drain a create acknowledgement even after the merchant aborts so its
                 // known ID can be retired. An unacknowledged create remains unknown.
                 // A started/finalized replay or failed cleanup never becomes a claimed
                 // cancellation, and this best-effort cleanup never retries a payment.
-                await this.cancelAuthorization(authorizationId).catch(() => { });
+                const retired = await this.cancelAuthorization(authorizationId).catch(() => null);
+                // A retirement whose acknowledgement says no processor request started: the thrown error
+                // says so. The API echoes the reason the row carries, so a row retired earlier as
+                // merchant_never_retried can answer that a processor request did start; then nothing changes.
+                if (retired?.processor_request_started === false && failure instanceof PaymentOutcomeUnknownError)
+                    failure.processorRequestStarted = false;
             }
         }
     }
@@ -1688,6 +2437,65 @@ export class VaultClient {
         }
         return { paymentIntentId: pi.id, amount: pi.amount, currency: pi.currency };
     }
+    /**
+     * Ask whether the page may save the card with the Stripe payment method an
+     * approval produced: a SetupIntent confirm that carries no card and pays with
+     * exactly the approved payment method (the page's own, or written by the
+     * adapters in place of a card the confirm carries again).
+     * The API allows a card save only for a company Agentcard turned it on for,
+     * for an approval given on the Vault page, not by voice, with no amount, and
+     * a SetupIntent Stripe reports still confirmable on the same Stripe account;
+     * any other answer rejects with a CheckoutApiError whose code says why (for
+     * example `continuation_invalid` where it is off, `amount_mismatch`). Nothing
+     * is charged: the adapters continue the page's request once this resolves.
+     */
+    async checkStripeSetupContinuation(authorizationId, request) {
+        if (!/^cauth_[A-Za-z0-9_-]{1,128}$/.test(authorizationId))
+            throw new Error('Invalid authorization ID.');
+        const rec = findRecognizer(request.url, this.registry);
+        if (rec?.psp !== 'stripe')
+            throw new Error('Only a Stripe request can continue an approved Stripe payment method.');
+        let confirmed = null;
+        try {
+            confirmed = /^\/v1\/setup_intents\/(seti_[A-Za-z0-9]+)\/confirm$/.exec(new URL(request.url).pathname)?.[1] ?? null;
+        }
+        catch {
+            confirmed = null;
+        }
+        if (!confirmed)
+            throw new Error('Only a Stripe SetupIntent confirmation can continue into a card save.');
+        const result = await this.post(`/v2/checkout/authorizations/${authorizationId}/continuations`, {
+            request: { url: request.url, method: request.method, headers: pickHeaders(request.headers, rec.passthroughHeaders), body: request.body },
+        }, AbortSignal.timeout(15_000));
+        const si = result?.setup_intent;
+        // The answer names the SetupIntent this page confirms, and no payment.
+        if (result?.object !== 'checkout_continuation' || result.continuation !== 'allowed' || result.authorization !== authorizationId
+            || result.payment_intent !== undefined || !si || si.id !== confirmed) {
+            throw new Error('The continuation answer was not recognized.');
+        }
+        return { setupIntentId: confirmed };
+    }
+    /**
+     * Create a merchant-session probe, the phase-0 read of the deterministic merchant total:
+     * `user` is the org's connected user, who opens the returned Vault link and reads the
+     * merchant's own total once through Agentcard's merchant-session relay. The capture is
+     * the merchant's cookie jar as captureMerchantSession read it; the capture rules run
+     * again here, so no bot-manager cookie and no signed-in session ever leaves. No card is
+     * involved. The API answers 404 for every org not on its probe list.
+     */
+    async createMerchantSessionProbe(input) {
+        const capture = merchantSessionCapture(input.capture.profile, input.capture.cookies);
+        const created = await this.post('/v2/checkout/merchant-session-probes', { user: input.user, profile: capture.profile, session: { cookies: capture.cookies } }, AbortSignal.timeout(15_000));
+        return { id: created.id, profile: created.profile, approvalUrl: created.approval_url, expiresAt: created.expires_at };
+    }
+    /**
+     * Record the same read made from the autopilot egress by the rustls runner (the API's
+     * egressResultSchema: statuses, header names, sizes, times, totals, hashes and the
+     * certificate chain's SPKI hashes). Once per probe.
+     */
+    async recordMerchantSessionEgress(probeId, result) {
+        await this.post(`/v2/checkout/merchant-session-probes/${encodeURIComponent(probeId)}/egress-result`, { result }, AbortSignal.timeout(15_000));
+    }
     /**
      * After a merchant-hosted payment priced by the merchant's own total: what the merchant's
      * confirmation says it charged (merchant-total.ts merchantChargeReport builds `report`
@@ -1896,6 +2704,112 @@ export class VaultClient {
         return this.call(`/v2/checkout/preparations/${id}`, { signal }, false, undefined, 0);
     }
 }
+/**
+ * A card endpoint request, checked whole before any network call: a profile in this
+ * build's table; no other checkout context, Autopilot or preparation (the cardholder
+ * approves every such payment); the agent's amount, the only authority here; a
+ * session the API and the device would take (payment-core
+ * merchantCardEndpointSessionRefusal: the profile's URL, headers, cookies, Referer and
+ * body, paused on its checkout page); for a merchant that keeps its own record of the
+ * order, that record, held to the agent's amount and currency, and refused for an order
+ * that renews or a checkout in test mode (admitCardEndpointFacts); and the profile's
+ * status last, so that refusal means every other check passed. Nothing it throws names
+ * the URL, the body or a session value.
+ */
+function admitCardEndpoint(input) {
+    const named = input.request.merchant_card_endpoint;
+    const profile = isRecord(named) && typeof named.profile === 'string' ? cardEndpointById(named.profile) : null;
+    if (!profile || !isRecord(named))
+        throw new Error('merchant_card_endpoint names no card endpoint Agentcard reviewed.');
+    if (input.request.mercado_checkout !== undefined || hasStripeCheckoutMarker(input.request) || hasOwnedShopMarker(input.request)) {
+        throw new CardEndpointRefusedError(profile.id, 'request_unsupported', 'the request carries another checkout\'s context');
+    }
+    if (input.executionMode === 'autopilot' || input.grantId !== undefined)
+        throw new CardEndpointRefusedError(profile.id, 'approval_required');
+    if (input.preparation || input.stripeCheckoutEnvironment !== undefined)
+        throw new CardEndpointRefusedError(profile.id, 'preparation_unsupported');
+    if (input.amount == null || typeof input.currency !== 'string' || !input.currency)
+        throw new CardEndpointRefusedError(profile.id, 'amount_required');
+    const session = named.session;
+    if (!isRecord(session) || (input.request.method ?? 'POST').toUpperCase() !== 'POST' || input.request.url !== session.url) {
+        throw new CardEndpointRefusedError(profile.id, 'request_unsupported', 'the request is not the session\'s card request');
+    }
+    const refusal = cardEndpointSessionRefusal(profile, session);
+    if (refusal)
+        throw new CardEndpointRefusedError(profile.id, 'request_unsupported', refusal);
+    const facts = admitCardEndpointFacts(profile, session, named.facts, input);
+    if (!cardEndpointLive(profile))
+        throw new CardEndpointRefusedError(profile.id, 'not_enabled');
+    return { profile: profile.id, session, ...(facts ? { facts } : {}) };
+}
+/**
+ * The merchant's own record of the order, for a profile whose merchant keeps one
+ * (profile.facts), read with the rules the API reads it with (payment-core
+ * readMerchantCardEndpointFacts and merchantCardEndpointFactsRefusal): required, bound
+ * to this checkout's session, in the reviewed layout; a total or currency that differs
+ * from the agent's is an AmountMismatchError against the merchant's total, and a
+ * renewing order or a checkout in test mode is refused. Card endpoint payments are live
+ * only, so the record must say the checkout is live. Undefined for any other profile,
+ * which sends none.
+ */
+function admitCardEndpointFacts(profile, session, sent, input) {
+    if (!profile.facts) {
+        if (sent !== undefined)
+            throw new CardEndpointRefusedError(profile.id, 'request_unsupported', 'the request carries an order record this merchant has none of');
+        return undefined;
+    }
+    if (sent === undefined)
+        throw new CardEndpointRefusedError(profile.id, 'facts_unavailable', `${profile.merchant}'s own record of this order was not read`);
+    const read = sharedReadFacts(profile.id, session.url, sent);
+    if (!read.ok)
+        throw new CardEndpointRefusedError(profile.id, 'facts_unavailable', read.refusal);
+    const currency = String(input.currency).toLowerCase();
+    const refusal = sharedFactsRefusal(profile.id, read.facts, { amountCents: typeof input.amount === 'number' ? input.amount : Number.NaN, currency, live: true });
+    if (refusal?.code === 'amount' || refusal?.code === 'currency') {
+        // An integer amount is compared here; a decimal string is left to the API, which
+        // reads it in the currency's units and holds it to the same total.
+        if (typeof input.amount === 'number') {
+            throw new AmountMismatchError(null, input.amount, read.facts.amount.amountCents, currency, read.facts.amount.currency, 'create', 'merchant_total');
+        }
+    }
+    else if (refusal) {
+        throw new CardEndpointRefusedError(profile.id, 'facts_refused', refusal.reason);
+    }
+    return sent;
+}
+/**
+ * The merchant's answer to the device's card request, as the API serves it once
+ * (merchant_card_endpoint.answer), checked before any of it reaches the page: the
+ * profile the request named, an HTTP status, string headers, Set-Cookie strings and a
+ * body, or `withheld` with none of them. An answer the API no longer holds
+ * (answer_expired) or cannot vouch for leaves the outcome unknown: the card was sent.
+ */
+function cardEndpointReplay(s, authorizationId, profile, metadata) {
+    const unknown = (reason) => new PaymentOutcomeUnknownError(authorizationId, reason);
+    if (metadata.executionMode === 'autopilot')
+        throw unknown('autopilot_submission_mode_invalid');
+    const named = s.merchant_card_endpoint;
+    if (!isRecord(named) || named.profile !== profile)
+        throw unknown('merchant_answer_malformed');
+    if (named.answer_expired === true)
+        throw unknown('merchant_answer_expired');
+    const answer = named.answer;
+    if (!isRecord(answer) || !Number.isInteger(answer.status) || answer.status < 100 || answer.status > 599)
+        throw unknown('merchant_answer_malformed');
+    const base = { mode: CARD_ENDPOINT_MODE, authorizationId, profile, status: answer.status, ...metadata };
+    if (answer.withheld !== undefined) {
+        if (answer.withheld !== 'card_in_response' && answer.withheld !== 'unreadable_in_response' && answer.withheld !== 'refused_step_in_response') {
+            throw unknown('merchant_answer_malformed');
+        }
+        return { ...base, headers: {}, setCookies: [], body: '', withheld: answer.withheld };
+    }
+    const headers = answer.headers;
+    const setCookies = answer.set_cookies;
+    if (answer.status < 200 || typeof answer.bodyText !== 'string' || !isRecord(headers) || !Object.values(headers).every((value) => typeof value === 'string')
+        || !Array.isArray(setCookies) || !setCookies.every((value) => typeof value === 'string'))
+        throw unknown('merchant_answer_malformed');
+    return { ...base, headers: { ...headers }, setCookies: [...setCookies], body: answer.bodyText, withheld: null };
+}
 function executionMetadata(state, authorizationId, previous = {}) {
     if (state.execution_mode === undefined)
         return previous;
@@ -1909,6 +2823,15 @@ function executionMetadata(state, authorizationId, previous = {}) {
         throw new PaymentOutcomeUnknownError(authorizationId, 'autopilot_grant_changed');
     return { executionMode: 'autopilot', grantId: state.grant_id };
 }
+/**
+ * What authorize() creates a Verifone authorization as: a cse payment that only a
+ * prepared checkout may make, forwarding no header but content-type. Never matched
+ * against a URL: authorize() uses it only for an armed Verifone profile's request.
+ */
+const VERIFONE_RECOGNIZER = Object.freeze({
+    psp: 'verifone', match: /(?!)/, encoding: 'json', passthroughHeaders: [],
+    clientSideEncrypted: true, mode: 'cse', preparationRequired: true,
+});
 /**
  * What authorize() creates a merchant-hosted authorization as: an Adyen cse
  * payment that only a prepared checkout may make (so an unprepared request is
@@ -1939,6 +2862,51 @@ function assertMerchantHostedRequest(input, profile) {
     if (verdict.verdict === 'pass')
         throw new Error(`not a card request Agentcard reviewed for ${profile.merchant}.`);
 }
+/**
+ * Refuse, before any create or prompt, a Verifone request this client cannot pay: a profile
+ * Agentcard has not turned on (observe), Autopilot (the cardholder approves every one), or a
+ * request its rules do not pause (anything but its reviewed card request).
+ */
+function assertVerifoneRequest(input, profile) {
+    if (profile.status !== 'enabled') {
+        throw new Error(`Agentcard has not turned on payments to ${profile.merchant} yet. Nothing was charged.`);
+    }
+    if (input.executionMode === 'autopilot' || input.grantId !== undefined) {
+        throw new Error(`A payment to ${profile.merchant} needs the cardholder's approval every time; Autopilot cannot pay it.`);
+    }
+    const verdict = classifyVerifoneProfileRequest(profile, input.request.url, input.request.method ?? 'POST', input.request.body);
+    if (verdict.verdict === 'abort')
+        throw new Error(`Refusing to pay ${profile.merchant}: ${verdict.reason}. Nothing was charged.`);
+    if (verdict.verdict === 'pass')
+        throw new Error(`not a card request Agentcard reviewed for ${profile.merchant}.`);
+}
+/**
+ * The approved read of a Verifone authorization, as the replay the adapters continue: the
+ * device's blob for the profile (`kind: 'verifone'`), beside the profile and the SHA-256 of the
+ * body the API checked at create. Anything else, a create that was not Verifone's, another
+ * profile, or a blob the API no longer serves (`substitutions_expired`) is an unknown outcome:
+ * the device may already have encrypted the card, and nothing here can pay with it.
+ */
+function verifoneApproval(s, authorizationId, profile) {
+    const malformed = () => new PaymentOutcomeUnknownError(authorizationId, 'cse_substitutions_malformed');
+    if (!profile)
+        throw malformed();
+    if (s.substitutions_expired === true)
+        throw new PaymentOutcomeUnknownError(authorizationId, 'substitutions_expired');
+    const served = s.verifone;
+    if (!isVerifoneSubstitution(s.substitutions, profile.id) || !isRecord(served) || served.profile !== profile.id
+        || typeof served.body_sha256 !== 'string' || !/^[0-9a-f]{64}$/.test(served.body_sha256))
+        throw malformed();
+    return {
+        mode: 'cse',
+        kind: 'verifone',
+        authorizationId,
+        profile: profile.id,
+        substitutions: { encoding: 'json', kind: 'verifone', profile: profile.id, blob: s.substitutions.blob },
+        bodySha256: served.body_sha256,
+        substitutionsExpiresAt: typeof s.substitutions_expires_at === 'string' ? s.substitutions_expires_at : null,
+    };
+}
 const isRecord = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
 const FORBIDDEN_STEPS = new Set(['__proto__', 'constructor', 'prototype']);
 /**