@agent-cards/checkout 0.15.1 → 0.16.0

package/dist/checkout-com.generated.d.ts

@@ -0,0 +1,4 @@
+declare function checkoutComPreparationUrl(environment: any): any;
+declare function checkoutComEnvironment(url: any): "production" | "sandbox" | undefined;
+declare function isPreparedCheckoutComRequest(url: any, method: any, body: any, environment: any, headers: any): boolean;
+export { checkoutComEnvironment, checkoutComPreparationUrl, isPreparedCheckoutComRequest };

package/dist/checkout-com.generated.js

@@ -0,0 +1,183 @@
+// @ts-nocheck
+// Generated from @agent-cards/payment-core. Do not edit.
+// artifact-sha256: aaa2f76129db849a23bf8bb44043f5cff2b45e853b16b5de4d61a1f6a10cd392
+// src/checkout-com.js
+var ENDPOINTS = Object.freeze({
+    production: ["https://api.checkout.com/tokens", "https://card-acquisition-gateway.checkout.com/tokens"],
+    sandbox: ["https://api.sandbox.checkout.com/tokens", "https://card-acquisition-gateway.sandbox.checkout.com/tokens"]
+});
+var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var own = (value, name) => Object.prototype.hasOwnProperty.call(value, name);
+var keys = (value, allowed) => record(value) && Object.keys(value).every((name) => allowed.includes(name));
+var exact = (pattern, value) => typeof value === "string" && pattern.exec(value)?.[0] === value;
+var text = (value, max = 1024) => typeof value === "string" && value.length <= max && !/[\u0000-\u001f\u007f]/.test(value);
+var digits = (value, min, max) => typeof value === "string" && value.length >= min && value.length <= max && !/[^0-9]/.test(value);
+function readBody(body) {
+    if (typeof body !== "string" || !body || body.length > 65536)
+        return null;
+    let at = 0, nodes = 0;
+    const fail = () => {
+        throw new Error("invalid_checkout_com_json");
+    };
+    const space = () => {
+        while (" 	\r\n".includes(body[at] ?? "\0"))
+            at++;
+    };
+    const string = () => {
+        space();
+        const start = at;
+        if (body[at++] !== '"')
+            fail();
+        while (at < body.length) {
+            const char = body[at++];
+            if (char === "\\") {
+                at++;
+                continue;
+            }
+            if (char === '"')
+                return JSON.parse(body.slice(start, at));
+        }
+        return fail();
+    };
+    const value = (depth) => {
+        if (depth > 12 || ++nodes > 1e3)
+            fail();
+        space();
+        const char = body[at];
+        if (char === '"')
+            return string();
+        if (char === "{") {
+            at++;
+            const result = /* @__PURE__ */ Object.create(null), seen = /* @__PURE__ */ new Set();
+            space();
+            if (body[at] === "}") {
+                at++;
+                return result;
+            }
+            while (true) {
+                const key = string();
+                if (seen.has(key) || ["__proto__", "constructor", "prototype"].includes(key))
+                    fail();
+                seen.add(key);
+                space();
+                if (body[at++] !== ":")
+                    fail();
+                result[key] = value(depth + 1);
+                space();
+                const next = body[at++];
+                if (next === "}")
+                    return result;
+                if (next !== ",")
+                    fail();
+            }
+        }
+        if (char === "[") {
+            at++;
+            const result = [];
+            space();
+            if (body[at] === "]") {
+                at++;
+                return result;
+            }
+            while (true) {
+                result.push(value(depth + 1));
+                space();
+                const next = body[at++];
+                if (next === "]")
+                    return result;
+                if (next !== ",")
+                    fail();
+            }
+        }
+        for (const literal of ["true", "false", "null"]) {
+            if (body.startsWith(literal, at)) {
+                at += literal.length;
+                return JSON.parse(literal);
+            }
+        }
+        const number = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/.exec(body.slice(at));
+        if (!number)
+            fail();
+        at += number[0].length;
+        const parsed = Number(number[0]);
+        if (!Number.isFinite(parsed))
+            fail();
+        return parsed;
+    };
+    try {
+        const parsed = value(0);
+        space();
+        return at === body.length && record(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function checkoutComPreparationUrl(environment) {
+    if (environment !== "production" && environment !== "sandbox")
+        throw new Error("unsupported_preparation_environment");
+    return ENDPOINTS[environment][1];
+}
+function checkoutComEnvironment(url) {
+    if (ENDPOINTS.production.includes(url))
+        return "production";
+    if (ENDPOINTS.sandbox.includes(url))
+        return "sandbox";
+    return void 0;
+}
+var ADDRESS_TEXT = ["address_line1", "address_line2", "city", "state", "zip", "name"];
+function billing(value) {
+    if (!keys(value, [...ADDRESS_TEXT, "country", "phone"]) || ADDRESS_TEXT.some((key) => own(value, key) && !text(value[key])))
+        return false;
+    if (own(value, "country") && !exact(/^[A-Za-z]{2}$/, value.country))
+        return false;
+    return !own(value, "phone") || keys(value.phone, ["country_code", "number"]) && Object.values(value.phone).every((value2) => text(value2, 64));
+}
+function guestCard(value) {
+    if (!keys(value, ["type", "number", "expiry_month", "expiry_year", "cvv", "name", "billing_address", "consumer_wallet"]) || value.type !== "card" || !digits(value.number, 12, 19) || !digits(value.cvv, 3, 4) || !Number.isInteger(value.expiry_month) || value.expiry_month < 1 || value.expiry_month > 12 || !Number.isInteger(value.expiry_year) || value.expiry_year < 2e3 || value.expiry_year > 9999 || own(value, "name") && !text(value.name) || own(value, "billing_address") && !billing(value.billing_address))
+        return false;
+    if (own(value, "consumer_wallet")) {
+        const wallet = value.consumer_wallet;
+        if (!keys(wallet, ["settings"]) || !keys(wallet.settings, ["preferred_locale"]) || !exact(/^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8}){0,3}$/, wallet.settings.preferred_locale))
+            return false;
+    }
+    return true;
+}
+var BROWSER_HEADERS = /* @__PURE__ */ new Set([
+    "accept",
+    "accept-language",
+    "accept-encoding",
+    "content-length",
+    "origin",
+    "referer",
+    "user-agent",
+    "host",
+    "connection",
+    "cache-control",
+    "pragma",
+    "priority",
+    "dnt",
+    "sec-fetch-dest",
+    "sec-fetch-mode",
+    "sec-fetch-site",
+    "sec-fetch-user"
+]);
+function guestHeaders(headers) {
+    if (!record(headers))
+        return false;
+    const parsed = /* @__PURE__ */ new Map();
+    let bytes = 0;
+    for (const [name, value] of Object.entries(headers)) {
+        const lower = name.toLowerCase();
+        if (parsed.size >= 64 || parsed.has(lower) || !exact(/^[A-Za-z0-9-]+$/, name) || !text(value, 8192) || (bytes += name.length + value.length) > 32768)
+            return false;
+        if (!["content-type", "authorization"].includes(lower) && !BROWSER_HEADERS.has(lower) && !exact(/^sec-ch-ua(?:-[a-z0-9-]+)?$/, lower))
+            return false;
+        parsed.set(lower, value);
+    }
+    return exact(/^application\/json(?:;\s*charset=utf-8)?$/i, parsed.get("content-type")) && exact(/^(?:Bearer )?pk_[A-Za-z0-9_-]{1,256}\$?$/, parsed.get("authorization"));
+}
+function isPreparedCheckoutComRequest(url, method, body, environment, headers) {
+    return (environment === "production" || environment === "sandbox") && method === "POST" && checkoutComEnvironment(url) === environment && guestHeaders(headers) && guestCard(readBody(body));
+}
+export { checkoutComEnvironment, checkoutComPreparationUrl, isPreparedCheckoutComRequest };

package/dist/client.d.ts

@@ -248,6 +248,9 @@ export declare class ApprovalTimeoutError extends Error {
 export declare class CheckoutCancelledError extends Error {
     constructor();
 }
+/** The reasons an org runtime may stamp when it retires an authorization; see VaultClient.cancelAuthorization. */
+export type RuntimeCancelReason = 'merchant_request_aborted' | 'merchant_never_retried';
+export declare const RUNTIME_CANCEL_REASONS: readonly RuntimeCancelReason[];
 /** The payment may have reached the processor. Reconcile the merchant order before any new attempt. */
 export declare class PaymentOutcomeUnknownError extends Error {
     authorizationId: string | null;
@@ -479,6 +482,14 @@ export declare class VaultClient {
     syncRegistry(): Promise<void>;
     /** True when this request is a card tokenization we can take over. */
     isCardRequest(url: string, method?: string): boolean;
+    /**
+     * How the card would reach the processor on this request (`token`, `cse`
+     * or `hosted_form`; absent on the entry means `token`), or null when the
+     * registry does not recognize it. The adapters read it to decide whether an
+     * approval outlives the page's own request: a hosted form is a navigation
+     * and cannot.
+     */
+    checkoutModeOf(url: string, method?: string): CheckoutMode | null;
     /**
      * Glob url patterns covering every host the CURRENT registry can send a card
      * to — what a raw CDP connection has to hand `Fetch.enable` before any card
@@ -503,13 +514,30 @@ export declare class VaultClient {
     authorize(input: AuthorizeInput): Promise<ReplayResponse>;
     /** A lost bind acknowledgement must never resume the request. Recover metadata only for safe cleanup. */
     private retireUncertainPreparation;
-    /** Retire only a pre-replay authorization. A 409 or missing response remains unknown. */
-    cancelAuthorization(authorizationId: string): Promise<{
+    /**
+     * Retire an authorization the runtime is done with. A 409 or missing
+     * response remains unknown.
+     *
+     * `merchant_request_aborted` (the default): the merchant request is gone
+     * and the row must still be awaiting the person with no replay started; the
+     * acknowledgement carries `processor_request_started: false`.
+     *
+     * `merchant_never_retried`: the page abandoned its request while the person
+     * decided, the adapter kept the approval for the page's retry, and none
+     * came. The row may already be `approved` (a token or ciphertext minted on
+     * the device that this runtime handed to no request), so
+     * `processor_request_started` says whether the processor was asked; the API
+     * stamps this reason only where no charge can have been made and answers
+     * 409 otherwise. The acknowledgement echoes the reason the row actually
+     * carries: a row retired earlier under the other runtime reason answers
+     * with that one.
+     */
+    cancelAuthorization(authorizationId: string, reason?: RuntimeCancelReason): Promise<{
         id: string;
         status: 'declined';
-        reason: 'merchant_request_aborted';
+        reason: RuntimeCancelReason;
         cancelled: true;
-        processor_request_started: false;
+        processor_request_started: boolean;
     }>;
     /**
      * POST the create, with two typed twists: a 502 `amount_unverifiable`

package/dist/client.js

@@ -54,6 +54,7 @@ export class ApprovalTimeoutError extends Error {
 export class CheckoutCancelledError extends Error {
     constructor() { super('checkout cancelled locally before authorization creation'); this.name = 'CheckoutCancelledError'; }
 }
+export const RUNTIME_CANCEL_REASONS = ['merchant_request_aborted', 'merchant_never_retried'];
 /** The payment may have reached the processor. Reconcile the merchant order before any new attempt. */
 export class PaymentOutcomeUnknownError extends Error {
     authorizationId;
@@ -411,6 +412,19 @@ export class VaultClient {
     isCardRequest(url, method = 'POST') {
         return method.toUpperCase() === 'POST' && findRecognizer(url, this.registry) !== null;
     }
+    /**
+     * How the card would reach the processor on this request (`token`, `cse`
+     * or `hosted_form`; absent on the entry means `token`), or null when the
+     * registry does not recognize it. The adapters read it to decide whether an
+     * approval outlives the page's own request: a hosted form is a navigation
+     * and cannot.
+     */
+    checkoutModeOf(url, method = 'POST') {
+        if (method.toUpperCase() !== 'POST')
+            return null;
+        const rec = findRecognizer(url, this.registry);
+        return rec ? rec.mode ?? 'token' : null;
+    }
     /**
      * Glob url patterns covering every host the CURRENT registry can send a card
      * to — what a raw CDP connection has to hand `Fetch.enable` before any card
@@ -577,7 +591,7 @@ export class VaultClient {
                 throw new CheckoutPreparationError(preparation.id, 'expired');
             if (input.user !== preparation.user || input.merchant !== preparation.merchant || (typeof input.amount === 'number' && input.amount !== preparation.amount) || (typeof input.amount === 'string' && !validAmountInput(input.amount))
                 || input.currency?.toLowerCase() !== preparation.currency || input.cardId !== preparation.cardId
-                || !matchesPreparedRequest(preparation.psp, preparation.environment, input.request.url, input.request.method ?? 'POST', input.request.body))
+                || !matchesPreparedRequest(preparation.psp, preparation.environment, input.request.url, input.request.method ?? 'POST', input.request.body, input.request.headers))
                 throw new CheckoutPreparationError(preparation.id, 'checkout_changed');
         }
         if (input.signal?.aborted)
@@ -947,18 +961,40 @@ export class VaultClient {
         await this.cancelAuthorization(id).catch(() => { });
         return id;
     }
-    /** Retire only a pre-replay authorization. A 409 or missing response remains unknown. */
-    async cancelAuthorization(authorizationId) {
+    /**
+     * Retire an authorization the runtime is done with. A 409 or missing
+     * response remains unknown.
+     *
+     * `merchant_request_aborted` (the default): the merchant request is gone
+     * and the row must still be awaiting the person with no replay started; the
+     * acknowledgement carries `processor_request_started: false`.
+     *
+     * `merchant_never_retried`: the page abandoned its request while the person
+     * decided, the adapter kept the approval for the page's retry, and none
+     * came. The row may already be `approved` (a token or ciphertext minted on
+     * the device that this runtime handed to no request), so
+     * `processor_request_started` says whether the processor was asked; the API
+     * stamps this reason only where no charge can have been made and answers
+     * 409 otherwise. The acknowledgement echoes the reason the row actually
+     * carries: a row retired earlier under the other runtime reason answers
+     * with that one.
+     */
+    async cancelAuthorization(authorizationId, reason = 'merchant_request_aborted') {
         if (!/^cauth_[A-Za-z0-9_-]{1,128}$/.test(authorizationId))
             throw new Error('Invalid authorization ID.');
-        const result = await this.post(`/v2/checkout/authorizations/${authorizationId}/cancel`, {}, AbortSignal.timeout(5_000));
-        if (result?.id !== authorizationId || result.status !== 'declined'
-            || result.reason !== 'merchant_request_aborted' || result.cancelled !== true
-            || result.processor_request_started !== false) {
+        if (!RUNTIME_CANCEL_REASONS.includes(reason))
+            throw new Error('Unsupported cancellation reason.');
+        const result = await this.post(`/v2/checkout/authorizations/${authorizationId}/cancel`, reason === 'merchant_request_aborted' ? {} : { reason }, AbortSignal.timeout(5_000));
+        const recorded = result?.reason;
+        if (result?.id !== authorizationId || result.status !== 'declined' || result.cancelled !== true
+            || typeof recorded !== 'string' || !RUNTIME_CANCEL_REASONS.includes(recorded)
+            || typeof result.processor_request_started !== 'boolean'
+            // The plain cancellation is only ever confirmed before the card moved.
+            || (recorded === 'merchant_request_aborted' && result.processor_request_started !== false)) {
             throw new PaymentOutcomeUnknownError(authorizationId, 'authorization_cancel_unconfirmed');
         }
-        return { id: authorizationId, status: 'declined', reason: 'merchant_request_aborted',
-            cancelled: true, processor_request_started: false };
+        return { id: authorizationId, status: 'declined', reason: recorded,
+            cancelled: true, processor_request_started: result.processor_request_started };
     }
     /**
      * POST the create, with two typed twists: a 502 `amount_unverifiable`

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { VaultClient, CardEncryptedError, UnsupportedModeError, ApprovalTimeoutError, ApprovalDeclinedError, AmountMismatchError, PresetRefusedError, PRESET_REFUSAL_REASONS, IntentNotConfirmableError, ProcessorRefusedError, CheckoutApiError, redactUrl, SUPPORTED_MODES, PaymentOutcomeUnknownError, CheckoutCancelledError, CheckoutPreparationError, } from './client.js';
-export type { PausedRequest, ReplayResponse, TokenReplay, CseReplay, HostedFormReplay, AmountAuthority, AuthorizeInput, VaultClientOptions, PrepareCheckoutOptions, PrepareCheckoutInput, PreparedCheckout, RazorpayProcessorError, ExecutionMetadata, } from './client.js';
+export type { PausedRequest, ReplayResponse, TokenReplay, CseReplay, HostedFormReplay, AmountAuthority, AuthorizeInput, VaultClientOptions, PrepareCheckoutOptions, PrepareCheckoutInput, PreparedCheckout, RazorpayProcessorError, RuntimeCancelReason, ExecutionMetadata, } from './client.js';
 export { attachToCdp, attachToPlaywright, corsHeadersFor, corsDecision, withCorsHeaders } from './cdp.js';
 export { CheckoutAttachmentError } from './attachment.js';
 export type { CdpLike, AttachOptions, CorsOutcome } from './cdp.js';

package/dist/lifecycle.d.ts

@@ -94,6 +94,31 @@ export declare class CheckoutLifecycle implements CheckoutController {
     cancel(): void;
     /** The exact browser request is gone; a late approval cannot reopen it. */
     merchantRequestAborted(): void;
+    /**
+     * The page abandoned its card request (its own script timed out) while
+     * the cardholder is still deciding. The approval stays pending and the
+     * page's next matching request will be answered from it, so the status
+     * stays `awaiting_approval`; the reason says the page has to ask again.
+     * Not a hold: nothing is refused, and no card or token has moved.
+     */
+    merchantRequestLost(): void;
+    /**
+     * The cardholder approved, and there is no live page request to hand the
+     * answer to: the page gave up on its own request while they decided.
+     * `ready_to_submit` is the state a prepared checkout uses for "consent in
+     * hand, click Pay": the application's next Pay action produces the request
+     * this approval answers, with no second prompt on the phone.
+     */
+    awaitingMerchantRetry(authorizationId: string): void;
+    /**
+     * The page never asked again inside the retry wait and the API confirmed
+     * the approval is retired: `declined`, like any other approval that ended
+     * with nothing charged, and not held, because the next card request is a
+     * new question (the cardholder is told to ask their agent to try again).
+     * A retirement the API refused or did not confirm is an unknown outcome and
+     * is reported through failed() instead, which holds.
+     */
+    merchantNeverRetried(authorizationId: string | null): void;
     unsupported(): void;
     prepareHandoff(replay: ReplayResponse, requestUrl: string): void;
     handedOff(replay: ReplayResponse): void;

package/dist/lifecycle.js

@@ -79,6 +79,40 @@ export class CheckoutLifecycle {
         this.held = true;
         this.set({ ...this.state, status: 'outcome_unknown', reason: 'merchant_request_aborted' });
     }
+    /**
+     * The page abandoned its card request (its own script timed out) while
+     * the cardholder is still deciding. The approval stays pending and the
+     * page's next matching request will be answered from it, so the status
+     * stays `awaiting_approval`; the reason says the page has to ask again.
+     * Not a hold: nothing is refused, and no card or token has moved.
+     */
+    merchantRequestLost() {
+        this.set({ ...this.state, reason: 'merchant_request_lost' });
+    }
+    /**
+     * The cardholder approved, and there is no live page request to hand the
+     * answer to: the page gave up on its own request while they decided.
+     * `ready_to_submit` is the state a prepared checkout uses for "consent in
+     * hand, click Pay": the application's next Pay action produces the request
+     * this approval answers, with no second prompt on the phone.
+     */
+    awaitingMerchantRetry(authorizationId) {
+        this.set({ status: 'ready_to_submit', authorizationId, reason: 'awaiting_merchant_retry',
+            ...(this.state.preparationId ? { preparationId: this.state.preparationId } : {}) });
+    }
+    /**
+     * The page never asked again inside the retry wait and the API confirmed
+     * the approval is retired: `declined`, like any other approval that ended
+     * with nothing charged, and not held, because the next card request is a
+     * new question (the cardholder is told to ask their agent to try again).
+     * A retirement the API refused or did not confirm is an unknown outcome and
+     * is reported through failed() instead, which holds.
+     */
+    merchantNeverRetried(authorizationId) {
+        if (this.cancelled)
+            return;
+        this.set({ ...this.state, authorizationId, status: 'declined', reason: 'merchant_never_retried' });
+    }
     unsupported() {
         this.held = true;
         if (this.state.authorizationId)

package/dist/preparation.d.ts

@@ -15,7 +15,7 @@ export declare class PreparationGate {
     constructor(opts: AttachOptions, lifecycle: CheckoutLifecycle, readDocumentUrl: () => Promise<string>);
     private prepare;
     /** Called for every recognized card mutation, before any await or local retry guard. */
-    claim(requestUrl: string, requestBody?: string | null): PreparedCheckout | undefined;
+    claim(requestUrl: string, requestBody?: string | null, requestHeaders?: Record<string, string>): PreparedCheckout | undefined;
     assertDocument(): Promise<void>;
     private readDocument;
     isEngaged(): boolean;

package/dist/preparation.js

@@ -92,7 +92,7 @@ export class PreparationGate {
         // Keep the signal listener after ready: caller cancellation retires the handle too.
     }
     /** Called for every recognized card mutation, before any await or local retry guard. */
-    claim(requestUrl, requestBody) {
+    claim(requestUrl, requestBody, requestHeaders) {
         this.observedRequest = true;
         if (this.state === 'unused')
             return undefined;
@@ -101,7 +101,7 @@ export class PreparationGate {
             throw new CheckoutPreparationError(this.prepared?.id ?? null, 'already_used_or_unavailable');
         }
         const prepared = this.prepared;
-        if (Date.parse(prepared.expiresAt) <= Date.now() || !matchesPreparedRequest(prepared.psp, prepared.environment, requestUrl, 'POST', requestBody)) {
+        if (Date.parse(prepared.expiresAt) <= Date.now() || !matchesPreparedRequest(prepared.psp, prepared.environment, requestUrl, 'POST', requestBody, requestHeaders)) {
             const reason = Date.parse(prepared.expiresAt) <= Date.now() ? 'expired' : 'checkout_changed';
             this.invalidate(reason);
             throw new CheckoutPreparationError(prepared.id, reason);

package/dist/prepared-processor.d.ts

@@ -1,4 +1,4 @@
-export type PreparationProcessor = 'square' | 'braintree' | 'worldpay' | 'bambora' | 'mercado_pago' | 'recurly' | 'spreedly' | 'adyen';
+export type PreparationProcessor = 'square' | 'braintree' | 'worldpay' | 'bambora' | 'mercado_pago' | 'recurly' | 'spreedly' | 'adyen' | 'checkout_com';
 export type PreparationEnvironment = 'production' | 'sandbox' | 'shared';
 /** How the approved card reaches the processor: the device's own request (token), or ciphertext the device produces for this browser to send (cse, Adyen). */
 export type PreparationMode = 'token' | 'cse';
@@ -7,4 +7,4 @@ export declare function preparationMode(psp: string): PreparationMode;
 export declare function validPreparationEnvironment(psp: string, environment: string): boolean;
 export declare function preparationEndpoint(psp: PreparationProcessor, environment: PreparationEnvironment): string;
 /** Processor identity and environment are part of the device's prior consent. */
-export declare function matchesPreparedRequest(psp: PreparationProcessor, environment: PreparationEnvironment, requestUrl: string, method: string, body?: string | null): boolean;
+export declare function matchesPreparedRequest(psp: PreparationProcessor, environment: PreparationEnvironment, requestUrl: string, method: string, body?: string | null, headers?: Record<string, string>): boolean;

package/dist/prepared-processor.js

@@ -2,6 +2,7 @@ import { adyenPreparationUrl, isPreparedAdyenRequest } from './adyen.generated.j
 import { braintreeEnvironment, isPreparedBraintreeRequest, readTokenizationJson } from './braintree.js';
 import { isPreparedRecurlyRequest } from './recurly.generated.js';
 import { isPreparedSpreedlyRequest, isSpreedlyTokenRequest, SPREEDLY_TOKEN_ENDPOINT } from './spreedly.generated.js';
+import { checkoutComPreparationUrl, isPreparedCheckoutComRequest } from './checkout-com.generated.js';
 export function preparationMode(psp) {
     return psp === 'adyen' ? 'cse' : 'token';
 }
@@ -9,11 +10,13 @@ export function preparationMode(psp) {
 export function validPreparationEnvironment(psp, environment) {
     if (psp === 'bambora' || psp === 'mercado_pago' || psp === 'recurly' || psp === 'spreedly')
         return environment === 'shared';
-    return ['square', 'braintree', 'worldpay', 'adyen'].includes(psp) && ['production', 'sandbox'].includes(environment);
+    return ['square', 'braintree', 'worldpay', 'adyen', 'checkout_com'].includes(psp) && ['production', 'sandbox'].includes(environment);
 }
 export function preparationEndpoint(psp, environment) {
     if (!validPreparationEnvironment(psp, environment))
         throw new Error('unsupported_preparation_processor');
+    if (psp === 'checkout_com')
+        return checkoutComPreparationUrl(environment);
     if (psp === 'adyen')
         return adyenPreparationUrl(environment);
     if (psp === 'bambora')
@@ -73,9 +76,11 @@ function freshCardBody(psp, body) {
     return true;
 }
 /** Processor identity and environment are part of the device's prior consent. */
-export function matchesPreparedRequest(psp, environment, requestUrl, method, body) {
+export function matchesPreparedRequest(psp, environment, requestUrl, method, body, headers) {
     if (method.toUpperCase() !== 'POST' || !validPreparationEnvironment(psp, environment))
         return false;
+    if (psp === 'checkout_com')
+        return isPreparedCheckoutComRequest(requestUrl, method, body ?? null, environment, headers);
     if (psp === 'adyen')
         return isPreparedAdyenRequest(requestUrl, method, body ?? null, environment);
     if (psp === 'braintree')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-cards/checkout",
-  "version": "0.15.1",
+  "version": "0.16.0",
   "description": "Let browser agents pay with the user's own card, without your infrastructure ever touching card data.",
   "type": "module",
   "main": "dist/index.js",
@@ -27,8 +27,8 @@
     "_comment_build": "The public SDK keeps zero runtime dependencies. Its build vendors deterministic metadata and substitution artifacts from the internal payment core; TypeScript remains pinned.",
     "build": "node ../payment-core/scripts/build.mjs && node scripts/generate-payment-core.mjs && npx -y -p typescript@5.9.3 tsc && node scripts/generate-preflight-contract.mjs",
     "prepublishOnly": "pnpm build",
-    "test": "node test.mjs && node --test lifecycle.test.mjs merchant-abort.test.mjs preparation.test.mjs braintree.test.mjs autopilot.test.mjs stripe-checkout.test.mjs payment-core.test.mjs prepared-processor.test.mjs minimum-delay.test.mjs paysafe.test.mjs attachment.test.mjs mercado-checkout.test.mjs mercado-polling.test.mjs && node --test preflight-package.test.mjs preflight-collector.test.mjs && node --test kernel-native-qualification.test.mjs && node --test ../vault/scripts/recurly-validation/watch-duty-sdk-result.test.mjs",
-    "test:browser": "node browser.test.mjs && node stripe-browser.test.mjs && node preparation-browser.test.mjs && node owned-shop-browser.test.mjs && node spreedly-browser.test.mjs",
+    "test": "node test.mjs && node --test lifecycle.test.mjs merchant-abort.test.mjs preparation.test.mjs braintree.test.mjs autopilot.test.mjs stripe-checkout.test.mjs payment-core.test.mjs prepared-processor.test.mjs minimum-delay.test.mjs paysafe.test.mjs attachment.test.mjs worker-targets.test.mjs mercado-checkout.test.mjs mercado-polling.test.mjs && node --test preflight-package.test.mjs preflight-collector.test.mjs && node --test kernel-native-qualification.test.mjs && node --test ../vault/scripts/recurly-validation/watch-duty-sdk-result.test.mjs",
+    "test:browser": "node browser.test.mjs && node stripe-browser.test.mjs && node preparation-browser.test.mjs && node checkout-com-browser.test.mjs && node owned-shop-browser.test.mjs && node spreedly-browser.test.mjs && node worker-browser.test.mjs",
     "check:payment-core": "node scripts/generate-payment-core.mjs --check",
     "test:preflight": "node --test preflight-package.test.mjs preflight-collector.test.mjs kernel-native-qualification.test.mjs",
     "test:preflight:browser": "node preflight-browser.test.mjs",