@agent-cards/sdk 0.20.0 → 0.22.0

package/dist/client.js

@@ -1,23 +1,43 @@
-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';
 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 { 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 { 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
@@ -31,31 +51,256 @@ export const SUPPORTED_REGISTRY_FEATURES = ['card_fields', 'checkout_sessions'];
 /**
  * Dark-launch capabilities this build can finish. Sent on syncRegistry as
  * ?capabilities= so the API also serves the recognizers gated behind one of
- * these. `fiserv_card_capture`: Fiserv Commerce Hub's Secure Data Capture card
+ * these, and only to an org Agentcard enabled for the processor.
+ * `fiserv_card_capture`: Fiserv Commerce Hub's Secure Data Capture card
  * capture, which this build pauses and pays only through a prepared checkout
  * (pre-claim.ts, fiserv.ts). The API serves Fiserv's recognizer only to a build
  * that lists it and only for a company Agentcard turned Fiserv on for, so an older
  * SDK never pauses a capture it cannot finish and no SDK pauses one for a company
  * Fiserv is off for; the API also refuses a Fiserv payment for every such company.
+ * `gmo_shared_pk`: GMO token v2's getToken on the shared-key path, which this
+ * build judges before it pauses (gmo.ts) and pays only for the amount the
+ * agent passes. A gated recognizer never sits in BUILTIN_REGISTRY, so it is
+ * paused only after a sync.
+ * `capture_context`: CyberSource Flex Microform, whose create carries the capture
+ * context this build reads from the card field iframe (cybersource-flex.ts); the API
+ * 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.
  */
-export const SUPPORTED_CAPABILITIES = ['fiserv_card_capture'];
+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'];
+/**
+ * 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. 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, PELECARD_PSP, WSPAY_PSP];
+/** How AmountRequiredError names a processor. */
+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) {
@@ -78,6 +323,50 @@ export class UnsupportedModeError extends Error {
         this.name = 'UnsupportedModeError';
     }
 }
+/**
+ * The recognizer is gated behind a dark-launch capability this SDK build does not
+ * declare (SUPPORTED_CAPABILITIES), so it cannot send what that processor's create
+ * needs. Thrown locally before any create or prompt, and terminal. A registry the
+ * API served never holds such an entry (it serves a gated one only to a build that
+ * declares it); a hand-built one can.
+ */
+export class UnsupportedCapabilityError extends Error {
+    capability;
+    constructor(capability) {
+        super(`the checkout needs the "${capability}" capability, which this version of @agent-cards/checkout cannot complete; upgrade the SDK.`);
+        this.capability = capability;
+        this.name = 'UnsupportedCapabilityError';
+    }
+}
+/**
+ * placeholderCard() found no stored card to describe (`card_not_found`), the stored card's
+ * network has no documented placeholder number (`brand_unsupported`), or the stored card
+ * carries no usable expiry (`expiry_unknown`). Nothing was created and nothing was charged.
+ */
+export class PlaceholderCardError extends Error {
+    reason;
+    constructor(reason) {
+        super(`no placeholder card: ${reason}`);
+        this.reason = reason;
+        this.name = 'PlaceholderCardError';
+    }
+}
+/**
+ * The placeholder number per network: a documented test card that the pinned Microform
+ * card-type table detects as that network and nothing else. Visa, Mastercard, Amex and JCB
+ * are CyberSource's own test cards (developer.cybersource.com hello-world testing guide).
+ * Discover is not: CyberSource's 6011111111111117 falls in the table's Maestro range, so a
+ * merchant that allows Discover but not Maestro refuses it in the card field itself; Stripe's
+ * documented Discover test card 6011000990139424 is detected as Discover alone. A network
+ * outside this list has no placeholder and placeholderCard() refuses it rather than guess.
+ */
+const PLACEHOLDER_NUMBERS = Object.freeze({
+    visa: '4111111111111111',
+    mastercard: '5555555555554444',
+    amex: '378282246310005',
+    discover: '6011000990139424',
+    jcb: '3566111111111113',
+});
 /**
  * The recognizer says this processor is preparation-required, and no preparation
  * was passed. Its card may be sent only after the cardholder approved a
@@ -94,6 +383,48 @@ export class PreparationRequiredError extends Error {
         this.name = 'PreparationRequiredError';
     }
 }
+/**
+ * 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),
+ * 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;
+    code = 'amount_required';
+    constructor(psp) {
+        const processor = PROCESSOR_NAMES[psp] ?? psp;
+        super(`A ${processor} payment request names no amount, so pass amount and currency: that is the amount the cardholder approves. Nothing was created and nothing was charged.`);
+        this.psp = psp;
+        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'; }
 }
@@ -437,10 +768,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,
@@ -450,6 +784,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 {
@@ -497,18 +841,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;
     }
 }
 /**
@@ -540,6 +912,13 @@ 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'];
 /** 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];
@@ -553,6 +932,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;
@@ -568,6 +961,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();
@@ -671,9 +1070,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() {
@@ -688,9 +1092,31 @@ export class VaultClient {
         let raw;
         // ?capabilities= is the dark-launch half of the same negotiation: a
         // processor gated behind a capability is served only when this build lists
-        // it. This build lists fiserv_card_capture, so it arms Fiserv's card capture
-        // for a company Agentcard turned Fiserv on for; an older build, and every
-        // other company's, never sees that recognizer.
+        // it (SUPPORTED_CAPABILITIES: fiserv_card_capture, gmo_shared_pk,
+        // 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
@@ -707,12 +1133,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,
@@ -740,28 +1185,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.
@@ -786,12 +1276,48 @@ export class VaultClient {
         const registry = this.mergedRegistry();
         return this.sandbox ? [...deriveCardUrlPatterns(registry), ...LOOPBACK_URL_PATTERNS] : deriveCardUrlPatterns(registry);
     }
+    /**
+     * What to type into a checkout so the page's own card facts match the stored card that
+     * pays (see PlaceholderCard): read from GET /api/v2/vault_cards, which lists each stored card's
+     * network and expiry. `cardId` names the stored card; omitted, the user's most recently added
+     * card. Pin the returned `cardId` on the attachment or authorize(), so the approval page
+     * preselects that card: without a pin the page preselects its own choice (its recommended
+     * card, or the first card the cardholder's device can open), which can be another card. After
+     * prepare(), pass the prepared checkout's `cardId`, the card the cardholder already approved.
+     * The facts hold only while the cardholder pays with that card. Throws PlaceholderCardError
+     * when there is no such card, its network has no placeholder, or it carries no expiry.
+     */
+    async placeholderCard(input) {
+        if (!input || typeof input.user !== 'string' || !input.user)
+            throw new Error('placeholderCard needs the user whose stored card will pay.');
+        // The card list lives under /api/v2 only: the API aliases /v2/checkout alone without the prefix.
+        const list = await this.get(`/api/v2/vault_cards?user_id=${encodeURIComponent(input.user)}`, input.signal);
+        const cards = Array.isArray(list?.data) ? list.data : [];
+        const card = (input.cardId === undefined ? cards[0] : cards.find((entry) => entry?.id === input.cardId));
+        if (!card || typeof card !== 'object' || typeof card.id !== 'string' || !card.id)
+            throw new PlaceholderCardError('card_not_found');
+        const brand = typeof card.brand === 'string' ? card.brand.toLowerCase() : '';
+        const number = Object.prototype.hasOwnProperty.call(PLACEHOLDER_NUMBERS, brand) ? PLACEHOLDER_NUMBERS[brand] : undefined;
+        if (!number)
+            throw new PlaceholderCardError('brand_unsupported');
+        const month = card.expiry_month, year = card.expiry_year;
+        if (!Number.isSafeInteger(month) || month < 1 || month > 12
+            || !Number.isSafeInteger(year) || year < 2000 || year > 2099)
+            throw new PlaceholderCardError('expiry_unknown');
+        return Object.freeze({
+            cardId: card.id, brand, number, securityCode: brand === 'amex' ? '1234' : '123',
+            expiryMonth: String(month).padStart(2, '0'), expiryYear: String(year),
+        });
+    }
     /** Wait for real device approval before the caller starts native tokenization. */
     async prepareCheckout(input) {
         input = { ...input };
         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
@@ -799,7 +1325,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);
@@ -821,11 +1361,25 @@ 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');
+        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
@@ -833,6 +1387,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');
@@ -850,7 +1413,10 @@ 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 } : {}),
             }, 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');
@@ -881,12 +1447,16 @@ 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)))
                         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,
@@ -896,7 +1466,10 @@ 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 } : {}),
                     });
                     this.preparations.add(prepared);
                     ready = true;
@@ -911,13 +1484,17 @@ 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))))
                     || (input.psp === 'fiserv' && error.status === 502 && error.code === 'cse_key_unavailable')))
                 throw fail(error.code);
             throw fail(signal.aborted ? 'cancelled' : 'preparation_unconfirmed', id);
@@ -935,6 +1512,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`, {
@@ -961,6 +1562,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))
@@ -1021,14 +1625,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');
         }
@@ -1038,46 +1644,99 @@ 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);
+        }
+        // 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 && 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;
+        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.');
+        }
+        if (flex && !validCybersourceFlexSidecar(input.request.capture_context, input.request.microform)) {
+            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.');
         }
-        if (rec.clientSideEncrypted && mode !== 'cse')
-            throw new CardEncryptedError(rec.psp);
-        if (!SUPPORTED_MODES.includes(mode))
-            throw new UnsupportedModeError(mode);
-        // 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.');
+        }
+        // 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
@@ -1087,8 +1746,26 @@ 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 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 && 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)
@@ -1101,7 +1778,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 },
+        } : {
             user: input.user,
             merchant: input.merchant,
             // snake_case on the wire; camelCase is this SDK's convention.
@@ -1124,17 +1815,29 @@ 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),
                     ...(checkoutContext ? { [STRIPE_CHECKOUT_CONTEXT_HEADER]: encodeStripeCheckoutContext(checkoutContext) } : {}) },
                 body: input.request.body,
                 ...(mercadoContext ? { mercado_checkout: mercadoContext } : {}),
+                ...(flex ? {
+                    capture_context: input.request.capture_context,
+                    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 {
@@ -1174,7 +1877,11 @@ 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;
         let execution = {};
         let approvalDelivered = false;
         const deliverApproval = (state) => {
@@ -1220,7 +1927,7 @@ 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) : 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');
@@ -1255,7 +1962,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') {
@@ -1276,6 +1983,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
@@ -1287,19 +2001,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
@@ -1323,17 +2048,85 @@ 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)) {
                         throw new PaymentOutcomeUnknownError(authorizationId, 'approved_response_malformed');
                     }
+                    // A Flex approval answers the card field with the transient token CyberSource signed for
+                    // the device's sealed card, which the device checked before it approved. Anything else
+                    // is not an answer to hand the field iframe: the device may already have sent the card.
+                    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 {
@@ -1346,6 +2139,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 {
@@ -1358,6 +2171,29 @@ export class VaultClient {
                         response.body = JSON.stringify(receipt);
                         response.headers = { 'content-type': 'application/json' };
                     }
+                    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.
+                        const answer = gmoTokenAnswer(response.status, response.body);
+                        if (!answer)
+                            throw new PaymentOutcomeUnknownError(authorizationId, 'gmo_token_unconfirmed');
+                        response.status = answer.status;
+                        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 {
@@ -1428,7 +2264,9 @@ export class VaultClient {
         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
@@ -1521,6 +2359,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`
@@ -1729,6 +2626,73 @@ 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); 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);
+    if (!cardEndpointLive(profile))
+        throw new CardEndpointRefusedError(profile.id, 'not_enabled');
+    return { profile: profile.id, session };
+}
+/**
+ * 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')
+            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;
@@ -1742,6 +2706,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
@@ -1772,6 +2745,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']);
 /**