@agent-cards/sdk 0.23.19 → 0.23.21

package/dist/cdp.js

@@ -1,5 +1,5 @@
 import { BUILTIN_REGISTRY, cardUrlPatterns } from './registry.js';
-import { AdyenTestPlatformRefusedError, AmountRequiredError, ApprovalDeclinedError, ApprovalTimeoutError, CardEncryptedError, CheckoutApiError, CheckoutCancelledError, CheckoutPreparationError, MerchantTotalError, PaymentOutcomeUnknownError, PreparationRequiredError, ProcessorRefusedError, UnsupportedCapabilityError, UnsupportedModeError, } from './client.js';
+import { AdyenTestPlatformRefusedError, AmountRequiredError, ApprovalDeclinedError, ApprovalTimeoutError, CardEncryptedError, CheckoutApiError, CheckoutCancelledError, CheckoutPreparationError, MerchantTotalError, PaymentOutcomeUnknownError, PreparationRequiredError, ProcessorRefusedError, UnsupportedCapabilityError, UnsupportedModeError, redactUrl, } from './client.js';
 import { PreparationGate } from './preparation.js';
 import { preparedApprovalAnswersRetry } from './prepared-processor.js';
 import { StripeCheckoutGate } from './stripe-checkout.js';
@@ -8,15 +8,21 @@ 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, classifyEprotectRequest, eprotectScriptAnswer } from './eprotect.js';
-import { dispatchPreClaim, eventUrl, isArmedCreditguardCall } from './pre-claim.js';
+import { dispatchPreClaim, eventUrl, isArmedCreditguardCall, routesHipayVault } from './pre-claim.js';
 import { GMO_TOKEN_V1_PATTERNS, gmoRequestShop, isGmoTokenV1Request, recognizesGmo } from './gmo.js';
 import { isPaddleVgsCardsUrl } from './paddle-vgs.generated.js';
 import { PADDLE_VGS_PAY_PATTERNS, PaddleVgsPayGate, isPaddleCheckoutService, recognizesPaddleVgs } from './paddle-vgs-pay.js';
 import { DatatransRepeats } from './datatrans.js';
+import { TokenexIframeRepeats, isArmedTokenexIframeUrl } from './tokenex-iframe.js';
 import { SHIJI_STS_COMPANION_WINDOW_MS, ShijiStsCompanions, ShijiStsError, isShijiStsHost, shijiStsTokenContinuation, } from './shiji-sts.js';
 import { paddleTokenexTokenContinuation } from './paddle-tokenex.js';
+import { twoC2pContinuation, twoC2pRetire } from './twoc2p.js';
 import { isArmedEkashuUrl } from './ekashu.js';
+import { isArmedTransbankUrl } from './transbank.js';
 import { isArmedRedsysUrl } from './redsys.js';
+import { isArmedPrzelewy24Url } from './przelewy24.js';
+import { isArmedQuickpayUrl } from './quickpay.js';
+import { COMGATE_CARD_PATTERNS, isArmedComgateUrl, servesComgate } from './comgate.js';
 import { PAYPAL_HOSTED_FIELDS_PATTERNS, isPaypalHostedFieldsConfirm } from './paypal-hosted-fields.js';
 import { EBANX_RESEND_PATTERNS, EbanxFollowUps, isEbanxResendUrl } from './ebanx.js';
 import { PAYPAL_CARD_FORM_PATTERNS, isPaypalCardFormUrl } from './paypal-card-forms.js';
@@ -30,6 +36,7 @@ import { MerchantHandoffWatch } from './merchant-handoff.js';
 import { MERCHANT_PAGE_WAIT_MS, MerchantTotalWatch } from './merchant-total-watch.js';
 import { hostedFormSubmittedPage } from './hosted-form.js';
 import { armSendWindow, failsAsNetworkError, preparedSendWindowMs, sendWindowProcessor } from './amadeus.js';
+import { HoldAnsweredError, HoldEndedError, HoldGate, HoldRefusedError, matchHoldOnlyRule } from './hold.js';
 import { CheckoutLifecycle, paymentEndpointGuards } from './lifecycle.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, cardEndpointNavigationAnswer, cardEndpointPatterns, cardEndpointRouted, } from './card-endpoint.js';
@@ -99,13 +106,22 @@ function isExtensionWorker(type, url) {
  * A different, explicitly identified context belongs to another checkout.
  * An extension's own worker owns no merchant request and does not count.
  */
-function assertContextTarget(target, merchantContext) {
+function assertContextTarget(target, merchantContext, allow = {}) {
     if (!targetRecord(target))
         throw new CheckoutAttachmentError('unavailable');
     if (contextId(target.browserContextId) && target.browserContextId !== merchantContext)
         return;
     if (isExtensionWorker(target.type, target.url))
         return;
+    const knownContext = target.browserContextId === undefined || contextId(target.browserContextId);
+    // Every armed frame sends its requests past the site's service workers (Network.setBypassServiceWorker), so a
+    // worker in the merchant's context can no longer send a card request out of the interception's reach.
+    if (allow.serviceWorkers && target.type === 'service_worker' && knownContext)
+        return;
+    // A shared worker's own requests pause nowhere (Fetch does not reach them), so it is watched instead: its Network
+    // reports are read, and a card request seen there ends the checkout before anything is approved (sharedWorkers).
+    if (allow.sharedWorkers && target.type === 'shared_worker' && knownContext)
+        return;
     if (!['page', 'iframe', 'worker', 'browser_ui'].includes(target.type)
         || (target.browserContextId !== undefined && !contextId(target.browserContextId))) {
         throw new CheckoutAttachmentError('unavailable');
@@ -203,6 +219,9 @@ function isApprovalOutcome(err) {
 function isTerminal(err) {
     if (err instanceof CheckoutApiError)
         return err.permanent;
+    // A hold's decision is final for the attachment: every later card request fails at once.
+    if (err instanceof HoldEndedError || err instanceof HoldAnsweredError)
+        return true;
     // 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';
@@ -350,6 +369,16 @@ function cseContinuation(opts, url, body, replay, approved, preparation) {
     const paddleTokenex = replay.kind === undefined ? paddleTokenexTokenContinuation(url, body, replay.substitutions, replay.paddleTokenexFacts, approved) : null;
     if (paddleTokenex)
         return { body: paddleTokenex.body, shijiCvv: null, shijiCvvKeySequenceSha256: null };
+    // 2C2P writes one card field under its pinned key, which the generic Adyen swap refuses as no JWE, so it is
+    // dispatched by the Payment URL to substituteTwoC2p (twoc2p.ts), only into the one Payment the approval was made for.
+    // A refusal there sent the field nowhere, so the approval is retired as merchant_never_retried, as a merchant-hosted
+    // one is (cseContinuationBody), and the API stops serving the field; a retirement the API does not confirm is
+    // reported as approval_retire_unconfirmed (twoc2p.ts twoC2pRetire).
+    const twoc2p = replay.kind === undefined
+        ? twoC2pContinuation(url, body, replay.substitutions, approved, twoC2pRetire(opts.vault, replay.authorizationId, opts.onEvent))
+        : null;
+    if (twoc2p)
+        return { body: twoc2p.body, shijiCvv: null, shijiCvvKeySequenceSha256: null };
     return { body: cseContinuationBody(opts, body, replay, url, preparation), shijiCvv: null, shijiCvvKeySequenceSha256: null };
 }
 /**
@@ -1388,7 +1417,7 @@ function merchantAttempt(lifecycle, survives) {
     // 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' || reason === 'secure_acceptance_send_window_closed'
-        || reason === 'wix_payments_send_window_closed'
+        || reason === 'wix_payments_send_window_closed' || reason === 'hipay_send_window_closed'
         ? new CheckoutPreparationError(lifecycle.getState().preparationId ?? null, reason)
         : new PaymentOutcomeUnknownError(lifecycle.getState().authorizationId, reason);
     const attempt = {
@@ -1549,6 +1578,35 @@ function replayOf(result, timeoutMs) {
     return { mode: 'token', authorizationId, status: response.status, headers: { ...response.headers }, body: response.body, amountVerified: null,
         ...(result.processor_context !== undefined ? { processorContext: result.processor_context } : {}), ...execution };
 }
+/** A CDP Fetch url pattern (`*` any run of characters, `?` one, `\\` escapes) against a URL. */
+function urlPatternMatches(pattern, url) {
+    let re = '';
+    for (let i = 0; i < pattern.length; i++) {
+        const c = pattern[i];
+        if (c === '\\' && i + 1 < pattern.length) {
+            re += pattern[++i].replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            continue;
+        }
+        re += c === '*' ? '.*' : c === '?' ? '.' : c.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    try {
+        return new RegExp(`^${re}$`).test(url);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Wait for the hold's decision on a request; the request going away (its attempt stopped) ends the hold as lost,
+ * which rejects the decision.
+ */
+function holdUntilDecided(decision, signal, lost) {
+    if (signal.aborted)
+        lost();
+    else
+        signal.addEventListener('abort', lost, { once: true });
+    return decision.finally(() => signal.removeEventListener('abort', lost));
+}
 /**
  * Worldpay eProtect's registration, resumed by the business. The read carries the registration as the API
  * stored it, bare JSON, and the paused request is the vendor's JSONP <script>, which runs its answer and reads
@@ -1688,12 +1746,16 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
     opts = safeOptions(opts);
     if (opts.pauseOnly && typeof opts.onPaused !== 'function')
         throw new Error('pauseOnly needs onPaused: the business receives the paused request there and answers it with controller.resume.');
+    if (opts.pauseOnly && opts.hold)
+        throw new Error('hold and pauseOnly are two different pauses: attach with one of them.');
     const setupTimeoutMs = attachmentDeadline(opts.attachmentTimeoutMs);
     const setupStop = new AbortController();
     let attachmentReady = false;
     let setupFailureReported = false;
     const ownedSessions = new Set([pageSessionId]);
     const sessionTypes = new Map([[pageSessionId, 'page']]);
+    // Each window this attachment adopted (adoptOpenedWindow): its session, and its target's id, which is its main frame's.
+    const windowTargets = new Map();
     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.
@@ -1749,6 +1811,23 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
     // The page target's id, which is its main frame's id; read once the attachment is set up.
     let pageTargetId;
     const lifecycle = new CheckoutLifecycle(opts);
+    // Hold mode: the first card request is held with nothing created until controller.release or cancel (hold.ts).
+    const holdGate = opts.hold ? new HoldGate(typeof opts.hold === 'object' ? opts.hold : {}, opts.vault?.sandbox === true, (type, detail) => opts.onEvent?.({ type, detail })) : null;
+    if (holdGate) {
+        lifecycle.setHold(holdGate);
+        lifecycle.abort.signal.addEventListener('abort', () => { void holdGate.cancel('checkout_cancelled'); }, { once: true });
+    }
+    // The hold-only request (Bolt's tokenizer, a placeholder post) held now, by its Network id, so the page giving it up ends the hold.
+    let holdOnlyNetworkId = null;
+    const bypassServiceWorkers = (opts.serviceWorkers ?? (holdGate ? 'bypass' : 'refuse')) === 'bypass';
+    const sharedWorkerMode = opts.sharedWorkers ?? (holdGate ? 'accept' : 'refuse');
+    const observeSharedWorkers = sharedWorkerMode === 'observe';
+    const targetAllowance = { serviceWorkers: bypassServiceWorkers, sharedWorkers: sharedWorkerMode !== 'refuse' };
+    // Shared workers being watched: their target ids (claimed before the attach answers) and their sessions.
+    const watchedWorkerTargets = new Set();
+    const watchedWorkerSessions = new Set();
+    // The watches still starting, by target id: a later report of the worker waits for its watch, and so does the attachment.
+    const workerWatches = new Map();
     const stripeCheckout = new StripeCheckoutGate(opts);
     const mercadoCheckout = new MercadoCheckoutGate();
     // CyberSource Flex card field iframes and their capture contexts, recorded from the CDP
@@ -1801,6 +1880,20 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
         preparationFrameId = tree.frameTree.frame.id;
         return tree.frameTree.frame.url;
     };
+    // The URL the page's main frame last committed: its target's URL when the attachment is set up, then kept from
+    // Page.frameNavigated and Page.navigatedWithinDocument, and from the page target's own reports (notePageTarget),
+    // which name a document the page commits before this attachment has enabled its Page events. Chromium leaves
+    // Page.getFrameTree unanswered on the page's session while that session's own top-level navigation is paused (a
+    // hosted page entry the page sends this window to, by script or through the merchant's redirect), so
+    // readDocumentUrl would wait out its bound and the create would name no checkout page. For that one paused request
+    // the page is still the document it last committed.
+    let committedTopUrl;
+    /** A TargetInfo of the page's own target names the URL the page last committed: the target list, and each report. */
+    const notePageTarget = (info) => {
+        if (pageTargetId !== undefined && info?.targetId === pageTargetId && info?.type === 'page' && typeof info.url === 'string' && info.url) {
+            committedTopUrl = info.url.split('#')[0];
+        }
+    };
     // 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
@@ -1835,7 +1928,8 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
         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 };
+        return { navigation: frame.parentId || (sessionId !== pageSessionId && !(sessionId && windowTargets.has(sessionId))) ? 'frame' : 'top',
+            url: typeof frame.url === 'string' ? frame.url : undefined };
     };
     /**
      * Which frame a paused document request navigates, as documentFrame reads it, without the frame tree where
@@ -1851,6 +1945,9 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             return 'frame';
         if (sessionId === pageSessionId && pageTargetId !== undefined && frameId === pageTargetId)
             return 'top';
+        // An adopted window's main frame is that window's own top-level document, and its frame tree is as unanswered.
+        if (sessionId && windowTargets.get(sessionId) === frameId)
+            return 'top';
         return (await documentFrame(sessionId, frameId))?.navigation ?? null;
     };
     /**
@@ -2044,6 +2141,9 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
     let lastSubmitted = null;
     // The approved Datatrans answers, per frameId: the repeat rule (datatrans.ts).
     const datatransRepeats = new DatatransRepeats();
+    // The approved TokenEx iframe answers, per frameId (the card-number frame is an out-of-process iframe whose own
+    // session pauses its post; its frameId names it): the repeat rule (tokenex-iframe.ts).
+    const tokenexIframeRepeats = new TokenexIframeRepeats();
     // The card product each Worldline MyCheckout hosted checkout chose (worldline-mycheckout.ts).
     const worldlineProducts = new WorldlineMyCheckoutProducts();
     // The Shiji STS getCvvId companion of the getTokenId this attachment last continued (shiji-sts.ts).
@@ -2088,11 +2188,17 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
     // EBANX's 3-D Secure calls and hosted confirm, which send the typed card again
     // after its token: the cardholder's device sends one the approved token request
     // covers, and any other is refused (see ebanx.ts).
+    // ComGate's card hosts are armed only for an org the API served ComGate to, so the
+    // gate can fail every card post there while the gateway link pauses (see comgate.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 : []), ...juspayCheckout.urlPatterns(), ...cardEndpointPatterns(),
             ...(payrails ? PAYRAILS_GUARD_PATTERNS : []), ...PAYPAL_HOSTED_FIELDS_PATTERNS, ...PAYPAL_CARD_FORM_PATTERNS,
-            ...CYBERSOURCE_SECURE_ACCEPTANCE_PATTERNS, ...(recognizesPaddleVgs(opts.vault) ? PADDLE_VGS_PAY_PATTERNS : []), ...EBANX_RESEND_PATTERNS])];
+            ...CYBERSOURCE_SECURE_ACCEPTANCE_PATTERNS, ...(recognizesPaddleVgs(opts.vault) ? PADDLE_VGS_PAY_PATTERNS : []), ...EBANX_RESEND_PATTERNS,
+            ...(servesComgate(opts.vault) ? COMGATE_CARD_PATTERNS : [])])];
+    // The hold-only rules' patterns (Bolt's tokenizer; every request a placeholder card can ride, by resource type).
+    const fetchPatterns = [...urlPatterns.map((urlPattern) => ({ urlPattern, requestStage: 'Request' })),
+        ...(holdGate ? holdGate.patterns().map((p) => ({ ...p, requestStage: 'Request' })) : [])];
     const arm = async (sessionId, resume = false, worker = false) => {
         const key = sessionId ?? '__root__';
         if (armed.has(key))
@@ -2109,6 +2215,12 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             };
             await cdp.send('Network.enable', {}, sessionId);
             assertActive();
+            // Requests skip the site's service workers, so every one stays in this frame's Fetch interception. Required:
+            // a frame that cannot bypass them is not armed.
+            if (bypassServiceWorkers && !worker) {
+                await cdp.send('Network.setBypassServiceWorker', { bypass: true }, sessionId);
+                assertActive();
+            }
             // Worker Fetch does not exist in Chrome. Its requests pause on the owning
             // frame, but its abort/finish events arrive on the worker Network session.
             // Keep that session attached and paused until Network is listening, then
@@ -2116,9 +2228,7 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             if (!worker) {
                 await cdp.send('Page.enable', {}, sessionId).catch(() => { });
                 assertActive();
-                await cdp.send('Fetch.enable', {
-                    patterns: urlPatterns.map((urlPattern) => ({ urlPattern, requestStage: 'Request' })),
-                }, sessionId);
+                await cdp.send('Fetch.enable', { patterns: fetchPatterns }, sessionId);
                 assertActive();
             }
             // Descend into this target's own children (iframes inside iframes).
@@ -2147,6 +2257,56 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             arming.delete(key);
         }
     };
+    /**
+     * Watch a shared worker of the merchant's context (sharedWorkers 'observe'): attach to it from the browser root,
+     * read its Network reports, and release it. Its requests cannot be paused, so a card request seen there ends the
+     * checkout (see the Network.requestWillBeSent handler). A worker that cannot be watched ends it too.
+     */
+    const watchSharedWorker = async (target) => {
+        if (sharedWorkerMode === 'refuse' || typeof target?.targetId !== 'string')
+            return;
+        // Chrome reports every existing target (Target.targetCreated) before it answers setDiscoverTargets, so that
+        // report starts the watch: the attachment's own pass over the targets waits for it rather than passing it by.
+        const starting = workerWatches.get(target.targetId);
+        if (starting)
+            return starting;
+        if (watchedWorkerTargets.has(target.targetId))
+            return;
+        if (contextId(target.browserContextId) && target.browserContextId !== merchantContext)
+            return;
+        watchedWorkerTargets.add(target.targetId);
+        if (!observeSharedWorkers) {
+            opts.onEvent?.({ type: 'shared_worker_unwatched', detail: { scheme: String(target.url ?? '').split(':')[0] || null } });
+            return;
+        }
+        const watch = (async () => {
+            const { sessionId: workerSession } = await cdp.send('Target.attachToTarget', { targetId: target.targetId, flatten: true });
+            if (typeof workerSession !== 'string' || !workerSession)
+                throw new CheckoutAttachmentError('unavailable');
+            watchedWorkerSessions.add(workerSession);
+            rejectedSessions.add(workerSession);
+            await cdp.send('Network.enable', {}, workerSession);
+            await cdp.send('Runtime.runIfWaitingForDebugger', {}, workerSession).catch(() => { });
+            opts.onEvent?.({ type: 'shared_worker_watched', detail: { scheme: String(target.url ?? '').split(':')[0] || null } });
+        })().catch((error) => failInterception(error instanceof CheckoutAttachmentError ? error : new CheckoutAttachmentError('unavailable')))
+            .finally(() => workerWatches.delete(target.targetId));
+        workerWatches.set(target.targetId, watch);
+        return watch;
+    };
+    /** A card request a watched shared worker sent: it could not be held, so nothing may be approved from here on. */
+    const sharedWorkerCardRequest = (request) => {
+        const url = typeof request?.url === 'string' ? request.url : '';
+        const method = typeof request?.method === 'string' ? request.method : 'GET';
+        if (!url)
+            return false;
+        if (typeof opts.vault?.isCardRequest === 'function' && opts.vault.isCardRequest(url, method))
+            return true;
+        if (!holdGate)
+            return false;
+        const body = typeof request.postData === 'string' ? request.postData : request.hasPostData ? null : '';
+        // A body too large to ride the report is read as a card request only by its address (Bolt's tokenizer).
+        return !!matchHoldOnlyRule({ url, method, body: body ?? '' }, holdGate.rules) || (body === null && !!matchHoldOnlyRule({ url, method, body: '' }, holdGate.rules.filter((r) => !r.body)));
+    };
     const failInterception = (error) => {
         if (setupFailureReported)
             return;
@@ -2164,6 +2324,55 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
         lifecycle.failed(new PaymentOutcomeUnknownError(lifecycle.getState().authorizationId, 'browser_interception_unavailable'));
         opts.onEvent?.({ type: 'failed', detail: 'browser_interception_unavailable' });
     };
+    /**
+     * A window the merchant's page opened (window.open, or a form or link aimed at a new window), or one such a window
+     * opened in turn, in the merchant's own browser context: it belongs to this checkout, so it is attached and armed
+     * as the page is, and its requests reach the same gates. Chromium reports the window (Target.targetCreated, with its
+     * openerId) as it starts, and the page session's auto-attach never covers a new page target. The attach races the
+     * window's first request: a window that opens on the merchant's page and is sent on to a hosted page by script or
+     * by the merchant's redirect is armed before that entry; a window opened straight onto a hosted page can load it
+     * first, as every window did before. A window reported while this attachment still arms the page waits in
+     * pendingWindows and is adopted once the page is armed, inside the setup deadline and before the attachment reports
+     * ready, its opener judged then, so a window that window opened is adopted after it. A window that is gone before it
+     * could be attached was never armed, as before; one attached but not armed fails the attachment, as a frame does.
+     */
+    const openedWindows = new Set();
+    const pendingWindows = [];
+    const adoptOpenedWindow = async (info, duringSetup = false) => {
+        if (!info || info.type !== 'page' || typeof info.targetId !== 'string' || !info.targetId || info.targetId === pageTargetId
+            || openedWindows.has(info.targetId) || info.browserContextId !== merchantContext)
+            return;
+        if (setupStop.signal.aborted)
+            return;
+        if (!attachmentReady && !duringSetup) {
+            pendingWindows.push(info);
+            return;
+        }
+        if (typeof info.openerId !== 'string' || !(info.openerId === pageTargetId || openedWindows.has(info.openerId)))
+            return;
+        openedWindows.add(info.targetId);
+        let child;
+        try {
+            child = (await cdp.send('Target.attachToTarget', { targetId: info.targetId, flatten: true }))?.sessionId;
+        }
+        catch {
+            return;
+        }
+        try {
+            if (typeof child !== 'string' || !child || ownedSessions.has(child) || detachedSessions.has(child) || rejectedSessions.has(child)) {
+                throw new CheckoutAttachmentError('unavailable');
+            }
+            ownedSessions.add(child);
+            sessionTypes.set(child, 'page');
+            sessionParents.set(child, pageSessionId);
+            windowTargets.set(child, info.targetId);
+            await arm(child);
+            opts.onEvent?.({ type: 'window_armed', detail: {} });
+        }
+        catch (error) {
+            failInterception(error);
+        }
+    };
     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
@@ -2174,14 +2383,28 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             shijiCompanions.releasePage((page) => page === replaced);
         }
         if ((method === 'Target.targetCreated' || method === 'Target.targetInfoChanged') && targetContextKnown) {
+            // The page's own target reports each document it commits from discovery on, Page events or not.
+            notePageTarget(params?.targetInfo);
             try {
-                assertContextTarget(params?.targetInfo, merchantContext);
+                assertContextTarget(params?.targetInfo, merchantContext, targetAllowance);
+                if (params?.targetInfo?.type === 'shared_worker')
+                    void watchSharedWorker(params.targetInfo);
             }
             catch (error) {
                 failInterception(error);
             }
+            if (method === 'Target.targetCreated')
+                await adoptOpenedWindow(params?.targetInfo);
             return;
         }
+        // The page's main frame committed a document, or moved within it: the URL a held top-level navigation leaves.
+        if (sessionId === pageSessionId && method === 'Page.frameNavigated' && !params.frame?.parentId && typeof params.frame?.url === 'string') {
+            committedTopUrl = params.frame.url;
+        }
+        if (sessionId === pageSessionId && method === 'Page.navigatedWithinDocument' && pageTargetId !== undefined
+            && params?.frameId === pageTargetId && typeof params?.url === 'string') {
+            committedTopUrl = params.url.split('#')[0];
+        }
         if (((method === 'Page.frameNavigated' && !params.frame?.parentId) || (method === 'Page.navigatedWithinDocument' && preparationFrameId && params.frameId === preparationFrameId)) && sessionId === pageSessionId) {
             preparationGate.invalidate('merchant_document_changed');
             mercadoCheckout.invalidate();
@@ -2203,6 +2426,7 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             || (method === 'Target.detachedFromTarget' && params.sessionId === pageSessionId)) {
             detachedSessions.add(pageSessionId);
             setupStop.abort(new CheckoutAttachmentError('closed'));
+            holdGate?.close();
             preparationGate.invalidate('merchant_document_closed');
             stripeCheckout.invalidate();
             mercadoCheckout.invalidate();
@@ -2218,6 +2442,20 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             if (handoffNetwork)
                 merchantHandoff.failed();
         }
+        // A watched shared worker sent a card request: it went out unpaused, so nothing is approved from here on.
+        if (method === 'Network.requestWillBeSent' && sessionId && watchedWorkerSessions.has(sessionId) && sharedWorkerCardRequest(params?.request)) {
+            // Origin and path as redactUrl reads them, so a credential a processor writes into the path never shows.
+            let endpoint = '';
+            try {
+                new URL(params.request.url);
+                endpoint = redactUrl(params.request.url);
+            }
+            catch { /* unreadable */ }
+            opts.onEvent?.({ type: 'card_request_unwatched', detail: { endpoint, from: 'shared_worker' } });
+            void holdGate?.cancel('card_request_unwatched');
+            failInterception(new CheckoutAttachmentError('unavailable'));
+            return;
+        }
         // The transport is browser-scoped. A second tab's request or child target
         // must never be authorized with this page's merchant, amount or preparation.
         if (!sessionId || !ownedSessions.has(sessionId))
@@ -2325,6 +2563,10 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             return;
         }
         if (method === 'Network.loadingFailed') {
+            // The held request given up by the page (its own timeout) or failed by the hold itself: nothing was sent.
+            if (holdGate && holdGate.state === 'held' && ((holdOnlyNetworkId && params.requestId === holdOnlyNetworkId)
+                || (activeRequest && activeRequest.networkId === params.requestId && activeRequest.sourceSessionId === sessionId)))
+                holdGate.lost();
             merchantTotal.log.failed(requestKey(sessionId, params.requestId));
             const recordKey = cardEndpointRecord.keyFor(requestKey(sessionId, params.requestId), params.requestId);
             if (recordKey)
@@ -2414,6 +2656,13 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
         }
         if (method === 'Target.attachedToTarget') {
             const child = params.sessionId;
+            if (params?.targetInfo?.type === 'shared_worker' && watchedWorkerTargets.has(params.targetInfo.targetId)) {
+                if (typeof child === 'string' && child) {
+                    watchedWorkerSessions.add(child);
+                    rejectedSessions.add(child);
+                }
+                return;
+            }
             if (rejectedSessions.has(child))
                 return;
             // A browser-root transport can report another context through an owned
@@ -2437,6 +2686,13 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             }
             if (setupStop.signal.aborted)
                 return;
+            // A service worker the page's frames bypass: released from its debugger wait and left alone, never owned.
+            if (bypassServiceWorkers && params.targetInfo?.type === 'service_worker' && typeof child === 'string' && child
+                && child !== pageSessionId && !ownedSessions.has(child)) {
+                rejectedSessions.add(child);
+                await cdp.send('Runtime.runIfWaitingForDebugger', {}, child).catch(() => { });
+                return;
+            }
             // CDP may omit the context ID for ordinary children; keep those attached.
             try {
                 if (typeof child !== 'string' || !child || !['page', 'iframe', 'worker'].includes(params.targetInfo?.type)) {
@@ -2477,9 +2733,50 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
         const { requestId, request, resourceType, networkId, frameId } = params;
         // When this request paused: the merchant's total is read as of this moment.
         const pausedAt = Date.now();
+        // The page's own top-level navigation, paused: its frame tree cannot be read until this request is decided, so its
+        // document is the one it last committed (committedTopUrl). Every other request reads the frame tree as before.
+        const readPausedDocument = resourceType === 'Document' && sessionId === pageSessionId && pageTargetId !== undefined
+            && frameId === pageTargetId && committedTopUrl !== undefined ? async () => committedTopUrl : readDocumentUrl;
         // A paused document request has not committed either: it only starts the context's check.
         if (resourceType === 'Document')
             microforms.warm(withFragment(request));
+        // Hold mode: a card request no recogniser pays (Bolt's sealed tokenizer, a body carrying the placeholder card) is
+        // held too, and can only be cancelled (or, in sandbox, a placeholder post sent on unchanged). Never recorded.
+        if (holdGate) {
+            // A request any of the SDK's own rules arms (a recogniser, a reviewed card endpoint, a guard, Stripe Checkout,
+            // Mercado, a merchant profile...) goes down the SDK's own path; only what none of them covers is hold-only.
+            const recognised = (typeof opts.vault?.isCardRequest === 'function' && opts.vault.isCardRequest(request.url, request.method))
+                || urlPatterns.some((pattern) => urlPatternMatches(pattern, request.url));
+            const holdRule = recognised ? null : matchHoldOnlyRule({ url: request.url, method: request.method, body: pausedBody(request) }, holdGate.rules);
+            if (holdRule) {
+                const failHeld = () => cdp.send('Fetch.failRequest', { requestId, errorReason: 'BlockedByClient' }, sessionId).catch(() => { });
+                if (!attachmentReady || setupStop.signal.aborted || holdGate.refuse(holdRule.psp, request.url)) {
+                    await failHeld();
+                    return;
+                }
+                holdOnlyNetworkId = typeof networkId === 'string' && networkId ? networkId : null;
+                let decision;
+                try {
+                    decision = await holdGate.hold({ psp: holdRule.psp, url: request.url, kind: holdRule.kind, replayable: false, rule: holdRule });
+                }
+                catch {
+                    holdOnlyNetworkId = null;
+                    await failHeld();
+                    return;
+                }
+                finally { /* the decision is in */ }
+                holdOnlyNetworkId = null;
+                if (decision.kind === 'continue') {
+                    // Sandbox only (HoldGate.release): the post carries the documented placeholder test number and nothing else.
+                    const ok = await cdp.send('Fetch.continueRequest', { requestId }, sessionId).then(() => true, () => false);
+                    decision.settle(ok ? { outcome: 'continued' } : { outcome: 'failed', detail: 'continue_failed' });
+                    return;
+                }
+                await failHeld();
+                decision.settle({ outcome: 'failed', detail: 'not_replayable' });
+                return;
+            }
+        }
         // One pre-claim gate registry decides and performs the mechanics through
         // these effects; the state accessors read the same closure variables the
         // inline gates did. It resolves synchronously for an ordinary card request,
@@ -2522,6 +2819,7 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             cybersourceFlex: { judge: (flexRequest) => microforms.judge(flexRequest, frameId, () => rereadMicroforms(sessionId, frameId)) },
             juspay: juspayCheckout,
             datatrans: datatransRepeats,
+            tokenexIframe: tokenexIframeRepeats,
             ebanx: ebanxFollowUps,
             frame: typeof frameId === 'string' && frameId ? frameId : undefined,
             payrails,
@@ -2593,7 +2891,7 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
         if (awaitingApproval && activeRequest?.attempt.lost && !terminal && !setupStop.signal.aborted && !lifecycle.isCancelled()
             && typeof networkId === 'string' && networkId) {
             const retryBody = pausedBody(request);
-            const retry = retryBody === null ? null : requestIdentity(opts, request.url, request.method, retryBody, documentKey(await documentUrlOf(readDocumentUrl, lifecycle.abort.signal)), await pageAmountOf(opts), flexPause?.shape, request.headers);
+            const retry = retryBody === null ? null : requestIdentity(opts, request.url, request.method, retryBody, documentKey(await documentUrlOf(readPausedDocument, lifecycle.abort.signal)), await pageAmountOf(opts), flexPause?.shape, request.headers);
             // A prepared approval is answered only in the card frame it was bound in: the same request from
             // another frame (a replacement for a removed one, or a second card frame) is refused below.
             if (retry && activeRequest?.attempt.lost && sameCheckoutRequest(activeRequest.identity, retry)
@@ -2670,6 +2968,13 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             await cdp.send('Fetch.failRequest', { requestId, errorReason: cdpFailure(request.url) }, sessionId).catch(() => { });
             return;
         }
+        // Hold mode: one request held at a time, and none after a decision.
+        if (holdGate && holdGate.refuse(recognizerNameOf(opts, request.url, request.method), request.url)) {
+            if (preparation)
+                preparationGate.retireUnboundClaim();
+            await refusePaused(requestId, sessionId, request.url, cardEndpoint, heldNavigationRefusal(terminal, awaitingApproval, lifecycle));
+            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.
@@ -2686,6 +2991,8 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
         let ebanxRemembered = false;
         // The business's pause, so resume resolves once the page has its answer.
         let businessPause = null;
+        // Hold mode: the person's release, settled with what came of it.
+        let holdRelease = null;
         // A prepared Amadeus SDK add must be sent within its window (see amadeus.ts).
         let disarmSendWindow = null;
         try {
@@ -2738,7 +3045,7 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 await preparationGate.assertDocument();
             // One bounded read of the document serves both the merchant origin and
             // the identity a retry has to repeat (see sameCheckoutRequest).
-            const documentUrl = await documentUrlOf(readDocumentUrl, attempt.signal);
+            const documentUrl = await documentUrlOf(readPausedDocument, attempt.signal);
             const pageOrigin = pageOriginFrom(documentUrl);
             // The agent's amount is a card endpoint's only authority: no page total is read.
             const pageAmount = cardEndpoint ? undefined : await pageAmountOf(opts);
@@ -2776,15 +3083,45 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             // 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();
+            // Hold mode: nothing is created until the person's total releases the request (hold.ts).
+            if (holdGate) {
+                if (holdGate.state !== 'watching') {
+                    // Another card request was held while this one was being read: this one is refused alone.
+                    holdGate.refuse(recognizerNameOf(opts, request.url, request.method), request.url);
+                    throw new HoldRefusedError();
+                }
+                const decision = await holdUntilDecided(holdGate.hold({ psp: recognizerNameOf(opts, request.url, request.method), url: request.url,
+                    kind: 'card_request', replayable: true }), attempt.signal, () => holdGate.lost());
+                if (decision.kind !== 'release') {
+                    decision.settle({ outcome: 'failed', detail: 'not_releasable' });
+                    throw new HoldEndedError('not_releasable');
+                }
+                holdRelease = decision;
+                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.
             const pause = opts.pauseOnly ? pauseForBusiness(opts, lifecycle, attempt.signal, { url: request.url, method: request.method, headers: request.headers ?? {}, body }, pageOrigin) : null;
             businessPause = pause;
-            const replay = pause ? eprotectResumedReplay(await pause.replay, request) : await opts.vault.authorize({
+            // A sandbox hold never sends the request on: the approval is created at the released total and read, the
+            // page's request fails the moment it exists, and the attempt ends with nothing charged.
+            const holdSandbox = !!holdRelease && opts.vault.sandbox === true;
+            const holdMerchantStop = holdSandbox ? new AbortController() : null;
+            // The approval outlives the page's request, but not the checkout: cancelling the attachment while the approval is
+            // open retires it at Agentcard (the client cancels an authorization whose merchant signal aborted).
+            if (holdMerchantStop) {
+                const retire = () => holdMerchantStop.abort();
+                if (lifecycle.abort.signal.aborted)
+                    retire();
+                else
+                    lifecycle.abort.signal.addEventListener('abort', retire, { once: true });
+            }
+            let holdRequestFailed = false;
+            const authorization = pause ? null : opts.vault.authorize({
                 user: opts.user,
                 merchant: opts.merchant,
-                amount: opts.amount,
-                currency: opts.currency,
+                amount: holdRelease ? holdRelease.amount : opts.amount,
+                currency: holdRelease ? holdRelease.currency : opts.currency,
                 cardId: preparation?.cardId ?? opts.cardId,
                 executionMode: opts.executionMode,
                 grantId: opts.grantId,
@@ -2796,11 +3133,23 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 preparation,
                 timeoutMs: opts.timeoutMs,
                 signal: lifecycle.abort.signal,
-                merchantSignal: attempt.signal,
+                // A sandbox hold's approval outlives the page's request on purpose: that request is failed once it exists.
+                merchantSignal: holdMerchantStop?.signal ?? attempt.signal,
                 // What the merchant's own checkout said its total was, as this browser recorded it
                 // (read only for a reviewed profile priced by it): the page is the card request's.
                 merchantTotal: merchantTotal.capture(pausedAt, cardPage),
-                onAuthorizationCreated: (id) => lifecycle.approvalCreated(id),
+                onAuthorizationCreated: (id) => {
+                    lifecycle.approvalCreated(id);
+                    if (holdSandbox && !holdRequestFailed) {
+                        holdRequestFailed = true;
+                        // The page's request is let go of before it is failed, so its failure report does not end this attempt:
+                        // the approval it raised is read to its end, and nothing is ever delivered to the page.
+                        if (activeRequest?.attempt === attempt)
+                            activeRequest = null;
+                        opts.onEvent?.({ type: 'card_request_not_sent', detail: { authorizationId: id } });
+                        void cdp.send('Fetch.failRequest', { requestId, errorReason: cdpFailure(request.url) }, sessionId).catch(() => { });
+                    }
+                },
                 onApprovalUrl: (url) => { if (!preparation && !attempt.signal.aborted) {
                     lifecycle.approvalUrl(url);
                     return opts.onApprovalUrl?.(url);
@@ -2812,6 +3161,15 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                         ...(flexPause ? flexPause.sidecar : {}),
                         ...(payrailsSidecar ? { payrails: payrailsSidecar } : {}) },
             });
+            if (holdSandbox && authorization) {
+                const outcome = await authorization.then((r) => ({ outcome: 'approved_not_charged', authorizationId: r.authorizationId }), (err) => ({ outcome: err instanceof ApprovalDeclinedError ? 'declined' : err instanceof ApprovalTimeoutError ? 'expired' : 'failed',
+                    authorizationId: lifecycle.getState().authorizationId, detail: failureSummary(err) }));
+                if (!holdRequestFailed)
+                    await cdp.send('Fetch.failRequest', { requestId, errorReason: cdpFailure(request.url) }, sessionId).catch(() => { });
+                holdRelease.settle(outcome);
+                throw new HoldAnsweredError(outcome);
+            }
+            const replay = pause ? eprotectResumedReplay(await pause.replay, request) : await authorization;
             attempt.assertLive();
             approvedId = replay.authorizationId;
             if (lifecycle.isCancelled())
@@ -2979,6 +3337,7 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 }, 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);
+                tokenexIframeRepeats.remember(activeRequest?.frameId || undefined, deliverRequest.url, deliverBody, replay);
                 attempt.assertLive();
                 // 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).
@@ -2992,8 +3351,18 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             if (handedOver)
                 lifecycle.handedOff(replay);
             businessPause?.delivered.resolve();
+            holdRelease?.settle({ outcome: 'authorized', authorizationId: replay.authorizationId });
         }
         catch (err) {
+            if (err instanceof HoldRefusedError) {
+                // Refused alone: the request another rule holds, and the checkout's state, are left as they are.
+                if (activeRequest?.attempt === attempt)
+                    activeRequest = null;
+                await refusePaused(attempt.target?.requestId ?? requestId, attempt.target?.sessionId ?? sessionId, request.url, cardEndpoint, heldNavigationRefusal(terminal, false, lifecycle));
+                return;
+            }
+            holdRelease?.settle(err instanceof HoldAnsweredError ? err.outcome : { outcome: err instanceof ApprovalDeclinedError ? 'declined' : err instanceof ApprovalTimeoutError ? 'expired' : 'failed',
+                authorizationId: approvedId ?? lifecycle.getState().authorizationId, detail: failureSummary(err) });
             // Ignore the failure event caused by our own safe decline/error abort.
             const dead = attempt.target ?? { requestId, sessionId };
             // An EBANX token answer this handoff kept follow-ups for and did not finish handing over: nothing after it is
@@ -3067,6 +3436,11 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             targetContextKnown = true;
             // A page target's id is its main frame's id: a navigation of that frame is the page's own (pausedNavigation).
             pageTargetId = typeof targetInfo.targetId === 'string' && targetInfo.targetId ? targetInfo.targetId : undefined;
+            // The page's URL as its target reports it: the document a held top-level navigation leaves until the page commits
+            // another one (the Page.frameNavigated branch above, and notePageTarget for a commit before the Page events are on).
+            // No frame tree read: a navigation the page starts while this attachment arms would hold it.
+            if (committedTopUrl === undefined && typeof targetInfo.url === 'string' && targetInfo.url)
+                committedTopUrl = targetInfo.url.split('#')[0];
             await cdp.send('Target.setDiscoverTargets', { discover: true });
             assertActive();
             const { targetInfos } = await cdp.send('Target.getTargets');
@@ -3074,24 +3448,43 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             if (!Array.isArray(targetInfos))
                 throw new CheckoutAttachmentError('unavailable');
             for (const target of targetInfos)
-                assertContextTarget(target, merchantContext);
+                assertContextTarget(target, merchantContext, targetAllowance);
+            // The page may have committed another document since its TargetInfo was read; the list names the one it holds.
+            for (const target of targetInfos)
+                notePageTarget(target);
+            for (const target of targetInfos)
+                if (target?.type === 'shared_worker')
+                    await watchSharedWorker(target);
             await arm(pageSessionId);
             // Existing OOPIFs report attachment before the parent's acknowledgement,
             // but their Fetch setup finishes later. Do not invite the caller to press
-            // Pay while one of those already-running frames is still unprotected.
-            while (arming.size)
-                await Promise.all(arming.values());
+            // Pay while one of those already-running frames is still unprotected, or
+            // while a shared worker reported during setup is not yet watched.
+            // A window the page opened while this attachment armed it is attached and armed here too, in the order Chromium
+            // reported it (adoptOpenedWindow), and the frames and workers such a window brings are waited for as the page's
+            // own are, all under the setup deadline. One that cannot be armed fails the attachment.
+            while (arming.size || workerWatches.size || pendingWindows.length) {
+                if (arming.size || workerWatches.size)
+                    await Promise.all([...arming.values(), ...workerWatches.values()]);
+                else
+                    await adoptOpenedWindow(pendingWindows.shift(), true);
+                assertActive();
+            }
             assertActive();
         }, setupTimeoutMs, setupStop.signal);
         if (setupStop.signal.aborted)
             throw attachmentFailure(setupStop.signal.reason);
         attachmentReady = true;
-        opts.onEvent?.({ type: 'fetch_armed', detail: { patterns: urlPatterns } });
+        // A window reported after that drain, before this line, is adopted the way a later window is.
+        for (const info of pendingWindows.splice(0))
+            void adoptOpenedWindow(info);
+        opts.onEvent?.({ type: 'fetch_armed', detail: { patterns: urlPatterns, ...(holdGate ? { hold: true, holdRules: holdGate.rules.map((r) => r.psp) } : {}), ...(bypassServiceWorkers ? { serviceWorkers: 'bypass' } : {}) } });
     }
     catch (error) {
         const failure = attachmentFailure(error);
         setupStop.abort(failure);
         terminal = failure;
+        holdGate?.close();
         if (!setupFailureReported) {
             setupFailureReported = true;
             lifecycle.cancel();
@@ -3116,6 +3509,8 @@ export async function attachToPlaywright(page, opts) {
     opts = safeOptions(opts);
     if (opts.pauseOnly)
         throw new Error('pauseOnly is a raw CDP mode (attachToCdp); attachToPlaywright creates the authorization itself.');
+    if (opts.hold)
+        throw new Error('hold is a raw CDP mode (attachToCdp): it needs the frames\' own interception.');
     const setupTimeoutMs = attachmentDeadline(opts.attachmentTimeoutMs);
     const setupStop = new AbortController();
     let attachmentReady = false;
@@ -3422,6 +3817,8 @@ export async function attachToPlaywright(page, opts) {
     let lastSubmitted = null;
     // The approved Datatrans answers, per Frame: the repeat rule (datatrans.ts).
     const datatransRepeats = new DatatransRepeats();
+    // The approved TokenEx iframe answers, per Frame: the repeat rule (tokenex-iframe.ts).
+    const tokenexIframeRepeats = new TokenexIframeRepeats();
     // The card product each Worldline MyCheckout hosted checkout chose (worldline-mycheckout.ts).
     const worldlineProducts = new WorldlineMyCheckoutProducts();
     const frameOf = (request) => { try {
@@ -3442,8 +3839,10 @@ export async function attachToPlaywright(page, opts) {
         // 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).
         // Gravy's session fields are a PUT, so a URL a PUT recognizer claims is routed too; the
-        // pre-claim gates then pause only the PUT and continue the URL's other methods.
+        // pre-claim gates then pause only the PUT and continue the URL's other methods. A hosted page
+        // entered with a plain GET (hosted-entry.ts, ComGate's gateway link) is routed by its exact link.
         (url) => opts.vault.isCardRequest(url.toString()) || opts.vault.isCardRequest(url.toString(), 'PUT')
+            || opts.vault.isCardRequest(url.toString(), 'GET')
             || 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.
@@ -3461,9 +3860,16 @@ export async function attachToPlaywright(page, opts) {
             || 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 Przelewy24's pay wall hosts once its entry is served (przelewy24.ts), as attachToCdp arms
+            // the hosts: the card method's post, the card form's post and the Saferpay resolver reach the Przelewy24
+            // gate and fail.
+            || isArmedPrzelewy24Url(opts.vault, 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())
+            // Every request to a Webpay host once its entry is served (transbank.ts), as attachToCdp arms the hosts: the
+            // token's submit and Webpay's card steps reach the Webpay gate and fail, and the entry pauses.
+            || isArmedTransbankUrl(opts.vault, url.toString())
             // A CreditGuard page's own calls beside its submit (its card lookup and its 3-D Secure calls), for an
             // org the API served CreditGuard to, as attachToCdp arms its hosts: the CreditGuard gate answers them
             // under a ready preparation and lets them go on with none (pre-claim.ts isArmedCreditguardCall).
@@ -3471,6 +3877,15 @@ export async function attachToPlaywright(page, opts) {
             // Every request to a Redsys host once its entry is served (redsys.ts), as attachToCdp arms the
             // hosts: the card page's post and Redsys's other card requests reach the Redsys gate and fail.
             || isArmedRedsysUrl(opts.vault, url.toString())
+            // Every request to QuickPay's host once its entry is served (quickpay.ts), as attachToCdp arms the host:
+            // the window's card post, its other card requests and its card lookup reach the QuickPay gate and fail.
+            || isArmedQuickpayUrl(opts.vault, url.toString())
+            // Every request to one of ComGate's card hosts once its entry is served (comgate.ts), as attachToCdp arms them:
+            // the gateway's card post and every other card call there reach the ComGate gate and fail.
+            || isArmedComgateUrl(opts.vault, url.toString())
+            // Every request on the TokenEx iframe's /iframe/v3 path once its entry is served (tokenex-iframe.ts), as attachToCdp
+            // arms its hosts: a card post the recognizer's exact URL does not match reaches the TokenEx gate and fails.
+            || isArmedTokenexIframeUrl(opts.vault, url.toString())
             // PayPal's legacy Hosted Fields confirm, for every org, as attachToCdp arms it (paypal-hosted-fields.ts).
             || isPaypalHostedFieldsConfirm(url.toString())
             // PayPal's Card Fields confirm and GraphQL on www.paypal.com, for every org, as attachToCdp arms them (paypal-card-forms.ts).
@@ -3480,7 +3895,10 @@ export async function attachToPlaywright(page, opts) {
             // Paddle's checkout services, routed only for an org the API served Paddle VGS to (see attachToCdp).
             || (isPaddleCheckoutService(url.toString()) && recognizesPaddleVgs(opts.vault))
             // EBANX's 3-D Secure calls and hosted confirm, for every org, as attachToCdp arms them (ebanx.ts).
-            || isEbanxResendUrl(url.toString()), async (route) => {
+            || isEbanxResendUrl(url.toString())
+            // HiPay's two vault hosts, routed only for an org the API served HiPay to, as attachToCdp arms both hosts from the
+            // recognizer: the frame's /update reaches the HiPay gate and fails (pre-claim.ts routesHipayVault).
+            || routesHipayVault(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();
@@ -3573,6 +3991,7 @@ export async function attachToPlaywright(page, opts) {
                     } },
                 juspay: juspayCheckout,
                 datatrans: datatransRepeats,
+                tokenexIframe: tokenexIframeRepeats,
                 ebanx: ebanxFollowUps,
                 frame: frameOf(request),
                 payrails,
@@ -3959,6 +4378,7 @@ export async function attachToPlaywright(page, opts) {
                     }
                     await deliverTo.fulfill({ status: replay.status, headers: withCorsHeaders(replay.headers, cors.headers), body: replay.body });
                     datatransRepeats.remember(frameOf(deliverRequest), deliverRequest.url(), deliverBody, replay);
+                    tokenexIframeRepeats.remember(frameOf(deliverRequest), deliverRequest.url(), deliverBody, replay);
                     assertRequestLive();
                     // See the same step in attachToCdp.
                     aci.answered(deliverRequest.url(), { status: replay.status, headers: replay.headers, body: replay.body }, replay.authorizationId);