@agent-cards/sdk 0.21.0 → 0.23.0

package/dist/cdp.js

@@ -1,26 +1,44 @@
 import { BUILTIN_REGISTRY, cardUrlPatterns } from './registry.js';
-import { AdyenTestPlatformRefusedError, AmountRequiredError, ApprovalDeclinedError, ApprovalTimeoutError, CardEncryptedError, CheckoutApiError, CheckoutCancelledError, MerchantTotalError, PaymentOutcomeUnknownError, PreparationRequiredError, ProcessorRefusedError, UnsupportedCapabilityError, UnsupportedModeError, } from './client.js';
+import { AdyenTestPlatformRefusedError, AmountRequiredError, ApprovalDeclinedError, ApprovalTimeoutError, CardEncryptedError, CheckoutApiError, CheckoutCancelledError, CheckoutPreparationError, MerchantTotalError, PaymentOutcomeUnknownError, PreparationRequiredError, ProcessorRefusedError, UnsupportedCapabilityError, UnsupportedModeError, } from './client.js';
 import { PreparationGate } from './preparation.js';
 import { StripeCheckoutGate } from './stripe-checkout.js';
 import { MercadoCheckoutGate } from './mercado-checkout.js';
 import { MERCADO_CHECKOUT_PATTERN } from './mercado-checkout.generated.js';
+import { JuspayCheckoutGate } from './juspay-gate.js';
+import { ACI_CHECKOUT_REUSED, AciGate, playwrightReplacesNavigationBody } from './aci.js';
+import { EprotectGate } from './eprotect.js';
 import { dispatchPreClaim, eventUrl } from './pre-claim.js';
 import { GMO_TOKEN_V1_PATTERNS, gmoRequestShop, isGmoTokenV1Request, recognizesGmo } from './gmo.js';
+import { DatatransRepeats } from './datatrans.js';
+import { SHIJI_STS_COMPANION_WINDOW_MS, ShijiStsCompanions, ShijiStsError, isShijiStsHost, shijiStsTokenContinuation, } from './shiji-sts.js';
+import { isArmedEkashuUrl } from './ekashu.js';
 import { CheckoutAttachmentError, attachmentDeadline, attachmentFailure, withinAttachmentDeadline } from './attachment.js';
 import { cseBody } from './cse-body.js';
+import { STRIPE_SETUP_INTENT_CONFIRM, setupConfirmPayingWith } from './stripe-setup.js';
 import { replayTemplatedUrl, reviewedMerchantProfileUrlPatterns } from './merchant-hosted.js';
+import { verifoneTemplatedUrl } from './verifone.js';
 import { MerchantHandoffWatch } from './merchant-handoff.js';
 import { MERCHANT_PAGE_WAIT_MS, MerchantTotalWatch } from './merchant-total-watch.js';
 import { hostedFormSubmittedPage } from './hosted-form.js';
+import { amadeusSendWindowMs, armSendWindow, failsAsNetworkError } from './amadeus.js';
 import { CheckoutLifecycle, paymentEndpointGuards } from './lifecycle.js';
-import { CaptureContexts, MicroformFrames, judgeMicroformFrameUrls, refusedRequestFailure } from './cybersource-flex.js';
+import { CaptureContexts, MicroformFrames, judgeMicroformFrameUrls, loadedCardMicroformFromUrls, refusedRequestFailure, } from './cybersource-flex.js';
+import { CARD_ENDPOINT_REFUSED_STEP_ANSWER, CARD_ENDPOINT_WITHHELD_ANSWER, CardEndpointRefusedError, captureCardEndpointSession, cardEndpointAnswerHeaders, cardEndpointCookies, cardEndpointDetail, cardEndpointFor, cardEndpointNavigationAnswer, cardEndpointPatterns, cardEndpointResendFor, } from './card-endpoint.js';
+import { CardEndpointFactsWatch } from './card-endpoint-facts.js';
+import { PAYRAILS_GUARD_PATTERNS, PAYRAILS_INIT_BODY_LIMIT, PayrailsSessionCapture, isPayrailsHost, payrailsInitCandidate, recognizesPayrails, } from './payrails.js';
+import { cardEndpointStoppedPage, refusedNavigationOutcome } from './card-endpoint-page.js';
 /**
- * Fetch.failRequest's errorReason for a paused request the CDP adapter will not let through: the
- * CDP form of refusedRequestFailure ('Failed' for a CyberSource Flex request, so the Microform field
- * reports it to the page; 'Aborted' for every other request, as before).
+ * How an adapter fails a paused request it will not let through: as a network error for a
+ * CyberSource Flex request (refusedRequestFailure, so the Microform field reports it to the page)
+ * and for an Amadeus card request (failsAsNetworkError, so the SDK's tunnel reports it at once), as
+ * an abort for every other request, as before.
  */
+function refusalFailure(url) {
+    return refusedRequestFailure(url) === 'failed' || failsAsNetworkError(url) ? 'failed' : 'aborted';
+}
+/** Fetch.failRequest's errorReason for the same request: the CDP form of refusalFailure. */
 function cdpFailure(url) {
-    return refusedRequestFailure(url) === 'failed' ? 'Failed' : 'Aborted';
+    return refusalFailure(url) === 'failed' ? 'Failed' : 'Aborted';
 }
 // Every URL that leaves this module through onEvent is redacted to origin +
 // path first. A paused PaymentIntent confirm can carry the client secret in
@@ -131,6 +149,11 @@ const APPROVAL_COOLDOWN_MS = 5_000;
  * re-post is right; latching the whole attachment is not, because the prior
  * row declines or expires and the same form is then a new question. The
  * quiet window absorbs the burst; the next request past it is judged afresh.
+ *
+ * A 400 for a stale Authorize.Net fingerprint (CheckoutApiError
+ * isStaleFingerprint) is answered the same way: no prompt was raised, and the
+ * form the page renders after a reload carries a fresh fingerprint, so the
+ * attachment is quieted rather than latched.
  */
 function isApprovalOutcome(err) {
     // Processor refusals are held by the lifecycle until explicit merchant
@@ -139,7 +162,7 @@ function isApprovalOutcome(err) {
     if (err instanceof ProcessorRefusedError)
         return false;
     if (err instanceof CheckoutApiError)
-        return err.code === 'duplicate_submission';
+        return err.code === 'duplicate_submission' || err.isStaleFingerprint;
     return err instanceof ApprovalDeclinedError || err instanceof ApprovalTimeoutError;
 }
 /**
@@ -154,7 +177,8 @@ function isApprovalOutcome(err) {
  *
  * Terminal means "will answer identically next time no matter who does what":
  * a misconfiguration or an unsupported PSP. Nothing a person does changes
- * those, so asking again is pure waste. A GMO request with no `amount`
+ * those, so asking again is pure waste. A GMO request, a Pelecard submission
+ * or a WSPay confirm with no `amount`
  * (AmountRequiredError) is one: the attachment's options do not change.
  *
  * Other errors may be retryable unless the lifecycle holds the attachment
@@ -172,6 +196,10 @@ function isTerminal(err) {
     // Refused at create for Adyen's test platform: the page's next request is refused the same way.
     if (err instanceof AdyenTestPlatformRefusedError)
         return err.stage === 'create';
+    // A card endpoint refusal about the attachment (no amount, Autopilot, a profile this
+    // build does not pay) answers every request alike; one about the request does not.
+    if (err instanceof CardEndpointRefusedError)
+        return err.permanent;
     return err instanceof CardEncryptedError || err instanceof UnsupportedModeError || err instanceof PreparationRequiredError
         || err instanceof AmountRequiredError || err instanceof UnsupportedCapabilityError;
 }
@@ -189,7 +217,7 @@ function cseContinuationBody(opts, body, replay, url, preparation) {
         return cseBody(body, replay, url, preparation);
     }
     catch (error) {
-        if (replay.kind === 'merchant_hosted' && typeof opts.vault?.cancelAuthorization === 'function') {
+        if ((replay.kind === 'merchant_hosted' || replay.kind === 'verifone') && typeof opts.vault?.cancelAuthorization === 'function') {
             void Promise.resolve().then(() => opts.vault.cancelAuthorization(replay.authorizationId, 'merchant_never_retried')).catch(() => { });
         }
         throw error;
@@ -279,13 +307,121 @@ function watchPlaywrightHandoff(page, request, watch, answered) {
             watch.failed();
         } } };
 }
-/** The `authorized` event's detail for a cse continuation; a merchant-hosted one names its profile and templated URL. */
-function cseAuthorizedDetail(replay, url) {
-    const base = { mode: 'cse', authorizationId: replay.authorizationId, fields: Object.keys(replay.substitutions.fields) };
+/** The `authorized` event's detail for a cse continuation; a merchant-hosted or Verifone one names its profile and templated URL. */
+function cseAuthorizedDetail(replay, url, shijiCvv = null) {
+    if (replay.kind === 'verifone') {
+        return { mode: 'cse', authorizationId: replay.authorizationId, fields: ['encryptedCard'], kind: 'verifone', profile: replay.profile,
+            url: verifoneTemplatedUrl(replay.profile, url) };
+    }
+    // A Shiji STS getTokenId carried pan and expires; its cvv waits for the companion getCvvId.
+    const base = { mode: 'cse', authorizationId: replay.authorizationId, fields: shijiCvv !== null ? ['pan', 'expires'] : Object.keys(replay.substitutions.fields) };
     return replay.kind === 'merchant_hosted'
         ? { ...base, kind: 'merchant_hosted', profile: replay.profile, url: replayTemplatedUrl(replay, url) }
         : base;
 }
+/**
+ * The cse continuation for a paused request, by processor. A Shiji STS
+ * getTokenId takes the device's pan and expires at the body root and hands back
+ * the device's cvv, which that body does not carry: the adapter binds it to the
+ * getCvvId companion right before the continue (shiji-sts.ts). It is written
+ * only into `approved`, the request the approval was created from, byte for
+ * byte, so the accessToken and keySequence are the ones the API reviewed, and
+ * the cvv is bound to the reviewed getCvvId keys the approval served
+ * (`shijiCvvKeySequences`): no keys, no continuation. Every other processor
+ * takes cseContinuationBody (cse-body.ts cseBody), and `shijiCvv` and
+ * `shijiCvvKeySequences` are null.
+ */
+function cseContinuation(opts, url, body, replay, approved, preparation) {
+    const shiji = shijiStsTokenContinuation(url, body, replay.substitutions, approved, replay.kind === 'merchant_hosted' || replay.kind === 'verifone' ? undefined : replay.shijiStsCompanion);
+    return shiji ? { body: shiji.body, shijiCvv: shiji.cvv, shijiCvvKeySequences: shiji.cvvKeySequences }
+        : { body: cseContinuationBody(opts, body, replay, url, preparation), shijiCvv: null, shijiCvvKeySequences: null };
+}
+/**
+ * The opaque page id a Shiji STS companion is bound to: the CDP session and
+ * frame the request paused in. The getCvvId must come from the same frame as
+ * the getTokenId it follows. Kept to the printable ASCII the binding accepts.
+ */
+function cdpShijiPage(sessionId, frameId) {
+    return `${cdpShijiSession(sessionId)}${typeof frameId === 'string' && frameId ? frameId : 'none'}`.replace(/[^\x21-\x7e]/g, '_').slice(0, 256);
+}
+/** The start every cdpShijiPage id of one CDP session shares, so a detached target releases its binding. */
+function cdpShijiSession(sessionId) {
+    return `cdp:${sessionId ?? 'root'}:`.replace(/[^\x21-\x7e]/g, '_');
+}
+/**
+ * The same for a Playwright request: its frame, numbered once per attachment
+ * process. A request with no frame (a service worker's) gets an id no other
+ * request shares, so it never binds.
+ */
+const playwrightShijiFrames = new WeakMap();
+let playwrightShijiSeq = 0;
+function playwrightShijiPage(request) {
+    let frame = null;
+    try {
+        frame = request?.frame?.() ?? null;
+    }
+    catch {
+        frame = null;
+    }
+    if (!frame || typeof frame !== 'object')
+        return `pw:none:${++playwrightShijiSeq}`;
+    let id = playwrightShijiFrames.get(frame);
+    if (!id) {
+        id = `pw:frame:${++playwrightShijiSeq}`;
+        playwrightShijiFrames.set(frame, id);
+    }
+    return id;
+}
+/**
+ * The document a Playwright frame holds: its performance.timeOrigin, read in that frame. A new
+ * document in the frame (a reload, about:blank, a page that answered a link) has its own, while
+ * history.pushState, a hash change and a navigation the page cancels keep the document and so this
+ * value: Playwright reports all of them as framenavigated and names no document, so the adapter reads
+ * it. Null when the frame or its document cannot be read (no frame, detached, replaced mid-read);
+ * undefined when the read has not settled within the companion window: a frame with a navigation
+ * pending answers only once that navigation commits or is cancelled, and past the window no
+ * getCvvId could claim the binding anyway.
+ */
+async function playwrightFrameDocument(frame) {
+    if (!frame || typeof frame !== 'object' || typeof frame.evaluate !== 'function')
+        return null;
+    let timer;
+    try {
+        const origin = await Promise.race([
+            Promise.resolve(frame.evaluate('performance.timeOrigin')),
+            new Promise((resolve) => { timer = setTimeout(() => resolve(UNSETTLED), SHIJI_STS_COMPANION_WINDOW_MS); }),
+        ]);
+        if (origin === UNSETTLED)
+            return undefined;
+        return typeof origin === 'number' && Number.isFinite(origin) ? String(origin) : null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+const UNSETTLED = Symbol('unsettled');
+/**
+ * The opaque page id a Shiji STS companion is bound to in Playwright: the request's frame
+ * (playwrightShijiPage) and the document that frame holds (playwrightFrameDocument), so a getCvvId
+ * from a document that replaced the getTokenId's never matches the binding. Null when the document
+ * cannot be read.
+ */
+async function playwrightShijiDocumentPage(request) {
+    const page = playwrightShijiPage(request);
+    let frame = null;
+    try {
+        frame = request?.frame?.() ?? null;
+    }
+    catch {
+        frame = null;
+    }
+    const document = await playwrightFrameDocument(frame);
+    return typeof document === 'string' ? `${page}:doc:${document}` : null;
+}
 /**
  * The paused request's body, or null when Chromium says there is one and did
  * not hand it over. `postData` is set only for a text body; a binary or a
@@ -305,6 +441,66 @@ function pausedBody(request) {
         return null;
     return Buffer.concat(entries.map((e) => Buffer.from(e.bytes, 'base64'))).toString('utf8');
 }
+/** The frames of a Page.getFrameTree answer from its root down to `frameId`, or undefined when it is not there. */
+function framePath(node, frameId, depth = 0) {
+    if (!node?.frame || depth > 64)
+        return undefined;
+    if (node.frame.id === frameId)
+        return [node.frame];
+    for (const child of Array.isArray(node.childFrames) ? node.childFrames : []) {
+        const path = framePath(child, frameId, depth + 1);
+        if (path)
+            return [node.frame, ...path];
+    }
+    return undefined;
+}
+/**
+ * The URLs of the frame a paused request came from and of every frame above it, sender first. A
+ * session answers only for its own frames (Page.getFrameTree), and a cross-origin frame is a session
+ * of its own, so at the root of one session the walk moves on to the session that attached it, from
+ * the frame the child named as its parent (the root's Frame.parentId, else the target's
+ * parentFrameId). Undefined unless the walk reaches the page's own root within one second in all: a
+ * frame that is not found, a session that does not answer and a parent frame nobody named each leave
+ * the chain unread. Asked only for a request the pre-claim gates attribute through its frames (see
+ * nuveiPreClaim in pre-claim.ts).
+ */
+async function pausedFrameChain(cdp, sessionId, frameId, parentOf) {
+    if (typeof frameId !== 'string' || !frameId)
+        return undefined;
+    const deadline = Date.now() + 1_000;
+    const urls = [];
+    let session = sessionId, frame = frameId;
+    for (let hop = 0; hop < 16; hop++) {
+        let timer;
+        let tree;
+        try {
+            tree = await Promise.race([
+                cdp.send('Page.getFrameTree', {}, session),
+                new Promise(resolve => { timer = setTimeout(resolve, Math.max(0, deadline - Date.now())); }),
+            ]);
+        }
+        catch {
+            return undefined;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        const path = framePath(tree?.frameTree, frame);
+        if (!path)
+            return undefined;
+        for (let i = path.length - 1; i >= 0; i--)
+            urls.push(typeof path[i].url === 'string' ? path[i].url : '');
+        const parent = session === undefined ? undefined : parentOf(session);
+        if (!parent)
+            return urls;
+        const next = typeof path[0].parentId === 'string' && path[0].parentId ? path[0].parentId : parent.frameId;
+        if (!next)
+            return undefined;
+        session = parent.sessionId;
+        frame = next;
+    }
+    return undefined;
+}
 const BODY_UNREADABLE_REASON = 'the paused request\'s body could not be read (no postData and no postDataEntries)';
 /**
  * The CORS headers a fulfilled CROSS-ORIGIN request needs, or null when the
@@ -424,6 +620,207 @@ export function withCorsHeaders(headers, cors) {
     }
     return out;
 }
+/**
+ * The request a card endpoint approval is asked for: `request` names the URL and
+ * nothing else, and the profile travels with the captured session in
+ * merchant_card_endpoint, the one member the API seals, with the merchant's own cut
+ * record of the order for a profile that reads one.
+ */
+function cardEndpointRequest(profile, session, facts = null) {
+    return { url: session.url, method: 'POST', headers: {}, body: '', merchant_card_endpoint: { profile: profile.id, session, ...(facts ? { facts } : {}) } };
+}
+/**
+ * The merchant's own record of the order for a paused card request of a profile that
+ * reads one (card-endpoint-facts.ts), or null for any other profile. A request with no
+ * record to send is refused before any create, naming no value.
+ */
+async function cardEndpointFacts(watch, profile, url, pausedAt, signal) {
+    if (!profile.facts)
+        return null;
+    const captured = await watch.capture(profile, url, pausedAt, signal);
+    if (!captured.record)
+        throw new CardEndpointRefusedError(profile.id, 'facts_unavailable', captured.refusal);
+    return captured.record;
+}
+/** A card endpoint refusal as an event: the profile, the endpoint origin, the reason, and the fields it is about, never a value. */
+function reportCardEndpointRefusal(opts, profile, error) {
+    if (!profile || !(error instanceof CardEndpointRefusedError))
+        return;
+    opts.onEvent?.({ type: 'card_endpoint_refused', detail: { ...cardEndpointDetail(profile), reason: error.reason, ...(error.detail ? { refusal: error.detail } : {}) } });
+}
+/**
+ * Network.setCookie parameters: a URL and no domain for a host-only cookie, which Chrome
+ * keeps on the endpoint host alone, or the domain with its leading dot and no URL for a
+ * rotation of a domain cookie the browser holds there (CardEndpointSetCookie.domain).
+ */
+function cdpCookieParams(cookie) {
+    return { name: cookie.name, value: cookie.value, ...(cookie.domain !== undefined ? { domain: `.${cookie.domain}` } : { url: `${cookie.origin}/` }),
+        path: cookie.path, secure: cookie.secure, httpOnly: cookie.httpOnly,
+        ...(cookie.sameSite ? { sameSite: cookie.sameSite } : {}), ...(cookie.expires !== undefined ? { expires: cookie.expires } : {}) };
+}
+/**
+ * context.addCookies parameters at the cookie's path: the endpoint host with no leading
+ * dot, which Chromium keeps host-only, or the domain of a rotated domain cookie with its
+ * leading dot (CardEndpointSetCookie.domain).
+ */
+function playwrightCookieParams(cookie) {
+    return { name: cookie.name, value: cookie.value, domain: cookie.domain !== undefined ? `.${cookie.domain}` : cookie.host, path: cookie.path,
+        secure: cookie.secure, httpOnly: cookie.httpOnly,
+        ...(cookie.sameSite ? { sameSite: cookie.sameSite } : {}), ...(cookie.expires !== undefined ? { expires: cookie.expires } : {}) };
+}
+/**
+ * The page a stopped card form navigation is answered with (card-endpoint-page.ts): the
+ * card never left the device, it reached the merchant and the answer cannot be shown, or
+ * a payment for this checkout is waiting or may have reached the merchant.
+ */
+function stoppedNavigationPage(profile, outcome, reason, authorizationId) {
+    return cardEndpointStoppedPage({ outcome, reason, merchant: profile.merchant, authorizationId });
+}
+/** The API refused the create because this checkout already has a payment waiting or sent (409 merchant_checkout_in_use). */
+function checkoutInUse(error) {
+    return error instanceof CheckoutApiError && error.code === 'merchant_checkout_in_use';
+}
+/**
+ * How a card form navigation the attachment refuses before any approval (not ready, held,
+ * busy, quiet, or after a failure that ends every later request) is answered. The API's
+ * refusal of this checkout as already paying keeps saying so on every later post. Otherwise
+ * the page reads the attachment (refusedNavigationOutcome): while an approval is outstanding,
+ * or once a payment may exist, it says a payment is in progress and names its authorization,
+ * never that nothing was sent.
+ */
+function heldNavigationRefusal(terminal, awaitingApproval, lifecycle) {
+    if (checkoutInUse(terminal))
+        return { outcome: 'payment_in_progress', reason: 'checkout_in_use', authorizationId: null };
+    const state = lifecycle.getState();
+    const outcome = refusedNavigationOutcome({ awaitingApproval, status: state.status });
+    return { outcome, reason: 'blocked', authorizationId: outcome === 'payment_in_progress' ? state.authorizationId : null };
+}
+/**
+ * How a card form navigation whose approval failed is answered, for `authorizationId`. Once
+ * the device approved or the hand-off began (`sent`), the card reached the merchant. Before
+ * that it may have left only while the authorization stood: a PaymentOutcomeUnknownError
+ * whose authorization the API confirmed retired before any processor request
+ * (processorRequestStarted false) sent nothing, and any other one may have reached the
+ * merchant. The API's refusal of a checkout already paying says a payment is in progress.
+ * Every other failure stopped the card before it left.
+ */
+function failedNavigationRefusal(error, sent, authorizationId) {
+    if (sent)
+        return { outcome: 'sent_answer_not_shown', reason: 'outcome_unknown', authorizationId };
+    if (error instanceof PaymentOutcomeUnknownError) {
+        return error.processorRequestStarted === false ? { outcome: 'stopped_before_send', reason: 'not_approved', authorizationId }
+            : { outcome: 'payment_in_progress', reason: 'outcome_unknown', authorizationId };
+    }
+    if (checkoutInUse(error))
+        return { outcome: 'payment_in_progress', reason: 'checkout_in_use', authorizationId };
+    return { outcome: 'stopped_before_send', reason: stoppedBeforeSendReason(error), authorizationId };
+}
+/**
+ * What a Playwright request navigates: 'top' for the page, 'frame' for an iframe, or null
+ * for a fetch, an XHR or a subresource, and for a request whose frame cannot be read.
+ */
+function playwrightNavigation(request) {
+    try {
+        const navigating = typeof request.isNavigationRequest === 'function' ? request.isNavigationRequest() === true : request.resourceType?.() === 'document';
+        if (!navigating)
+            return null;
+        const frame = request.frame?.();
+        if (!frame)
+            return null;
+        return frame.parentFrame?.() ? 'frame' : 'top';
+    }
+    catch {
+        return null;
+    }
+}
+/** Why a card form navigation stopped before its card left, from the error that stopped it. */
+function stoppedBeforeSendReason(error) {
+    return error instanceof CardEndpointRefusedError ? (error.reason === 'not_enabled' ? 'not_enabled' : 'request_unsupported') : 'not_approved';
+}
+/**
+ * Answer a paused card endpoint request with what the cardholder's device reported.
+ * A withheld answer (it carried the card, or a stream the device cannot read) becomes
+ * the fixed error the merchant's page stops on, and the outcome is unknown: the
+ * merchant holds the card and its answer did not come back. Otherwise the merchant's
+ * cookies are written first (cardEndpointCookies, against the endpoint's jar as read
+ * now), so the page's next call carries them, and the request is answered with the
+ * merchant's status, the profile's answer
+ * headers, the CORS answer the request needs, and the body. Resolves false for a
+ * withheld answer and true when the merchant's answer was handed over.
+ *
+ * A profile whose page submits its form as a navigation is answered as a page load: a
+ * withheld answer, or a redirect that would make the browser post the form again, gets
+ * the stopped page (the card reached the merchant, the answer is not shown); a 301, 302
+ * or 303 is handed over as a redirect to its one https Location, which the browser
+ * follows in its own session with the merchant's cookies written first; any other
+ * answer is the page itself. No CORS answer rides on a page load.
+ */
+async function deliverCardEndpointAnswer(opts, lifecycle, profile, replay, request, io) {
+    // Only the request that named this profile is answered from its merchant's answer.
+    if (!profile || replay.profile !== profile.id)
+        throw new PaymentOutcomeUnknownError(replay.authorizationId, 'approved_mode_unsupported');
+    const cors = corsDecision(request.url, request.headers);
+    const navigation = profile.navigation !== null;
+    if (replay.withheld) {
+        const fixed = replay.withheld === 'refused_step_in_response' ? CARD_ENDPOINT_REFUSED_STEP_ANSWER : CARD_ENDPOINT_WITHHELD_ANSWER;
+        await io.fulfill(navigation ? stoppedNavigationPage(profile, 'sent_answer_not_shown', 'answer_withheld', replay.authorizationId)
+            : { status: fixed.status, headers: withCorsHeaders({ ...fixed.headers }, cors.headers), body: fixed.body });
+        io.assertLive();
+        lifecycle.failed(new PaymentOutcomeUnknownError(replay.authorizationId, 'merchant_answer_withheld'), true);
+        opts.onEvent?.({ type: 'merchant_answer_withheld', detail: { authorizationId: replay.authorizationId, ...cardEndpointDetail(profile), reason: replay.withheld } });
+        return false;
+    }
+    // The jar decides where a rotation lands, so it is read only when there is one to write.
+    let jar = [];
+    if (replay.setCookies.length > 0 && profile.response.headers.includes('set-cookie')) {
+        try {
+            const read = await io.readJar();
+            jar = Array.isArray(read) ? read.map((held) => ({ name: String(held?.name ?? ''), domain: String(held?.domain ?? '') })) : null;
+        }
+        catch {
+            jar = null;
+        }
+    }
+    const { cookies, skipped } = cardEndpointCookies(profile, request.url, replay.setCookies, Date.now(), jar);
+    // A navigation's answer is judged before any cookie is written: a redirect it cannot follow ends on the stopped page.
+    const verdict = navigation ? cardEndpointNavigationAnswer(profile, { status: replay.status, headers: replay.headers }, request.url) : { kind: 'page' };
+    if (verdict.kind === 'refused') {
+        await io.fulfill(stoppedNavigationPage(profile, 'sent_answer_not_shown', verdict.reason, replay.authorizationId));
+        io.assertLive();
+        lifecycle.failed(new PaymentOutcomeUnknownError(replay.authorizationId, 'merchant_redirect_refused'), true);
+        opts.onEvent?.({ type: 'merchant_answer_withheld', detail: { authorizationId: replay.authorizationId, ...cardEndpointDetail(profile), reason: verdict.reason } });
+        return false;
+    }
+    let written = 0;
+    let refused = 0;
+    for (const cookie of cookies) {
+        // A cookie the browser refuses is counted, never fatal: the merchant already holds
+        // the card, and its answer still has to reach the page.
+        try {
+            await io.writeCookie(cookie);
+            written += 1;
+        }
+        catch {
+            refused += 1;
+        }
+    }
+    io.assertLive();
+    if (verdict.kind === 'redirect') {
+        await io.fulfill({ status: verdict.status, headers: { location: verdict.location, 'cache-control': 'no-store' }, body: '' });
+    }
+    else if (navigation) {
+        const headers = cardEndpointAnswerHeaders(profile, replay.headers);
+        delete headers.location;
+        await io.fulfill({ status: replay.status, headers, body: replay.body });
+    }
+    else {
+        await io.fulfill({ status: replay.status, headers: withCorsHeaders(cardEndpointAnswerHeaders(profile, replay.headers), cors.headers), body: replay.body });
+    }
+    io.assertLive();
+    opts.onEvent?.({ type: 'authorized', detail: { mode: 'card_endpoint', authorizationId: replay.authorizationId, ...cardEndpointDetail(profile),
+            status: replay.status, ...(navigation ? { answered: verdict.kind } : { cors: cors.outcome }), cookies: { written, skipped: skipped + refused } } });
+    return true;
+}
 /** CDP's header shape: `{ name, value }` entries. */
 function headerEntries(headers) {
     return Object.entries(headers).map(([name, value]) => ({ name, value: String(value) }));
@@ -462,6 +859,21 @@ function pageOriginFrom(documentUrl) {
         return undefined;
     }
 }
+/** The URL of the document the frame `frameId` holds, from the frame tree of the CDP session a request paused on. */
+async function frameUrlIn(cdp, sessionId, frameId) {
+    if (typeof frameId !== 'string' || frameId === '')
+        throw new Error('merchant_document_unavailable');
+    const tree = await cdp.send('Page.getFrameTree', {}, sessionId);
+    const stack = tree?.frameTree ? [tree.frameTree] : [];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node?.frame?.id === frameId && typeof node.frame.url === 'string')
+            return node.frame.url;
+        for (const child of node?.childFrames ?? [])
+            stack.push(child);
+    }
+    throw new Error('merchant_document_unavailable');
+}
 /**
  * The top-level document's URL, read once with a one-second bound when a card
  * request pauses: pageOriginFrom derives the merchant origin from it, and the
@@ -551,26 +963,13 @@ function failureSummary(error) {
     // Why the merchant's own total could not stand behind the payment, and at which step.
     if (error instanceof MerchantTotalError)
         return `${error.name}: ${error.code}${error.reasonCode ? ` (${error.reasonCode})` : ''}`;
+    if (error instanceof CardEndpointRefusedError)
+        return `${error.name}: ${error.reason}`;
     return error instanceof Error ? error.name : 'CheckoutError';
 }
 const STRIPE_PAYMENT_INTENT_CONFIRM = /^\/v1\/payment_intents\/pi_[A-Za-z0-9]+\/confirm$/;
-/**
- * A page that tokenized the card through an approval, then confirms the
- * payment in the browser with the token it got back (confirmCardPayment with
- * payment_method: 'pm_...', confirmPayment with a confirmation token). That
- * confirmation carries no card, and the hold after a Stripe tokenization
- * would refuse it. The API decides instead whether it is the payment the
- * cardholder approved (the approved amount and currency, on the same Stripe
- * account, paid with exactly the approved token).
- *
- * Synchronous on purpose: every paused request passes through here, and an
- * await would reorder it against the attachment's own events. Returns the
- * approval to check, with the lifecycle's one continuation claimed, or null
- * when this is not such a confirmation and the ordinary rules apply.
- */
 function claimStripeContinuation(opts, lifecycle, url, method, body) {
-    if (body == null || typeof opts.vault.checkStripeContinuation !== 'function' || !lifecycle.isBlocked()
-        || method.toUpperCase() !== 'POST')
+    if (body == null || !lifecycle.isBlocked() || method.toUpperCase() !== 'POST')
         return null;
     let parsed;
     try {
@@ -579,25 +978,57 @@ function claimStripeContinuation(opts, lifecycle, url, method, body) {
     catch {
         return null;
     }
-    if (parsed.origin !== 'https://api.stripe.com' || !STRIPE_PAYMENT_INTENT_CONFIRM.test(parsed.pathname)
-        || opts.vault.withoutCard?.(url, body) !== 'refuse')
+    if (parsed.origin !== 'https://api.stripe.com')
+        return null;
+    if (STRIPE_PAYMENT_INTENT_CONFIRM.test(parsed.pathname)) {
+        if (typeof opts.vault.checkStripeContinuation !== 'function' || opts.vault.withoutCard?.(url, body) !== 'refuse')
+            return null;
+        const authorizationId = lifecycle.claimStripeContinuation();
+        return authorizationId ? { authorizationId, kind: 'payment', body, rewritten: false } : null;
+    }
+    if (!STRIPE_SETUP_INTENT_CONFIRM.test(parsed.pathname) || typeof opts.vault.checkStripeSetupContinuation !== 'function')
         return null;
-    return lifecycle.claimStripeContinuation();
+    const withoutCard = opts.vault.withoutCard?.(url, body);
+    let send = null;
+    if (withoutCard === 'refuse')
+        send = body;
+    else if (withoutCard === null) {
+        // The card again, inline: only the approved payment method may replace it,
+        // and only when what is left carries no card at all.
+        const paymentMethod = lifecycle.approvedStripePaymentMethod();
+        send = paymentMethod ? setupConfirmPayingWith(body, paymentMethod) : null;
+        if (send !== null && opts.vault.withoutCard?.(url, send) !== 'refuse')
+            send = null;
+    }
+    if (send === null)
+        return null;
+    const authorizationId = lifecycle.claimStripeContinuation();
+    return authorizationId ? { authorizationId, kind: 'setup', body: send, rewritten: send !== body } : null;
 }
-/** Ask the API about a claimed continuation and settle the claim. True: continue the page's request untouched. */
-async function checkStripeContinuation(opts, lifecycle, authorizationId, request) {
-    let paymentIntentId = null;
+/**
+ * Ask the API about a claimed continuation, with the body it would continue
+ * with, and settle the claim. True: continue the page's request with that body
+ * (untouched unless the claim rewrote it).
+ */
+async function checkStripeContinuation(opts, lifecycle, claim, request) {
+    const { authorizationId, kind } = claim;
+    let intentId = null;
     try {
-        paymentIntentId = (await opts.vault.checkStripeContinuation(authorizationId, request)).paymentIntentId;
+        intentId = kind === 'setup'
+            ? (await opts.vault.checkStripeSetupContinuation(authorizationId, { ...request, body: claim.body })).setupIntentId
+            : (await opts.vault.checkStripeContinuation(authorizationId, { ...request, body: claim.body })).paymentIntentId;
     }
     catch (error) {
         opts.onEvent?.({ type: 'blocked', detail: failureSummary(error) });
     }
     // The checkout may have been cancelled or reconciled while the API answered.
-    const proceed = lifecycle.stripeContinuationChecked(paymentIntentId !== null);
-    if (proceed)
-        opts.onEvent?.({ type: 'stripe_payment_continued', detail: { authorizationId, paymentIntentId } });
-    else if (paymentIntentId !== null)
+    const proceed = lifecycle.stripeContinuationChecked(intentId !== null, kind);
+    if (proceed) {
+        opts.onEvent?.(kind === 'setup'
+            ? { type: 'stripe_setup_continued', detail: { authorizationId, setupIntentId: intentId, rewritten: claim.rewritten } }
+            : { type: 'stripe_payment_continued', detail: { authorizationId, paymentIntentId: intentId } });
+    }
+    else if (intentId !== null)
         opts.onEvent?.({ type: 'blocked', detail: 'stripe_continuation_superseded' });
     return proceed;
 }
@@ -690,15 +1121,20 @@ function luhn(digits) {
     return sum % 10 === 0;
 }
 /**
- * The card-placeholder runs in a body: every 13 to 19 digit run that passes
- * Luhn, sorted. The placeholder the agent typed (4242 4242 4242 4242, 4111
- * 1111 1111 1111) passes; a millisecond timestamp or an order number fails
- * nine times in ten, and when one passes it merely makes the match stricter.
- * A client-side-encrypted body (Adyen) carries no digits at all and yields
- * an empty list on both sides.
+ * The card-placeholder runs in a body: every run of 13 to 19 digits that
+ * passes Luhn, with any single spaces between its digits taken out, sorted.
+ * The placeholder the agent typed (4242 4242 4242 4242, 4111 1111 1111 1111)
+ * passes whether the page sends its digits alone or grouped by spaces the way
+ * the card input shows them, which is how WSPay's card frame sends it. A
+ * millisecond timestamp or an order number fails nine times in ten, and when
+ * one passes it merely makes the match stricter. A body with no single space
+ * between two digits yields exactly the contiguous runs it always did,
+ * because the optional space never matches there. A client-side-encrypted
+ * body (Adyen) carries no digits at all and yields an empty list on both
+ * sides.
  */
 function cardRuns(body) {
-    return (body.match(/\d{13,19}/g) ?? []).filter(luhn).sort();
+    return (body.match(/\d(?: ?\d){12,18}/g) ?? []).map((run) => run.replace(/ /g, '')).filter(luhn).sort();
 }
 /** Every key path in a JSON value, arrays flattened so an element's order or count does not count. */
 function jsonKeyPaths(value, prefix, out) {
@@ -800,12 +1236,24 @@ function sameCheckoutRequest(first, retry) {
  * answer is a token or ciphertext, and any request for the same purchase can
  * carry it. No for a hosted form (a navigation: there is no request to
  * answer once the page has moved on), a prepared checkout (single use, bound
- * to one native request by design), a native Stripe Checkout step, and a
- * Mercado Pago request whose claim is bound to one document read. Unknown
- * modes (a duck-typed vault without checkoutModeOf) are taken as `token`.
+ * to one native request by design), a native Stripe Checkout step, a
+ * Mercado Pago request whose claim is bound to one document read, a Juspay
+ * /txns (the device pays that request's own order; a page that clicks Pay
+ * again creates a new order, which the earlier answer would send to the
+ * earlier order's bank check), a Payrails save (device_encrypt: the device
+ * sends that one save itself, under the idempotency key the page gave it, so a
+ * retry is a new question), and any request to a Shiji STS host. Shiji
+ * encrypts every merchant's card under one static key, so the device's
+ * ciphertext tokenizes the card in whichever STS session carries it, and a
+ * retry the shape rule accepts (sameCheckoutRequest compares key paths, never
+ * values) can name another Shiji merchant's accessToken and keySequence than
+ * the request the API reviewed at create. No legitimate retry is lost:
+ * sts.proxy's fetch sets no timeout, so the page never gives up on its own
+ * getTokenId while the cardholder decides. Unknown modes (a duck-typed vault
+ * without checkoutModeOf) are taken as `token`.
  */
 function survivesAbandonment(opts, url, method, navigation, bound) {
-    if (navigation || bound)
+    if (navigation || bound || isShijiStsHost(url))
         return false;
     const mode = typeof opts.vault?.checkoutModeOf === 'function' ? opts.vault.checkoutModeOf(url, method) : 'token';
     return mode === 'token' || mode === 'cse';
@@ -836,7 +1284,12 @@ function merchantAttempt(lifecycle, survives) {
     let rebound = false;
     let delivering = false;
     let bound = null;
-    const error = () => new PaymentOutcomeUnknownError(lifecycle.getState().authorizationId, reason);
+    // An Amadeus send window closes only once the API confirms the card never left the device and
+    // never can (amadeus.ts): a known non-payment, so the prepared checkout ends failed with that
+    // reason, and a fresh attachment can prepare again. Every other stop leaves the outcome unknown.
+    const error = () => reason === 'amadeus_send_window_closed'
+        ? new CheckoutPreparationError(lifecycle.getState().preparationId ?? null, reason)
+        : new PaymentOutcomeUnknownError(lifecycle.getState().authorizationId, reason);
     const attempt = {
         signal: controller.signal,
         /** The browser request that currently carries this attempt; null while the page has none. */
@@ -1059,6 +1512,23 @@ function pauseForBusiness(opts, lifecycle, attemptSignal, request, pageOrigin) {
     });
     return { replay, delivered: { resolve: deliveredResolve, reject: deliveredReject } };
 }
+/**
+ * Arm the send window of a request paused under a preparation, when its processor sets one: only a
+ * prepared Amadeus SDK add does (amadeus.ts). Returns the disarm function, or null with no window.
+ * lifecycle.begin() cleared the authorization ID, so the one the window reads is this attempt's.
+ */
+function armWindowFor(opts, lifecycle, attempt, preparation, url, delivering) {
+    const ms = preparation ? amadeusSendWindowMs(preparation.psp, url) : null;
+    if (ms === null || !preparation)
+        return null;
+    return armSendWindow(ms, attempt, {
+        authorizationId: () => lifecycle.getState().authorizationId,
+        delivering,
+        cancel: typeof opts.vault?.cancelAuthorization === 'function' ? (id) => opts.vault.cancelAuthorization(id) : undefined,
+        retirePreparation: typeof opts.vault?.retirePreparation === 'function' ? () => opts.vault.retirePreparation(preparation.id) : undefined,
+        onEvent: opts.onEvent,
+    });
+}
 /**
  * Take over card tokenization for a page.
  *
@@ -1090,6 +1560,9 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
     const ownedSessions = new Set([pageSessionId]);
     const sessionTypes = new Map([[pageSessionId, 'page']]);
     const sessionParents = new Map();
+    // The frame in its parent session that a child target hangs from (TargetInfo.parentFrameId), so a
+    // frame lookup can climb from a cross-origin frame into the document that frames it.
+    const sessionParentFrames = new Map();
     const detachedSessions = new Set();
     const rejectedSessions = new Set();
     const workerOwners = new Map();
@@ -1174,6 +1647,10 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             clearTimeout(timer);
         }
     };
+    // Juspay's tokenize answer and the synthetic tokens it issued (juspay-gate.ts).
+    const juspayCheckout = new JuspayCheckoutGate(opts.vault);
+    const aci = new AciGate(opts.vault);
+    const eprotect = new EprotectGate(opts.vault);
     let preparationFrameId;
     const readDocumentUrl = async () => {
         const tree = await cdp.send('Page.getFrameTree', {}, pageSessionId);
@@ -1182,7 +1659,58 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
         preparationFrameId = tree.frameTree.frame.id;
         return tree.frameTree.frame.url;
     };
-    const preparationGate = new PreparationGate(opts, lifecycle, readDocumentUrl);
+    // prepare({ tokenizeBeforePay: true }) sends the card Microform whose field documents are committed
+    // now. A field's commit can come before this attachment enabled its session, so no event reports
+    // it; each iframe session's own frame tree, and the page's, is read once first (as rereadMicroforms
+    // reads the pausing one), and every field found there is recorded (cybersource-flex.ts MicroformFrames).
+    const readLoadedMicroform = async () => {
+        const sessions = [pageSessionId, ...[...ownedSessions].filter(session => sessionTypes.get(session) === 'iframe' && !sessionDetached(session))];
+        await Promise.all(sessions.map(session => rereadMicroforms(session, '').catch(() => undefined)));
+        return microforms.loadedCard();
+    };
+    /**
+     * The frame a paused document request navigates, read from the frame tree of the
+     * session it paused on: 'top' for the page itself, 'frame' for an iframe (a frame with
+     * a parent, or the root of an iframe's own session), with that frame's current
+     * document URL, where the form was submitted. Null when the frame is not in the tree.
+     */
+    const documentFrame = async (sessionId, frameId) => {
+        if (typeof frameId !== 'string' || !frameId)
+            return null;
+        const tree = await cdp.send('Page.getFrameTree', {}, sessionId);
+        const find = (node, depth) => {
+            if (!node || depth > 32)
+                return null;
+            if (node.frame?.id === frameId)
+                return node.frame;
+            for (const child of Array.isArray(node.childFrames) ? node.childFrames : []) {
+                const hit = find(child, depth + 1);
+                if (hit)
+                    return hit;
+            }
+            return null;
+        };
+        const frame = find(tree?.frameTree, 0);
+        if (!frame)
+            return null;
+        return { navigation: frame.parentId || sessionId !== pageSessionId ? 'frame' : 'top', url: typeof frame.url === 'string' ? frame.url : undefined };
+    };
+    /**
+     * Refuse a paused request after the pre-claim gates: a card form navigation gets the
+     * stopped page (card-endpoint-page.ts) that `refusal` describes, since an aborted page
+     * load renders nothing and invites another click on Pay; any other request fails as
+     * cdpFailure says (a network error for CyberSource Flex and Amadeus, else an abort).
+     */
+    const refusePaused = async (requestId, sessionId, url, profile, refusal) => {
+        if (profile && profile.navigation !== null) {
+            const page = stoppedNavigationPage(profile, refusal.outcome, refusal.reason, refusal.authorizationId);
+            await cdp.send('Fetch.fulfillRequest', { requestId, responseCode: page.status, responseHeaders: headerEntries(page.headers),
+                body: Buffer.from(page.body).toString('base64') }, sessionId).catch(() => { });
+            return;
+        }
+        await cdp.send('Fetch.failRequest', { requestId, errorReason: cdpFailure(url) }, sessionId).catch(() => { });
+    };
+    const preparationGate = new PreparationGate(opts, lifecycle, readDocumentUrl, readLoadedMicroform);
     // A merchant-hosted request this attachment continued with the Vault's
     // ciphertext, and the Network identity its answer arrives under.
     const merchantHandoff = new MerchantHandoffWatch(lifecycle, opts.onEvent);
@@ -1192,8 +1720,17 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
     // The merchant's own total (merchant-total-watch.ts): its checkout responses, recorded
     // read-only from attach on, and the approval a hand-off answers, for the charge report.
     const merchantTotal = new MerchantTotalWatch(opts.onEvent, opts.vault);
+    // A reviewed card endpoint merchant's own record of the order (card-endpoint-facts.ts).
+    const cardEndpointRecord = new CardEndpointFactsWatch();
     let handoffReplay = null;
     const guards = paymentEndpointGuards(opts.paymentEndpoints);
+    // Payrails sessions this page's own XHR and fetch answers carried, read only
+    // when the synced registry pauses Payrails' save (an org the API served the
+    // dark entry to); null otherwise, and no answer is read (see payrails.ts).
+    const payrails = recognizesPayrails(opts.vault) ? new PayrailsSessionCapture() : null;
+    // Answers that may carry a Payrails init payload, by session and Network ID,
+    // read once they finish loading.
+    const payrailsAnswers = new Set();
     const armed = new Set();
     const arming = new Map();
     // Set once a failure proves that retrying cannot help; see isTerminal.
@@ -1344,6 +1881,15 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
     // The hosted form the cardholder already submitted; see HOSTED_FORM_REPEAT_QUIET_MS.
     const repeatQuietMs = opts.hostedFormRepeatQuietMs ?? HOSTED_FORM_REPEAT_QUIET_MS;
     let lastSubmitted = null;
+    // The approved Datatrans answers, per frameId: the repeat rule (datatrans.ts).
+    const datatransRepeats = new DatatransRepeats();
+    // The Shiji STS getCvvId companion of the getTokenId this attachment last continued (shiji-sts.ts).
+    // A cancelled attachment drops it, and the device's CVV ciphertext with it, at once: no getCvvId
+    // can use it any more (pre-claim.ts refuses every one once the lifecycle is aborted). The page,
+    // frame or target going away drops it too (the detach handlers below), and so does the frame
+    // committing a new document (Page.frameNavigated, at the top of the event handler).
+    const shijiCompanions = new ShijiStsCompanions();
+    lifecycle.abort.signal.addEventListener('abort', () => shijiCompanions.release(), { once: true });
     const derived = typeof opts.vault?.cardUrlPatterns === 'function' ? opts.vault.cardUrlPatterns() : [];
     // The endpoint and siblings of every merchant profile this build reviewed
     // (merchant-hosted.ts), which a VaultClient arms from the start: a profile's card
@@ -1351,13 +1897,22 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
     // it, before or after any syncRegistry(). The gate continues untouched a request
     // that the vault names no profile for.
     const merchantPatterns = [...reviewedMerchantProfileUrlPatterns(),
-        ...(typeof opts.vault?.merchantProfileUrlPatterns === 'function' ? opts.vault.merchantProfileUrlPatterns() : [])];
+        ...(typeof opts.vault?.merchantProfileUrlPatterns === 'function' ? opts.vault.merchantProfileUrlPatterns() : []),
+        // Every request to an armed Verifone merchant's origin (verifone.ts), armed from the profiles
+        // the last syncRegistry() served: none before one, and none for a company Verifone is off for.
+        ...(typeof opts.vault?.verifoneProfileUrlPatterns === 'function' ? opts.vault.verifoneProfileUrlPatterns() : [])];
     // GMO token v1's JSONP GET is armed only when the synced registry recognizes
     // GMO (an org the API served the dark entry to), so the gate can refuse it;
     // for every other org it is never intercepted, as before (see gmo.ts).
+    // Every reviewed card endpoint is armed in any status: a card request to one this build
+    // does not pay is paused only to be refused, so the placeholder card never reaches the
+    // merchant, and a request with no card in it continues untouched.
+    // Every Payrails host is intercepted only for an org the API served Payrails
+    // to, so the gate can abort a card-form payment (see payrails.ts).
     const urlPatterns = [...new Set([...(derived.length > 0 ? derived : FALLBACK_CARD_PATTERNS), ...guards.patterns,
             ...(stripeCheckout.isEnabled() ? ['https://api.stripe.com/*'] : []), MERCADO_CHECKOUT_PATTERN, ...merchantPatterns,
-            ...(recognizesGmo(opts.vault) ? GMO_TOKEN_V1_PATTERNS : [])])];
+            ...(recognizesGmo(opts.vault) ? GMO_TOKEN_V1_PATTERNS : []), ...juspayCheckout.urlPatterns(), ...cardEndpointPatterns(),
+            ...(payrails ? PAYRAILS_GUARD_PATTERNS : [])])];
     const arm = async (sessionId, resume = false, worker = false) => {
         const key = sessionId ?? '__root__';
         if (armed.has(key))
@@ -1430,6 +1985,14 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
         opts.onEvent?.({ type: 'failed', detail: 'browser_interception_unavailable' });
     };
     cdp.on(async (method, params, sessionId) => {
+        // A frame that committed a new document drops the companion binding made for the getTokenId its
+        // old document sent, with the device's CVV ciphertext: the document that replaced it never
+        // obtained the approval, whatever accessToken and key it sends. A same-document navigation is
+        // Page.navigatedWithinDocument and keeps the binding.
+        if (method === 'Page.frameNavigated' && typeof params?.frame?.id === 'string') {
+            const replaced = cdpShijiPage(sessionId, params.frame.id);
+            shijiCompanions.releasePage((page) => page === replaced);
+        }
         if ((method === 'Target.targetCreated' || method === 'Target.targetInfoChanged') && targetContextKnown) {
             try {
                 assertContextTarget(params?.targetInfo, merchantContext);
@@ -1465,6 +2028,8 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             mercadoCheckout.invalidate();
             // The root page owns every attached OOPIF; its loss ends child requests too.
             activeRequest?.attempt.stop();
+            // No getCvvId can come from a closed page: drop the companion and its CVV ciphertext.
+            shijiCompanions.release();
             // Nothing can read the merchant's answer to a continued merchant-hosted
             // request any more, nor the page's report of a retry: a retry is judged on
             // what was read, then the answer is an unknown outcome unless it arrived.
@@ -1502,6 +2067,7 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 merchantTotal.sent(key, { method: params.request.method, url: params.request.url,
                     ...(typeof params.request.postData === 'string' ? { requestBody: params.request.postData } : {}),
                     ...(typeof params.loaderId === 'string' && params.loaderId ? { page: `${owner}:${params.loaderId}` } : {}) });
+                cardEndpointRecord.sent(key, { method: params.request.method, url: params.request.url, resourceType: params.type ?? null, networkId: params.requestId });
             }
             if (matchesActive) {
                 try {
@@ -1524,16 +2090,39 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
         if (method === 'Network.loadingFinished') {
             const key = requestKey(sessionId, params.requestId);
             requestSources.delete(key);
+            // An out-of-process frame's document finishes on the frame's own session, under the
+            // network id its request was reported with on the parent's (keyFor).
+            const recordKey = cardEndpointRecord.keyFor(key, params.requestId);
+            if (recordKey) {
+                const completedAt = Date.now();
+                // Its place among the answers that finished, before its text is read: texts can come back out of order.
+                cardEndpointRecord.finished(recordKey);
+                cdp.send('Network.getResponseBody', { requestId: params.requestId }, sessionId).then((read) => cardEndpointRecord.read(recordKey, typeof read?.body === 'string'
+                    ? (read.base64Encoded ? Buffer.from(read.body, 'base64').toString('utf8') : read.body) : null, completedAt), () => cardEndpointRecord.read(recordKey, null, completedAt));
+            }
             if (merchantTotal.log.tracks(key)) {
                 // When it finished, then its text: a merchant response the total or the charge is read from.
                 const completedAt = Date.now();
                 cdp.send('Network.getResponseBody', { requestId: params.requestId }, sessionId).then((read) => merchantTotal.log.read(key, typeof read?.body === 'string'
                     ? (read.base64Encoded ? Buffer.from(read.body, 'base64').toString('utf8') : read.body) : null, completedAt), () => merchantTotal.log.read(key, null, completedAt));
             }
+            if (payrails && payrailsAnswers.delete(requestKey(sessionId, params.requestId))
+                && !(Number(params.encodedDataLength) > PAYRAILS_INIT_BODY_LIMIT)) {
+                payrails.reading(cdp.send('Network.getResponseBody', { requestId: params.requestId }, sessionId).then((answer) => {
+                    if (typeof answer?.body !== 'string')
+                        return;
+                    const body = answer.base64Encoded ? Buffer.from(answer.body, 'base64').toString('utf8') : answer.body;
+                    if (body.length <= PAYRAILS_INIT_BODY_LIMIT)
+                        payrails.observe(body);
+                }));
+            }
             return;
         }
         if (method === 'Network.responseReceived') {
             merchantTotal.log.answered(requestKey(sessionId, params.requestId), params.response?.status);
+            const recordKey = cardEndpointRecord.keyFor(requestKey(sessionId, params.requestId), params.requestId);
+            if (recordKey)
+                cardEndpointRecord.answered(recordKey, params.response?.status);
             // The merchant's answer to a continued merchant-hosted request: 5xx is an unknown outcome.
             if (handoffNetwork && params.requestId === handoffNetwork.networkId && sessionId === handoffNetwork.sessionId) {
                 merchantHandoff.responded(params.response?.status);
@@ -1543,12 +2132,24 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 if (handoffReplay)
                     merchantTotal.answered(handoffReplay, opts.vault);
             }
+            // A 2xx XHR or fetch answer with a JSON type may carry a Payrails init
+            // payload; its body is read once it finishes loading.
+            if (payrails && payrailsInitCandidate(params?.type, params?.response?.status, params?.response?.mimeType)) {
+                payrailsAnswers.add(requestKey(sessionId, params.requestId));
+                // An answer that never finishes loading is forgotten with the oldest, not kept forever.
+                if (payrailsAnswers.size > 256)
+                    payrailsAnswers.delete(payrailsAnswers.values().next().value);
+            }
             return;
         }
         if (method === 'Network.loadingFailed') {
             merchantTotal.log.failed(requestKey(sessionId, params.requestId));
+            const recordKey = cardEndpointRecord.keyFor(requestKey(sessionId, params.requestId), params.requestId);
+            if (recordKey)
+                cardEndpointRecord.failed(recordKey);
             if (handoffNetwork && params.requestId === handoffNetwork.networkId && sessionId === handoffNetwork.sessionId)
                 merchantHandoff.failed();
+            payrailsAnswers.delete(requestKey(sessionId, params.requestId));
             if (activeRequest && activeRequest.networkId === params.requestId && activeRequest.sourceSessionId === sessionId) {
                 const dead = { requestId: activeRequest.requestId, sessionId: activeRequest.sessionId, request: activeRequest.request };
                 // A request a dedicated worker sent keeps today's behaviour: its loss
@@ -1590,6 +2191,16 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 : method === 'Inspector.detached' ? activeRequest.sessionId === sessionId
                     : activeRequest.sessionId === sessionId && activeRequest.frameId === params.frameId))
                 activeRequest.attempt.stop();
+            // The frame or target the bound getTokenId came from is gone, so its getCvvId cannot follow:
+            // drop the companion binding and the CVV ciphertext it holds (a binding elsewhere stays).
+            if (method === 'Page.frameDetached') {
+                const gone = cdpShijiPage(sessionId, params.frameId);
+                shijiCompanions.releasePage((page) => page === gone);
+            }
+            else {
+                const gone = cdpShijiSession(method === 'Target.detachedFromTarget' ? params.sessionId : sessionId);
+                shijiCompanions.releasePage((page) => page.startsWith(gone));
+            }
             if (method !== 'Page.frameDetached') {
                 const detached = method === 'Target.detachedFromTarget' ? params.sessionId : sessionId;
                 detachedSessions.add(detached);
@@ -1653,6 +2264,9 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 ownedSessions.add(child);
                 sessionTypes.set(child, params.targetInfo.type);
                 sessionParents.set(child, sessionId);
+                if (typeof params.targetInfo.parentFrameId === 'string' && params.targetInfo.parentFrameId) {
+                    sessionParentFrames.set(child, params.targetInfo.parentFrameId);
+                }
                 if (params.targetInfo.type === 'worker') {
                     const owner = workerOwners.get(sessionId) ?? sessionId;
                     workerOwners.set(child, owner);
@@ -1688,9 +2302,15 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
         // a pause hands work back to the claim flow below.
         const preClaimResult = dispatchPreClaim({
             // headers and body are read lazily, inside the gate that needs them (see PreClaimContext.request).
-            request: { url: request.url, method: request.method, get headers() { return request.headers; }, get body() { return pausedBody(request); } },
-            vault: opts.vault, guards, mercado: mercadoCheckout, stripe: stripeCheckout,
+            request: { url: request.url, method: request.method, get headers() { return request.headers; }, get body() { return pausedBody(request); },
+                navigation: resourceType === 'Document' },
+            vault: opts.vault, guards, mercado: mercadoCheckout, stripe: stripeCheckout, aci, eprotect,
+            // This adapter drives Chromium, which sends the body Fetch.continueRequest replaces on a
+            // navigation (the ACI browser test's classic case, design gate G3).
+            replacesNavigationBody: async () => true,
             readDocumentUrl, lifecycle, preparationGate, onEvent: opts.onEvent, failureSummary,
+            // Read only for a card endpoint whose page submits its form as a navigation.
+            navigation: async () => (resourceType === 'Document' ? (await documentFrame(sessionId, frameId))?.navigation ?? null : null),
             effects: {
                 continueRequest: (postData) => cdp.send('Fetch.continueRequest', { requestId, ...(postData !== undefined ? { postData: Buffer.from(postData).toString('base64') } : {}) }, sessionId),
                 answer: (response) => cdp.send('Fetch.fulfillRequest', { requestId, responseCode: response.status,
@@ -1707,10 +2327,19 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             stripeAttachmentBusy: () => arming.has(sessionId ?? '__root__'),
             requestInactive: () => false,
             awaitingApproval: () => awaitingApproval,
+            initiatorFrames: () => pausedFrameChain(cdp, sessionId, frameId, child => {
+                const parent = sessionParents.get(child);
+                return parent === undefined ? undefined : { sessionId: parent, frameId: sessionParentFrames.get(child) };
+            }),
             stripeStep: null,
             merchantHandoff: { retried: (profile) => merchantHandoff.retried(profile, (judge) => awaitRetryReport(sessionId, networkId, judge)) },
             // The card field iframe that sent a Flex request is the paused request's own frame.
             cybersourceFlex: { judge: (flexRequest) => microforms.judge(flexRequest, frameId, () => rereadMicroforms(sessionId, frameId)) },
+            juspay: juspayCheckout,
+            datatrans: datatransRepeats,
+            frame: typeof frameId === 'string' && frameId ? frameId : undefined,
+            payrails,
+            shijiSts: { companions: shijiCompanions, page: () => cdpShijiPage(sessionId, frameId) },
         });
         const preClaim = preClaimResult instanceof Promise ? await preClaimResult : preClaimResult;
         if (preClaim.kind !== 'pause')
@@ -1718,14 +2347,38 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
         const stripeStep = preClaim.stripeStep;
         // The capture context and fields a CyberSource Flex create carries, and its retry shape.
         const flexPause = preClaim.cybersourceFlex;
+        // A reviewed merchant's own card endpoint this build pays (see card-endpoint.ts), and
+        // for one whose page submits its form as a navigation, which frame it navigates.
+        const cardEndpoint = preClaim.cardEndpoint ?? null;
+        // A Payrails card save the gate bound to a captured session: its key rides on the create.
+        const payrailsSidecar = preClaim.payrails;
+        const cardNavigation = preClaim.navigation;
         if (!attachmentReady || arming.has(sessionId ?? '__root__') || setupStop.signal.aborted) {
             opts.onEvent?.({ type: 'blocked', detail: 'checkout_interception_not_ready' });
-            await cdp.send('Fetch.failRequest', { requestId, errorReason: cdpFailure(request.url) }, sessionId).catch(() => { });
+            await refusePaused(requestId, sessionId, request.url, cardEndpoint, heldNavigationRefusal(terminal, awaitingApproval, lifecycle));
+            return;
+        }
+        // A request the catalog marks as routine without a card (a confirmation
+        // token for a saved method, a bank source, a Checkout Session confirm with
+        // the method hosted Checkout created, every Amadeus action but the card
+        // add and store) was never ours: it continues in every state, like a
+        // request the catalog does not recognize. It is judged before the
+        // preparation claim, so it neither spends a ready preparation nor counts
+        // as the page's first card request: Amadeus's SDK sends its load to the
+        // card URL as the payment step opens, before prepare(), and Air France's
+        // Nuvei payment with a ccTempToken follows the prepared Amadeus add. One
+        // without a card anywhere else is judged after the holds below, and so is
+        // a Nuvei payment without a card once this attachment has handed Nuvei the
+        // card (VaultClient.withoutCard).
+        const continuationBody = pausedBody(request);
+        const withoutCard = stripeStep ? null : opts.vault.withoutCard?.(request.url, continuationBody, lifecycle.cardHandoffs()) ?? null;
+        if (withoutCard === 'continue') {
+            await cdp.send('Fetch.continueRequest', { requestId }, sessionId).catch(() => { });
             return;
         }
         let preparation;
         try {
-            preparation = stripeStep ? undefined : preparationGate.claim(request.url, pausedBody(request), request.headers);
+            preparation = stripeStep ? undefined : preparationGate.claim(request.url, request.method, pausedBody(request), request.headers);
         }
         catch (error) {
             opts.onEvent?.({ type: 'blocked', detail: failureSummary(error) });
@@ -1756,32 +2409,23 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 return;
             }
         }
-        // A request the catalog marks as routine without a card (a confirmation
-        // token for a saved method, a bank source, a Checkout Session confirm with
-        // the method hosted Checkout created) was never ours: it continues in
-        // every state, like a request the catalog does not recognize. One without
-        // a card anywhere else is judged after the holds below.
-        const continuationBody = pausedBody(request);
-        const withoutCard = stripeStep ? null : opts.vault.withoutCard?.(request.url, continuationBody) ?? null;
-        if (withoutCard === 'continue') {
-            if (preparation)
-                preparationGate.retireUnboundClaim();
-            await cdp.send('Fetch.continueRequest', { requestId }, sessionId).catch(() => { });
-            return;
-        }
         // Not gated on awaitingApproval: the page can send this confirmation while
         // the token's own delivery is still being acknowledged. The lifecycle
         // opens the claim only once a Stripe tokenization is being handed over.
-        const continuationId = stripeStep || terminal ? null
+        const continuation = stripeStep || terminal ? null
             : claimStripeContinuation(opts, lifecycle, request.url, request.method, continuationBody);
-        if (continuationId) {
+        if (continuation) {
             if (preparation)
                 preparationGate.retireUnboundClaim();
-            if (await checkStripeContinuation(opts, lifecycle, continuationId, { url: request.url, method: request.method, headers: request.headers, body: continuationBody }) && !setupStop.signal.aborted) {
-                await cdp.send('Fetch.continueRequest', { requestId }, sessionId).catch(() => { });
+            if (await checkStripeContinuation(opts, lifecycle, continuation, { url: request.url, method: request.method, headers: request.headers }) && !setupStop.signal.aborted) {
+                // A card save that carried the card again continues with the body the
+                // API allowed, and postData alone rides the command (see cse-body.ts
+                // for why no header, Content-Length included, is ever overridden).
+                await cdp.send('Fetch.continueRequest', { requestId,
+                    ...(continuation.rewritten ? { postData: Buffer.from(continuation.body).toString('base64') } : {}) }, sessionId).catch(() => { });
                 return;
             }
-            await cdp.send('Fetch.failRequest', { requestId, errorReason: 'Aborted' }, sessionId).catch(() => { });
+            await cdp.send('Fetch.failRequest', { requestId, errorReason: cdpFailure(request.url) }, sessionId).catch(() => { });
             return;
         }
         // Same stop condition as the Playwright adapter: once a failure proves
@@ -1798,33 +2442,40 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             opts.onEvent?.({ type: 'blocked', detail: why instanceof Error ? failureSummary(why) : String(why) });
             if (preparation)
                 preparationGate.retireUnboundClaim();
-            await cdp.send('Fetch.failRequest', { requestId, errorReason: cdpFailure(request.url) }, sessionId).catch(() => { });
+            // A card form navigation never reads that nothing was sent while a payment for this checkout may exist.
+            await refusePaused(requestId, sessionId, request.url, cardEndpoint, heldNavigationRefusal(terminal, awaitingApproval, lifecycle));
             if (repeatedAuthorizationId)
                 void opts.vault.reportDuplicateGuard?.(repeatedAuthorizationId);
             return;
         }
         // A recognized request that carries no card is not a card request: a
-        // Stripe confirmation paying with a method the page created itself. It is
-        // judged only after the holds above, so a request that would reuse an
-        // approved token is still refused there (card-fields.js requestWithoutCard).
+        // Stripe confirmation paying with a method the page created itself, or a
+        // Nuvei payment with a token Nuvei may have minted from the approved card.
+        // It is judged only after the holds above, so a request that would reuse
+        // an approved token is still refused there (VaultClient.withoutCard).
         if (withoutCard === 'refuse') {
             if (preparation)
                 preparationGate.retireUnboundClaim();
             opts.onEvent?.({ type: 'blocked', detail: 'request_without_card' });
-            await cdp.send('Fetch.failRequest', { requestId, errorReason: 'Aborted' }, sessionId).catch(() => { });
+            await cdp.send('Fetch.failRequest', { requestId, errorReason: cdpFailure(request.url) }, sessionId).catch(() => { });
             return;
         }
         // Reserve BEFORE the first await (the authorize call below yields), so two
         // requests can never both clear the check above and raise two prompts for
         // one checkout.
         awaitingApproval = true;
-        const attempt = merchantAttempt(lifecycle, survivesAbandonment(opts, request.url, request.method, resourceType === 'Document', !!preparation || !!stripeStep || mercadoCheckout.requiresDocument(request.url, request.method)));
+        // A card endpoint approval never outlives its request: the device answers that
+        // request, and a retry after the page gave up on it is refused, not bound.
+        const attempt = merchantAttempt(lifecycle, survivesAbandonment(opts, request.url, request.method, resourceType === 'Document', !!preparation || !!stripeStep || !!cardEndpoint || mercadoCheckout.requiresDocument(request.url, request.method)
+            || juspayCheckout.bindsApproval(request.url, request.method)));
         let handoffStarted = false;
         // The approval the device gave, and whether it reached a browser request.
         let approvedId = null;
         let deliveryBegun = false;
         // The business's pause, so resume resolves once the page has its answer.
         let businessPause = null;
+        // A prepared Amadeus SDK add must be sent within its window (see amadeus.ts).
+        let disarmSendWindow = null;
         try {
             const body = pausedBody(request);
             if (body === null) {
@@ -1845,7 +2496,10 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                     void opts.vault.reportDuplicateGuard?.(lastSubmitted.authorizationId);
                 return;
             }
-            opts.onEvent?.({ type: 'card_request_paused', detail: { url: eventUrl(opts.vault, request.url), recognizer: recognizerNameOf(opts, request.url, request.method), ...(resourceType ? { resourceType } : {}) } });
+            // A card endpoint's URL carries the merchant's cart and booking ids: its events
+            // name the profile and the endpoint origin instead.
+            opts.onEvent?.({ type: 'card_request_paused', detail: { ...(cardEndpoint ? cardEndpointDetail(cardEndpoint) : { url: eventUrl(opts.vault, request.url) }),
+                    recognizer: recognizerNameOf(opts, request.url, request.method), ...(resourceType ? { resourceType } : {}) } });
             lifecycle.begin();
             const approvalStartedAt = Date.now();
             const payToInterceptMs = readPayToInterceptMs(opts.payClickedAt, approvalStartedAt);
@@ -1856,6 +2510,16 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             attempt.bind({ requestId, sessionId, request });
             activeRequest = { attempt, requestId, networkId, sessionId, frameId, request,
                 identity: requestIdentity(opts, request.url, request.method, body, undefined, undefined, flexPause?.shape) };
+            // An ACI card-number request: the page's CVC and expiry requests for its checkout are held
+            // until this approval ends (see AciGate). One whose checkout already has a card-number
+            // request running or answered never begins; the pre-claim gate refuses it before this.
+            if (!aci.begin(request.url, request.method, body, preparation?.merchantOrigin)) {
+                throw new CheckoutPreparationError(preparation?.id ?? null, ACI_CHECKOUT_REUSED);
+            }
+            // A Worldpay eProtect registration: the vendor's give-up report for it ends this attempt as
+            // the page abandoning its request (see EprotectGate.gaveUp).
+            eprotect.begin(request.url, request.method, () => attempt.stop());
+            disarmSendWindow = armWindowFor(opts, lifecycle, attempt, preparation, request.url, () => deliveryBegun);
             await awaitRequestSource(activeRequest);
             if (preparation)
                 await preparationGate.assertDocument();
@@ -1863,7 +2527,8 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             // the identity a retry has to repeat (see sameCheckoutRequest).
             const documentUrl = await documentUrlOf(readDocumentUrl, attempt.signal);
             const pageOrigin = pageOriginFrom(documentUrl);
-            const pageAmount = await pageAmountOf(opts);
+            // The agent's amount is a card endpoint's only authority: no page total is read.
+            const pageAmount = cardEndpoint ? undefined : await pageAmountOf(opts);
             attempt.assertLive();
             activeRequest.identity.documentUrl = documentKey(documentUrl);
             activeRequest.identity.pageAmount = pageAmount;
@@ -1879,6 +2544,24 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             const cardKey = requestKey(activeRequest?.sourceSessionId ?? sessionId ?? '', networkId ?? '');
             const cardPage = merchantTotal.priced(request.url)
                 ? await merchantTotal.pageFor(cardKey, MERCHANT_PAGE_WAIT_MS, attempt.signal) : merchantTotal.pageOf(cardKey);
+            // The card endpoint's session: the profile's own headers from the paused request,
+            // the endpoint's cookie jar for a cookie profile (Chrome keeps it out of the
+            // paused headers, HttpOnly cookies included), and a Referer on the origin the
+            // request is sent from: the profile's card vault frame when it names one, else
+            // the checkout page.
+            // A form inside an iframe is judged by the iframe's own document, where it was submitted, and
+            // a checkout in a frame the merchant's page embeds by that frame's own document.
+            const capturedOrigin = cardEndpoint?.navigation === 'frame'
+                ? pageOriginFrom((await documentFrame(sessionId, frameId).catch(() => null))?.url)
+                : cardEndpoint?.checkout_frame
+                    ? pageOriginFrom(await documentUrlOf(() => frameUrlIn(cdp, sessionId, frameId), attempt.signal)) : pageOrigin;
+            const session = cardEndpoint ? await captureCardEndpointSession(cardEndpoint, {
+                url: request.url, headers: request.headers, body, pageOrigin: capturedOrigin, navigation: cardNavigation,
+                cookies: async () => (await cdp.send('Network.getCookies', { urls: [request.url] }, sessionId))?.cookies ?? [],
+            }) : null;
+            attempt.assertLive();
+            // The merchant's own record of the order, as of the pause, for a profile that reads one.
+            const cardRecord = cardEndpoint ? await cardEndpointFacts(cardEndpointRecord, cardEndpoint, request.url, pausedAt, attempt.signal) : null;
             attempt.assertLive();
             // Decision 176: pause only. The business creates the authorization from the paused request and answers
             // through controller.resume; the replay it hands back goes down the same delivery path as a create's.
@@ -1909,10 +2592,12 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                     lifecycle.approvalUrl(url);
                     return opts.onApprovalUrl?.(url);
                 } },
-                request: stripeStep?.phase === 'final' ? stripeStep.request : { url: request.url, method: request.method, headers: request.headers, body,
-                    ...(mercadoCheckout.requiresDocument(request.url, request.method)
-                        ? { mercado_checkout: mercadoCheckout.claimToken(request.url, request.method, await readDocumentUrl()) } : {}),
-                    ...(flexPause ? flexPause.sidecar : {}) },
+                request: stripeStep?.phase === 'final' ? stripeStep.request : cardEndpoint && session ? cardEndpointRequest(cardEndpoint, session, cardRecord)
+                    : { url: request.url, method: request.method, headers: request.headers, body,
+                        ...(mercadoCheckout.requiresDocument(request.url, request.method)
+                            ? { mercado_checkout: mercadoCheckout.claimToken(request.url, request.method, await readDocumentUrl()) } : {}),
+                        ...(flexPause ? flexPause.sidecar : {}),
+                        ...(payrailsSidecar ? { payrails: payrailsSidecar } : {}) },
             });
             attempt.assertLive();
             approvedId = replay.authorizationId;
@@ -1943,7 +2628,22 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             attempt.beginDelivery();
             lifecycle.prepareHandoff(replay, deliverRequest.url);
             handoffStarted = replay.mode !== 'cse';
-            if (replay.mode === 'hosted_form') {
+            // False only for a card endpoint answer the device withheld (see deliverCardEndpointAnswer).
+            let handedOver = true;
+            if (replay.mode === 'card_endpoint') {
+                handedOver = await deliverCardEndpointAnswer(opts, lifecycle, cardEndpoint, replay, { url: deliverRequest.url, headers: deliverRequest.headers }, {
+                    readJar: async () => (await cdp.send('Network.getCookies', { urls: [deliverRequest.url] }, deliverOn))?.cookies,
+                    writeCookie: async (cookie) => {
+                        const written = await cdp.send('Network.setCookie', cdpCookieParams(cookie), deliverOn);
+                        if (written?.success === false)
+                            throw new Error('cookie_refused');
+                    },
+                    fulfill: (response) => cdp.send('Fetch.fulfillRequest', { requestId: deliverTo, responseCode: response.status,
+                        responseHeaders: headerEntries(response.headers), body: Buffer.from(response.body).toString('base64') }, deliverOn),
+                    assertLive: () => attempt.assertLive(),
+                });
+            }
+            else if (replay.mode === 'hosted_form') {
                 // The device submitted the processor's own form; the processor
                 // answered the device. The paused NAVIGATION is fulfilled with a page
                 // that says exactly that (see hosted-form.ts for why not an abort and
@@ -1974,20 +2674,41 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 if (replay.kind === 'merchant_hosted')
                     await merchantTotal.release(replay, opts.vault, attempt.signal);
                 attempt.assertLive();
-                const postData = Buffer.from(cseContinuationBody(opts, deliverBody, replay, deliverRequest.url, preparation)).toString('base64');
+                // A Shiji STS getTokenId carries pan and expires only; the device's cvv
+                // is bound to its getCvvId companion before the continue, so the
+                // companion cannot arrive first, and dropped if the continue fails.
+                // Both go only to the request the approval was created from, from the
+                // frame that sent it (cseContinuation refuses any other body).
+                const continuation = cseContinuation(opts, deliverRequest.url, deliverBody, replay, { url: request.url, body }, preparation);
+                const postData = Buffer.from(continuation.body).toString('base64');
+                if (continuation.shijiCvv !== null) {
+                    shijiCompanions.bind({ url: request.url, method: request.method, body }, cdpShijiPage(sessionId, frameId), continuation.shijiCvv, continuation.shijiCvvKeySequences ?? []);
+                }
                 handoffStarted = true;
+                if (replay.kind === 'verifone') {
+                    // The merchant's own server answers a Verifone continuation, as a merchant-hosted one.
+                    merchantHandoff.begin(replay.profile, replay.authorizationId, verifoneTemplatedUrl(replay.profile, deliverRequest.url));
+                    handoffNetwork = { sessionId: activeRequest?.sourceSessionId ?? deliverOn, networkId: activeRequest?.networkId ?? '' };
+                }
                 if (replay.kind === 'merchant_hosted') {
                     // Watched from before the continue, so an answer that races the command is still read.
                     merchantHandoff.begin(replay.profile, replay.authorizationId, replayTemplatedUrl(replay, deliverRequest.url));
                     handoffNetwork = { sessionId: activeRequest?.sourceSessionId ?? deliverOn, networkId: activeRequest?.networkId ?? '' };
                     handoffReplay = replay;
                 }
-                await cdp.send('Fetch.continueRequest', {
-                    requestId: deliverTo,
-                    postData,
-                }, deliverOn);
+                try {
+                    await cdp.send('Fetch.continueRequest', {
+                        requestId: deliverTo,
+                        postData,
+                    }, deliverOn);
+                }
+                catch (error) {
+                    if (continuation.shijiCvv !== null)
+                        shijiCompanions.release();
+                    throw error;
+                }
                 attempt.assertLive();
-                opts.onEvent?.({ type: 'authorized', detail: cseAuthorizedDetail(replay, deliverRequest.url) });
+                opts.onEvent?.({ type: 'authorized', detail: cseAuthorizedDetail(replay, deliverRequest.url, continuation.shijiCvv) });
             }
             else {
                 // The processor's answer, handed to the page as if the processor had
@@ -1995,7 +2716,9 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 // see corsHeadersFor for why the answer has to carry the headers. The
                 // decision rides on the event, so a fulfill the page could not read
                 // (no usable Origin on a cross-origin request) is visible in telemetry
-                // rather than only as the page's own "connection error".
+                // rather than only as the page's own "connection error". A
+                // device_encrypt answer (Payrails' 201, which the device obtained) is
+                // handed over the same way.
                 const cors = corsDecision(deliverRequest.url, deliverRequest.headers);
                 await cdp.send('Fetch.fulfillRequest', {
                     requestId: deliverTo,
@@ -2003,10 +2726,20 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                     responseHeaders: headerEntries(withCorsHeaders(replay.headers, cors.headers)),
                     body: Buffer.from(replay.body).toString('base64'),
                 }, deliverOn);
+                // The frame that received it: the paused request's, or its retry's once rebound.
+                datatransRepeats.remember(activeRequest?.frameId || undefined, deliverRequest.url, deliverBody, replay);
                 attempt.assertLive();
-                opts.onEvent?.({ type: 'authorized', detail: { mode: 'token', authorizationId: replay.authorizationId, amountVerified: replay.amountVerified ?? null, cors: cors.outcome } });
+                // An ACI card-number request answered: its checkout's held CVC and expiry requests get the
+                // same answer, and its /payment submission may continue (see AciGate).
+                aci.answered(deliverRequest.url, { status: replay.status, headers: replay.headers, body: replay.body }, replay.authorizationId);
+                // An eProtect registration answered: a give-up report for it from here on means the
+                // vendor script stopped listening before the answer landed (see EprotectGate.gaveUp).
+                eprotect.delivered(deliverRequest.url, () => lifecycle.merchantRequestAborted());
+                opts.onEvent?.({ type: 'authorized', detail: { mode: replay.mode === 'device_encrypt' ? 'device_encrypt' : 'token', authorizationId: replay.authorizationId,
+                        amountVerified: replay.mode === 'device_encrypt' ? null : replay.amountVerified ?? null, cors: cors.outcome } });
             }
-            lifecycle.handedOff(replay);
+            if (handedOver)
+                lifecycle.handedOff(replay);
             businessPause?.delivered.resolve();
         }
         catch (err) {
@@ -2045,14 +2778,20 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                     terminal = err;
                 else if (isApprovalOutcome(err))
                     quietUntil = Date.now() + cooldownMs;
+                reportCardEndpointRefusal(opts, cardEndpoint, err);
                 opts.onEvent?.({ type: 'failed', detail: failureSummary(err) });
             }
-            await cdp.send('Fetch.failRequest', { requestId: dead.requestId, errorReason: cdpFailure(request.url) }, dead.sessionId).catch(() => { });
+            // A card form navigation ends on the stopped page: its card reached the merchant once the
+            // device approved (the merchant answered it) or the hand-off began; see failedNavigationRefusal.
+            await refusePaused(dead.requestId, dead.sessionId, request.url, cardEndpoint, failedNavigationRefusal(err, handoffStarted || approvedId !== null, approvedId ?? lifecycle.getState().authorizationId));
             settlePause();
         }
         finally {
+            disarmSendWindow?.();
             if (activeRequest?.attempt === attempt)
                 activeRequest = null;
+            aci.end();
+            eprotect.end();
             awaitingApproval = false;
             lifecycle.end();
             if (preparation)
@@ -2144,12 +2883,27 @@ export async function attachToPlaywright(page, opts) {
             return undefined;
         }
     };
+    // Juspay's tokenize answer and the synthetic tokens it issued (juspay-gate.ts).
+    const juspayCheckout = new JuspayCheckoutGate(opts.vault);
+    const aci = new AciGate(opts.vault);
+    let navigationBodyReplaced;
+    const eprotect = new EprotectGate(opts.vault);
     const readDocumentUrl = async () => {
         if (page.isClosed?.() || typeof page.url !== 'function')
             throw new Error('merchant_document_unavailable');
         return page.url();
     };
-    const preparationGate = new PreparationGate(opts, lifecycle, readDocumentUrl);
+    // prepare({ tokenizeBeforePay: true }) sends the card Microform whose fields are on the page now.
+    const preparationGate = new PreparationGate(opts, lifecycle, readDocumentUrl, () => {
+        let frames = [];
+        try {
+            frames = page.frames?.() ?? [];
+        }
+        catch {
+            frames = [];
+        }
+        return loadedCardMicroformFromUrls(frames.map(frameUrlOf));
+    });
     // A merchant-hosted request this attachment continued, and its answer; see watchPlaywrightHandoff.
     const merchantHandoff = new MerchantHandoffWatch(lifecycle, opts.onEvent);
     let handoffAnswer = null;
@@ -2160,6 +2914,8 @@ export async function attachToPlaywright(page, opts) {
     // but sends no document request, so it keeps the page id, as CDP's loaderId does. Nor does
     // a document request that commits nothing: one that failed, or one answered 204 or 205.
     const merchantTotal = new MerchantTotalWatch(opts.onEvent, opts.vault);
+    // A reviewed card endpoint merchant's own record of the order (card-endpoint-facts.ts).
+    const cardEndpointRecord = new CardEndpointFactsWatch();
     let documentSerial = 1;
     // The main frame's document request that no navigation has committed yet.
     let documentRequest = null;
@@ -2181,6 +2937,24 @@ export async function attachToPlaywright(page, opts) {
             return false;
         }
     };
+    // The Shiji STS getCvvId companion of the getTokenId this attachment last continued (shiji-sts.ts).
+    // Dropped, with the device's CVV ciphertext, as soon as no getCvvId can use it: a cancel, the page
+    // closing or crashing, the frame the bound getTokenId came from detaching, or that frame committing
+    // a new document (the handlers below).
+    const shijiCompanions = new ShijiStsCompanions();
+    lifecycle.abort.signal.addEventListener('abort', () => shijiCompanions.release(), { once: true });
+    // An answer to a request the facts watch records began to arrive: the watch orders what the page sent after a
+    // record by this moment, since Playwright reports the answer's end after the page's next request. Listened to only
+    // once the page sent such a request, so a page that never meets a merchant with facts carries no extra listener.
+    let factsAnswers = false;
+    const factsAnswer = (response) => {
+        try {
+            const key = keyOf(response.request());
+            if (cardEndpointRecord.tracks(key))
+                cardEndpointRecord.answered(key, response.status());
+        }
+        catch { /* a response the page already dropped */ }
+    };
     page.on?.('request', (request) => {
         // A new document is on its way: the main frame's next navigation commits it.
         if (mainDocument(request))
@@ -2191,6 +2965,16 @@ export async function attachToPlaywright(page, opts) {
                 ...(typeof body === 'string' ? { requestBody: body } : {}), page: `doc:${documentSerial}` });
         }
         catch { /* a request the page already dropped */ }
+        try {
+            cardEndpointRecord.sent(keyOf(request), { method: request.method(), url: request.url(),
+                resourceType: typeof request.resourceType === 'function' ? request.resourceType() : null });
+            // From the first request the watch records, it also hears when each answer begins to arrive (factsAnswer).
+            if (!factsAnswers && cardEndpointRecord.tracks(keyOf(request))) {
+                factsAnswers = true;
+                page.on?.('response', factsAnswer);
+            }
+        }
+        catch { /* a request the page already dropped */ }
     });
     page.on?.('requestfinished', (request) => {
         // A document answered 204 or 205 loads nothing, so no navigation will commit it.
@@ -2201,6 +2985,27 @@ export async function attachToPlaywright(page, opts) {
             }).catch(() => { });
         }
         const key = keyOf(request);
+        if (cardEndpointRecord.tracks(key)) {
+            const finishedAt = Date.now();
+            // Its place among the answers that finished, before its text is read: texts can come back out of order.
+            cardEndpointRecord.finished(key);
+            Promise.resolve().then(async () => {
+                const response = await request.response();
+                if (!response) {
+                    cardEndpointRecord.failed(key);
+                    return;
+                }
+                cardEndpointRecord.answered(key, response.status());
+                let text = null;
+                try {
+                    text = await response.text();
+                }
+                catch {
+                    text = null;
+                }
+                cardEndpointRecord.read(key, text, finishedAt);
+            }).catch(() => cardEndpointRecord.failed(key));
+        }
         if (!merchantTotal.log.tracks(key))
             return;
         const completedAt = Date.now();
@@ -2224,6 +3029,25 @@ export async function attachToPlaywright(page, opts) {
         }).catch(() => merchantTotal.log.failed(key));
     });
     const guards = paymentEndpointGuards(opts.paymentEndpoints);
+    // Payrails sessions this page's own XHR and fetch answers carried, read only
+    // when the synced registry pauses Payrails' save; see attachToCdp.
+    const payrails = recognizesPayrails(opts.vault) ? new PayrailsSessionCapture() : null;
+    if (payrails) {
+        page.on?.('response', (response) => {
+            try {
+                const headers = response.headers?.() ?? {};
+                if (!payrailsInitCandidate(response.request?.()?.resourceType?.(), response.status?.(), headers['content-type']))
+                    return;
+                if (Number(headers['content-length']) > PAYRAILS_INIT_BODY_LIMIT)
+                    return;
+                payrails.reading(Promise.resolve().then(() => response.text()).then((body) => {
+                    if (typeof body === 'string' && body.length <= PAYRAILS_INIT_BODY_LIMIT)
+                        payrails.observe(body);
+                }));
+            }
+            catch { /* an answer that cannot be read carries no session */ }
+        });
+    }
     // Playwright's own routing, NOT a hand-rolled CDP session.
     //
     // A CDPSession from `newCDPSession(page)` is bound to the PAGE target and its
@@ -2251,6 +3075,7 @@ export async function attachToPlaywright(page, opts) {
         if (request === documentRequest)
             documentRequest = null;
         merchantTotal.log.failed(keyOf(request));
+        cardEndpointRecord.failed(keyOf(request));
         if (activeRequest && activeRequest.request === request && activeRequest.attempt.lose()) {
             // The page's own script gave up on its request; the cardholder's
             // approval did not (see merchantAttempt). Forget the request's identity
@@ -2261,13 +3086,28 @@ export async function attachToPlaywright(page, opts) {
         }
     });
     page.on?.('close', () => { if (!attachmentReady)
-        setupStop.abort(new CheckoutAttachmentError('closed')); preparationGate.invalidate('merchant_document_closed'); stripeCheckout.invalidate(); mercadoCheckout.invalidate(); activeRequest?.attempt.stop(); handoffAnswer?.closed(); });
+        setupStop.abort(new CheckoutAttachmentError('closed')); preparationGate.invalidate('merchant_document_closed'); stripeCheckout.invalidate(); mercadoCheckout.invalidate(); activeRequest?.attempt.stop(); handoffAnswer?.closed(); shijiCompanions.release(); });
     page.on?.('crash', () => { if (!attachmentReady)
-        setupStop.abort(new CheckoutAttachmentError('closed')); preparationGate.invalidate('merchant_document_closed'); stripeCheckout.invalidate(); mercadoCheckout.invalidate(); activeRequest?.attempt.stop(); handoffAnswer?.closed(); });
+        setupStop.abort(new CheckoutAttachmentError('closed')); preparationGate.invalidate('merchant_document_closed'); stripeCheckout.invalidate(); mercadoCheckout.invalidate(); activeRequest?.attempt.stop(); handoffAnswer?.closed(); shijiCompanions.release(); });
     page.on?.('framenavigated', (frame) => {
         // A CyberSource Flex card field iframe loaded: start its capture-context check now, so its
         // card request pauses without waiting on it (cybersource-flex.ts).
         microformContexts.warm(frameUrlOf(frame));
+        // The bound getTokenId's frame navigated. history.pushState, a hash change and a navigation the
+        // page cancels keep its document; a new document replaces it. Read which, and drop the binding and
+        // the device's CVV ciphertext only when the frame holds another document now or cannot be read; a
+        // read still waiting on a pending navigation when the window closes keeps it (the binding expires
+        // with the window). A claim reads the document as well, so a getCvvId is judged the same way.
+        const boundPage = shijiCompanions.boundPage();
+        const shijiFrame = frame && typeof frame === 'object' ? playwrightShijiFrames.get(frame) : undefined;
+        if (boundPage && shijiFrame && boundPage.startsWith(`${shijiFrame}:doc:`)) {
+            void playwrightFrameDocument(frame).then((document) => {
+                if (document === undefined)
+                    return;
+                if (document === null || boundPage !== `${shijiFrame}:doc:${document}`)
+                    shijiCompanions.releasePage((page) => page === boundPage);
+            });
+        }
         if (frame === page.mainFrame?.()) {
             if (documentRequest) {
                 documentRequest = null;
@@ -2298,24 +3138,58 @@ export async function attachToPlaywright(page, opts) {
     page.on?.('framedetached', (frame) => {
         if (activeRequest?.frames.includes(frame))
             activeRequest.attempt.stop();
+        const gone = frame && typeof frame === 'object' ? playwrightShijiFrames.get(frame) : undefined;
+        if (gone)
+            shijiCompanions.releasePage((bound) => bound.startsWith(`${gone}:doc:`));
     });
     // The hosted form the cardholder already submitted; see HOSTED_FORM_REPEAT_QUIET_MS.
     const repeatQuietMs = opts.hostedFormRepeatQuietMs ?? HOSTED_FORM_REPEAT_QUIET_MS;
     let lastSubmitted = null;
+    // The approved Datatrans answers, per Frame: the repeat rule (datatrans.ts).
+    const datatransRepeats = new DatatransRepeats();
+    const frameOf = (request) => { try {
+        return request.frame?.() ?? undefined;
+    }
+    catch {
+        return undefined;
+    } };
     const install = async (assertActive) => {
         if (page.isClosed?.()) {
             const failure = new CheckoutAttachmentError('closed');
             setupStop.abort(failure);
             throw failure;
         }
-        await page.route((url) => opts.vault.isCardRequest(url.toString()) || guards.matches(url.toString()) || stripeCheckout.matches(url.toString()) || mercadoCheckout.matches(url.toString())
+        await page.route(
+        // The matcher sees only the URL. ACI's /payment and /registration are not the recognizer's URL,
+        // so the ACI gate routes them (never ACI's widget script, /bins or /v1/collect).
+        // The matcher sees only the URL. Worldpay eProtect's registration is a GET, so its family and
+        // the vendor's give-up reports are routed by the eProtect gate (never its scripts).
+        (url) => opts.vault.isCardRequest(url.toString()) || guards.matches(url.toString()) || stripeCheckout.matches(url.toString()) || mercadoCheckout.matches(url.toString())
+            || eprotect.matches(url.toString())
             // An armed merchant profile's endpoint or a sibling of it (merchant-hosted.ts), as attachToCdp arms it.
             || (typeof opts.vault.merchantProfileOf === 'function' && opts.vault.merchantProfileOf(url.toString()) !== null)
+            // An armed Verifone merchant's origin (verifone.ts), as attachToCdp arms it.
+            || (typeof opts.vault.verifoneProfileOf === 'function' && opts.vault.verifoneProfileOf(url.toString()) !== null)
             // GMO token v1's JSONP GET, routed only for an org the API served GMO to (see attachToCdp).
-            || (isGmoTokenV1Request(url.toString()) && recognizesGmo(opts.vault)), async (route) => {
+            || (isGmoTokenV1Request(url.toString()) && recognizesGmo(opts.vault))
+            || juspayCheckout.matches(url.toString())
+            // Every reviewed card endpoint, in any status (the pre-claim gate holds only a request that carries a card,
+            // and refuses one this build does not pay).
+            || cardEndpointFor(url.toString(), 'POST') !== null
+            // A request that sends the typed card to such a merchant again, refused in every status.
+            || cardEndpointResendFor(url.toString(), 'POST') !== null
+            || aci.matches(url.toString())
+            // Every Payrails host, routed only for an org the API served Payrails to (see attachToCdp).
+            || (payrails !== null && isPayrailsHost(url.toString()))
+            // Every request to an NMI host whose entry is served (ekashu.ts), as attachToCdp arms the
+            // host: the card page's post and its 3-D Secure calls reach the NMI gate and fail.
+            || isArmedEkashuUrl(opts.vault, url.toString()), async (route) => {
             const request = route.request();
             // When this request paused, and the page it came from: the merchant's total is read as of now.
             const pausedAt = Date.now();
+            // The frame and document a Shiji STS request came from, read as it pauses: an approved
+            // getTokenId's companion binding belongs to that document (playwrightShijiDocumentPage).
+            const shijiDocumentPage = isShijiStsHost(request.url()) ? playwrightShijiDocumentPage(request) : null;
             const pausedPage = merchantTotal.pageOf(keyOf(request)) ?? `doc:${documentSerial}`;
             // One pre-claim gate registry decides and performs the mechanics through
             // Playwright's own routing; the accessors read the same state the inline
@@ -2327,14 +3201,36 @@ export async function attachToPlaywright(page, opts) {
                 // headers() and postData() are read lazily, inside the gate that needs them (see
                 // PreClaimContext.request): a Playwright request mock without headers() and no Stripe checkout
                 // never invokes it, and a body Playwright cannot read stops a Mercado checkout the way it did inline.
-                request: { url: request.url(), method: request.method(), get headers() { return request.headers(); }, get body() { return request.postData(); } },
-                vault: opts.vault, guards, mercado: mercadoCheckout, stripe: stripeCheckout,
+                // postData() is null for no body, an empty one and a streamed upload alike; Payrails'
+                // gate refuses a null or empty body on every adapter, its static host aside (see payrailsPreClaim).
+                // At an armed Verifone merchant's origin a gate reads that null as '', a request with no body:
+                // in Chromium, Playwright hands over the bytes of a Blob, a File, a FormData and a large JSON
+                // body (measured on fetch, XMLHttpRequest and sendBeacon), so its null there is a request with no
+                // body in practice; a body Chromium keeps no bytes for, such as a stream, is the one left, and
+                // attachToCdp aborts it. Every other request's gate reads the null as it comes.
+                request: { url: request.url(), method: request.method(), get headers() { return request.headers(); },
+                    get body() {
+                        const body = request.postData();
+                        return body === null && typeof opts.vault.verifoneProfileOf === 'function' && opts.vault.verifoneProfileOf(request.url()) !== null ? '' : body;
+                    },
+                    get navigation() { try {
+                        return request.isNavigationRequest?.() === true;
+                    }
+                    catch {
+                        return false;
+                    } } },
+                vault: opts.vault, guards, mercado: mercadoCheckout, stripe: stripeCheckout, aci, eprotect,
+                // Asked once, and only for ACI's classic-mode /payment: whether this page's engine sends
+                // the body route.continue replaces on a navigation (aci.ts playwrightReplacesNavigationBody).
+                replacesNavigationBody: () => (navigationBodyReplaced ??= playwrightReplacesNavigationBody(page)),
                 readDocumentUrl, lifecycle, preparationGate, onEvent: opts.onEvent, failureSummary,
+                // Read only for a card endpoint whose page submits its form as a navigation (see attachToCdp).
+                navigation: async () => playwrightNavigation(request),
                 effects: {
                     continueRequest: (postData) => postData !== undefined ? route.continue({ postData }) : route.fallback(),
                     answer: (response) => route.fulfill({ ...response,
                         headers: withCorsHeaders(response.headers, corsHeadersFor(request.url(), request.headers())) }),
-                    abort: () => route.abort(refusedRequestFailure(request.url())),
+                    abort: () => route.abort(refusalFailure(request.url())),
                 },
                 attachmentReady: () => attachmentReady,
                 interceptionAborted: () => setupStop.signal.aborted,
@@ -2344,6 +3240,19 @@ export async function attachToPlaywright(page, opts) {
                 stripeAttachmentBusy: () => false,
                 requestInactive: () => !!(page.isClosed?.() || request.failure?.()),
                 awaitingApproval: () => awaitingApproval,
+                // The request's frame, then each parent up to the page's main frame; a request with no frame
+                // (a service worker's) has no chain.
+                initiatorFrames: () => {
+                    const urls = [];
+                    try {
+                        for (let frame = request.frame(); frame && urls.length < 64; frame = frame.parentFrame())
+                            urls.push(frame.url());
+                    }
+                    catch {
+                        return undefined;
+                    }
+                    return urls.length ? urls : undefined;
+                },
                 stripeStep: null,
                 // This route arrives after every answer the page read before sending it; only an unfollowed 3xx is left to settle.
                 merchantHandoff: { retried: (profile) => merchantHandoff.retried(profile, () => { handoffAnswer?.settle(); return false; }) },
@@ -2365,6 +3274,11 @@ export async function attachToPlaywright(page, opts) {
                         }
                         return judgeMicroformFrameUrls(flexRequest, frameUrlOf(issuing), frames.map(frameUrlOf), microformContexts);
                     } },
+                juspay: juspayCheckout,
+                datatrans: datatransRepeats,
+                frame: frameOf(request),
+                payrails,
+                shijiSts: { companions: shijiCompanions, page: async () => (await playwrightShijiDocumentPage(request)) ?? `pw:none:${++playwrightShijiSeq}` },
             });
             const preClaim = preClaimResult instanceof Promise ? await preClaimResult : preClaimResult;
             if (preClaim.kind !== 'pause')
@@ -2372,17 +3286,35 @@ export async function attachToPlaywright(page, opts) {
             const stripeStep = preClaim.stripeStep;
             // The capture context and fields a CyberSource Flex create carries, and its retry shape.
             const flexPause = preClaim.cybersourceFlex;
+            // A reviewed merchant's own card endpoint this build pays (see card-endpoint.ts), and
+            // for one whose page submits its form as a navigation, which frame it navigates.
+            const cardEndpoint = preClaim.cardEndpoint ?? null;
+            // A Payrails card save the gate bound to a captured session: its key rides on the create.
+            const payrailsSidecar = preClaim.payrails;
+            const cardNavigation = preClaim.navigation;
+            // A card form navigation is refused with the stopped page, anything else as refusalFailure says (see attachToCdp
+            // refusePaused).
+            const refuseRoute = (target, refusal) => (cardEndpoint && cardEndpoint.navigation !== null
+                ? target.fulfill(stoppedNavigationPage(cardEndpoint, refusal.outcome, refusal.reason, refusal.authorizationId))
+                : target.abort(refusalFailure(request.url())));
             if (!attachmentReady || setupStop.signal.aborted) {
                 opts.onEvent?.({ type: 'blocked', detail: 'checkout_interception_not_ready' });
-                return route.abort(refusedRequestFailure(request.url()));
+                return refuseRoute(route, heldNavigationRefusal(terminal, awaitingApproval, lifecycle));
             }
+            // Same order as attachToCdp: a routine card-free request continues in
+            // every state, before the preparation claim, so it neither spends a
+            // ready preparation nor counts as the page's first card request.
+            const continuationBody = request.postData();
+            const withoutCard = stripeStep ? null : opts.vault.withoutCard?.(request.url(), continuationBody, lifecycle.cardHandoffs()) ?? null;
+            if (withoutCard === 'continue')
+                return route.fallback();
             let preparation;
             try {
-                preparation = stripeStep ? undefined : preparationGate.claim(request.url(), request.postData() ?? '', request.headers());
+                preparation = stripeStep ? undefined : preparationGate.claim(request.url(), request.method(), request.postData() ?? '', request.headers());
             }
             catch (error) {
                 opts.onEvent?.({ type: 'blocked', detail: failureSummary(error) });
-                return route.abort(refusedRequestFailure(request.url()));
+                return route.abort(refusalFailure(request.url()));
             }
             // The page asking again for the purchase an outstanding approval is
             // for, after its own request timed out: bind it to that approval (see
@@ -2405,30 +3337,24 @@ export async function attachToPlaywright(page, opts) {
                     return;
                 }
             }
-            // Same order as attachToCdp: a routine card-free request continues in every state.
-            const continuationBody = request.postData();
-            const withoutCard = stripeStep ? null : opts.vault.withoutCard?.(request.url(), continuationBody) ?? null;
-            if (withoutCard === 'continue') {
-                if (preparation)
-                    preparationGate.retireUnboundClaim();
-                return route.fallback();
-            }
-            const continuationId = stripeStep || terminal ? null
+            const continuation = stripeStep || terminal ? null
                 : claimStripeContinuation(opts, lifecycle, request.url(), request.method(), continuationBody);
-            if (continuationId) {
+            if (continuation) {
                 if (preparation)
                     preparationGate.retireUnboundClaim();
-                if (await checkStripeContinuation(opts, lifecycle, continuationId, { url: request.url(), method: request.method(), headers: request.headers(), body: continuationBody }) && !setupStop.signal.aborted) {
-                    return route.fallback();
+                if (await checkStripeContinuation(opts, lifecycle, continuation, { url: request.url(), method: request.method(), headers: request.headers() }) && !setupStop.signal.aborted) {
+                    // As in attachToCdp: a rewritten card save continues with the allowed body; Playwright recomputes the length.
+                    return continuation.rewritten ? route.continue({ postData: continuation.body }) : route.fallback();
                 }
-                return route.abort('aborted');
+                return route.abort(refusalFailure(request.url()));
             }
             // Fail closed and stay quiet: no card may reach the PSP, but neither may
             // the page's retry loop turn into a stream of doomed API calls. Every
             // abort in this adapter is 'aborted' (ERR_ABORTED), and a CyberSource
             // Flex request's is 'failed' (refusedRequestFailure), the same codes the
             // CDP adapter's Fetch.failRequest uses, so a refused request resolves
-            // identically whichever adapter is attached.
+            // identically whichever adapter is attached. An Amadeus card request is
+            // 'failed' (ERR_FAILED) in both too, see failsAsNetworkError (refusalFailure).
             if (terminal || lifecycle.isBlocked() || awaitingApproval || Date.now() < quietUntil) {
                 let repeatedAuthorizationId = null;
                 if (lastSubmitted) {
@@ -2445,7 +3371,8 @@ export async function attachToPlaywright(page, opts) {
                 opts.onEvent?.({ type: 'blocked', detail: why instanceof Error ? failureSummary(why) : String(why) });
                 if (preparation)
                     preparationGate.retireUnboundClaim();
-                const refused = await route.abort(refusedRequestFailure(request.url()));
+                // As in attachToCdp: never that nothing was sent while a payment for this checkout may exist.
+                const refused = await refuseRoute(route, heldNavigationRefusal(terminal, awaitingApproval, lifecycle));
                 if (repeatedAuthorizationId)
                     void opts.vault.reportDuplicateGuard?.(repeatedAuthorizationId);
                 return refused;
@@ -2455,7 +3382,7 @@ export async function attachToPlaywright(page, opts) {
                 if (preparation)
                     preparationGate.retireUnboundClaim();
                 opts.onEvent?.({ type: 'blocked', detail: 'request_without_card' });
-                return route.abort('aborted');
+                return route.abort(refusalFailure(request.url()));
             }
             // Reserved before anything that could yield, matching attachToCdp.
             awaitingApproval = true;
@@ -2466,7 +3393,9 @@ export async function attachToPlaywright(page, opts) {
             catch {
                 navigation = false;
             }
-            const attempt = merchantAttempt(lifecycle, survivesAbandonment(opts, request.url(), request.method(), navigation, !!preparation || !!stripeStep || mercadoCheckout.requiresDocument(request.url(), request.method())));
+            // A card endpoint approval never outlives its request (see attachToCdp).
+            const attempt = merchantAttempt(lifecycle, survivesAbandonment(opts, request.url(), request.method(), navigation, !!preparation || !!stripeStep || !!cardEndpoint || mercadoCheckout.requiresDocument(request.url(), request.method())
+                || juspayCheckout.bindsApproval(request.url(), request.method())));
             const frames = [];
             try {
                 for (let frame = request.frame?.(); frame; frame = frame.parentFrame?.())
@@ -2487,28 +3416,40 @@ export async function attachToPlaywright(page, opts) {
             // The approval the device gave, and whether it reached a browser request.
             let approvedId = null;
             let deliveryBegun = false;
+            // A prepared Amadeus SDK add must be sent within its window (see amadeus.ts).
+            let disarmSendWindow = null;
             try {
                 const body = request.postData() ?? '';
                 if (isRepeatOfSubmitted(lastSubmitted, request.url(), body, repeatQuietMs)) {
                     opts.onEvent?.({ type: 'blocked', detail: HOSTED_FORM_REPEAT_REASON });
-                    const refused = await route.abort(refusedRequestFailure(request.url()));
+                    const refused = await route.abort(refusalFailure(request.url()));
                     if (lastSubmitted)
                         void opts.vault.reportDuplicateGuard?.(lastSubmitted.authorizationId);
                     return refused;
                 }
-                opts.onEvent?.({ type: 'card_request_paused', detail: { url: eventUrl(opts.vault, request.url()), recognizer: recognizerNameOf(opts, request.url(), request.method()) } });
+                // A card endpoint's events name the profile and the endpoint origin, never its URL (see attachToCdp).
+                opts.onEvent?.({ type: 'card_request_paused', detail: { ...(cardEndpoint ? cardEndpointDetail(cardEndpoint) : { url: eventUrl(opts.vault, request.url()) }),
+                        recognizer: recognizerNameOf(opts, request.url(), request.method()) } });
                 lifecycle.begin();
                 const approvalStartedAt = Date.now();
                 const payToInterceptMs = readPayToInterceptMs(opts.payClickedAt, approvalStartedAt);
                 attempt.bind({ route, request, frames });
                 activeRequest = { request, frames, attempt,
                     identity: requestIdentity(opts, request.url(), request.method(), body, undefined, undefined, flexPause?.shape) };
+                // An ACI card-number request: see the same step in attachToCdp.
+                if (!aci.begin(request.url(), request.method(), body, preparation?.merchantOrigin)) {
+                    throw new CheckoutPreparationError(preparation?.id ?? null, ACI_CHECKOUT_REUSED);
+                }
+                // A Worldpay eProtect registration: see the same step in attachToCdp.
+                eprotect.begin(request.url(), request.method(), () => attempt.stop());
+                disarmSendWindow = armWindowFor(opts, lifecycle, attempt, preparation, request.url(), () => deliveryBegun);
                 if (preparation)
                     await preparationGate.assertDocument();
                 // One bounded read serves the merchant origin and the retry identity; see attachToCdp.
                 const documentUrl = await documentUrlOf(readDocumentUrl, attempt.signal);
                 const pageOrigin = pageOriginFrom(documentUrl);
-                const pageAmount = await pageAmountOf(opts);
+                // The agent's amount is a card endpoint's only authority: no page total is read.
+                const pageAmount = cardEndpoint ? undefined : await pageAmountOf(opts);
                 assertRequestLive();
                 activeRequest.identity.documentUrl = documentKey(documentUrl);
                 activeRequest.identity.pageAmount = pageAmount;
@@ -2518,6 +3459,30 @@ export async function attachToPlaywright(page, opts) {
                 const merchantOrigin = preparation?.merchantOrigin ?? (opts.executionMode === 'user_approval'
                     ? opts.merchantOrigin : pageOrigin?.startsWith('https:') ? pageOrigin : opts.merchantOrigin);
                 assertRequestLive();
+                // The card endpoint's session (see attachToCdp): request.headers() never carries
+                // the cookie jar, so the endpoint's cookies are read from the context.
+                // A form inside an iframe is judged by the iframe's own document, where it was submitted, and
+                // a checkout in a frame the merchant's page embeds by that frame's own document.
+                let capturedOrigin = pageOrigin;
+                if (cardEndpoint?.navigation === 'frame') {
+                    try {
+                        capturedOrigin = pageOriginFrom(request.frame?.()?.url?.());
+                    }
+                    catch {
+                        capturedOrigin = undefined;
+                    }
+                }
+                else if (cardEndpoint?.checkout_frame) {
+                    capturedOrigin = pageOriginFrom(await documentUrlOf(async () => String(request.frame().url()), attempt.signal));
+                }
+                const session = cardEndpoint ? await captureCardEndpointSession(cardEndpoint, {
+                    url: request.url(), headers: request.headers(), body, pageOrigin: capturedOrigin, navigation: cardNavigation,
+                    cookies: async () => await page.context().cookies(request.url()),
+                }) : null;
+                assertRequestLive();
+                // The merchant's own record of the order, as of the pause (see attachToCdp).
+                const cardRecord = cardEndpoint ? await cardEndpointFacts(cardEndpointRecord, cardEndpoint, request.url(), pausedAt, attempt.signal) : null;
+                assertRequestLive();
                 const replay = await opts.vault.authorize({
                     user: opts.user,
                     merchant: opts.merchant,
@@ -2542,10 +3507,12 @@ export async function attachToPlaywright(page, opts) {
                         lifecycle.approvalUrl(url);
                         return opts.onApprovalUrl?.(url);
                     } },
-                    request: stripeStep?.phase === 'final' ? stripeStep.request : { url: request.url(), method: request.method(), headers: request.headers(), body,
-                        ...(mercadoCheckout.requiresDocument(request.url(), request.method())
-                            ? { mercado_checkout: mercadoCheckout.claimToken(request.url(), request.method(), await readDocumentUrl()) } : {}),
-                        ...(flexPause ? flexPause.sidecar : {}) },
+                    request: stripeStep?.phase === 'final' ? stripeStep.request : cardEndpoint && session ? cardEndpointRequest(cardEndpoint, session, cardRecord)
+                        : { url: request.url(), method: request.method(), headers: request.headers(), body,
+                            ...(mercadoCheckout.requiresDocument(request.url(), request.method())
+                                ? { mercado_checkout: mercadoCheckout.claimToken(request.url(), request.method(), await readDocumentUrl()) } : {}),
+                            ...(flexPause ? flexPause.sidecar : {}),
+                            ...(payrailsSidecar ? { payrails: payrailsSidecar } : {}) },
                 });
                 assertRequestLive();
                 approvedId = replay.authorizationId;
@@ -2570,7 +3537,17 @@ export async function attachToPlaywright(page, opts) {
                 attempt.beginDelivery();
                 lifecycle.prepareHandoff(replay, deliverRequest.url());
                 handoffStarted = replay.mode !== 'cse';
-                if (replay.mode === 'hosted_form') {
+                // False only for a card endpoint answer the device withheld (see deliverCardEndpointAnswer).
+                let handedOver = true;
+                if (replay.mode === 'card_endpoint') {
+                    handedOver = await deliverCardEndpointAnswer(opts, lifecycle, cardEndpoint, replay, { url: deliverRequest.url(), headers: deliverRequest.headers() }, {
+                        readJar: () => page.context().cookies(deliverRequest.url()),
+                        writeCookie: (cookie) => page.context().addCookies([playwrightCookieParams(cookie)]),
+                        fulfill: (response) => deliverTo.fulfill(response),
+                        assertLive: assertRequestLive,
+                    });
+                }
+                else if (replay.mode === 'hosted_form') {
                     // Same as the CDP path: the paused navigation resolves to the
                     // synthetic page, and a re-post of this form is refused.
                     const synthetic = hostedFormSubmittedPage({ authorizationId: replay.authorizationId, merchant: opts.merchant, submittedAt: replay.submittedAt });
@@ -2588,8 +3565,26 @@ export async function attachToPlaywright(page, opts) {
                     if (replay.kind === 'merchant_hosted')
                         await merchantTotal.release(replay, opts.vault, attempt.signal);
                     assertRequestLive();
-                    const postData = cseContinuationBody(opts, deliverBody, replay, deliverRequest.url(), preparation);
+                    // A Shiji STS getTokenId binds the device's cvv to its companion
+                    // first, exactly as in attachToCdp: only for the request the
+                    // approval was created from, and its frame.
+                    const continuation = cseContinuation(opts, deliverRequest.url(), deliverBody, replay, { url: request.url(), body }, preparation);
+                    if (continuation.shijiCvv !== null) {
+                        // The document the getTokenId paused in. One that cannot be read leaves the CVV nowhere to
+                        // go, so the card is not tokenized either.
+                        const boundPage = shijiDocumentPage ? await shijiDocumentPage : null;
+                        if (boundPage === null)
+                            throw new ShijiStsError('unsupported');
+                        assertRequestLive();
+                        shijiCompanions.bind({ url: request.url(), method: request.method(), body }, boundPage, continuation.shijiCvv, continuation.shijiCvvKeySequences ?? []);
+                    }
                     handoffStarted = true;
+                    if (replay.kind === 'verifone') {
+                        // The merchant's own server answers a Verifone continuation, as a merchant-hosted one.
+                        merchantHandoff.begin(replay.profile, replay.authorizationId, verifoneTemplatedUrl(replay.profile, deliverRequest.url()));
+                        handoffAnswer?.stop();
+                        handoffAnswer = watchPlaywrightHandoff(page, deliverRequest, merchantHandoff);
+                    }
                     if (replay.kind === 'merchant_hosted') {
                         merchantHandoff.begin(replay.profile, replay.authorizationId, replayTemplatedUrl(replay, deliverRequest.url()));
                         // Watched from before the continue: 5xx, a failure or the page closing is an unknown outcome.
@@ -2597,9 +3592,16 @@ export async function attachToPlaywright(page, opts) {
                         handoffAnswer?.stop();
                         handoffAnswer = watchPlaywrightHandoff(page, deliverRequest, merchantHandoff, () => merchantTotal.answered(replay, opts.vault));
                     }
-                    await deliverTo.continue({ postData });
+                    try {
+                        await deliverTo.continue({ postData: continuation.body });
+                    }
+                    catch (error) {
+                        if (continuation.shijiCvv !== null)
+                            shijiCompanions.release();
+                        throw error;
+                    }
                     assertRequestLive();
-                    opts.onEvent?.({ type: 'authorized', detail: cseAuthorizedDetail(replay, deliverRequest.url()) });
+                    opts.onEvent?.({ type: 'authorized', detail: cseAuthorizedDetail(replay, deliverRequest.url(), continuation.shijiCvv) });
                 }
                 else {
                     // Playwright adds these itself when a cross-origin fulfill carries
@@ -2607,10 +3609,17 @@ export async function attachToPlaywright(page, opts) {
                     // cross-origin answer is the same whichever adapter ran.
                     const cors = corsDecision(deliverRequest.url(), deliverRequest.headers());
                     await deliverTo.fulfill({ status: replay.status, headers: withCorsHeaders(replay.headers, cors.headers), body: replay.body });
+                    datatransRepeats.remember(frameOf(deliverRequest), deliverRequest.url(), deliverBody, replay);
                     assertRequestLive();
-                    opts.onEvent?.({ type: 'authorized', detail: { mode: 'token', authorizationId: replay.authorizationId, amountVerified: replay.amountVerified ?? null, cors: cors.outcome } });
+                    // See the same step in attachToCdp.
+                    aci.answered(deliverRequest.url(), { status: replay.status, headers: replay.headers, body: replay.body }, replay.authorizationId);
+                    // See the same step in attachToCdp.
+                    eprotect.delivered(deliverRequest.url(), () => lifecycle.merchantRequestAborted());
+                    opts.onEvent?.({ type: 'authorized', detail: { mode: replay.mode === 'device_encrypt' ? 'device_encrypt' : 'token', authorizationId: replay.authorizationId,
+                            amountVerified: replay.mode === 'device_encrypt' ? null : replay.amountVerified ?? null, cors: cors.outcome } });
                 }
-                lifecycle.handedOff(replay);
+                if (handedOver)
+                    lifecycle.handedOff(replay);
             }
             catch (err) {
                 const dead = attempt.target?.route ?? route;
@@ -2635,13 +3644,18 @@ export async function attachToPlaywright(page, opts) {
                         terminal = err;
                     else if (isApprovalOutcome(err))
                         quietUntil = Date.now() + cooldownMs;
+                    reportCardEndpointRefusal(opts, cardEndpoint, err);
                     opts.onEvent?.({ type: 'failed', detail: failureSummary(err) });
                 }
-                await dead.abort(refusedRequestFailure(request.url())).catch(() => { });
+                // As in attachToCdp: a card form navigation ends on the stopped page (failedNavigationRefusal).
+                await Promise.resolve().then(() => refuseRoute(dead, failedNavigationRefusal(err, handoffStarted || approvedId !== null, approvedId ?? lifecycle.getState().authorizationId))).catch(() => { });
             }
             finally {
+                disarmSendWindow?.();
                 if (activeRequest?.attempt === attempt)
                     activeRequest = null;
+                aci.end();
+                eprotect.end();
                 awaitingApproval = false;
                 lifecycle.end();
                 if (preparation)