@agent-cards/checkout 0.15.1 → 0.16.0

package/dist/cdp.js

@@ -35,6 +35,27 @@ function isRepeatOfSubmitted(last, url, body, quietMs) {
     return !!last && last.url === url && last.body === body && Date.now() - last.at < quietMs;
 }
 const HOSTED_FORM_REPEAT_REASON = 'already submitted on the cardholder\'s device';
+function targetRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function contextId(value) {
+    return typeof value === 'string' && value.length > 0 && value.length <= 256 && !/[\u0000-\u0020\u007f]/.test(value);
+}
+/** Dedicated worker requests use their owning frame's Fetch interception.
+ * Shared/service workers do not have that ownership guarantee. Refuse their
+ * browser context, including newly discovered targets, before approving a card.
+ * A different, explicitly identified context belongs to another checkout.
+ */
+function assertContextTarget(target, merchantContext) {
+    if (!targetRecord(target))
+        throw new CheckoutAttachmentError('unavailable');
+    if (contextId(target.browserContextId) && target.browserContextId !== merchantContext)
+        return;
+    if (!['page', 'iframe', 'worker', 'browser_ui'].includes(target.type)
+        || (target.browserContextId !== undefined && !contextId(target.browserContextId))) {
+        throw new CheckoutAttachmentError('unavailable');
+    }
+}
 /**
  * How long to stop asking after a person declines or ignores an approval.
  *
@@ -285,7 +306,29 @@ function headerEntries(headers) {
  * undefined and the authorization goes out without one (a merchant, category
  * or place rule then refuses it as unknown, never the request itself).
  */
-async function pageOriginOf(readDocumentUrl, signal) {
+function pageOriginFrom(documentUrl) {
+    if (typeof documentUrl !== 'string')
+        return undefined;
+    try {
+        const url = new URL(documentUrl);
+        if (url.username || url.password)
+            return undefined;
+        if (url.protocol === 'https:' || (url.protocol === 'http:' && url.hostname === 'localhost'))
+            return url.origin;
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * 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
+ * retry rule (sameCheckoutRequest) compares it. Undefined when the page
+ * cannot be read, the attempt was stopped, or the read was late; the
+ * authorization then goes out without a page origin and no retry can bind.
+ */
+async function documentUrlOf(readDocumentUrl, signal) {
     let timer;
     let abort;
     try {
@@ -299,14 +342,7 @@ async function pageOriginOf(readDocumentUrl, signal) {
                     abort();
             }),
         ]);
-        if (typeof documentUrl !== 'string')
-            return undefined;
-        const url = new URL(documentUrl);
-        if (url.username || url.password)
-            return undefined;
-        if (url.protocol === 'https:' || (url.protocol === 'http:' && url.hostname === 'localhost'))
-            return url.origin;
-        return undefined;
+        return typeof documentUrl === 'string' ? documentUrl : undefined;
     }
     catch {
         return undefined;
@@ -370,21 +406,338 @@ function failureSummary(error) {
         return `${error.name}: ${error.code ?? `http_${error.status}`}`;
     return error instanceof Error ? error.name : 'CheckoutError';
 }
-/** Separate from explicit cancellation: the client can drain a late create ID. */
-function merchantAttempt(lifecycle) {
+/**
+ * How long an approval waits, after the cardholder gives it, for the page to
+ * issue the request it will answer.
+ *
+ * This only matters when the page's own script abandoned its card request
+ * while the person was deciding (Braintree's client gives up after 60
+ * seconds, Square's after about 10) and did not ask again on its own. The
+ * approval is real: the device sent the card to the processor and a token
+ * came back, or encrypted it for the agent's browser. What is missing is a
+ * request to hand it to, and the application supplies one by clicking Pay
+ * again (the controller reads `ready_to_submit` with reason
+ * `awaiting_merchant_retry` while this wait runs). Two minutes is a first
+ * value, chosen rather than measured: long enough for an agent loop to read
+ * the state and act, short enough that a minted token never sits usable for
+ * the rest of the approval window. The approval window itself is the ceiling,
+ * whatever this is set to. Overridable per attach via `merchantRetryWaitMs`;
+ * the benchmark's retry gaps are what should replace it.
+ */
+const MERCHANT_RETRY_WAIT_MS = 2 * 60_000;
+function retryWaitMs(value) {
+    if (value === undefined)
+        return MERCHANT_RETRY_WAIT_MS;
+    if (!Number.isSafeInteger(value) || value <= 0 || value > 15 * 60_000) {
+        throw new Error('merchantRetryWaitMs must be an integer between 1 and 900000.');
+    }
+    return value;
+}
+/** The page never asked again inside the retry wait; see merchantAttempt.awaitTarget. */
+class MerchantNeverRetried extends Error {
+    authorizationId;
+    constructor(authorizationId) {
+        super('the merchant page never asked again');
+        this.authorizationId = authorizationId;
+        this.name = 'MerchantNeverRetried';
+    }
+}
+/** A body field that names the purchase's amount or currency, wherever a processor puts it. */
+const AMOUNT_KEY = /^(amount|amount_?cents|total|sum|currency|currency_?code)$/i;
+/**
+ * The amount and currency a body names, as `path=value` pairs: Adyen's
+ * `amount.value` and `amount.currency`, Razorpay's and Nuvei's `amount`
+ * and `currency`, Paysafe's `amount` and `currencyCode`, Tranzila's `sum`.
+ * A pure tokenization (Braintree, Square, Shopify, a Stripe PaymentMethod)
+ * names none and yields an empty list.
+ */
+function bodyAmounts(value, prefix, parentKey, out) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            bodyAmounts(item, `${prefix}[]`, parentKey, out);
+        return;
+    }
+    if (value === null || typeof value !== 'object') {
+        const key = prefix.split('.').pop() ?? '';
+        if (AMOUNT_KEY.test(key) || (key === 'value' && AMOUNT_KEY.test(parentKey)))
+            out.push(`${prefix}=${String(value)}`);
+        return;
+    }
+    const own = prefix.split('.').pop() ?? '';
+    for (const [key, child] of Object.entries(value))
+        bodyAmounts(child, prefix ? `${prefix}.${key}` : key, own, out);
+}
+/** The document a request came from, as compared between a request and its retry. */
+function documentKey(url) {
+    if (typeof url !== 'string')
+        return undefined;
+    try {
+        const parsed = new URL(url);
+        parsed.hash = '';
+        return parsed.href;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Luhn, on a run of digits: the placeholder card the agent typed passes it, most other long numbers do not. */
+function luhn(digits) {
+    let sum = 0;
+    for (let i = 0; i < digits.length; i++) {
+        let d = digits.charCodeAt(digits.length - 1 - i) - 48;
+        if (i % 2 === 1) {
+            d *= 2;
+            if (d > 9)
+                d -= 9;
+        }
+        sum += d;
+    }
+    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.
+ */
+function cardRuns(body) {
+    return (body.match(/\d{13,19}/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) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            jsonKeyPaths(item, `${prefix}[]`, out);
+        return;
+    }
+    if (value === null || typeof value !== 'object') {
+        if (prefix)
+            out.add(prefix);
+        return;
+    }
+    for (const [key, child] of Object.entries(value))
+        jsonKeyPaths(child, prefix ? `${prefix}.${key}` : key, out);
+}
+/**
+ * The shape of a body plus its card placeholder, as a string two bodies can
+ * be compared by. JSON: its sorted key paths and its card runs, so a body the
+ * client regenerated (a new session id, a new nonce, a fresh encryption of
+ * the same dummy card) still matches while a different operation, a saved
+ * card or another card does not. Form-encoded: its sorted keys and its card
+ * runs, so Stripe's per-attempt `time_on_page` and fraud ids do not break a
+ * match but a different field set does. Anything else: the body itself.
+ */
+function bodyShape(body) {
+    const runs = cardRuns(body).join(',');
+    const trimmed = body.trimStart();
+    if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+        try {
+            const parsed = JSON.parse(body);
+            const paths = new Set();
+            jsonKeyPaths(parsed, '', paths);
+            const amounts = [];
+            bodyAmounts(parsed, '', '', amounts);
+            return { shape: `json:${[...paths].sort().join('|')};cards:${runs};amounts:${amounts.sort().join('|')}`, namesAmount: amounts.length > 0 };
+        }
+        catch { /* not JSON after all */ }
+    }
+    if (/^[^=&\s]+=[^&]*(&[^=&\s]+=[^&]*)*$/.test(body)) {
+        const params = new URLSearchParams(body);
+        const keys = [...new Set([...params.keys()])].sort();
+        const amounts = [...params.entries()].filter(([key]) => AMOUNT_KEY.test(key)).map(([key, value]) => `${key}=${value}`).sort();
+        return { shape: `form:${keys.join('|')};cards:${runs};amounts:${amounts.join('|')}`, namesAmount: amounts.length > 0 };
+    }
+    return { shape: `raw:${body}`, namesAmount: false };
+}
+/** The identity of a request from its parts; see CheckoutRequestIdentity. */
+function requestIdentity(opts, url, method, body, documentUrl, pageAmount) {
+    const shaped = bodyShape(body);
+    return { url, method, documentUrl, pageAmount, body: shaped.shape,
+        amountEvidence: opts.amount != null || pageAmount !== undefined || shaped.namesAmount };
+}
+/**
+ * May this request be answered from the approval the other one raised?
+ *
+ * The plan this implements says the rule starts strict and loosens per
+ * processor with evidence, so it is strict: the same processor endpoint (the
+ * full URL, query included), the same method, the same top-level document,
+ * the same page total when the integrator reads one, and a body of the same
+ * shape carrying the same card placeholder and the same amount when the
+ * request names one. A request from another page, to another endpoint, for
+ * another card, for another amount or with another set of fields is a new
+ * question and is refused here, which leaves it to the ordinary "an approval
+ * is already outstanding" path.
+ *
+ * An amount has to be in evidence somewhere: the integrator's hint (what the
+ * cardholder was shown), the page total, or the request's own bytes. A
+ * tokenization request names no amount, so on a checkout with no hint and no
+ * page reader nothing could tell a retry for the approved cart from one for
+ * a changed cart, and the approval is not reused. With a page reader, a
+ * changed total refuses the retry; the hint is the integrator's statement of
+ * the purchase, and the approval was given for it.
+ */
+function sameCheckoutRequest(first, retry) {
+    return first.amountEvidence && first.url === retry.url && first.method.toUpperCase() === retry.method.toUpperCase()
+        && first.documentUrl !== undefined && first.documentUrl === retry.documentUrl
+        && (first.pageAmount?.amount === retry.pageAmount?.amount && first.pageAmount?.currency === retry.pageAmount?.currency)
+        && first.body === retry.body;
+}
+/**
+ * Whether an approval may outlive the page's own request on this checkout.
+ *
+ * Yes for a plain tokenization or an encrypted-card request: the device's
+ * 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`.
+ */
+function survivesAbandonment(opts, url, method, navigation, bound) {
+    if (navigation || bound)
+        return false;
+    const mode = typeof opts.vault?.checkoutModeOf === 'function' ? opts.vault.checkoutModeOf(url, method) : 'token';
+    return mode === 'token' || mode === 'cse';
+}
+/**
+ * One card request's attempt at an approval, and the browser request that
+ * currently carries it. Separate from explicit cancellation: the client can
+ * drain a late create ID.
+ *
+ * The request and the approval have different lives. The page's own script
+ * can abandon its request (Braintree's client gives up after 60 seconds,
+ * Square's after about 10) while the cardholder is still deciding on their
+ * phone; nothing about the checkout changed, the page asked and stopped
+ * listening. lose() records that: the approval keeps polling, the page's next
+ * request for the same purchase binds through bind() and is answered from the
+ * same authorization, and awaitTarget() is how the approval finds the request
+ * to answer, waiting for a retry when none is live. stop() is for the page
+ * itself going away (navigation of a prepared document, frame removal, close,
+ * crash), a request lost once delivery began, or an attempt that cannot
+ * survive abandonment at all: the approval cannot be reopened and the client
+ * cancels it.
+ */
+function merchantAttempt(lifecycle, survives) {
     const controller = new AbortController();
-    const error = () => new PaymentOutcomeUnknownError(lifecycle.getState().authorizationId, 'merchant_request_aborted');
-    return {
+    let reason = 'merchant_request_aborted';
+    let target = null;
+    let lost = false;
+    let rebound = false;
+    let delivering = false;
+    let bound = null;
+    const error = () => new PaymentOutcomeUnknownError(lifecycle.getState().authorizationId, reason);
+    const attempt = {
         signal: controller.signal,
-        stop() {
+        /** The browser request that currently carries this attempt; null while the page has none. */
+        get target() { return target; },
+        /** The page abandoned its request and has not asked again yet. */
+        get lost() { return lost; },
+        bind(next) { target = next; rebound = lost; lost = false; bound?.(); },
+        /** Delivery to the current target has begun; a loss from here on is an unknown outcome, never a retry. */
+        beginDelivery() { delivering = true; },
+        /** The page abandoned the current request. True when the approval survives it, false when the attempt stopped. */
+        lose() {
+            if (controller.signal.aborted)
+                return false;
+            if (!survives || delivering) {
+                attempt.stop();
+                return false;
+            }
+            target = null;
+            lost = true;
+            lifecycle.merchantRequestLost();
+            return true;
+        },
+        stop(cause = 'merchant_request_aborted') {
             if (controller.signal.aborted)
                 return;
-            lifecycle.merchantRequestAborted();
+            reason = cause;
+            if (cause === 'merchant_request_aborted')
+                lifecycle.merchantRequestAborted();
+            else
+                lifecycle.failed(error());
             controller.abort(error());
         },
         assertLive() { if (controller.signal.aborted)
             throw error(); },
+        /**
+         * The request to answer: the live one at once, or the page's retry,
+         * waited for up to `waitMs`. Resolves `rebound` when the answer goes to
+         * a request other than the one that raised the approval, so the caller
+         * can re-run request attribution on it. Rejects with MerchantNeverRetried
+         * when the wait ends with no request, and with the attempt's own error
+         * when the page goes away meanwhile.
+         */
+        async awaitTarget(waitMs, stopSignals, onWaiting) {
+            attempt.assertLive();
+            if (target && !lost)
+                return { target, rebound };
+            onWaiting();
+            const signals = [controller.signal, ...stopSignals];
+            let timer;
+            let onAbort = () => { };
+            try {
+                await new Promise((resolve, reject) => {
+                    bound = resolve;
+                    onAbort = () => { try {
+                        attempt.assertLive();
+                        reject(new Error('checkout cancelled locally before the merchant asked again'));
+                    }
+                    catch (stopped) {
+                        reject(stopped);
+                    } };
+                    for (const signal of signals)
+                        signal.addEventListener('abort', onAbort, { once: true });
+                    if (signals.some((signal) => signal.aborted))
+                        onAbort();
+                    timer = setTimeout(() => reject(new MerchantNeverRetried(lifecycle.getState().authorizationId)), waitMs);
+                });
+            }
+            finally {
+                bound = null;
+                clearTimeout(timer);
+                for (const signal of signals)
+                    signal.removeEventListener('abort', onAbort);
+            }
+            attempt.assertLive();
+            if (!target)
+                throw new MerchantNeverRetried(lifecycle.getState().authorizationId);
+            return { target, rebound };
+        },
     };
+    return attempt;
+}
+/**
+ * The retry wait, capped by what is left of the approval window: a token
+ * must never sit usable past the moment the row itself would have expired.
+ */
+function boundedRetryWait(waitMs, approvalStartedAt, timeoutMs) {
+    const windowEnd = approvalStartedAt + (timeoutMs ?? 15 * 60_000);
+    return Math.max(0, Math.min(waitMs, windowEnd - Date.now()));
+}
+/**
+ * Retire an approval the page never asked for again, and tell the lifecycle
+ * what became of it. A confirmed retirement ends as `declined` with reason
+ * `merchant_never_retried` (the cardholder's screen says the merchant did
+ * not finish and nothing was charged, and the next card request is a new
+ * question); anything else is an unknown outcome the application must
+ * reconcile, which holds the attachment. A vault without cancelAuthorization
+ * (a duck-typed client) cannot retire anything and lands there too.
+ */
+async function retireUnusedApproval(opts, lifecycle, authorizationId) {
+    const cancel = typeof opts.vault?.cancelAuthorization === 'function' && authorizationId
+        ? opts.vault.cancelAuthorization(authorizationId, 'merchant_never_retried') : Promise.reject(new Error('no authorization to retire'));
+    try {
+        await cancel;
+        lifecycle.merchantNeverRetried(authorizationId);
+        opts.onEvent?.({ type: 'failed', detail: 'merchant_never_retried' });
+    }
+    catch {
+        lifecycle.failed(new PaymentOutcomeUnknownError(authorizationId, 'authorization_cancel_unconfirmed'), true);
+        opts.onEvent?.({ type: 'failed', detail: 'PaymentOutcomeUnknownError' });
+    }
 }
 /**
  * Take over card tokenization for a page.
@@ -409,6 +762,56 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
     const setupStop = new AbortController();
     let attachmentReady = false;
     let setupFailureReported = false;
+    const ownedSessions = new Set([pageSessionId]);
+    const sessionTypes = new Map([[pageSessionId, 'page']]);
+    const sessionParents = new Map();
+    const detachedSessions = new Set();
+    const workerOwners = new Map();
+    const ownersWithWorkers = new Set();
+    // Network IDs are scoped to their emitting session. Retired records are
+    // separate from live requests, but still disqualify an indistinguishable
+    // delayed Fetch event; deleting that evidence could approve a lost request.
+    const requestSources = new Map();
+    const retiredSources = new Map();
+    const retiredCounts = new Map();
+    // Keep exact evidence for the first 1,024 failures per owner. Later failures
+    // enter a fixed 256 KiB Bloom filter with seven positions: a membership hit
+    // refuses that Network ID, never the whole frame merely for reaching a cap.
+    // Fetch lacks the emitter session, so compact evidence uses owner + Network
+    // ID; exact records below still use session + ID. False positives may refuse
+    // a request, but a failed identity is never forgotten or treated as live.
+    // The filters are controller-local and monotonic. They are not rotated or
+    // cleared on worker detach; arbitrary late Network/Fetch delivery is allowed.
+    // A sufficiently long history can saturate a filter and reduce availability.
+    const retiredSummaries = new Map();
+    const summaryBytes = 256 * 1024;
+    const summaryPositions = (id) => {
+        const positions = [];
+        for (let seed = 1; seed <= 7; seed++) {
+            let hash = 0x811c9dc5 ^ Math.imul(seed, 0x9e3779b9);
+            for (let i = 0; i < id.length; i++)
+                hash = Math.imul(hash ^ id.charCodeAt(i), 0x01000193);
+            hash = Math.imul(hash ^ (hash >>> 16), 0x85ebca6b);
+            hash = Math.imul(hash ^ (hash >>> 13), 0xc2b2ae35);
+            positions.push((hash ^ (hash >>> 16)) & (summaryBytes * 8 - 1));
+        }
+        return positions;
+    };
+    const hasRetiredSummary = (owner, id) => {
+        const bits = retiredSummaries.get(owner);
+        return !!bits && summaryPositions(id).every(bit => (bits[bit >>> 3] & (1 << (bit & 7))) !== 0);
+    };
+    const requestKey = (sessionId, id) => JSON.stringify([sessionId, id]);
+    const sessionDetached = (sessionId) => {
+        while (sessionId) {
+            if (detachedSessions.has(sessionId))
+                return true;
+            sessionId = sessionParents.get(sessionId);
+        }
+        return false;
+    };
+    let merchantContext;
+    let targetContextKnown = false;
     const lifecycle = new CheckoutLifecycle(opts);
     const stripeCheckout = new StripeCheckoutGate(opts);
     const mercadoCheckout = new MercadoCheckoutGate();
@@ -431,14 +834,128 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
     let quietUntil = 0;
     // One outstanding approval at a time; see the note above isApprovalOutcome.
     let awaitingApproval = false;
+    // How long an approval waits for the page to ask again; see MERCHANT_RETRY_WAIT_MS.
+    const retryWait = retryWaitMs(opts.merchantRetryWaitMs);
     let activeRequest = null;
+    const sourceOwner = (source) => workerOwners.get(source.sessionId) ?? source.sessionId;
+    const retireSource = (source) => {
+        const owner = sourceOwner(source), key = requestKey(source.sessionId, source.networkId);
+        const count = (retiredCounts.get(owner) ?? 0) + (retiredSources.has(key) ? 0 : 1);
+        // Compact overflow without dropping failed identities or turning unrelated
+        // background failures into a permanent refusal of every request in a frame.
+        if (count > 1024) {
+            let bits = retiredSummaries.get(owner);
+            if (!bits) {
+                bits = new Uint8Array(summaryBytes);
+                retiredSummaries.set(owner, bits);
+            }
+            for (const bit of summaryPositions(source.networkId))
+                bits[bit >>> 3] |= 1 << (bit & 7);
+            if (activeRequest?.sessionId === owner && hasRetiredSummary(owner, activeRequest.networkId)) {
+                activeRequest.attempt.stop('browser_interception_unavailable');
+            }
+            return;
+        }
+        retiredCounts.set(owner, count);
+        retiredSources.set(key, source);
+    };
+    const identifyRequest = (request) => {
+        if (request.sessionId && hasRetiredSummary(request.sessionId, request.networkId)) {
+            request.attempt.stop('browser_interception_unavailable');
+            request.attempt.assertLive();
+        }
+        const matches = (source) => {
+            const metadata = source.request;
+            return sourceOwner(source) === request.sessionId
+                && source.networkId === request.networkId && (!metadata
+                || (metadata.url === request.request.url && metadata.method === request.request.method
+                    // A missing body is unknown, not evidence of a different request.
+                    && !(typeof metadata.postData === 'string' && typeof request.request.postData === 'string'
+                        && metadata.postData !== request.request.postData)));
+        };
+        const candidates = [...requestSources.values(), ...retiredSources.values()].filter(matches);
+        if (!candidates.length)
+            return false;
+        // A failure can arrive before its Network request description. Do not
+        // ignore that possible source and assign its Fetch to a live sibling.
+        if (candidates.some(source => !source.request)) {
+            if (request.sourceSessionId) {
+                request.attempt.stop('browser_interception_unavailable');
+                request.attempt.assertLive();
+            }
+            return false;
+        }
+        if (candidates.length !== 1) {
+            request.attempt.stop('browser_interception_unavailable');
+            request.attempt.assertLive();
+        }
+        const source = candidates[0];
+        if (request.sourceSessionId && request.sourceSessionId !== source.sessionId) {
+            request.attempt.stop('browser_interception_unavailable');
+        }
+        request.sourceSessionId = source.sessionId;
+        if (sessionDetached(source.sessionId) || retiredSources.has(requestKey(source.sessionId, source.networkId)))
+            request.attempt.stop();
+        request.attempt.assertLive();
+        return true;
+    };
+    /** A frame's Fetch event does not identify which dedicated worker sent it.
+     * Require the exact Network event before asking the Vault whenever that frame
+     * has had workers. A sibling's detach proves nothing about an unknown request;
+     * missing attribution instead expires without releasing any card or token.
+     * Keep detached ancestry so a late event cannot revive a lost worker request.
+     */
+    const awaitRequestSource = async (request) => {
+        if (identifyRequest(request))
+            return;
+        if (!request.sessionId || !ownersWithWorkers.has(request.sessionId)) {
+            if (request.sessionId && retiredSources.has(requestKey(request.sessionId, request.networkId))) {
+                request.attempt.stop();
+                request.attempt.assertLive();
+            }
+            request.sourceSessionId = request.sessionId;
+            return;
+        }
+        let timer;
+        let changed = () => { };
+        const signals = [request.attempt.signal, lifecycle.abort.signal, setupStop.signal];
+        try {
+            await new Promise((resolve, reject) => {
+                changed = () => {
+                    try {
+                        request.attempt.assertLive();
+                        if (lifecycle.isCancelled())
+                            throw new Error('checkout cancelled locally before approval');
+                        if (setupStop.signal.aborted)
+                            throw new PaymentOutcomeUnknownError(null, 'browser_interception_unavailable');
+                        if (identifyRequest(request))
+                            resolve();
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                };
+                request.attributionChanged = changed;
+                for (const signal of signals)
+                    signal.addEventListener('abort', changed, { once: true });
+                timer = setTimeout(() => reject(new PaymentOutcomeUnknownError(null, 'browser_interception_unavailable')), setupTimeoutMs);
+                changed();
+            });
+        }
+        finally {
+            clearTimeout(timer);
+            for (const signal of signals)
+                signal.removeEventListener('abort', changed);
+            delete request.attributionChanged;
+        }
+    };
     // 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;
     const derived = typeof opts.vault?.cardUrlPatterns === 'function' ? opts.vault.cardUrlPatterns() : [];
     const urlPatterns = [...new Set([...(derived.length > 0 ? derived : FALLBACK_CARD_PATTERNS), ...guards.patterns,
             ...(stripeCheckout.isEnabled() ? ['https://api.stripe.com/*'] : []), MERCADO_CHECKOUT_PATTERN])];
-    const arm = async (sessionId, resume = false) => {
+    const arm = async (sessionId, resume = false, worker = false) => {
         const key = sessionId ?? '__root__';
         if (armed.has(key))
             return;
@@ -446,15 +963,26 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             return arming.get(key);
         // Fetch's interception ID differs from Network's ID. Enable failure events
         // before intercepting and bind each attempt to both its ID and CDP session.
-        const pending = withinAttachmentDeadline(async (assertActive) => {
+        const pending = withinAttachmentDeadline(async (assertDeadline) => {
+            const assertActive = () => {
+                assertDeadline();
+                if (sessionId && detachedSessions.has(sessionId))
+                    throw new CheckoutAttachmentError('closed');
+            };
             await cdp.send('Network.enable', {}, sessionId);
             assertActive();
-            await cdp.send('Page.enable', {}, sessionId).catch(() => { });
-            assertActive();
-            await cdp.send('Fetch.enable', {
-                patterns: urlPatterns.map((urlPattern) => ({ urlPattern, requestStage: 'Request' })),
-            }, 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
+            // resume it only after its nested workers can be attached recursively.
+            if (!worker) {
+                await cdp.send('Page.enable', {}, sessionId).catch(() => { });
+                assertActive();
+                await cdp.send('Fetch.enable', {
+                    patterns: urlPatterns.map((urlPattern) => ({ urlPattern, requestStage: 'Request' })),
+                }, sessionId);
+                assertActive();
+            }
             // Descend into this target's own children (iframes inside iframes).
             await cdp.send('Target.setAutoAttach', {
                 autoAttach: true, waitForDebuggerOnStart: true, flatten: true,
@@ -481,7 +1009,33 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             arming.delete(key);
         }
     };
+    const failInterception = (error) => {
+        if (setupFailureReported)
+            return;
+        setupFailureReported = true;
+        setupStop.abort(attachmentFailure(error));
+        terminal = new Error('browser_interception_unavailable');
+        // A new target changes future interception, not the result of an earlier
+        // attempt. Preserve a settled result or handoff while still refusing new
+        // requests. Approval/preparation in progress must instead be retired.
+        const status = lifecycle.getState().status;
+        if (status === 'completed' || (!activeRequest && !['idle', 'awaiting_approval', 'ready_to_submit'].includes(status)))
+            return;
+        activeRequest?.attempt.stop();
+        preparationGate.invalidate('browser_interception_unavailable');
+        lifecycle.failed(new PaymentOutcomeUnknownError(lifecycle.getState().authorizationId, 'browser_interception_unavailable'));
+        opts.onEvent?.({ type: 'failed', detail: 'browser_interception_unavailable' });
+    };
     cdp.on(async (method, params, sessionId) => {
+        if ((method === 'Target.targetCreated' || method === 'Target.targetInfoChanged') && targetContextKnown) {
+            try {
+                assertContextTarget(params?.targetInfo, merchantContext);
+            }
+            catch (error) {
+                failInterception(error);
+            }
+            return;
+        }
         if (((method === 'Page.frameNavigated' && !params.frame?.parentId) || (method === 'Page.navigatedWithinDocument' && preparationFrameId && params.frameId === preparationFrameId)) && sessionId === pageSessionId) {
             preparationGate.invalidate('merchant_document_changed');
             mercadoCheckout.invalidate();
@@ -491,10 +1045,17 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             }
             if (preparationGate.isEngaged())
                 activeRequest?.attempt.stop();
+            // The page that abandoned its request has moved to another document:
+            // its approval cannot be answered there and is cancelled. A reload of
+            // the same document is not that; its re-issued request is the retry.
+            if (method === 'Page.frameNavigated' && activeRequest?.attempt.lost
+                && documentKey(params.frame?.url) !== activeRequest.identity.documentUrl)
+                activeRequest.attempt.stop();
             return;
         }
         if ((method === 'Inspector.detached' && sessionId === pageSessionId)
             || (method === 'Target.detachedFromTarget' && params.sessionId === pageSessionId)) {
+            detachedSessions.add(pageSessionId);
             setupStop.abort(new CheckoutAttachmentError('closed'));
             preparationGate.invalidate('merchant_document_closed');
             stripeCheckout.invalidate();
@@ -502,9 +1063,69 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             // The root page owns every attached OOPIF; its loss ends child requests too.
             activeRequest?.attempt.stop();
         }
+        // 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))
+            return;
+        if (method === 'Network.requestWillBeSent') {
+            const owner = workerOwners.get(sessionId) ?? sessionId;
+            const matchesActive = activeRequest?.sessionId === owner && activeRequest.networkId === params.requestId;
+            // Only identification may consume a late event from a detached target.
+            // Its Fetch events, children and commands remain permanently ignored.
+            if (sessionDetached(sessionId) && !matchesActive)
+                return;
+            const key = requestKey(sessionId, params.requestId);
+            const record = { sessionId, networkId: params.requestId, request: params.request };
+            if (sessionDetached(sessionId) || retiredSources.has(key) || hasRetiredSummary(owner, params.requestId))
+                retireSource(record);
+            else
+                requestSources.set(key, record);
+            if (matchesActive) {
+                try {
+                    identifyRequest(activeRequest);
+                }
+                catch { /* stop already retires the exact attempt */ }
+                activeRequest.attributionChanged?.();
+            }
+            return;
+        }
+        if (sessionDetached(sessionId))
+            return;
+        if (method === 'Network.loadingFinished') {
+            requestSources.delete(requestKey(sessionId, params.requestId));
+            return;
+        }
         if (method === 'Network.loadingFailed') {
-            if (activeRequest && activeRequest.networkId === params.requestId && activeRequest.sessionId === sessionId)
-                activeRequest.attempt.stop();
+            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
+                // stops the attempt. A worker's retry pauses on the owning frame and
+                // is attributed only through the worker's own Network events, and
+                // binding an approval across that attribution is not something this
+                // change claims to get right; the observed failure is page script.
+                const fromWorker = sessionId !== activeRequest.sessionId;
+                if (fromWorker ? (activeRequest.attempt.stop(), false) : activeRequest.attempt.lose()) {
+                    // The page's own script gave up on its request; the cardholder's
+                    // approval did not (see merchantAttempt). Release the dead
+                    // interception and forget the request's identity, so no later event
+                    // on it can pass for the retry's.
+                    activeRequest.networkId = '';
+                    activeRequest.frameId = undefined;
+                    activeRequest.sourceSessionId = undefined;
+                    opts.onEvent?.({ type: 'merchant_request_lost', detail: { authorizationId: lifecycle.getState().authorizationId } });
+                    cdp.send('Fetch.failRequest', { requestId: dead.requestId, errorReason: 'Aborted' }, dead.sessionId).catch(() => { });
+                }
+            }
+            const key = requestKey(sessionId, params.requestId);
+            retireSource(requestSources.get(key) ?? { sessionId, networkId: params.requestId });
+            requestSources.delete(key);
+            if (activeRequest?.sessionId === (workerOwners.get(sessionId) ?? sessionId) && activeRequest.networkId === params.requestId) {
+                try {
+                    identifyRequest(activeRequest);
+                }
+                catch { /* its exact origin is unavailable */ }
+                activeRequest.attributionChanged?.();
+            }
             return;
         }
         if (method === 'Target.detachedFromTarget' || method === 'Inspector.detached' || method === 'Page.frameDetached') {
@@ -512,6 +1133,23 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 : method === 'Inspector.detached' ? activeRequest.sessionId === sessionId
                     : activeRequest.sessionId === sessionId && activeRequest.frameId === params.frameId))
                 activeRequest.attempt.stop();
+            if (method !== 'Page.frameDetached') {
+                const detached = method === 'Target.detachedFromTarget' ? params.sessionId : sessionId;
+                detachedSessions.add(detached);
+                if (arming.has(detached))
+                    failInterception(new CheckoutAttachmentError('closed'));
+                // Terminating a worker need not emit loadingFailed. Its nested workers
+                // also lose their request. An unknown request waits for attribution;
+                // detaching an unrelated sibling must never cancel the card approval.
+                const source = activeRequest?.sourceSessionId;
+                if (activeRequest && (sessionDetached(activeRequest.sessionId) || (source && sessionDetached(source))))
+                    activeRequest.attempt.stop();
+                for (const [key, record] of requestSources)
+                    if (sessionDetached(record.sessionId)) {
+                        retireSource(record);
+                        requestSources.delete(key);
+                    }
+            }
             return;
         }
         if (method === 'Target.attachedToTarget') {
@@ -519,18 +1157,27 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 return;
             const child = params.sessionId;
             try {
-                await arm(child, true);
+                if (typeof child !== 'string' || !child || !['page', 'iframe', 'worker'].includes(params.targetInfo?.type)) {
+                    throw new CheckoutAttachmentError('unavailable');
+                }
+                if (child === pageSessionId || detachedSessions.has(child) || (ownedSessions.has(child)
+                    && (sessionParents.get(child) !== sessionId || sessionTypes.get(child) !== params.targetInfo.type))) {
+                    throw new CheckoutAttachmentError('unavailable');
+                }
+                ownedSessions.add(child);
+                sessionTypes.set(child, params.targetInfo.type);
+                sessionParents.set(child, sessionId);
+                if (params.targetInfo.type === 'worker') {
+                    const owner = workerOwners.get(sessionId) ?? sessionId;
+                    workerOwners.set(child, owner);
+                    ownersWithWorkers.add(owner);
+                }
+                await arm(child, true, params.targetInfo.type === 'worker');
             }
             catch (error) {
                 // Shared child setup and sibling cancellation can reject several
                 // handlers together. Publish the terminal setup failure only once.
-                if (setupFailureReported)
-                    return;
-                setupFailureReported = true;
-                setupStop.abort(attachmentFailure(error));
-                terminal = new Error('browser_interception_unavailable');
-                lifecycle.failed(new PaymentOutcomeUnknownError(lifecycle.getState().authorizationId, 'browser_interception_unavailable'));
-                opts.onEvent?.({ type: 'failed', detail: 'browser_interception_unavailable' });
+                failInterception(error);
                 // Leave this target paused: resuming an unarmed card frame would silently bypass the vault.
                 return;
             }
@@ -645,13 +1292,37 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
         }
         let preparation;
         try {
-            preparation = stripeStep ? undefined : preparationGate.claim(request.url, pausedBody(request));
+            preparation = stripeStep ? undefined : preparationGate.claim(request.url, pausedBody(request), request.headers);
         }
         catch (error) {
             opts.onEvent?.({ type: 'blocked', detail: failureSummary(error) });
             await cdp.send('Fetch.failRequest', { requestId, errorReason: 'Aborted' }, sessionId).catch(() => { });
             return;
         }
+        // The page asking again for the purchase an outstanding approval is for:
+        // its own request timed out while the cardholder decides (see
+        // merchantAttempt). Bind it to that approval instead of refusing it or
+        // raising a second prompt. A request that is not the same purchase falls
+        // through to the ordinary refusal below.
+        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));
+            if (retry && activeRequest?.attempt.lost && sameCheckoutRequest(activeRequest.identity, retry)) {
+                if (preparation)
+                    preparationGate.retireUnboundClaim();
+                activeRequest.requestId = requestId;
+                activeRequest.networkId = networkId;
+                activeRequest.sessionId = sessionId;
+                activeRequest.frameId = frameId;
+                activeRequest.request = request;
+                activeRequest.sourceSessionId = undefined;
+                opts.onEvent?.({ type: 'card_request_paused', detail: { url: redactUrl(request.url), ...(resourceType ? { resourceType } : {}),
+                        authorizationId: lifecycle.getState().authorizationId, retry: true } });
+                activeRequest.attempt.bind({ requestId, sessionId, request });
+                return;
+            }
+        }
         // Same stop condition as the Playwright adapter: once a failure proves
         // retrying is pointless, fail the request without calling the API again.
         if (terminal || lifecycle.isBlocked() || awaitingApproval || Date.now() < quietUntil) {
@@ -666,8 +1337,11 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
         // requests can never both clear the check above and raise two prompts for
         // one checkout.
         awaitingApproval = true;
-        const attempt = merchantAttempt(lifecycle);
+        const attempt = merchantAttempt(lifecycle, survivesAbandonment(opts, request.url, request.method, resourceType === 'Document', !!preparation || !!stripeStep || mercadoCheckout.requiresDocument(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;
         try {
             const body = pausedBody(request);
             if (body === null) {
@@ -688,16 +1362,26 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             }
             opts.onEvent?.({ type: 'card_request_paused', detail: { url: redactUrl(request.url), ...(resourceType ? { resourceType } : {}) } });
             lifecycle.begin();
+            const approvalStartedAt = Date.now();
             if (typeof networkId !== 'string' || !networkId) {
                 attempt.stop();
                 attempt.assertLive();
             }
-            activeRequest = { attempt, networkId, sessionId, frameId };
+            attempt.bind({ requestId, sessionId, request });
+            activeRequest = { attempt, requestId, networkId, sessionId, frameId, request,
+                identity: requestIdentity(opts, request.url, request.method, body, undefined, undefined) };
+            await awaitRequestSource(activeRequest);
             if (preparation)
                 await preparationGate.assertDocument();
-            const pageOrigin = await pageOriginOf(readDocumentUrl, attempt.signal);
+            // 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 pageOrigin = pageOriginFrom(documentUrl);
             const pageAmount = await pageAmountOf(opts);
             attempt.assertLive();
+            activeRequest.identity.documentUrl = documentKey(documentUrl);
+            activeRequest.identity.pageAmount = pageAmount;
+            activeRequest.identity.amountEvidence ||= pageAmount !== undefined;
             if (stripeStep)
                 stripeCheckout.assertClaim(stripeStep);
             const merchantOrigin = preparation?.merchantOrigin ?? (opts.executionMode === 'user_approval'
@@ -729,6 +1413,7 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                         ? { mercado_checkout: mercadoCheckout.claimToken(request.url, request.method, await readDocumentUrl()) } : {}) },
             });
             attempt.assertLive();
+            approvedId = replay.authorizationId;
             if (lifecycle.isCancelled())
                 throw new Error('checkout cancelled locally after approval');
             try {
@@ -738,7 +1423,23 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 throw new PaymentOutcomeUnknownError(replay.authorizationId, 'mercado_checkout_metadata_invalid');
             }
             attempt.assertLive();
-            lifecycle.prepareHandoff(replay, request.url);
+            // The request to answer: the one that raised the approval while it is
+            // still paused, or the page's retry when the page gave up on the first
+            // (waited for, bounded; see merchantAttempt.awaitTarget). A retry is
+            // attributed to its frame or worker exactly as the first request was.
+            const delivery = await attempt.awaitTarget(boundedRetryWait(retryWait, approvalStartedAt, opts.timeoutMs), [lifecycle.abort.signal, setupStop.signal], () => {
+                lifecycle.awaitingMerchantRetry(replay.authorizationId);
+                opts.onEvent?.({ type: 'approval_awaiting_merchant_retry', detail: { authorizationId: replay.authorizationId } });
+            });
+            if (delivery.rebound) {
+                await awaitRequestSource(activeRequest);
+                attempt.assertLive();
+            }
+            const { requestId: deliverTo, sessionId: deliverOn, request: deliverRequest } = delivery.target;
+            const deliverBody = delivery.rebound ? pausedBody(deliverRequest) ?? body : body;
+            deliveryBegun = true;
+            attempt.beginDelivery();
+            lifecycle.prepareHandoff(replay, deliverRequest.url);
             handoffStarted = replay.mode !== 'cse';
             if (replay.mode === 'hosted_form') {
                 // The device submitted the processor's own form; the processor
@@ -750,13 +1451,13 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 // A navigation response is never CORS-checked, so the CORS wrap is
                 // inert here; it is applied so every fulfill goes through one path.
                 await cdp.send('Fetch.fulfillRequest', {
-                    requestId,
+                    requestId: deliverTo,
                     responseCode: page.status,
-                    responseHeaders: headerEntries(withCorsHeaders(page.headers, corsHeadersFor(request.url, request.headers))),
+                    responseHeaders: headerEntries(withCorsHeaders(page.headers, corsHeadersFor(deliverRequest.url, deliverRequest.headers))),
                     body: Buffer.from(page.body).toString('base64'),
-                }, sessionId);
+                }, deliverOn);
                 attempt.assertLive();
-                lastSubmitted = { url: request.url, body, at: Date.now() };
+                lastSubmitted = { url: deliverRequest.url, body: deliverBody, at: Date.now() };
                 // Named for what it is: a device-attested submission with no
                 // processor evidence, never an `authorized` event.
                 opts.onEvent?.({ type: 'submitted_on_device', detail: { authorizationId: replay.authorizationId, submittedAt: replay.submittedAt, outcome: replay.outcome } });
@@ -767,12 +1468,12 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 // and cookies, and only the four ciphertext fields swapped in. Only
                 // postData rides on the command: no header override, ever (see
                 // cseBody for why a recomputed Content-Length is refused by Chromium).
-                const postData = Buffer.from(cseBody(body, replay)).toString('base64');
+                const postData = Buffer.from(cseBody(deliverBody, replay)).toString('base64');
                 handoffStarted = true;
                 await cdp.send('Fetch.continueRequest', {
-                    requestId,
+                    requestId: deliverTo,
                     postData,
-                }, sessionId);
+                }, deliverOn);
                 attempt.assertLive();
                 opts.onEvent?.({ type: 'authorized', detail: { mode: 'cse', authorizationId: replay.authorizationId, fields: Object.keys(replay.substitutions.fields) } });
             }
@@ -783,13 +1484,13 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 // 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".
-                const cors = corsDecision(request.url, request.headers);
+                const cors = corsDecision(deliverRequest.url, deliverRequest.headers);
                 await cdp.send('Fetch.fulfillRequest', {
-                    requestId,
+                    requestId: deliverTo,
                     responseCode: replay.status,
                     responseHeaders: headerEntries(withCorsHeaders(replay.headers, cors.headers)),
                     body: Buffer.from(replay.body).toString('base64'),
-                }, sessionId);
+                }, deliverOn);
                 attempt.assertLive();
                 opts.onEvent?.({ type: 'authorized', detail: { mode: 'token', authorizationId: replay.authorizationId, amountVerified: replay.amountVerified ?? null, cors: cors.outcome } });
             }
@@ -797,15 +1498,36 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
         }
         catch (err) {
             // Ignore the failure event caused by our own safe decline/error abort.
+            const dead = attempt.target ?? { requestId, sessionId };
             if (activeRequest?.attempt === attempt)
                 activeRequest = null;
-            lifecycle.failed(err, handoffStarted);
-            if (isTerminal(err))
-                terminal = err;
-            else if (isApprovalOutcome(err))
+            // Vault clients may normalize a merchantSignal abort. Preserve the
+            // adapter's more precise cause when ownership became ambiguous.
+            try {
+                attempt.assertLive();
+            }
+            catch (stopped) {
+                err = stopped;
+            }
+            if (err instanceof MerchantNeverRetried || (attempt.signal.aborted && approvedId && !deliveryBegun)) {
+                // The device approved and no request ever carried the answer: the
+                // page never asked again, or went away while the approval waited.
+                // Retire it (see retireUnusedApproval) and quiet the page's next
+                // request as after any other answered approval.
+                await retireUnusedApproval(opts, lifecycle, approvedId);
                 quietUntil = Date.now() + cooldownMs;
-            opts.onEvent?.({ type: 'failed', detail: failureSummary(err) });
-            await cdp.send('Fetch.failRequest', { requestId, errorReason: 'Aborted' }, sessionId).catch(() => { });
+            }
+            else {
+                // stop() already published the terminal state before aborting the Vault.
+                if (!attempt.signal.aborted)
+                    lifecycle.failed(err, handoffStarted);
+                if (isTerminal(err))
+                    terminal = err;
+                else if (isApprovalOutcome(err))
+                    quietUntil = Date.now() + cooldownMs;
+                opts.onEvent?.({ type: 'failed', detail: failureSummary(err) });
+            }
+            await cdp.send('Fetch.failRequest', { requestId: dead.requestId, errorReason: 'Aborted' }, dead.sessionId).catch(() => { });
         }
         finally {
             if (activeRequest?.attempt === attempt)
@@ -817,7 +1539,31 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
         }
     });
     try {
-        await arm(pageSessionId);
+        await withinAttachmentDeadline(async (assertActive) => {
+            const { targetInfo } = await cdp.send('Target.getTargetInfo', {}, pageSessionId);
+            assertActive();
+            if (!targetRecord(targetInfo) || targetInfo.type !== 'page'
+                || (targetInfo.browserContextId !== undefined && !contextId(targetInfo.browserContextId))) {
+                throw new CheckoutAttachmentError('unavailable');
+            }
+            merchantContext = targetInfo.browserContextId;
+            targetContextKnown = true;
+            await cdp.send('Target.setDiscoverTargets', { discover: true });
+            assertActive();
+            const { targetInfos } = await cdp.send('Target.getTargets');
+            assertActive();
+            if (!Array.isArray(targetInfos))
+                throw new CheckoutAttachmentError('unavailable');
+            for (const target of targetInfos)
+                assertContextTarget(target, merchantContext);
+            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());
+            assertActive();
+        }, setupTimeoutMs, setupStop.signal);
         if (setupStop.signal.aborted)
             throw attachmentFailure(setupStop.signal.reason);
         attachmentReady = true;
@@ -886,10 +1632,18 @@ export async function attachToPlaywright(page, opts) {
     let quietUntil = 0;
     // One outstanding approval at a time; see the note above isApprovalOutcome.
     let awaitingApproval = false;
+    // How long an approval waits for the page to ask again; see MERCHANT_RETRY_WAIT_MS.
+    const retryWait = retryWaitMs(opts.merchantRetryWaitMs);
     let activeRequest = null;
     page.on?.('requestfailed', (request) => {
-        if (activeRequest && activeRequest.request === request)
-            activeRequest.attempt.stop();
+        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
+            // so no later event on it can pass for the retry's.
+            activeRequest.request = null;
+            activeRequest.frames = [];
+            opts.onEvent?.({ type: 'merchant_request_lost', detail: { authorizationId: lifecycle.getState().authorizationId } });
+        }
     });
     page.on?.('close', () => { if (!attachmentReady)
         setupStop.abort(new CheckoutAttachmentError('closed')); preparationGate.invalidate('merchant_document_closed'); stripeCheckout.invalidate(); mercadoCheckout.invalidate(); activeRequest?.attempt.stop(); });
@@ -905,6 +1659,18 @@ export async function attachToPlaywright(page, opts) {
             }
             if (preparationGate.isEngaged())
                 activeRequest?.attempt.stop();
+            // The page that abandoned its request has moved to another document:
+            // its approval cannot be answered there and is cancelled. A reload of
+            // the same document is not that; its re-issued request is the retry.
+            let url;
+            try {
+                url = typeof frame.url === 'function' ? frame.url() : undefined;
+            }
+            catch {
+                url = undefined;
+            }
+            if (activeRequest?.attempt.lost && documentKey(url) !== activeRequest.identity.documentUrl)
+                activeRequest.attempt.stop();
         }
     });
     page.on?.('framedetached', (frame) => {
@@ -1017,12 +1783,33 @@ export async function attachToPlaywright(page, opts) {
             }
             let preparation;
             try {
-                preparation = stripeStep ? undefined : preparationGate.claim(request.url(), request.postData() ?? '');
+                preparation = stripeStep ? undefined : preparationGate.claim(request.url(), request.postData() ?? '', request.headers());
             }
             catch (error) {
                 opts.onEvent?.({ type: 'blocked', detail: failureSummary(error) });
                 return route.abort('aborted');
             }
+            // The page asking again for the purchase an outstanding approval is
+            // for, after its own request timed out: bind it to that approval (see
+            // merchantAttempt and the same check in attachToCdp).
+            if (awaitingApproval && activeRequest?.attempt.lost && !terminal && !setupStop.signal.aborted && !lifecycle.isCancelled()) {
+                const retry = requestIdentity(opts, request.url(), request.method(), request.postData() ?? '', documentKey(await documentUrlOf(readDocumentUrl, lifecycle.abort.signal)), await pageAmountOf(opts));
+                if (activeRequest?.attempt.lost && sameCheckoutRequest(activeRequest.identity, retry)) {
+                    if (preparation)
+                        preparationGate.retireUnboundClaim();
+                    const retryFrames = [];
+                    try {
+                        for (let frame = request.frame?.(); frame; frame = frame.parentFrame?.())
+                            retryFrames.push(frame);
+                    }
+                    catch { /* covered by requestfailed */ }
+                    activeRequest.request = request;
+                    activeRequest.frames = retryFrames;
+                    opts.onEvent?.({ type: 'card_request_paused', detail: { url: redactUrl(request.url()), authorizationId: lifecycle.getState().authorizationId, retry: true } });
+                    activeRequest.attempt.bind({ route, request, frames: retryFrames });
+                    return;
+                }
+            }
             // 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), the same code the
@@ -1037,19 +1824,34 @@ export async function attachToPlaywright(page, opts) {
             }
             // Reserved before anything that could yield, matching attachToCdp.
             awaitingApproval = true;
-            const attempt = merchantAttempt(lifecycle);
+            let navigation = false;
+            try {
+                navigation = typeof request.resourceType === 'function' && request.resourceType() === 'document';
+            }
+            catch {
+                navigation = false;
+            }
+            const attempt = merchantAttempt(lifecycle, survivesAbandonment(opts, request.url(), request.method(), navigation, !!preparation || !!stripeStep || mercadoCheckout.requiresDocument(request.url(), request.method())));
             const frames = [];
             try {
                 for (let frame = request.frame?.(); frame; frame = frame.parentFrame?.())
                     frames.push(frame);
             }
             catch { /* requestfailed/page close still cover unavailable frame metadata */ }
+            // Judged on the request that currently carries the attempt: after a
+            // retry binds, the first request's failure is history, not a loss.
             const assertRequestLive = () => {
-                if (request.failure?.() || page.isClosed?.() || frames.some(frame => frame.isDetached?.()))
+                const current = attempt.target;
+                if (current && (current.request.failure?.() || current.frames.some((frame) => frame.isDetached?.())))
+                    attempt.lose();
+                if (page.isClosed?.())
                     attempt.stop();
                 attempt.assertLive();
             };
             let handoffStarted = false;
+            // The approval the device gave, and whether it reached a browser request.
+            let approvedId = null;
+            let deliveryBegun = false;
             try {
                 const body = request.postData() ?? '';
                 if (isRepeatOfSubmitted(lastSubmitted, request.url(), body, repeatQuietMs)) {
@@ -1058,12 +1860,20 @@ export async function attachToPlaywright(page, opts) {
                 }
                 opts.onEvent?.({ type: 'card_request_paused', detail: { url: redactUrl(request.url()) } });
                 lifecycle.begin();
-                activeRequest = { request, frames, attempt };
+                const approvalStartedAt = Date.now();
+                attempt.bind({ route, request, frames });
+                activeRequest = { request, frames, attempt,
+                    identity: requestIdentity(opts, request.url(), request.method(), body, undefined, undefined) };
                 if (preparation)
                     await preparationGate.assertDocument();
-                const pageOrigin = await pageOriginOf(readDocumentUrl, attempt.signal);
+                // 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);
                 assertRequestLive();
+                activeRequest.identity.documentUrl = documentKey(documentUrl);
+                activeRequest.identity.pageAmount = pageAmount;
+                activeRequest.identity.amountEvidence ||= pageAmount !== undefined;
                 if (stripeStep)
                     stripeCheckout.assertClaim(stripeStep);
                 const merchantOrigin = preparation?.merchantOrigin ?? (opts.executionMode === 'user_approval'
@@ -1095,6 +1905,7 @@ export async function attachToPlaywright(page, opts) {
                             ? { mercado_checkout: mercadoCheckout.claimToken(request.url(), request.method(), await readDocumentUrl()) } : {}) },
                 });
                 assertRequestLive();
+                approvedId = replay.authorizationId;
                 if (lifecycle.isCancelled())
                     throw new Error('checkout cancelled locally after approval');
                 try {
@@ -1104,25 +1915,35 @@ export async function attachToPlaywright(page, opts) {
                     throw new PaymentOutcomeUnknownError(replay.authorizationId, 'mercado_checkout_metadata_invalid');
                 }
                 assertRequestLive();
-                lifecycle.prepareHandoff(replay, request.url());
+                // The request to answer: the paused one, or the page's retry when the
+                // page gave up on the first (see attachToCdp for the same step).
+                const delivery = await attempt.awaitTarget(boundedRetryWait(retryWait, approvalStartedAt, opts.timeoutMs), [lifecycle.abort.signal, setupStop.signal], () => {
+                    lifecycle.awaitingMerchantRetry(replay.authorizationId);
+                    opts.onEvent?.({ type: 'approval_awaiting_merchant_retry', detail: { authorizationId: replay.authorizationId } });
+                });
+                const { route: deliverTo, request: deliverRequest } = delivery.target;
+                const deliverBody = delivery.rebound ? deliverRequest.postData() ?? '' : body;
+                deliveryBegun = true;
+                attempt.beginDelivery();
+                lifecycle.prepareHandoff(replay, deliverRequest.url());
                 handoffStarted = replay.mode !== 'cse';
                 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 });
                     // Inert on a navigation (never CORS-checked); one path for every fulfill.
-                    await route.fulfill({ status: synthetic.status, headers: withCorsHeaders(synthetic.headers, corsHeadersFor(request.url(), request.headers())), body: synthetic.body });
+                    await deliverTo.fulfill({ status: synthetic.status, headers: withCorsHeaders(synthetic.headers, corsHeadersFor(deliverRequest.url(), deliverRequest.headers())), body: synthetic.body });
                     assertRequestLive();
-                    lastSubmitted = { url: request.url(), body, at: Date.now() };
+                    lastSubmitted = { url: deliverRequest.url(), body: deliverBody, at: Date.now() };
                     opts.onEvent?.({ type: 'submitted_on_device', detail: { authorizationId: replay.authorizationId, submittedAt: replay.submittedAt, outcome: replay.outcome } });
                 }
                 else if (replay.mode === 'cse') {
                     // Same as the CDP path: the request continues from this browser
                     // with the ciphertext swapped in and no header override; Playwright
                     // recomputes the length itself.
-                    const postData = cseBody(body, replay);
+                    const postData = cseBody(deliverBody, replay);
                     handoffStarted = true;
-                    await route.continue({ postData });
+                    await deliverTo.continue({ postData });
                     assertRequestLive();
                     opts.onEvent?.({ type: 'authorized', detail: { mode: 'cse', authorizationId: replay.authorizationId, fields: Object.keys(replay.substitutions.fields) } });
                 }
@@ -1130,23 +1951,39 @@ export async function attachToPlaywright(page, opts) {
                     // Playwright adds these itself when a cross-origin fulfill carries
                     // none; written here anyway (replacing a stale value) so a
                     // cross-origin answer is the same whichever adapter ran.
-                    const cors = corsDecision(request.url(), request.headers());
-                    await route.fulfill({ status: replay.status, headers: withCorsHeaders(replay.headers, cors.headers), body: replay.body });
+                    const cors = corsDecision(deliverRequest.url(), deliverRequest.headers());
+                    await deliverTo.fulfill({ status: replay.status, headers: withCorsHeaders(replay.headers, cors.headers), body: replay.body });
                     assertRequestLive();
                     opts.onEvent?.({ type: 'authorized', detail: { mode: 'token', authorizationId: replay.authorizationId, amountVerified: replay.amountVerified ?? null, cors: cors.outcome } });
                 }
                 lifecycle.handedOff(replay);
             }
             catch (err) {
+                const dead = attempt.target?.route ?? route;
                 if (activeRequest?.attempt === attempt)
                     activeRequest = null;
-                lifecycle.failed(err, handoffStarted);
-                if (isTerminal(err))
-                    terminal = err;
-                else if (isApprovalOutcome(err))
+                try {
+                    attempt.assertLive();
+                }
+                catch (stopped) {
+                    err = stopped;
+                }
+                if (err instanceof MerchantNeverRetried || (attempt.signal.aborted && approvedId && !deliveryBegun)) {
+                    // The device approved and no request ever carried the answer; see
+                    // the same branch in attachToCdp.
+                    await retireUnusedApproval(opts, lifecycle, approvedId);
                     quietUntil = Date.now() + cooldownMs;
-                opts.onEvent?.({ type: 'failed', detail: failureSummary(err) });
-                await route.abort('aborted').catch(() => { });
+                }
+                else {
+                    if (!attempt.signal.aborted)
+                        lifecycle.failed(err, handoffStarted);
+                    if (isTerminal(err))
+                        terminal = err;
+                    else if (isApprovalOutcome(err))
+                        quietUntil = Date.now() + cooldownMs;
+                    opts.onEvent?.({ type: 'failed', detail: failureSummary(err) });
+                }
+                await dead.abort('aborted').catch(() => { });
             }
             finally {
                 if (activeRequest?.attempt === attempt)