@agent-cards/checkout 0.4.1 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.6.0
+
+- Recognize Paysafe Checkout 1.8's exact hosted tokenization endpoints and preserve its native credential and correlation headers. The matching API registry and Vault deployment are required.
+- Recognize Checkout.com card tokenization at `card-acquisition-gateway.checkout.com/tokens` and its sandbox counterpart alongside the existing API hosts. The matching backend registry and Vault deployment are required; this entry does not establish native merchant payment completion.
+- Prepare Worldpay, Bambora and Mercado Pago checkout before the merchant's first Pay action. Use `psp: 'worldpay'` with `environment: 'production' | 'sandbox'`, or `psp: 'bambora' | 'mercado_pago'` with `environment: 'shared'`. Shared endpoints do not establish processor test mode. The merchant's credentials and checkout configuration determine that mode.
+- Keep the existing selected-card, merchant, document, amount, currency and one-use consent checks. The native request begins only after approval, and approval readiness lasts at most 30 seconds. The SDK does not extend processor deadlines or automatically retry after payment uncertainty. Matching API, Vault and preparation migration are required.
+- Bound Playwright and CDP setup with `attachmentTimeoutMs`, defaulting to 30 seconds. A stalled setup throws a sanitized `CheckoutAttachmentError`; late acknowledgements cannot start approval or retry setup, and concurrent setup failures report once. Close the failed checkout page and start a fresh context before trying again.
+- Preserve the original setup failure across attached frames: a transport failure reports `unavailable`, a deadline reports `timeout`, and an observed page closure reports `closed`.
+- Reject processor URLs with credentials or nondefault ports consistently across SDK and API discovery. Registry synchronization updates endpoint recognition; upgrading the SDK is required for the new preparation and setup behavior.
+
+The matching Vault/API release adds Mollie card-token and supported Airwallex intent-confirmation replay through browser-owned TLS, preserves Worldpay's native session media type and Bambora's `cvd` field, and reports Nuvei's unambiguous validation error as processor refusal. Local regression and Chromium fixture results do not establish native processor acceptance or a completed merchant purchase.
+
+## 0.5.0
+
+- Prepare Braintree card checkout with `controller.prepare({ psp: 'braintree', environment: 'production' | 'sandbox' })` before the merchant's first Pay action. The cardholder approves and unlocks first; one fresh native request then uses that approval without another notification. The matching API and Vault release is required.
+- Let native Braintree client-configuration queries pass without consuming consent. Prepared checkout accepts one card-tokenization mutation for the approved processor and environment. Other operations, ambiguous GraphQL payloads and legacy REST fallback cannot use the preparation.
+- Keep the native request timeout and one-use, card, merchant, amount, currency and document bindings. Approval readiness lasts at most 30 seconds. Tokenization amounts remain display-only; a token does not establish a paid order.
+- Add a real Chromium fixture with approval delayed 61 seconds before a fresh 60-second XHR, plus cancellation, request classification and binding regressions. The isolated fixture contacts no payment processor and is not live purchase proof.
+
 ## 0.4.1
 
 - Stop describing every processor request rejection as a card decline or proof that nothing was charged. `ProcessorRefusedError` keeps its existing class and code, with neutral wording and an optional `processorError` containing bounded Razorpay reason, source, step and payment/order identifiers from the matching API/Vault release. Older failure records cannot recover details that were not retained.

package/README.md

@@ -82,7 +82,7 @@ pair is shown and reported (`amountAuthority: 'display_only'`), not enforced.
 Then let your agent click "Pay" like it always does. `attachToCdp` pauses the
 request for approval and resumes it only while the merchant request remains
 live. Merchant timeouts still apply: Square's observed tokenization deadline
-is about 10 seconds for approval and token handoff. For human approval, use
+is about 10 seconds, and Braintree's native request timeout is 60 seconds, including approval and token handoff. For human approval, use
 `controller.prepare()` before the first Pay action as shown below.
 
 Playwright:
@@ -130,7 +130,7 @@ Coverage is specific to the processor request format, merchant setup, browser tr
 |---|---|
 | Shopify | supported, verified end to end |
 | Stripe | tokenization replay and direct card-bearing PaymentIntent confirms are implemented; direct confirms with `amountCents` + `currency` use backend amount verification. Browser token-to-intent continuation is unsupported and held. Validate the exact merchant flow before pilot use |
-| Braintree / PayPal | supported, verified end to end |
+| Braintree card tokenization | Prepared checkout supported; one live Haymarket Books ebook purchase with SDK `0.5.0` confirmed merchant fulfillment and SDK `completed` using a merchant receipt resolver. Independent processor capture/settlement, live 3DS and PayPal wallet flows remain unverified. |
 | Checkout.com | supported |
 | VGS Collect (Very Good Security; Wolt) | not supported: VGS's proxy aliases only submissions from its own iframe, so a replay from the cardholder's device is refused by the merchant (verified on Wolt, 2026-09-03). Not recognized, so the agent's browser is not paused there |
 | Adyen | supported (mode `cse`): the vault encrypts the card for Adyen on the cardholder's device and your browser sends it |
@@ -327,6 +327,16 @@ Playwright `CDPSession` is not the `CdpLike` interface. Raw CDP must preserve th
 Initial arming errors reject `attachToCdp`; a child that cannot be armed remains
 paused and reports `browser_interception_unavailable` for operator recovery.
 
+Await attachment before clicking Pay. Both adapters stop waiting for browser
+setup after 30 seconds and throw `CheckoutAttachmentError` with
+`code: 'checkout_attachment_failed'` and `reason: 'timeout'`, `'closed'` or
+`'unavailable'`. Use `attachmentTimeoutMs` to choose a setup deadline from 1 to
+300000 milliseconds, separately from the approval's `timeoutMs`.
+Close the failed checkout page and create a fresh browser context before
+trying again. A late setup response cannot reopen the failed attachment or
+request approval; intercepted card requests remain blocked. A setup failure
+does not establish the status of any earlier purchase.
+
 Use a checkout context created with `serviceWorkers: 'block'`. Playwright cannot
 route requests intercepted by a service worker. The SDK rejects already active
 service workers, but that check cannot prevent a site from registering one
@@ -400,7 +410,9 @@ do not reuse that token in a new attachment as a workaround. Configuration and
 unsupported-mode failures require fixing the integration. Bank flows requiring
 another confirmation and other stored-token chains remain unverified.
 
-Square's observed native tokenization request expires after about 10 seconds. SDK 0.4.0 adds approval before submission, requiring the matching preparation API and Vault deployment. Start human approval before the caller's first Pay action:
+Worldpay, Bambora and Mercado Pago preparation requires SDK 0.6.0 or later and the matching API and Vault release.
+
+Prepare a Square, Braintree, Worldpay, Bambora or Mercado Pago checkout before the first Pay action so the cardholder can approve before the native card request starts. The API and Vault deployments must support the selected processor:
 
 ```ts
 const checkout = await attachToPlaywright(page, {
@@ -409,19 +421,31 @@ const checkout = await attachToPlaywright(page, {
   onApprovalUrl: deliverPrivatelyToCardholder,
 });
 const preparation = await checkout.prepare({
-  psp: 'square',
-  environment: 'production', // explicit; use 'sandbox' for Square Sandbox
+  psp: 'braintree',
+  environment: 'production', // Square, Braintree and Worldpay: production or sandbox
 });
 // The cardholder has consented and unlocked the same approval document.
 // No processor request or payment has started.
 await page.getByRole('button', { name: 'Pay', exact: true }).click();
 ```
 
-`prepare()` is available on both Playwright and raw CDP controllers. It requires `amountCents` and `currency`, must precede the first recognized card request, and returns only when the cardholder's device is ready. It delivers the preparation URL through `onApprovalUrl` and `onUserAction`; binding the subsequent authorization sends no second approval link or SMS. The phone page must stay open. Its selected card, merchant origin, declared merchant, amount, currency and Square environment bind one fresh request. The amount remains `display_only`; a Square token does not enforce the merchant's eventual charge amount.
+`prepare()` is available on both Playwright and raw CDP controllers. It requires `amountCents` and `currency`, must precede the first recognized card request, and returns only when the cardholder's device is ready. It delivers the preparation URL through `onApprovalUrl` and `onUserAction`; binding the subsequent authorization sends no second approval link or SMS. The phone page must stay open. Its selected card, merchant origin, declared merchant, amount, currency, processor and environment bind one fresh request. The amount remains `display_only`; a card token does not enforce the merchant's eventual charge amount.
+
+| Processor | `environment` | Fresh native request |
+| --- | --- | --- |
+| Square | `production` or `sandbox` | Matching Square `/v2/card-nonce` host |
+| Braintree | `production` or `sandbox` | Matching Braintree GraphQL host and guest `TokenizeCreditCard` mutation |
+| Worldpay | `production` or `sandbox` | Matching Access Worldpay host and `/sessions/card` |
+| Bambora | `shared` | `/scripts/tokenization/tokens` on `api.bam.shift4api.net` or `api.na.bambora.com` |
+| Mercado Pago | `shared` | `api.mercadopago.com/v1/card_tokens` with a fresh card body |
+
+Use `environment: 'shared'` for Bambora and Mercado Pago because the same endpoint serves test and live requests. Agentcard cannot establish the processor's test mode from that URL or a credential prefix. Configure test mode through the merchant's processor account when testing. Agentcard's own `sandbox` flag remains separate. Prepared Worldpay, Bambora and Mercado Pago requests reject saved-card and recurring request bodies; a refused request retires the local preparation. Reconcile any existing merchant attempt before creating a new attachment.
+
+Braintree's native `ClientConfiguration` GraphQL query can run before, during or after preparation without using the approval. Only a single `TokenizeCreditCard` mutation can consume the prepared Braintree checkout. Prepared requests require guest card tokenization with explicit `options.validate: false`; omitted validation options, saved-card fields and `validate: true` are refused. Other GraphQL operations, batches and compound mutations are blocked. Braintree's legacy REST fallback cannot consume a prepared authorization.
 
-Readiness lasts up to 30 seconds (`preparation.expiresAt`) and appears as `ready_to_submit`, with `paymentStatus: 'not_started'`. Trigger the caller-owned Pay action immediately after the promise resolves. Expiry, navigation, cancellation, an early request or a changed checkout fails closed. A preparation and its attachment are single use; reconcile any bound authorization before creating a new attachment. The SDK never clicks Pay, reuses a stale request, pauses Square timers, or automatically retries a failed prepared checkout.
+Readiness lasts up to 30 seconds (`preparation.expiresAt`) and appears as `ready_to_submit`, with `paymentStatus: 'not_started'`. Trigger the caller-owned Pay action immediately after the promise resolves. Expiry, navigation, cancellation, an early request or a changed checkout fails closed. A preparation and its attachment are single use; reconcile any bound authorization before creating a new attachment. The SDK never clicks Pay, reuses a stale request, changes native request deadlines, or automatically retries a failed prepared checkout.
 
-After Pay, Square's native deadline still covers fresh authorization binding, device replay, relay and token handoff. A disconnected/backgrounded phone or slow transport can still miss it. A subsequent SCA challenge has its own lifetime after token handoff. If the merchant request aborts or its frame closes, the attachment blocks further requests and tries to retire the pre-replay authorization; a started replay or unconfirmed cancellation remains unknown. Without `prepare()`, approval loading and human interaction still share the native deadline, so delayed approval cannot finish that request.
+After Pay, the processor's native deadline still covers fresh authorization binding, device replay and token handoff. A disconnected/backgrounded phone or slow transport can still miss it. A subsequent SCA challenge has its own lifetime after token handoff. If the merchant request aborts or its frame closes, the attachment blocks further requests and tries to retire the pre-replay authorization; a started replay or unconfirmed cancellation remains unknown. Without `prepare()`, approval loading and human interaction still share the native deadline, so delayed approval cannot finish that request.
 
 Lost authorization polling, local approval timeouts, or interrupted browser
 handoffs produce `outcome_unknown` and block automatic retry. The thrown
@@ -470,9 +494,7 @@ The browser fixtures never contact a payment service. The general suite uses
 allowlisted loopback proxy and a temporary self-signed TLS stub (requires the
 `openssl` CLI). All other proxy destinations are rejected. These suites use an
 in-process Agentcard API fixture and loopback merchant pages. The preparation
-fixture denies all external traffic, waits more than ten seconds before any
-card request, and then checks one fresh request with an unchanged ten-second
-fixture abort timer. It exercises SDK ordering, not the native Square SDK. It proves nested-frame pause/resume, agent control during approval,
+fixture denies all external traffic and waits beyond each modeled request deadline before any card request: eleven seconds for Square, sixty-one seconds for Braintree, and six and a half seconds for Worldpay, Bambora and Mercado Pago. Each fixture then checks one fresh request with an unchanged abort timer. The five-second timer matches the inspected Worldpay and Bambora source; the Mercado Pago timer is a test boundary, not a measured native deadline. The fixture exercises SDK ordering with native-shaped request bodies and synthetic responses, not processor acceptance. It proves nested-frame pause/resume, agent control during approval,
 post-payment tasks in the same page, decline/expiry/cancel, unknown-outcome retry
 blocking, explicit unsupported endpoint behavior, and blocking an immediate real-browser
 Stripe token-to-intent fetch chain, including unrelated first intents, changed

package/dist/attachment.d.ts

@@ -0,0 +1,11 @@
+/** An attachment failure has no payment or browser credentials in its message. */
+export declare class CheckoutAttachmentError extends Error {
+    readonly reason: 'timeout' | 'closed' | 'unavailable';
+    readonly code = "checkout_attachment_failed";
+    constructor(reason: 'timeout' | 'closed' | 'unavailable');
+}
+/** Preserve a known setup cause without exposing raw transport errors. */
+export declare function attachmentFailure(error: unknown): CheckoutAttachmentError;
+export declare function attachmentDeadline(value: number | undefined): number;
+/** Stop waiting, then reject every late continuation before its next command. */
+export declare function withinAttachmentDeadline(arm: (assertActive: () => void) => Promise<void>, timeoutMs: number, signal: AbortSignal): Promise<void>;

package/dist/attachment.js

@@ -0,0 +1,50 @@
+/** An attachment failure has no payment or browser credentials in its message. */
+export class CheckoutAttachmentError extends Error {
+    reason;
+    code = 'checkout_attachment_failed';
+    constructor(reason) {
+        super('Could not attach checkout interception. Close this checkout page and retry in a fresh browser context.');
+        this.reason = reason;
+        this.name = 'CheckoutAttachmentError';
+    }
+}
+/** Preserve a known setup cause without exposing raw transport errors. */
+export function attachmentFailure(error) {
+    return error instanceof CheckoutAttachmentError ? error : new CheckoutAttachmentError('unavailable');
+}
+export function attachmentDeadline(value) {
+    if (value === undefined)
+        return 30_000;
+    if (!Number.isSafeInteger(value) || value <= 0 || value > 300_000) {
+        throw new Error('attachmentTimeoutMs must be an integer between 1 and 300000.');
+    }
+    return value;
+}
+/** Stop waiting, then reject every late continuation before its next command. */
+export async function withinAttachmentDeadline(arm, timeoutMs, signal) {
+    let stopped;
+    let timer;
+    let onAbort = () => { };
+    const assertActive = () => { if (stopped)
+        throw stopped; };
+    const deadline = new Promise((_resolve, reject) => {
+        const stop = (failure) => { stopped ??= failure; reject(stopped); };
+        onAbort = () => stop(attachmentFailure(signal.reason));
+        signal.addEventListener('abort', onAbort, { once: true });
+        if (signal.aborted)
+            onAbort();
+        else
+            timer = setTimeout(() => stop(new CheckoutAttachmentError('timeout')), timeoutMs);
+    });
+    try {
+        await Promise.race([deadline, Promise.resolve().then(() => { assertActive(); return arm(assertActive); })]);
+    }
+    catch (error) {
+        stopped ??= attachmentFailure(error);
+        throw stopped;
+    }
+    finally {
+        clearTimeout(timer);
+        signal.removeEventListener('abort', onAbort);
+    }
+}

package/dist/braintree.d.ts

@@ -0,0 +1,10 @@
+/** Classify native Braintree GraphQL requests without changing their bytes. */
+export type BraintreeEnvironment = 'production' | 'sandbox';
+export type BraintreeRequestKind = 'configuration' | 'tokenization' | 'invalid';
+export declare function braintreeEnvironment(url: string): BraintreeEnvironment | undefined;
+/** Bounded duplicate-aware JSON for fresh-card preparation bodies. */
+export declare function readTokenizationJson(body: string | null): Record<string, unknown> | null;
+/** Undefined belongs to another processor; invalid Braintree requests stay blocked. */
+export declare function classifyBraintreeRequest(url: string, method: string, body: string | null): BraintreeRequestKind | undefined;
+/** Preparation accepts guest tokenization only; ordinary interception stays broader. */
+export declare function isPreparedBraintreeRequest(body: string | null): boolean;

package/dist/braintree.js

@@ -0,0 +1,302 @@
+const PRODUCTION = 'https://payments.braintree-api.com/graphql';
+const SANDBOX = 'https://payments.sandbox.braintree-api.com/graphql';
+const MAX_BODY_LENGTH = 128 * 1024;
+const MAX_DEPTH = 32;
+const MAX_NODES = 10_000;
+export function braintreeEnvironment(url) {
+    return url === PRODUCTION ? 'production' : url === SANDBOX ? 'sandbox' : undefined;
+}
+function invalid() { throw new Error('invalid_braintree_request'); }
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+/** JSON.parse discards duplicate keys, so validate keys before using any value. */
+class JsonReader {
+    text;
+    at = 0;
+    nodes = 0;
+    constructor(text) {
+        this.text = text;
+    }
+    read() {
+        const value = this.value(0);
+        this.space();
+        if (this.at !== this.text.length)
+            invalid();
+        return value;
+    }
+    space() {
+        while (' \t\r\n'.includes(this.text[this.at] ?? '\0'))
+            this.at++;
+    }
+    take(expected) {
+        this.space();
+        if (this.text[this.at++] !== expected)
+            invalid();
+    }
+    string() {
+        this.space();
+        const start = this.at;
+        if (this.text[this.at++] !== '"')
+            invalid();
+        while (this.at < this.text.length) {
+            const char = this.text[this.at++];
+            if (char === '\\') {
+                this.at++;
+                continue;
+            }
+            if (char === '"')
+                return JSON.parse(this.text.slice(start, this.at));
+        }
+        return invalid();
+    }
+    value(depth) {
+        if (depth > MAX_DEPTH || ++this.nodes > MAX_NODES)
+            invalid();
+        this.space();
+        const char = this.text[this.at];
+        if (char === '"')
+            return this.string();
+        if (char === '{') {
+            this.at++;
+            const result = Object.create(null);
+            const keys = new Set();
+            this.space();
+            if (this.text[this.at] === '}') {
+                this.at++;
+                return result;
+            }
+            while (true) {
+                const key = this.string();
+                if (keys.has(key))
+                    invalid();
+                keys.add(key);
+                this.take(':');
+                result[key] = this.value(depth + 1);
+                this.space();
+                const next = this.text[this.at++];
+                if (next === '}')
+                    return result;
+                if (next !== ',')
+                    invalid();
+            }
+        }
+        if (char === '[') {
+            this.at++;
+            const result = [];
+            this.space();
+            if (this.text[this.at] === ']') {
+                this.at++;
+                return result;
+            }
+            while (true) {
+                result.push(this.value(depth + 1));
+                this.space();
+                const next = this.text[this.at++];
+                if (next === ']')
+                    return result;
+                if (next !== ',')
+                    invalid();
+            }
+        }
+        for (const [literal, value] of [['true', true], ['false', false], ['null', null]]) {
+            if (this.text.startsWith(literal, this.at)) {
+                this.at += literal.length;
+                return value;
+            }
+        }
+        const number = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/.exec(this.text.slice(this.at));
+        if (!number)
+            invalid();
+        this.at += number[0].length;
+        const value = Number(number[0]);
+        if (!Number.isFinite(value))
+            invalid();
+        return value;
+    }
+}
+/** Bounded duplicate-aware JSON for fresh-card preparation bodies. */
+export function readTokenizationJson(body) {
+    if (typeof body !== 'string' || body.length === 0 || body.length > MAX_BODY_LENGTH)
+        return null;
+    try {
+        const value = new JsonReader(body).read();
+        return record(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Native operations need names, punctuation and variables, never literals. */
+function lex(query) {
+    const tokens = [];
+    let at = 0;
+    while (at < query.length) {
+        const char = query[at];
+        if (' \t\r\n,'.includes(char)) {
+            at++;
+            continue;
+        }
+        if ('!$():{}'.includes(char)) {
+            tokens.push(char);
+            at++;
+        }
+        else if (/[A-Za-z_]/.test(char)) {
+            const start = at++;
+            while (at < query.length && /[A-Za-z_0-9]/.test(query[at]))
+                at++;
+            tokens.push(query.slice(start, at));
+        }
+        else
+            invalid(); // Includes comments, strings, fragments and directives.
+        if (tokens.length > MAX_NODES)
+            invalid();
+    }
+    return tokens;
+}
+class GraphqlReader {
+    tokens;
+    at = 0;
+    constructor(tokens) {
+        this.tokens = tokens;
+    }
+    peek() { return this.tokens[this.at]; }
+    take(expected) {
+        if (this.tokens[this.at++] !== expected)
+            invalid();
+    }
+    name() {
+        const value = this.tokens[this.at++];
+        if (!value || !/^[A-Za-z_][A-Za-z_0-9]*$/.test(value))
+            invalid();
+        return value;
+    }
+    read() {
+        const kind = this.name();
+        const name = this.name();
+        let inputDefinition = false;
+        if (this.peek() === '(') {
+            // No defaults, alternate types, unused variables or duplicate definitions.
+            for (const token of ['(', '$', 'input', ':', 'TokenizeCreditCardInput', '!', ')'])
+                this.take(token);
+            inputDefinition = true;
+        }
+        const fields = this.selection(0);
+        if (this.at !== this.tokens.length)
+            invalid();
+        return { kind, name, inputDefinition, fields };
+    }
+    selection(depth) {
+        if (depth > MAX_DEPTH)
+            invalid();
+        this.take('{');
+        const fields = [];
+        const names = new Set();
+        while (this.peek() !== '}') {
+            const name = this.name();
+            if (names.has(name))
+                invalid();
+            names.add(name);
+            const args = [];
+            if (this.peek() === '(') {
+                if (depth !== 0)
+                    invalid();
+                this.take('(');
+                const argument = this.name();
+                this.take(':');
+                this.take('$');
+                args.push({ name: argument, variable: this.name() });
+                this.take(')');
+            }
+            const children = this.peek() === '{' ? this.selection(depth + 1) : [];
+            fields.push({ name, arguments: args, fields: children });
+            // Aliases, directives and other punctuation cannot begin the next field.
+        }
+        this.take('}');
+        if (fields.length === 0)
+            invalid();
+        return fields;
+    }
+}
+/** Undefined belongs to another processor; invalid Braintree requests stay blocked. */
+export function classifyBraintreeRequest(url, method, body) {
+    let hostname;
+    try {
+        hostname = new URL(url).hostname;
+    }
+    catch {
+        return undefined;
+    }
+    if (hostname !== 'payments.braintree-api.com' && hostname !== 'payments.sandbox.braintree-api.com')
+        return undefined;
+    if (!braintreeEnvironment(url) || method !== 'POST' || typeof body !== 'string' || body.length === 0 || body.length > MAX_BODY_LENGTH)
+        return 'invalid';
+    try {
+        const envelope = new JsonReader(body).read();
+        if (!record(envelope) || typeof envelope.query !== 'string' || typeof envelope.operationName !== 'string')
+            return 'invalid';
+        if (Object.keys(envelope).some(key => !['query', 'operationName', 'variables', 'clientSdkMetadata'].includes(key)))
+            return 'invalid';
+        if (envelope.clientSdkMetadata !== undefined && !record(envelope.clientSdkMetadata))
+            return 'invalid';
+        const operation = new GraphqlReader(lex(envelope.query)).read();
+        if (operation.name !== envelope.operationName || operation.fields.length !== 1)
+            return 'invalid';
+        const root = operation.fields[0];
+        if (root.fields.length === 0)
+            return 'invalid';
+        const variables = envelope.variables === undefined ? Object.create(null) : envelope.variables;
+        if (!record(variables))
+            return 'invalid';
+        if (operation.kind === 'query' && ['ClientConfiguration', 'ClientConfigurationQuery'].includes(operation.name)
+            && !operation.inputDefinition && root.name === 'clientConfiguration' && root.arguments.length === 0
+            && Object.keys(variables).length === 0)
+            return 'configuration';
+        if (operation.kind !== 'mutation' || operation.name !== 'TokenizeCreditCard' || !operation.inputDefinition
+            || root.name !== 'tokenizeCreditCard' || root.arguments.length !== 1
+            || root.arguments[0].name !== 'input' || root.arguments[0].variable !== 'input'
+            || Object.keys(variables).length !== 1 || !record(variables.input) || !record(variables.input.creditCard))
+            return 'invalid';
+        const card = variables.input.creditCard;
+        if (!['number', 'expirationMonth', 'expirationYear'].every(key => typeof card[key] === 'string' && card[key].trim().length > 0))
+            return 'invalid';
+        if (card.cvv !== undefined && (typeof card.cvv !== 'string' || card.cvv.trim().length === 0))
+            return 'invalid';
+        return 'tokenization';
+    }
+    catch {
+        return 'invalid';
+    }
+}
+/** Preparation accepts guest tokenization only; ordinary interception stays broader. */
+export function isPreparedBraintreeRequest(body) {
+    if (classifyBraintreeRequest(PRODUCTION, 'POST', body) !== 'tokenization')
+        return false;
+    try {
+        const envelope = new JsonReader(body).read();
+        const variables = envelope.variables;
+        const input = variables.input;
+        if (Object.keys(input).some(key => key !== 'creditCard' && key !== 'options'))
+            return false;
+        const card = input.creditCard;
+        if (Object.keys(card).some(key => !['number', 'expirationMonth', 'expirationYear', 'cvv', 'cardholderName', 'billingAddress'].includes(key)))
+            return false;
+        if (Object.entries(card).some(([key, value]) => key !== 'billingAddress' && typeof value !== 'string'))
+            return false;
+        if (card.billingAddress !== undefined) {
+            if (!record(card.billingAddress))
+                return false;
+            const addressKeys = ['postalCode', 'firstName', 'lastName', 'company', 'streetAddress', 'extendedAddress',
+                'locality', 'region', 'countryCodeNumeric', 'countryCodeAlpha2', 'countryCodeAlpha3', 'countryName'];
+            if (Object.entries(card.billingAddress).some(([key, value]) => !addressKeys.includes(key) || typeof value !== 'string'))
+                return false;
+        }
+        // Fingerprint authorization defaults validation on when the option is absent.
+        // Preparation permits only an explicit request for a transient card token.
+        return record(input.options) && Object.keys(input.options).every(key => key === 'validate')
+            && input.options.validate === false;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/cdp.d.ts

@@ -87,6 +87,8 @@ export interface AttachOptions extends LifecycleOptions {
     currency?: string;
     cardId?: string;
     timeoutMs?: number;
+    /** Browser interception setup deadline, separate from approval. Defaults to 30000 ms; maximum 300000 ms. */
+    attachmentTimeoutMs?: number;
     /** Explicit payment endpoints to block if the registry cannot handle their method/format. Unlisted traffic is untouched. */
     paymentEndpoints?: readonly PaymentEndpointGuard[];
     onApprovalUrl?: (url: string) => void;