@agent-cards/checkout 0.10.0 → 0.12.0

package/dist/recurly.generated.js

@@ -0,0 +1,87 @@
+// Generated from @agent-cards/payment-core. Do not edit.
+// source-sha256: 6a1932841621aca1a7371165e0b54a161c4dd5bb077acc190a0c5399229fa350
+/** Normal Recurly.js 4 new-card POST, before it consumes an approval.
+ * Native fields and indexed form serialization: recurly/recurly-js commit
+ * 7cd9a2b131bf12d7cebfbc7eea1ba86aa54c60e7, lib/recurly/{token,request,fraud}.js
+ * and risk/{risk,three-d-secure/three-d-secure}.js. Worldpay and Cybersource
+ * risk sessions depend on the original card; proactive Braintree also produces
+ * another token type. All nonempty risk results are refused until collection
+ * can use the approved card. This function never rewrites the body.
+ */
+const SCALARS = new Set(['number', 'month', 'year', 'cvv', 'type', 'key', 'version', 'deviceId', 'sessionId', 'instanceId',
+    'first_name', 'last_name', 'address1', 'address2', 'company', 'country', 'city', 'state', 'postal_code', 'phone',
+    'vat_number', 'tax_identifier', 'tax_identifier_type', 'fraud_session_id', 'card_network_preference']);
+const BROWSER = new Set(['color_depth', 'java_enabled', 'language', 'referrer_url', 'screen_height', 'screen_width', 'time_zone_offset', 'user_agent']);
+const FRAUD_PROCESSORS = new Set(['kount', 'litle_threat_metrix', 'braintree', 'fraudnet']);
+const contiguous = (values) => [...values.keys()].sort((a, b) => Number(a) - Number(b)).every((value, index) => value === String(index));
+export function isPreparedRecurlyRequest(body) {
+    if (typeof body !== 'string' || !body || body.length > 65536)
+        return false;
+    const chunks = body.split('&');
+    if (chunks.length > 200)
+        return false;
+    const fields = new Map();
+    const fraud = new Map();
+    try {
+        for (const chunk of chunks) {
+            const separator = chunk.indexOf('=');
+            if (separator < 1)
+                return false;
+            const name = decodeURIComponent(chunk.slice(0, separator).replace(/\+/g, ' '));
+            const value = decodeURIComponent(chunk.slice(separator + 1).replace(/\+/g, ' '));
+            if (fields.has(name) || value.length > 4096 || /[\u0000-\u001f\u007f]/.test(value))
+                return false;
+            fields.set(name, value);
+            if (SCALARS.has(name))
+                continue;
+            const browser = /^browser\[([a-z_]+)\]$/.exec(name);
+            if (browser && BROWSER.has(browser[1]))
+                continue;
+            const structured = /^fraud\[([0-9]|1[0-9])\]\[(.+)\]$/.exec(name);
+            if (!structured)
+                return false;
+            const [, index, leaf] = structured;
+            if (!['processor', 'session_id'].includes(leaf) && !/^udf\]\[([0-9]|1[0-9])\]\[(label|value)$/.test(leaf))
+                return false;
+            if (!fraud.has(index))
+                fraud.set(index, new Map());
+            fraud.get(index).set(leaf, value);
+        }
+    }
+    catch {
+        return false;
+    }
+    const number = fields.get('number') ?? '', month = fields.get('month') ?? '', year = fields.get('year') ?? '';
+    if (!/^[0-9]{12,19}$/.test(number) || !/^[0-9]{1,2}$/.test(month) || Number(month) < 1 || Number(month) > 12
+        || !/^(?:[0-9]{2}|20[0-9]{2})$/.test(year))
+        return false;
+    if (fields.has('cvv') && fields.get('cvv') !== '' && !/^[0-9]{3,4}$/.test(fields.get('cvv')))
+        return false;
+    if (fields.has('type') && fields.get('type') !== 'credit_card')
+        return false;
+    // A co-badged network choice belongs to the entered card's supported brands.
+    if (fields.get('card_network_preference'))
+        return false;
+    if (fields.has('key') && !fields.get('key')?.trim())
+        return false;
+    if (!contiguous(fraud))
+        return false;
+    for (const item of fraud.values()) {
+        if (!FRAUD_PROCESSORS.has(item.get('processor') ?? '') || !item.get('session_id'))
+            return false;
+        const udf = new Map();
+        for (const key of item.keys()) {
+            const field = /^udf\]\[([0-9]|1[0-9])\]\[(label|value)$/.exec(key);
+            if (!field)
+                continue;
+            if (item.get('processor') !== 'kount')
+                return false;
+            if (!udf.has(field[1]))
+                udf.set(field[1], new Set());
+            udf.get(field[1]).add(field[2]);
+        }
+        if (!contiguous(udf) || [...udf.values()].some(keys => keys.size !== 2))
+            return false;
+    }
+    return true;
+}

package/dist/stripe-checkout.d.ts

@@ -1,6 +1,8 @@
+import { STRIPE_CHECKOUT_VALIDATION_CODES } from './stripe-checkout.generated.js';
 import type { PausedRequest } from './client.js';
-/** Explicit development enrollment; this option cannot enable production execution. */
+/** Test by default. Production requires explicit opt-in and an independently admitted live grant. */
 export interface StripeCheckoutOptions {
+    environment?: 'test' | 'production';
     sessionId: string;
     publishableKey: string;
 }
@@ -18,11 +20,12 @@ type Step = {
 };
 type Phase = Step['phase'] | 'unknown';
 type GateState = 'fresh' | 'stubbed' | 'submitted' | 'stopped';
+type ValidationCode = (typeof STRIPE_CHECKOUT_VALIDATION_CODES)[keyof typeof STRIPE_CHECKOUT_VALIDATION_CODES];
 export type StripeCheckoutBlockStage = 'request_read' | 'classification' | 'claim' | 'readiness' | 'document' | 'stub_response';
 type ReadinessReason = 'attachment_not_ready' | 'cancelled' | 'checkout_inactive' | 'approval_pending' | 'request_inactive';
 export type StripeCheckoutBlockReason = ReadinessReason | 'request_unavailable' | 'request_validation_failed' | 'context_already_present' | 'duplicate_tokenization' | 'duplicate_confirmation' | 'preparation_unavailable' | 'preparation_missing' | 'claim_invalidated' | 'document_changed' | 'document_unavailable' | 'readiness_unavailable' | 'stub_response_failed';
 /** Native pre-authorization refusal metadata. Never contains request or exception text.
- * Classification failures intentionally do not guess which shared-core predicate rejected.
+ * A classification code comes only from the shared core's fixed vocabulary.
  * gate_state is observed before the adapter retires a failed claim. A preserved duplicate
  * belongs to a competing request: consumers must not cancel the active checkout for it.
  */
@@ -33,6 +36,7 @@ export interface StripeCheckoutBlockedDetail {
     phase: Phase;
     stage: StripeCheckoutBlockStage;
     reason: StripeCheckoutBlockReason;
+    validation_code?: ValidationCode;
     gate_state: GateState;
     disposition: 'active_claim_preserved' | 'checkout_stopped';
 }
@@ -40,7 +44,8 @@ declare class StripeCheckoutRejectionError extends Error {
     readonly stage: StripeCheckoutBlockStage;
     readonly reason: StripeCheckoutBlockReason;
     readonly phase?: Phase | undefined;
-    constructor(message: string, stage: StripeCheckoutBlockStage, reason: StripeCheckoutBlockReason, phase?: Phase | undefined);
+    readonly validationCode?: ValidationCode | undefined;
+    constructor(message: string, stage: StripeCheckoutBlockStage, reason: StripeCheckoutBlockReason, phase?: Phase | undefined, validationCode?: ValidationCode | undefined);
 }
 export declare function stripeCheckoutReadinessError(reason: ReadinessReason): Error;
 /** A valid competing request must not retire the request that already claimed this step. */
@@ -53,6 +58,7 @@ export declare class StripeCheckoutClaimConflictError extends StripeCheckoutReje
  */
 export declare class StripeCheckoutGate {
     private state;
+    private billing?;
     private readonly binding?;
     constructor(options: {
         stripeCheckout?: StripeCheckoutOptions;

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

@@ -1,5 +1,34 @@
 declare var STRIPE_CHECKOUT_OPERATION: string;
 declare var STRIPE_CHECKOUT_CONTEXT_HEADER: string;
+declare var STRIPE_CHECKOUT_VALIDATION_CODES: Readonly<{
+    unclassified: "unclassified";
+    request_shape: "request_shape";
+    request_body_bounds: "request_body_bounds";
+    request_headers: "request_headers";
+    form_encoding: "form_encoding";
+    form_field_unknown: "form_field_unknown";
+    form_field_duplicate: "form_field_duplicate";
+    form_value_bounds: "form_value_bounds";
+    context_invalid: "context_invalid";
+    session_binding: "session_binding";
+    publishable_key: "publishable_key";
+    mode_binding: "mode_binding";
+    attribution_session: "attribution_session";
+    tokenization_fields: "tokenization_fields";
+    billing_email: "billing_email";
+    billing_binding: "billing_binding";
+    billing_conflict: "billing_conflict";
+    expected_amount: "expected_amount";
+    payment_method_type: "payment_method_type";
+    synthetic_payment_method: "synthetic_payment_method";
+    required_final_fields: "required_final_fields";
+}>;
+declare function stripeCheckoutValidationCode(error: any): "unclassified" | "request_shape" | "request_body_bounds" | "request_headers" | "form_encoding" | "form_field_unknown" | "form_field_duplicate" | "form_value_bounds" | "context_invalid" | "session_binding" | "publishable_key" | "mode_binding" | "attribution_session" | "tokenization_fields" | "billing_email" | "billing_binding" | "billing_conflict" | "expected_amount" | "payment_method_type" | "synthetic_payment_method" | "required_final_fields";
+declare function validateStripeCheckoutIdentity(value: any): Readonly<{
+    environment: any;
+    livemode: boolean;
+}>;
+declare function validateStripeCheckoutCard(card: any, environment?: string): boolean;
 declare function isStripeCheckoutHostedMode(value: any): boolean;
 declare function encodeStripeCheckoutContext(value: any): string;
 declare function hasStripeCheckoutMarker(request: any): boolean;
@@ -9,6 +38,12 @@ declare function parseStripeCheckoutContext(request: any): {
     synthetic_payment_method_id: any;
 } | null | undefined;
 declare function isStripeCheckoutEndpoint(raw: any): boolean;
+declare function captureStripeCheckoutBilling(request: any, options: any): Readonly<{
+    session_id: any;
+    synthetic_payment_method_id: any;
+    email: string | null;
+}>;
+declare function attachStripeCheckoutBilling(request: any, captured: any, options: any): any;
 declare function classifyStripeCheckoutRequest(request: any, options?: {}): {
     phase: string;
     session_id: any;
@@ -44,4 +79,4 @@ declare function prepareStripeCheckoutReplay(request: any, card: any, options?:
     };
     where: string[];
 };
-export { STRIPE_CHECKOUT_CONTEXT_HEADER, STRIPE_CHECKOUT_OPERATION, classifyStripeCheckoutRequest, createStripeCheckoutTokenizationStub, encodeStripeCheckoutContext, hasStripeCheckoutMarker, isStripeCheckoutEndpoint, isStripeCheckoutHostedMode, parseStripeCheckoutContext, parseStripeCheckoutResponse, prepareStripeCheckoutReplay };
+export { STRIPE_CHECKOUT_CONTEXT_HEADER, STRIPE_CHECKOUT_OPERATION, STRIPE_CHECKOUT_VALIDATION_CODES, attachStripeCheckoutBilling, captureStripeCheckoutBilling, classifyStripeCheckoutRequest, createStripeCheckoutTokenizationStub, encodeStripeCheckoutContext, hasStripeCheckoutMarker, isStripeCheckoutEndpoint, isStripeCheckoutHostedMode, parseStripeCheckoutContext, parseStripeCheckoutResponse, prepareStripeCheckoutReplay, stripeCheckoutValidationCode, validateStripeCheckoutCard, validateStripeCheckoutIdentity };

package/dist/stripe-checkout.generated.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 // Generated from @agent-cards/payment-core. Do not edit.
-// artifact-sha256: 41b6fde86ad6193d1d7cb505c7dda522c2d664a9939ee0a4a0b3028cfa8bfa06
+// artifact-sha256: edd2d9de25c51bf0f4ebdbe729366e6d94b9a045b054a0910571e0565bd3cae0
 // src/definitions.js
 function deepFreeze(value) {
     if (value && typeof value === "object" && !Object.isFrozen(value)) {
@@ -524,15 +524,82 @@ var replayPolicy = Object.freeze({ contentTypeFor, HEADER_NEVER_FORWARD });
 // src/stripe-checkout.js
 var STRIPE_CHECKOUT_OPERATION = "stripe.device_checkout_confirm.v1";
 var STRIPE_CHECKOUT_CONTEXT_HEADER = "x-agentcard-stripe-checkout-context";
-var SESSION = /^cs_test_[A-Za-z0-9]{1,200}(?![\s\S])/;
-var KEY = /^pk_test_[A-Za-z0-9_]{1,256}(?![\s\S])/;
+var SESSION = /^cs_(?:test|live)_[A-Za-z0-9]{1,200}(?![\s\S])/;
+var KEY = /^pk_(?:test|live)_[A-Za-z0-9_]{1,256}(?![\s\S])/;
 var SYNTHETIC = /^pm_agentcard_checkout_[A-Za-z0-9_-]{16,80}(?![\s\S])/;
-var reject = () => {
-    throw new Error("stripe_checkout_rejected");
+var STRIPE_CHECKOUT_VALIDATION_CODES = Object.freeze({
+    unclassified: "unclassified",
+    request_shape: "request_shape",
+    request_body_bounds: "request_body_bounds",
+    request_headers: "request_headers",
+    form_encoding: "form_encoding",
+    form_field_unknown: "form_field_unknown",
+    form_field_duplicate: "form_field_duplicate",
+    form_value_bounds: "form_value_bounds",
+    context_invalid: "context_invalid",
+    session_binding: "session_binding",
+    publishable_key: "publishable_key",
+    mode_binding: "mode_binding",
+    attribution_session: "attribution_session",
+    tokenization_fields: "tokenization_fields",
+    billing_email: "billing_email",
+    billing_binding: "billing_binding",
+    billing_conflict: "billing_conflict",
+    expected_amount: "expected_amount",
+    payment_method_type: "payment_method_type",
+    synthetic_payment_method: "synthetic_payment_method",
+    required_final_fields: "required_final_fields"
+});
+var validationCodes = /* @__PURE__ */ new WeakMap();
+var reject = (code = "unclassified") => {
+    const error = new Error("stripe_checkout_rejected");
+    validationCodes.set(error, code);
+    throw error;
 };
+function stripeCheckoutValidationCode(error) {
+    const code = validationCodes.get(error);
+    return Object.values(STRIPE_CHECKOUT_VALIDATION_CODES).find((value) => value === code) ?? STRIPE_CHECKOUT_VALIDATION_CODES.unclassified;
+}
 var object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 var opaque = (value) => typeof value === "string" && value.length <= 8192 && !/[\x00-\x1f\x7f]/.test(value);
 var alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+function validateStripeCheckoutIdentity(value) {
+    if (!object(value) || !["test", "production"].includes(value.environment ?? "test") || value.environment === null || !["sessionId", "publishableKey", "livemode"].some((key) => Object.hasOwn(value, key)))
+        reject("mode_binding");
+    const environment = value.environment ?? "test", livemode = environment === "production";
+    const mode = livemode ? "live" : "test";
+    if (Object.hasOwn(value, "sessionId") && (typeof value.sessionId !== "string" || !SESSION.test(value.sessionId) || !value.sessionId.startsWith(`cs_${mode}_`)) || Object.hasOwn(value, "publishableKey") && (typeof value.publishableKey !== "string" || !KEY.test(value.publishableKey) || !value.publishableKey.startsWith(`pk_${mode}_`)) || Object.hasOwn(value, "livemode") && value.livemode !== livemode)
+        reject("mode_binding");
+    return Object.freeze({ environment, livemode });
+}
+var TEST_CARDS = ["4242424242424242", "4000000000000002", "4000002500003155"];
+var SYNTHETIC_CARDS = [...TEST_CARDS, "4111111111111111"];
+function validateStripeCheckoutCard(card, environment = "test") {
+    if (!["test", "production"].includes(environment) || !object(card) || typeof card.number !== "string" || typeof card.cvc !== "string" || !/^(?:0?[1-9]|1[0-2])(?![\s\S])/.test(String(card.month)) || !/^(?:\d{2}|\d{4})(?![\s\S])/.test(String(card.year)) || card.name !== void 0 && !opaque(card.name))
+        reject();
+    if (environment === "test") {
+        if (!TEST_CARDS.includes(card.number) || card.cvc !== "123")
+            reject();
+    }
+    else {
+        if (!/^\d{13,19}(?![\s\S])/.test(card.number) || /^(\d)\1+(?![\s\S])/.test(card.number) || !/^\d{3,4}(?![\s\S])/.test(card.cvc) || SYNTHETIC_CARDS.includes(card.number))
+            reject();
+        let sum = 0, double = false;
+        for (let i = card.number.length - 1; i >= 0; i--) {
+            let digit = Number(card.number[i]);
+            if (double) {
+                digit *= 2;
+                if (digit > 9)
+                    digit -= 9;
+            }
+            sum += digit;
+            double = !double;
+        }
+        if (sum % 10 !== 0)
+            reject();
+    }
+    return true;
+}
 function isStripeCheckoutHostedMode(value) {
     return value === "hosted" || value === "hosted_page";
 }
@@ -550,7 +617,7 @@ function encodeAscii(value) {
 }
 function context(value) {
     if (!object(value) || Object.keys(value).length !== 3 || value.version !== 1 || !["version", "session_id", "synthetic_payment_method_id"].every((key) => Object.hasOwn(value, key)) || !SESSION.test(value.session_id) || !SYNTHETIC.test(value.synthetic_payment_method_id))
-        reject();
+        reject("context_invalid");
     return { version: 1, session_id: value.session_id, synthetic_payment_method_id: value.synthetic_payment_method_id };
 }
 function encodeStripeCheckoutContext(value) {
@@ -564,7 +631,7 @@ function parseStripeCheckoutContext(request) {
     if (!entries.length)
         return null;
     if (entries.length !== 1 || typeof entries[0][1] !== "string" || !/^[A-Za-z0-9_-]{1,1024}$/.test(entries[0][1]))
-        reject();
+        reject("context_invalid");
     const encoded = entries[0][1];
     let text = "", bits = 0, count = 0;
     for (const char of encoded) {
@@ -580,10 +647,10 @@ function parseStripeCheckoutContext(request) {
         value = context(JSON.parse(text));
     }
     catch {
-        reject();
+        reject("context_invalid");
     }
     if (encodeStripeCheckoutContext(value) !== encoded)
-        reject();
+        reject("context_invalid");
     return value;
 }
 function endpoint(raw) {
@@ -600,7 +667,7 @@ function endpoint(raw) {
 }
 function isStripeCheckoutEndpoint(raw) {
     const url = endpoint(raw);
-    const match = url && /^\/v1\/payment_pages\/(cs_test_[A-Za-z0-9]+)\/confirm$/.exec(url.pathname);
+    const match = url && /^\/v1\/payment_pages\/(cs_(?:test|live)_[A-Za-z0-9]+)\/confirm$/.exec(url.pathname);
     return !!match && SESSION.test(match[1]);
 }
 var finalFields = /* @__PURE__ */ new Set([
@@ -608,6 +675,7 @@ var finalFields = /* @__PURE__ */ new Set([
     "key",
     "expected_amount",
     "expected_payment_method_type",
+    "payment_method_data[billing_details][email]",
     "init_checksum",
     "js_checksum",
     "version",
@@ -619,6 +687,9 @@ var finalFields = /* @__PURE__ */ new Set([
     "sid",
     "passive_captcha_token",
     "passive_captcha_ekey",
+    "pxcts",
+    "pxvid",
+    "px3",
     ...[
         "checkout_config_id",
         "checkout_session_id",
@@ -658,24 +729,32 @@ var tokenFields = /* @__PURE__ */ new Set([
     ].map((key) => `client_attribution_metadata[${key}]`)
 ]);
 function form(request, fields) {
-    if (!object(request) || request.method !== "POST" || typeof request.body !== "string" || request.body.length > 2e4 || !object(request.headers) || Object.keys(request.headers).length > 40 || Object.values(request.headers).some((value) => !opaque(value)))
-        reject();
+    if (!object(request) || request.method !== "POST" || typeof request.body !== "string")
+        reject("request_shape");
+    if (request.body.length > 2e4)
+        reject("request_body_bounds");
+    if (!object(request.headers) || Object.keys(request.headers).length > 40 || Object.values(request.headers).some((value) => !opaque(value)))
+        reject("request_headers");
     const pairs = [];
     const seen = /* @__PURE__ */ new Set();
     for (const raw of request.body.split("&")) {
         const index = raw.indexOf("=");
         if (index < 1)
-            reject();
+            reject("form_encoding");
         let key, value;
         try {
             key = decodeURIComponent(raw.slice(0, index).replace(/\+/g, " "));
             value = decodeURIComponent(raw.slice(index + 1).replace(/\+/g, " "));
         }
         catch {
-            reject();
+            reject("form_encoding");
         }
-        if (!fields.has(key) || seen.has(key) || !opaque(value))
-            reject();
+        if (!fields.has(key))
+            reject("form_field_unknown");
+        if (seen.has(key))
+            reject("form_field_duplicate");
+        if (!opaque(value))
+            reject("form_value_bounds");
         seen.add(key);
         pairs.push({ key, value, raw });
     }
@@ -684,31 +763,60 @@ function form(request, fields) {
 function keyFor(request, values, expected) {
     const authorization = Object.entries(request.headers).filter(([key2]) => key2.toLowerCase() === "authorization");
     if (authorization.length > 1)
-        reject();
+        reject("publishable_key");
     let headerKey;
     if (authorization.length) {
-        const match = /^Bearer (pk_test_[A-Za-z0-9_]{1,256})$/.exec(authorization[0][1]);
+        const match = /^Bearer (pk_(?:test|live)_[A-Za-z0-9_]{1,256})$/.exec(authorization[0][1]);
         if (!match)
-            reject();
+            reject("publishable_key");
         headerKey = match[1];
     }
     const key = values.get("key") || headerKey;
     if (!KEY.test(key) || headerKey && headerKey !== key || expected !== void 0 && expected !== key)
-        reject();
+        reject("publishable_key");
     return key;
 }
+var billingEmail = (value) => value === null || typeof value === "string" && value.length > 0 && value.length <= 320 && opaque(value);
+function captureStripeCheckoutBilling(request, options) {
+    const phase = classifyStripeCheckoutRequest(request, options);
+    if (phase?.phase !== "tokenization" || !SYNTHETIC.test(options?.syntheticPaymentMethodId))
+        reject("billing_binding");
+    const email = form(request, tokenFields).values.get("billing_details[email]") ?? null;
+    if (!billingEmail(email))
+        reject("billing_email");
+    return Object.freeze({
+        session_id: phase.session_id,
+        synthetic_payment_method_id: options.syntheticPaymentMethodId,
+        email
+    });
+}
+function attachStripeCheckoutBilling(request, captured, options) {
+    const phase = classifyStripeCheckoutRequest(request, options);
+    if (phase?.phase !== "final" || !object(captured) || Object.keys(captured).length !== 3 || !["session_id", "synthetic_payment_method_id", "email"].every((key) => Object.hasOwn(captured, key)) || captured.session_id !== phase.session_id || captured.synthetic_payment_method_id !== phase.synthetic_payment_method_id || !billingEmail(captured.email))
+        reject("billing_binding");
+    const field = "payment_method_data[billing_details][email]";
+    const existing = form(request, finalFields).values.get(field);
+    if (existing !== void 0 && existing !== captured.email)
+        reject("billing_conflict");
+    if (captured.email === null || existing !== void 0)
+        return { ...request };
+    const body = `${request.body}&${encodeURIComponent(field)}=${encodeURIComponent(captured.email)}`;
+    const result = { ...request, body };
+    classifyStripeCheckoutRequest(result, options);
+    return result;
+}
 function classifyStripeCheckoutRequest(request, options = {}) {
     const url = endpoint(request?.url);
     if (!url) {
         if (hasStripeCheckoutMarker(request))
-            reject();
+            reject("context_invalid");
         return null;
     }
     const final = isStripeCheckoutEndpoint(request.url);
     const token = url.pathname === "/v1/payment_methods";
     if (!final && !token) {
         if (hasStripeCheckoutMarker(request))
-            reject();
+            reject("context_invalid");
         return null;
     }
     if (token && options.sessionId === void 0 && !hasStripeCheckoutMarker(request))
@@ -716,22 +824,34 @@ function classifyStripeCheckoutRequest(request, options = {}) {
     const marker = parseStripeCheckoutContext(request);
     const sessionId = final ? url.pathname.split("/")[3] : options.sessionId;
     if (!SESSION.test(sessionId) || options.sessionId !== void 0 && options.sessionId !== sessionId || marker && marker.session_id !== sessionId)
-        reject();
+        reject("session_binding");
     const { values } = form(request, final ? finalFields : tokenFields);
     const key = keyFor(request, values, options.publishableKey);
+    validateStripeCheckoutIdentity({ environment: options.environment, sessionId, publishableKey: key });
     const attributionSession = values.get("client_attribution_metadata[checkout_session_id]");
     if (attributionSession !== void 0 && attributionSession !== sessionId)
-        reject();
+        reject("attribution_session");
     if (token) {
         const number = values.get("card[number]");
         if (values.get("type") !== "card" || typeof number !== "string" || number.length > 64 || /[^0-9 -]/.test(number) || !["4111111111111111", "4242424242424242"].includes(number.replace(/[ -]/g, "")) || !/^\d{3}$/.test(values.get("card[cvc]") ?? "") || !/^(?:0?[1-9]|1[0-2])$/.test(values.get("card[exp_month]") ?? "") || !/^(?:\d{2}|\d{4})$/.test(values.get("card[exp_year]") ?? "") || values.has("allow_redisplay") && values.get("allow_redisplay") !== "unspecified")
-            reject();
+            reject("tokenization_fields");
         return { phase: "tokenization", session_id: sessionId, publishable_key: key };
     }
     const amount = values.get("expected_amount");
     const syntheticId = values.get("payment_method");
-    if (!/^[1-9]\d{0,11}$/.test(amount ?? "") || !Number.isSafeInteger(Number(amount)) || options.amountCents !== void 0 && options.amountCents !== Number(amount) || values.get("expected_payment_method_type") !== "card" || !SYNTHETIC.test(syntheticId) || ["init_checksum", "js_checksum", "version", "rv_timestamp"].some((key2) => !values.get(key2)) || options.syntheticPaymentMethodId !== void 0 && options.syntheticPaymentMethodId !== syntheticId || marker && marker.synthetic_payment_method_id !== syntheticId)
-        reject();
+    const email = values.get("payment_method_data[billing_details][email]");
+    if (email !== void 0 && !billingEmail(email))
+        reject("billing_email");
+    if (!/^[1-9]\d{0,11}$/.test(amount ?? "") || !Number.isSafeInteger(Number(amount)) || options.amountCents !== void 0 && options.amountCents !== Number(amount))
+        reject("expected_amount");
+    if (values.get("expected_payment_method_type") !== "card")
+        reject("payment_method_type");
+    if (!SYNTHETIC.test(syntheticId))
+        reject("synthetic_payment_method");
+    if (["init_checksum", "js_checksum", "version", "rv_timestamp"].some((key2) => !values.get(key2)))
+        reject("required_final_fields");
+    if (options.syntheticPaymentMethodId !== void 0 && options.syntheticPaymentMethodId !== syntheticId || marker && marker.synthetic_payment_method_id !== syntheticId)
+        reject("synthetic_payment_method");
     return {
         phase: "final",
         session_id: sessionId,
@@ -753,7 +873,7 @@ function createStripeCheckoutTokenizationStub(request, options) {
             id: options.syntheticPaymentMethodId,
             object: "payment_method",
             type: "card",
-            livemode: false,
+            livemode: validateStripeCheckoutIdentity({ environment: options.environment, sessionId: phase.session_id }).livemode,
             billing_details: { ...billing, address },
             card: {
                 brand: "visa",
@@ -783,11 +903,12 @@ function parseStripeCheckoutResponse(raw, options) {
     let value;
     try {
         value = typeof raw === "string" ? JSON.parse(raw) : raw;
+        validateStripeCheckoutIdentity({ environment: options?.environment, sessionId: options?.sessionId, livemode: value?.livemode });
     }
     catch {
         return null;
     }
-    if (!object(value) || !SESSION.test(options?.sessionId) || value.session_id !== options.sessionId || Object.keys(value).some((key) => !terminalFields.has(key)) || !["id", "object", "state", "status", "payment_status", "currency", "livemode", "session_id", "mode", "ui_mode"].every((key) => Object.hasOwn(value, key)) || typeof value.id !== "string" || !/^[A-Za-z0-9_]{1,256}(?![\s\S])/.test(value.id) || value.object !== "checkout.session" || value.state !== "succeeded" || value.status !== "complete" || value.payment_status !== "paid" || value.currency !== "usd" || value.livemode !== false || value.mode !== "payment" || !isStripeCheckoutHostedMode(value.ui_mode))
+    if (!object(value) || !SESSION.test(options?.sessionId) || value.session_id !== options.sessionId || Object.keys(value).some((key) => !terminalFields.has(key)) || !["id", "object", "state", "status", "payment_status", "currency", "livemode", "session_id", "mode", "ui_mode"].every((key) => Object.hasOwn(value, key)) || typeof value.id !== "string" || !/^[A-Za-z0-9_]{1,256}(?![\s\S])/.test(value.id) || value.object !== "checkout.session" || value.state !== "succeeded" || value.status !== "complete" || value.payment_status !== "paid" || value.currency !== "usd" || value.mode !== "payment" || !isStripeCheckoutHostedMode(value.ui_mode))
         return null;
     for (const key of ["success_url", "return_url"]) {
         if (!Object.hasOwn(value, key) || value[key] === null)
@@ -822,7 +943,7 @@ function prepareStripeCheckoutReplay(request, card, options = {}) {
         sessionId: marker.session_id,
         syntheticPaymentMethodId: marker.synthetic_payment_method_id
     });
-    if (phase?.phase !== "final" || options.amountCents !== void 0 && phase.amount_cents !== options.amountCents || options.sessionId !== void 0 && options.sessionId !== marker.session_id || !card || !["4242424242424242", "4000000000000002", "4000002500003155"].includes(card.number) || card.cvc !== "123" || !/^(?:0?[1-9]|1[0-2])$/.test(String(card.month)) || !/^(?:\d{2}|\d{4})$/.test(String(card.year)) || card.name !== void 0 && !opaque(card.name))
+    if (phase?.phase !== "final" || options.amountCents !== void 0 && phase.amount_cents !== options.amountCents || options.sessionId !== void 0 && options.sessionId !== marker.session_id || !validateStripeCheckoutCard(card, options.environment))
         reject();
     const replacements = {
         "payment_method_data[type]": "card",
@@ -840,4 +961,4 @@ function prepareStripeCheckoutReplay(request, card, options = {}) {
         where: Object.keys(replacements)
     };
 }
-export { STRIPE_CHECKOUT_CONTEXT_HEADER, STRIPE_CHECKOUT_OPERATION, classifyStripeCheckoutRequest, createStripeCheckoutTokenizationStub, encodeStripeCheckoutContext, hasStripeCheckoutMarker, isStripeCheckoutEndpoint, isStripeCheckoutHostedMode, parseStripeCheckoutContext, parseStripeCheckoutResponse, prepareStripeCheckoutReplay };
+export { STRIPE_CHECKOUT_CONTEXT_HEADER, STRIPE_CHECKOUT_OPERATION, STRIPE_CHECKOUT_VALIDATION_CODES, attachStripeCheckoutBilling, captureStripeCheckoutBilling, classifyStripeCheckoutRequest, createStripeCheckoutTokenizationStub, encodeStripeCheckoutContext, hasStripeCheckoutMarker, isStripeCheckoutEndpoint, isStripeCheckoutHostedMode, parseStripeCheckoutContext, parseStripeCheckoutResponse, prepareStripeCheckoutReplay, stripeCheckoutValidationCode, validateStripeCheckoutCard, validateStripeCheckoutIdentity };

package/dist/stripe-checkout.js

@@ -1,13 +1,15 @@
-import { classifyStripeCheckoutRequest, createStripeCheckoutTokenizationStub, encodeStripeCheckoutContext, isStripeCheckoutEndpoint, STRIPE_CHECKOUT_CONTEXT_HEADER, } from './stripe-checkout.generated.js';
+import { classifyStripeCheckoutRequest, createStripeCheckoutTokenizationStub, encodeStripeCheckoutContext, isStripeCheckoutEndpoint, STRIPE_CHECKOUT_CONTEXT_HEADER, captureStripeCheckoutBilling, attachStripeCheckoutBilling, validateStripeCheckoutIdentity, stripeCheckoutValidationCode, STRIPE_CHECKOUT_VALIDATION_CODES, } from './stripe-checkout.generated.js';
 class StripeCheckoutRejectionError extends Error {
     stage;
     reason;
     phase;
-    constructor(message, stage, reason, phase) {
+    validationCode;
+    constructor(message, stage, reason, phase, validationCode) {
         super(message);
         this.stage = stage;
         this.reason = reason;
         this.phase = phase;
+        this.validationCode = validationCode;
     }
 }
 export function stripeCheckoutReadinessError(reason) {
@@ -26,22 +28,23 @@ export class StripeCheckoutClaimConflictError extends StripeCheckoutRejectionErr
  */
 export class StripeCheckoutGate {
     state = 'fresh';
+    billing;
     binding;
     constructor(options) {
         if (!options.stripeCheckout)
             return;
-        const { sessionId, publishableKey } = options.stripeCheckout;
+        const { sessionId, publishableKey, environment } = options.stripeCheckout;
+        validateStripeCheckoutIdentity({ environment, sessionId, publishableKey });
         if (options.executionMode !== 'autopilot' || !/^apg_[A-Za-z0-9_-]{1,128}(?![\s\S])/.test(options.grantId ?? '')
-            || !Number.isSafeInteger(options.amount) || Number(options.amount) <= 0 || options.currency !== 'usd'
-            || !/^cs_test_[A-Za-z0-9]{1,200}(?![\s\S])/.test(sessionId) || !/^pk_test_[A-Za-z0-9_]{1,256}(?![\s\S])/.test(publishableKey))
-            throw new Error('Native Stripe Checkout requires a TEST session, grant and numeric USD amount.');
-        this.binding = Object.freeze({ sessionId, publishableKey, amountCents: options.amount,
+            || !Number.isSafeInteger(options.amount) || Number(options.amount) <= 0 || options.currency !== 'usd')
+            throw new Error('Native Stripe Checkout requires a mode-bound session, grant and numeric USD amount.');
+        this.binding = Object.freeze({ environment, sessionId, publishableKey, amountCents: options.amount,
             syntheticPaymentMethodId: `pm_agentcard_checkout_${crypto.randomUUID().replaceAll('-', '')}` });
     }
     matches(url) { return !!this.binding && isStripeCheckoutEndpoint(url); }
     isEnabled() { return !!this.binding; }
     isPrepared() { return this.state !== 'fresh'; }
-    invalidate() { this.state = 'stopped'; }
+    invalidate() { this.state = 'stopped'; this.billing = undefined; }
     /** Observability only: this endpoint label never participates in a payment decision. */
     describeRejection(error, rawUrl, stage, phase = 'unknown') {
         let family = 'other';
@@ -58,8 +61,10 @@ export class StripeCheckoutGate {
             readiness: 'readiness_unavailable', document: 'document_unavailable', stub_response: 'stub_response_failed',
         };
         const rejection = error instanceof StripeCheckoutRejectionError ? error : undefined;
+        const reason = rejection?.reason ?? fallback[stage];
         return { version: 1, processor: 'stripe', endpoint_family: family,
-            phase: rejection?.phase ?? phase, stage: rejection?.stage ?? stage, reason: rejection?.reason ?? fallback[stage],
+            phase: rejection?.phase ?? phase, stage: rejection?.stage ?? stage, reason,
+            ...(reason === 'request_validation_failed' ? { validation_code: rejection?.validationCode ?? STRIPE_CHECKOUT_VALIDATION_CODES.unclassified } : {}),
             gate_state: this.state, disposition: error instanceof StripeCheckoutClaimConflictError ? 'active_claim_preserved' : 'checkout_stopped' };
     }
     assertClaim(step) {
@@ -72,7 +77,7 @@ export class StripeCheckoutGate {
             return;
         const url = new URL(raw);
         if (url.origin !== 'https://checkout.stripe.com' || url.username || url.password
-            || ![`/c/pay/${this.binding.sessionId}`, `/pay/${this.binding.sessionId}`].includes(url.pathname)) {
+            || ![`/c/pay/${this.binding.sessionId}`, `/pay/${this.binding.sessionId}`, `/g/pay/${this.binding.sessionId}`, `/f/pay/${this.binding.sessionId}`].includes(url.pathname)) {
             this.invalidate();
             throw new StripeCheckoutRejectionError('Native Stripe Checkout document changed.', 'document', 'document_changed');
         }
@@ -86,8 +91,8 @@ export class StripeCheckoutGate {
         try {
             phase = classifyStripeCheckoutRequest(request, this.binding);
         }
-        catch {
-            throw new StripeCheckoutRejectionError('stripe_checkout_rejected', 'classification', 'request_validation_failed', 'unknown');
+        catch (error) {
+            throw new StripeCheckoutRejectionError('stripe_checkout_rejected', 'classification', 'request_validation_failed', 'unknown', stripeCheckoutValidationCode(error));
         }
         if (!phase)
             return null;
@@ -102,9 +107,13 @@ export class StripeCheckoutGate {
             this.state = 'stopped';
             let response;
             try {
+                this.billing = captureStripeCheckoutBilling(request, this.binding);
                 response = createStripeCheckoutTokenizationStub(request, this.binding);
             }
-            catch {
+            catch (error) {
+                const code = stripeCheckoutValidationCode(error);
+                if (code !== STRIPE_CHECKOUT_VALIDATION_CODES.unclassified)
+                    throw new StripeCheckoutRejectionError('stripe_checkout_rejected', 'classification', 'request_validation_failed', 'tokenization', code);
                 throw new StripeCheckoutRejectionError('stripe_checkout_rejected', 'stub_response', 'stub_response_failed', 'tokenization');
             }
             this.state = 'stubbed';
@@ -114,8 +123,17 @@ export class StripeCheckoutGate {
             throw new StripeCheckoutClaimConflictError('final');
         if (phase.phase !== 'final' || this.state !== 'stubbed')
             throw new StripeCheckoutRejectionError('Native Stripe Checkout has no matching prepared request.', 'claim', 'preparation_missing', diagnosticPhase);
+        let final;
+        try {
+            final = attachStripeCheckoutBilling(request, this.billing, this.binding);
+        }
+        catch (error) {
+            this.invalidate();
+            throw new StripeCheckoutRejectionError('stripe_checkout_rejected', 'classification', 'request_validation_failed', 'final', stripeCheckoutValidationCode(error));
+        }
         this.state = 'submitted';
-        return { phase: 'final', request: { ...request, headers: { ...request.headers,
+        this.billing = undefined;
+        return { phase: 'final', request: { ...final, headers: { ...final.headers,
                     [STRIPE_CHECKOUT_CONTEXT_HEADER]: encodeStripeCheckoutContext({ version: 1,
                         session_id: this.binding.sessionId, synthetic_payment_method_id: this.binding.syntheticPaymentMethodId }) } } };
     }