@agent-cards/checkout 0.6.0 → 0.8.0

package/dist/index.js

@@ -1,4 +1,4 @@
-export { VaultClient, CardEncryptedError, UnsupportedModeError, ApprovalTimeoutError, ApprovalDeclinedError, AmountMismatchError, IntentNotConfirmableError, ProcessorRefusedError, CheckoutApiError, redactUrl, SUPPORTED_MODES, PaymentOutcomeUnknownError, CheckoutCancelledError, CheckoutPreparationError, } from './client.js';
+export { VaultClient, CardEncryptedError, UnsupportedModeError, ApprovalTimeoutError, ApprovalDeclinedError, AmountMismatchError, PresetRefusedError, PRESET_REFUSAL_REASONS, IntentNotConfirmableError, ProcessorRefusedError, CheckoutApiError, redactUrl, SUPPORTED_MODES, PaymentOutcomeUnknownError, CheckoutCancelledError, CheckoutPreparationError, } from './client.js';
 export { attachToCdp, attachToPlaywright, corsHeadersFor, corsDecision, withCorsHeaders } from './cdp.js';
 export { CheckoutAttachmentError } from './attachment.js';
 export { substituteEncryptedFields, SubstitutionError } from './substitute.js';

package/dist/lifecycle.d.ts

@@ -59,6 +59,7 @@ export declare class CheckoutLifecycle implements CheckoutController {
     private cancelled;
     private merchantAborted;
     private unboundStripeToken;
+    private ownedShopOrderId;
     private reconciliation;
     private preparationHandler?;
     private preparationUsed;

package/dist/lifecycle.js

@@ -1,4 +1,5 @@
 import { ApprovalDeclinedError, ApprovalTimeoutError, CheckoutCancelledError, CheckoutPreparationError, IntentNotConfirmableError, PaymentOutcomeUnknownError, ProcessorRefusedError } from './client.js';
+import { parseOwnedShopReceipt, OWNED_SHOP_SKU, OWNED_SHOP_AMOUNT_CENTS, OWNED_SHOP_CURRENCY } from './owned-shop.generated.js';
 /** Shared by the raw CDP and Playwright transports. No browser ownership or payment execution lives here. */
 export class CheckoutLifecycle {
     options;
@@ -8,6 +9,7 @@ export class CheckoutLifecycle {
     cancelled = false;
     merchantAborted = false;
     unboundStripeToken = false;
+    ownedShopOrderId = null;
     reconciliation = null;
     preparationHandler;
     preparationUsed = false;
@@ -82,6 +84,20 @@ export class CheckoutLifecycle {
         this.set({ ...this.state, status: 'unsupported', reason: 'unrecognized_payment_endpoint' });
     }
     prepareHandoff(replay, requestUrl) {
+        if (replay.mode === 'token' && replay.executionMode === 'autopilot' && replay.shopOrderId) {
+            let receipt;
+            try {
+                receipt = parseOwnedShopReceipt(JSON.parse(replay.body), {
+                    order_id: replay.shopOrderId, sku: OWNED_SHOP_SKU, amount: OWNED_SHOP_AMOUNT_CENTS, currency: OWNED_SHOP_CURRENCY,
+                });
+            }
+            catch { /* An unrecognized response remains subject to the token continuation guard. */ }
+            if (receipt) {
+                this.ownedShopOrderId = receipt.order_id;
+                this.held = true;
+                return;
+            }
+        }
         // A tokenization approval has no authoritative PaymentIntent or amount
         // binding. Neither the first observed confirm nor the returned opaque
         // token can supply one. Hold even in compatibility mode: this attachment
@@ -102,6 +118,11 @@ export class CheckoutLifecycle {
     handedOff(replay) {
         if (this.merchantAborted)
             return;
+        if (this.ownedShopOrderId) {
+            this.held = true;
+            this.set({ status: 'completed', authorizationId: replay.authorizationId, mode: 'token', orderId: this.ownedShopOrderId });
+            return;
+        }
         const mismatch = (!replay.mode || replay.mode === 'token') && replay.amountVerified === false;
         this.held = !!this.options.requireMerchantResult || replay.mode === 'hosted_form' || mismatch || this.unboundStripeToken;
         this.set({ status: 'awaiting_merchant', authorizationId: replay.authorizationId, mode: replay.mode ?? 'token',
@@ -178,7 +199,10 @@ export class CheckoutLifecycle {
             result = { status: 'unknown' };
         if (result.status === 'completed' && typeof result.orderId === 'string' && result.orderId.length > 0) {
             this.held = true;
-            this.set({ ...this.state, status: 'completed', orderId: result.orderId });
+            // Merchant completion supersedes the earlier failure or user-action
+            // reason; keep the authorization and preparation context for observers.
+            const { reason: _previousReason, ...context } = this.state;
+            this.set({ ...context, status: 'completed', orderId: result.orderId });
         }
         else if (result.status === 'failed') {
             // Keep the guard armed until the application deliberately starts another attempt.
@@ -195,6 +219,8 @@ export class CheckoutLifecycle {
         return this.getState();
     }
     retryAfterMerchantFailure(result) {
+        if (this.ownedShopOrderId)
+            throw new Error('This shop payment already has a receipt; another payment is not permitted.');
         if (this.preparationUsed)
             throw new Error('Prepared checkouts are single use. Reconcile this attempt and create a new attachment.');
         if (this.active || this.reconciliation)

package/dist/owned-shop.generated.d.ts

@@ -0,0 +1,24 @@
+declare var OWNED_SHOP_OPERATION: string;
+declare var OWNED_SHOP_SKU: string;
+declare var OWNED_SHOP_AMOUNT_CENTS: number;
+declare var OWNED_SHOP_CURRENCY: string;
+declare var OWNED_SHOP_ORDER_FIELD: string;
+declare function isOwnedShopPaymentIntentId(value: any): boolean;
+declare function serializeOwnedShopOrder(value: any): string;
+declare function hasOwnedShopMarker(request: any): any;
+declare function parseOwnedShopOrder(request: any): {
+    order_id: any;
+    sku: string;
+    amount: number;
+    currency: string;
+} | null;
+declare function parseOwnedShopReceipt(value: any, expectedOrder: any): {
+    object: string;
+    order_id: any;
+    payment_intent_id: any;
+    status: string;
+    amount: number;
+    currency: string;
+    livemode: boolean;
+} | null;
+export { OWNED_SHOP_AMOUNT_CENTS, OWNED_SHOP_CURRENCY, OWNED_SHOP_OPERATION, OWNED_SHOP_ORDER_FIELD, OWNED_SHOP_SKU, hasOwnedShopMarker, isOwnedShopPaymentIntentId, parseOwnedShopOrder, parseOwnedShopReceipt, serializeOwnedShopOrder };

package/dist/owned-shop.generated.js

@@ -0,0 +1,108 @@
+// @ts-nocheck
+// Generated from @agent-cards/payment-core. Do not edit.
+// artifact-sha256: c8cfb844f3de3f156ee741a0167256d2e764ddfb7d243ce813e011761d3b711a
+// src/owned-shop.js
+var OWNED_SHOP_OPERATION = "stripe.owned_shop_token_to_payment_intent.v1";
+var OWNED_SHOP_SKU = "autopilot-pilot-100";
+var OWNED_SHOP_AMOUNT_CENTS = 100;
+var OWNED_SHOP_CURRENCY = "usd";
+var OWNED_SHOP_ORDER_FIELD = "agentcard_shop_order";
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}(?![\s\S])/;
+var INTENT = /^pi_[A-Za-z0-9]{1,200}(?![\s\S])/;
+var refuse = () => {
+    throw new Error("stripe_owned_shop_refused");
+};
+var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var keys = (value, allowed) => record(value) && Object.keys(value).length === allowed.length && Object.keys(value).every((key) => allowed.includes(key));
+function isOwnedShopPaymentIntentId(value) {
+    return typeof value === "string" && INTENT.test(value);
+}
+function order(value) {
+    if (!keys(value, ["order_id", "sku", "amount", "currency"]) || typeof value.order_id !== "string" || !UUID.test(value.order_id) || value.sku !== OWNED_SHOP_SKU || value.amount !== OWNED_SHOP_AMOUNT_CENTS || value.currency !== OWNED_SHOP_CURRENCY)
+        refuse();
+    return {
+        order_id: value.order_id,
+        sku: OWNED_SHOP_SKU,
+        amount: OWNED_SHOP_AMOUNT_CENTS,
+        currency: OWNED_SHOP_CURRENCY
+    };
+}
+function serializeOwnedShopOrder(value) {
+    return JSON.stringify(order(value));
+}
+function hasOwnedShopMarker(request) {
+    if (typeof request?.body !== "string")
+        return false;
+    return request.body.split("&").some((part) => {
+        const raw = part.split("=", 1)[0];
+        const loose = raw.replace(/\+/g, " ").replace(/%([0-9a-f]{2})/gi, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+        return loose.toLowerCase().includes(OWNED_SHOP_ORDER_FIELD);
+    });
+}
+function form(body) {
+    if (typeof body !== "string" || !body || body.length > 16384 || /[^\x21-\x7e]/.test(body))
+        refuse();
+    const chunks = body.split("&");
+    if (chunks.length > 16)
+        refuse();
+    const entries = /* @__PURE__ */ new Map();
+    const seen = /* @__PURE__ */ new Set();
+    for (const chunk of chunks) {
+        const eq = chunk.indexOf("=");
+        if (eq < 1)
+            refuse();
+        let key, value;
+        try {
+            key = decodeURIComponent(chunk.slice(0, eq).replace(/\+/g, " "));
+            value = decodeURIComponent(chunk.slice(eq + 1).replace(/\+/g, " "));
+        }
+        catch {
+            refuse();
+        }
+        if (seen.has(key.toLowerCase()) || value.length > 2048 || /[\x00-\x1f\x7f]/.test(key + value))
+            refuse();
+        seen.add(key.toLowerCase());
+        entries.set(key, value);
+    }
+    return entries;
+}
+function parseOwnedShopOrder(request) {
+    if (!hasOwnedShopMarker(request))
+        return null;
+    const entries = form(request.body);
+    if (!entries.has(OWNED_SHOP_ORDER_FIELD) || [...entries.keys()].some((key) => key !== OWNED_SHOP_ORDER_FIELD && key.toLowerCase().includes(OWNED_SHOP_ORDER_FIELD)))
+        refuse();
+    const encoded = entries.get(OWNED_SHOP_ORDER_FIELD);
+    let parsed;
+    try {
+        parsed = JSON.parse(encoded);
+    }
+    catch {
+        refuse();
+    }
+    const result = order(parsed);
+    if (serializeOwnedShopOrder(result) !== encoded)
+        refuse();
+    return result;
+}
+function parseOwnedShopReceipt(value, expectedOrder) {
+    let boundOrder;
+    try {
+        boundOrder = order(expectedOrder);
+    }
+    catch {
+        return null;
+    }
+    if (!keys(value, ["object", "order_id", "payment_intent_id", "status", "amount", "currency", "livemode"]) || value.object !== "agentcard_shop_receipt" || value.order_id !== boundOrder.order_id || !isOwnedShopPaymentIntentId(value.payment_intent_id) || value.status !== "succeeded" || value.amount !== OWNED_SHOP_AMOUNT_CENTS || value.currency !== OWNED_SHOP_CURRENCY || value.livemode !== false)
+        return null;
+    return {
+        object: "agentcard_shop_receipt",
+        order_id: boundOrder.order_id,
+        payment_intent_id: value.payment_intent_id,
+        status: "succeeded",
+        amount: OWNED_SHOP_AMOUNT_CENTS,
+        currency: OWNED_SHOP_CURRENCY,
+        livemode: false
+    };
+}
+export { OWNED_SHOP_AMOUNT_CENTS, OWNED_SHOP_CURRENCY, OWNED_SHOP_OPERATION, OWNED_SHOP_ORDER_FIELD, OWNED_SHOP_SKU, hasOwnedShopMarker, isOwnedShopPaymentIntentId, parseOwnedShopOrder, parseOwnedShopReceipt, serializeOwnedShopOrder };

package/dist/preparation.js

@@ -1,4 +1,5 @@
 import { CheckoutPreparationError } from './client.js';
+import { validAmountInput } from './client.js';
 import { matchesPreparedRequest, validPreparationEnvironment, preparationEndpoint } from './prepared-processor.js';
 /** A local, one-use rendezvous. It never starts or retries a merchant request. */
 export class PreparationGate {
@@ -39,7 +40,7 @@ export class PreparationGate {
             const tokenizer = preparationEndpoint(options.psp, options.environment);
             if (!this.opts.vault.isCardRequest(tokenizer, 'POST'))
                 throw new CheckoutPreparationError(null, 'processor_interception_unavailable');
-            if (!Number.isSafeInteger(this.opts.amountCents) || (this.opts.amountCents ?? 0) <= 0 || !/^[a-z]{3}$/i.test(this.opts.currency ?? ''))
+            if (!validAmountInput(this.opts.amount) || this.opts.amount === 0 || !/^[a-z]{3}$/i.test(this.opts.currency ?? ''))
                 throw new CheckoutPreparationError(null, 'amount_required');
             if (signal.aborted)
                 throw new CheckoutPreparationError(null, 'cancelled');
@@ -49,7 +50,7 @@ export class PreparationGate {
                 throw new CheckoutPreparationError(null, 'merchant_origin_invalid');
             const prepared = await this.opts.vault.prepareCheckout({
                 ...options, user: this.opts.user, merchant: this.opts.merchant,
-                amountCents: this.opts.amountCents, currency: this.opts.currency, cardId: this.opts.cardId,
+                amount: this.opts.amount, currency: this.opts.currency, cardId: this.opts.cardId,
                 merchantOrigin: page.origin, checkoutKey: crypto.randomUUID(), timeoutMs: this.opts.timeoutMs, signal,
                 onPreparationCreated: id => this.lifecycle.preparationCreated(id),
                 onApprovalUrl: url => {

package/dist/registry.d.ts

@@ -50,25 +50,8 @@ export interface Recognizer {
     /** How the card reaches the processor; absent means 'token'. Carried verbatim by syncRegistry. */
     mode?: CheckoutMode;
 }
-/**
- * Every PSP the service recognizes, shipped with the package.
- *
- * This list is the FALLBACK that decides interception whenever
- * `syncRegistry()` is skipped or its fetch fails — and that failure is silent
- * by design ("never break checkout over a registry fetch"). A PSP missing here
- * is not an error: its tokenization request is simply never paused, the vault
- * is never consulted, and the shopper pays with their OWN card.
- *
- * It shipped with only 5 of the service's 22 recognizers, which meant 17
- * processors degraded to a silent wrong-card charge for any integrator whose
- * sync had not landed. Generated from the backend registry
- * (packages/backend/src/services/checkout-recognizers.ts) so the two cannot
- * drift by transcription; `sdk-registry-drift.test.ts` fails CI if they do.
- *
- * Syncing still matters — it is how a NEW processor arrives without an npm
- * release. This list is the floor, not the ceiling.
- */
-export declare const BUILTIN_REGISTRY: Recognizer[];
+import { BUILTIN_REGISTRY } from './builtin-registry.generated.js';
+export { BUILTIN_REGISTRY };
 export declare function findRecognizer(url: string, registry?: Recognizer[]): Recognizer | null;
 /**
  * Glob url patterns covering every host in `registry` — what to hand

package/dist/registry.js

@@ -6,194 +6,9 @@
  * site shares another. The list is served from the Agentcard API at runtime so
  * integrators pick up new processors without shipping a release.
  */
-/**
- * Every PSP the service recognizes, shipped with the package.
- *
- * This list is the FALLBACK that decides interception whenever
- * `syncRegistry()` is skipped or its fetch fails — and that failure is silent
- * by design ("never break checkout over a registry fetch"). A PSP missing here
- * is not an error: its tokenization request is simply never paused, the vault
- * is never consulted, and the shopper pays with their OWN card.
- *
- * It shipped with only 5 of the service's 22 recognizers, which meant 17
- * processors degraded to a silent wrong-card charge for any integrator whose
- * sync had not landed. Generated from the backend registry
- * (packages/backend/src/services/checkout-recognizers.ts) so the two cannot
- * drift by transcription; `sdk-registry-drift.test.ts` fails CI if they do.
- *
- * Syncing still matters — it is how a NEW processor arrives without an npm
- * release. This list is the floor, not the ceiling.
- */
-export const BUILTIN_REGISTRY = [
-    {
-        psp: 'shopify',
-        match: /(checkout\.pci\.shopifyinc\.com|deposit\.[a-z0-9-]+\.shopifycs\.com)\/sessions/i,
-        hosts: ["^checkout\\.pci\\.shopifyinc\\.com$", "^deposit\\.[a-z0-9-]+\\.shopifycs\\.com$"],
-        encoding: 'json',
-        passthroughHeaders: [/^shopify-identification-signature$/i],
-    },
-    {
-        psp: 'stripe',
-        match: /api\.stripe\.com\/v1\/(payment_methods|tokens|setup_intents\/seti_\w+\/confirm|payment_intents\/pi_\w+\/confirm)/i,
-        hosts: ["^api\\.stripe\\.com$"],
-        encoding: 'form',
-        passthroughHeaders: [/^authorization$/i, /^stripe-version$/i, /^x-stripe-client-user-agent$/i],
-    },
-    {
-        psp: 'braintree',
-        match: /payments(\.sandbox)?\.braintree-api\.com\/graphql/i,
-        hosts: ["^payments\\.braintree-api\\.com$", "^payments\\.sandbox\\.braintree-api\\.com$"],
-        encoding: 'json',
-        passthroughHeaders: [/^authorization$/i, /^braintree-version$/i],
-    },
-    {
-        psp: 'checkout_com',
-        // Flow's native card controller can use either tokenization host.
-        match: /(api|card-acquisition-gateway)(\.sandbox)?\.checkout\.com\/tokens/i,
-        hosts: [
-            "^api\\.checkout\\.com$", "^api\\.sandbox\\.checkout\\.com$",
-            "^card-acquisition-gateway\\.checkout\\.com$", "^card-acquisition-gateway\\.sandbox\\.checkout\\.com$",
-        ],
-        encoding: 'json',
-        passthroughHeaders: [/^authorization$/i],
-    },
-    {
-        psp: 'adyen',
-        match: /(checkoutshopper-(test|live(-[a-z]+)?)\.adyen\.com|([a-z0-9-]+\.)*adyenpayments\.com)\/checkoutshopper\/v1\/sessions\/[A-Za-z0-9_-]+\/payments/i,
-        hosts: ["^checkoutshopper-(test|live(-[a-z]+)?)\\.adyen\\.com$", "^([a-z0-9-]+\\.)*adyenpayments\\.com$"],
-        encoding: 'json',
-        passthroughHeaders: [],
-        clientSideEncrypted: true,
-        mode: 'cse',
-    },
-    {
-        psp: 'tranzila',
-        match: /(direct\.tranzila\.com\/process\/n\/|directng\.tranzila\.com\/process\/?)/i,
-        hosts: ["^direct\\.tranzila\\.com$", "^directng\\.tranzila\\.com$"],
-        encoding: 'form',
-        passthroughHeaders: [],
-        mode: 'hosted_form',
-    },
-    {
-        psp: 'square',
-        match: /pci-connect\.squareup(?:sandbox)?\.com\/v2\/card-nonce/i,
-        hosts: ["^pci-connect\\.squareup\\.com$", "^pci-connect\\.squareupsandbox\\.com$"],
-        encoding: 'json',
-        passthroughHeaders: [],
-    },
-    {
-        psp: 'authorize_net',
-        match: /(api2|apitest)\.authorize\.net\/xml\/v1\/request\.api/i,
-        hosts: ["^api2\\.authorize\\.net$", "^apitest\\.authorize\\.net$"],
-        encoding: 'json',
-        passthroughHeaders: [],
-    },
-    {
-        psp: 'worldpay',
-        match: /(try\.)?access\.worldpay\.com\/(sessions\/card|verifiedTokens\/sessions)/i,
-        hosts: ["^access\\.worldpay\\.com$", "^try\\.access\\.worldpay\\.com$"],
-        encoding: 'json',
-        passthroughHeaders: [/^accept$/i],
-    },
-    {
-        psp: 'nuvei',
-        match: /(secure|ppp-test)\.safecharge\.com\/ppp\/api\/v1\/(?:cardTokenization|clientPayment|websdk\/initPaymentWithCardTokenization)\.do/i,
-        hosts: ["^secure\\.safecharge\\.com$", "^ppp-test\\.safecharge\\.com$"],
-        encoding: 'json',
-        passthroughHeaders: [],
-    },
-    {
-        psp: 'airwallex',
-        match: /(checkout(\.sandbox)?\.airwallex\.com|pci-api(\.sandbox)?\.airwallex\.com)\/api\/v1\/pa\/(payment_intents\/[^\/?#]+\/confirm|payment_consents\/[^\/?#]+\/verify|payment_methods\/create)(\?|$)/i,
-        hosts: ["^checkout\\.airwallex\\.com$", "^checkout\\.sandbox\\.airwallex\\.com$", "^pci-api\\.airwallex\\.com$", "^pci-api\\.sandbox\\.airwallex\\.com$"],
-        encoding: 'json',
-        passthroughHeaders: [/^client-secret$/i, /^authorization$/i, /^x-auth-token$/i, /^x-on-behalf-of$/i, /^x-api-version$/i],
-    },
-    {
-        psp: 'rapyd',
-        match: /(api|sandboxapi)\.rapyd\.net\/v1\/(?:hosted\/collect\/card\/[^\/?#]+\/payment_method|checkout\/checkout_[A-Za-z0-9]+)(?:[?#]|$)/i,
-        hosts: ["^api\\.rapyd\\.net$", "^sandboxapi\\.rapyd\\.net$"],
-        encoding: 'json',
-        passthroughHeaders: [],
-    },
-    {
-        psp: 'dlocal',
-        match: /ppmcc(-sandbox)?\.dlocal\.com\/cvault\/credit-card\/temporal/i,
-        hosts: ["^ppmcc\\.dlocal\\.com$", "^ppmcc-sandbox\\.dlocal\\.com$"],
-        encoding: 'json',
-        passthroughHeaders: [/^x-fields-api-key$/i, /^x-uow$/i, /^x-dlocal-infrav2$/i],
-    },
-    {
-        psp: 'ebanx',
-        match: /(?:(?:customer-frontier|customer|api-local-latam|api|sandbox-local-latam|sandbox)\.ebanx\.com|(?:api-diamond|api|sandbox)\.ebanxpay\.com)\/ws\/token/i,
-        hosts: ["^customer\\.ebanx\\.com$", "^customer-frontier\\.ebanx\\.com$", "^api\\.ebanx\\.com$", "^sandbox\\.ebanx\\.com$", "^api-local-latam\\.ebanx\\.com$", "^sandbox-local-latam\\.ebanx\\.com$", "^api-diamond\\.ebanxpay\\.com$", "^api\\.ebanxpay\\.com$", "^sandbox\\.ebanxpay\\.com$"],
-        encoding: 'json',
-        passthroughHeaders: [],
-    },
-    {
-        psp: 'mercado_pago',
-        match: /api\.mercadopago\.com\/v1\/card_tokens(?![\w\/-])/i,
-        hosts: ["^api\\.mercadopago\\.com$"],
-        encoding: 'json',
-        passthroughHeaders: [/^x-product-id$/i],
-    },
-    {
-        psp: 'payu',
-        match: /(secure\.payu\.com|(merch-prod|secure)\.snd\.payu\.com)\/api\/front\/tokens/i,
-        hosts: ["^secure\\.payu\\.com$", "^(merch-prod|secure)\\.snd\\.payu\\.com$"],
-        encoding: 'json',
-        passthroughHeaders: [],
-    },
-    {
-        psp: 'razorpay',
-        match: /api\.razorpay\.com\/v1\/(?:standard_checkout\/)?payments\/create\/(?:ajax|checkout|fees)/i,
-        hosts: ["^api\\.razorpay\\.com$"],
-        encoding: 'form',
-        passthroughHeaders: [/^x-razorpay-sessionid$/i, /^x-customer-access-token$/i],
-    },
-    {
-        psp: 'mollie',
-        match: /api\.cc\.mollie\.com\/v1\/card-tokens/i,
-        hosts: ["^api\\.cc\\.mollie\\.com$"],
-        encoding: 'json',
-        passthroughHeaders: [],
-    },
-    {
-        psp: 'paysafe',
-        match: /(?:api(\.test)?\.paysafe\.com\/(?:paymenthub\/v1\/singleusepaymenthandles|js\/api\/v1\/tokenize)|hosted(\.test)?\.paysafe\.com\/checkout\/api\/v1\/tokenize)(?![\w\/-])/i,
-        hosts: ["^api\\.paysafe\\.com$", "^api\\.test\\.paysafe\\.com$", "^hosted\\.paysafe\\.com$", "^hosted\\.test\\.paysafe\\.com$"],
-        encoding: 'json',
-        passthroughHeaders: [/^authorization$/i, /^x-paysafe-credentials$/i, /^correlationid$/i],
-    },
-    {
-        psp: 'recurly',
-        match: /api(\.eu)?\.recurly\.com\/js\/v1\/token(?![\w-])/i,
-        hosts: ["^api\\.recurly\\.com$", "^api\\.eu\\.recurly\\.com$"],
-        encoding: 'form',
-        passthroughHeaders: [/^recurly-credential-checkout-hostname$/i],
-    },
-    {
-        psp: 'moneris',
-        match: /(www3|esqa|gateway|gatewayqa|gatewayt|gatewaydev)\.moneris\.com\/HPPtoken\/request\.php/i,
-        hosts: ["^www3\\.moneris\\.com$", "^esqa\\.moneris\\.com$", "^gateway\\.moneris\\.com$", "^gatewayqa\\.moneris\\.com$", "^gatewayt\\.moneris\\.com$", "^gatewaydev\\.moneris\\.com$"],
-        encoding: 'form',
-        passthroughHeaders: [],
-    },
-    {
-        psp: 'bambora',
-        match: /(api\.na\.bambora\.com|api\.bam\.shift4api\.net)\/scripts\/tokenization\/tokens/i,
-        hosts: ["^api\\.na\\.bambora\\.com$", "^api\\.bam\\.shift4api\\.net$"],
-        encoding: 'json',
-        passthroughHeaders: [],
-    },
-    {
-        psp: 'global_payments',
-        match: /(?:api\.heartlandportico\.com\/SecureSubmit\.v1\/api\/token|cert\.api2\.heartlandportico\.com\/Hps\.Exchange\.PosGateway\.Hpf\.v1\/api\/token|apis(?:\.sandbox)?(?:\.eu)?\.globalpay\.com\/ucp\/(?:merchants\/[^\/]+\/)?payment-methods)/i,
-        hosts: ["^api\\.heartlandportico\\.com$", "^cert\\.api2\\.heartlandportico\\.com$", "^apis\\.globalpay\\.com$", "^apis\\.sandbox\\.globalpay\\.com$", "^apis\\.eu\\.globalpay\\.com$", "^apis\\.sandbox\\.eu\\.globalpay\\.com$"],
-        encoding: 'json',
-        passthroughHeaders: [/^authorization$/i, /^x-gp-version$/i],
-    },
-];
+// Pinned fallback generated from the single shared processor catalog.
+import { BUILTIN_REGISTRY } from './builtin-registry.generated.js';
+export { BUILTIN_REGISTRY };
 export function findRecognizer(url, registry = BUILTIN_REGISTRY) {
     // Match the way the SERVER does, on the PARSED url — never as a substring of
     // the raw string. `match` is unanchored, so a raw-string test classifies any

package/dist/substitute.d.ts

@@ -29,14 +29,10 @@ export interface Substitutions {
      */
     remove?: string[];
 }
-/** The paused body could not take the substitutions. Not terminal: the next request may differ. */
-export declare class SubstitutionError extends Error {
+declare class SubstitutionErrorShape extends Error {
     constructor(message: string);
 }
-/**
- * Return the paused JSON body with `sub.fields` written over the same-named
- * string members of the object at `sub.at`. Throws SubstitutionError when the
- * body is not JSON, the path does not lead to an object, or any field is not
- * already a string there.
- */
-export declare function substituteEncryptedFields(body: string, sub: Substitutions): string;
+export type SubstitutionError = SubstitutionErrorShape;
+export declare const SubstitutionError: typeof SubstitutionErrorShape;
+export declare const substituteEncryptedFields: (body: string, sub: Substitutions) => string;
+export {};

package/dist/substitute.js

@@ -16,72 +16,8 @@
  * and Adyen refuses the mismatch), and a body that does not carry the fields
  * is refused rather than guessed at.
  */
-/** The paused body could not take the substitutions. Not terminal: the next request may differ. */
-export class SubstitutionError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'SubstitutionError';
-    }
-}
-const FORBIDDEN_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
-function isPlainObject(v) {
-    return !!v && typeof v === 'object' && !Array.isArray(v);
-}
-/**
- * Return the paused JSON body with `sub.fields` written over the same-named
- * string members of the object at `sub.at`. Throws SubstitutionError when the
- * body is not JSON, the path does not lead to an object, or any field is not
- * already a string there.
- */
-export function substituteEncryptedFields(body, sub) {
-    if (!sub || sub.encoding !== 'json') {
-        throw new SubstitutionError(`unsupported substitution encoding: ${String(sub?.encoding)}`);
-    }
-    if (typeof sub.at !== 'string' || !sub.at)
-        throw new SubstitutionError('substitutions name no path');
-    if (!isPlainObject(sub.fields) || Object.keys(sub.fields).length === 0) {
-        throw new SubstitutionError('substitutions carry no fields');
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(body);
-    }
-    catch {
-        throw new SubstitutionError('the paused body is not JSON');
-    }
-    if (!isPlainObject(parsed))
-        throw new SubstitutionError('the paused body is not a JSON object');
-    let node = parsed;
-    for (const step of sub.at.split('.')) {
-        if (!step || FORBIDDEN_KEYS.has(step))
-            throw new SubstitutionError(`refusing substitution path ${sub.at}`);
-        const next = node[step];
-        if (!isPlainObject(next))
-            throw new SubstitutionError(`the paused body has no object at ${sub.at}`);
-        node = next;
-    }
-    for (const [key, value] of Object.entries(sub.fields)) {
-        if (FORBIDDEN_KEYS.has(key))
-            throw new SubstitutionError(`refusing substitution field ${key}`);
-        if (typeof value !== 'string' || value.length === 0)
-            throw new SubstitutionError(`substitution for ${key} is not a string`);
-        if (typeof node[key] !== 'string')
-            throw new SubstitutionError(`the paused body has no string field ${sub.at}.${key}`);
-    }
-    const remove = sub.remove ?? [];
-    if (!Array.isArray(remove))
-        throw new SubstitutionError('substitutions.remove is not a list');
-    for (const key of remove) {
-        if (typeof key !== 'string' || !key || FORBIDDEN_KEYS.has(key))
-            throw new SubstitutionError(`refusing removal of ${String(key)}`);
-        if (key in sub.fields)
-            throw new SubstitutionError(`substitution field ${key} is also listed for removal`);
-    }
-    // Only past every check, so a refused body is never half-written.
-    for (const [key, value] of Object.entries(sub.fields))
-        node[key] = value;
-    for (const key of remove)
-        if (Object.prototype.hasOwnProperty.call(node, key))
-            delete node[key];
-    return JSON.stringify(parsed);
-}
+// The implementation is bundled from the internal core; the published SDK
+// keeps its existing public types and does not require another package at runtime.
+import { substituteEncryptedFields as sharedSubstitute, SubstitutionError as SharedSubstitutionError, } from './substitutions.generated.js';
+export const SubstitutionError = SharedSubstitutionError;
+export const substituteEncryptedFields = sharedSubstitute;

package/dist/substitutions.generated.d.ts

@@ -0,0 +1,10 @@
+declare var SubstitutionError: {
+    new (message: any): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+};
+declare function substituteEncryptedFields(body: any, sub: any): string;
+export { SubstitutionError, substituteEncryptedFields };

package/dist/substitutions.generated.js

@@ -0,0 +1,66 @@
+// @ts-nocheck
+// Generated from @agent-cards/payment-core. Do not edit.
+// artifact-sha256: a74db713f1742d9bc5dc8efc78b364d2a69b255ee8da7f98345242f02114e6ce
+// src/substitutions.js
+var SubstitutionError = class extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "SubstitutionError";
+    }
+};
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isPlainObject(v) {
+    return !!v && typeof v === "object" && !Array.isArray(v);
+}
+function substituteEncryptedFields(body, sub) {
+    if (!sub || sub.encoding !== "json") {
+        throw new SubstitutionError(`unsupported substitution encoding: ${String(sub?.encoding)}`);
+    }
+    if (typeof sub.at !== "string" || !sub.at)
+        throw new SubstitutionError("substitutions name no path");
+    if (!isPlainObject(sub.fields) || Object.keys(sub.fields).length === 0) {
+        throw new SubstitutionError("substitutions carry no fields");
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        throw new SubstitutionError("the paused body is not JSON");
+    }
+    if (!isPlainObject(parsed))
+        throw new SubstitutionError("the paused body is not a JSON object");
+    let node = parsed;
+    for (const step of sub.at.split(".")) {
+        if (!step || FORBIDDEN_KEYS.has(step))
+            throw new SubstitutionError(`refusing substitution path ${sub.at}`);
+        const next = node[step];
+        if (!isPlainObject(next))
+            throw new SubstitutionError(`the paused body has no object at ${sub.at}`);
+        node = next;
+    }
+    for (const [key, value] of Object.entries(sub.fields)) {
+        if (FORBIDDEN_KEYS.has(key))
+            throw new SubstitutionError(`refusing substitution field ${key}`);
+        if (typeof value !== "string" || value.length === 0)
+            throw new SubstitutionError(`substitution for ${key} is not a string`);
+        if (typeof node[key] !== "string")
+            throw new SubstitutionError(`the paused body has no string field ${sub.at}.${key}`);
+    }
+    const remove = sub.remove ?? [];
+    if (!Array.isArray(remove))
+        throw new SubstitutionError("substitutions.remove is not a list");
+    for (const key of remove) {
+        if (typeof key !== "string" || !key || FORBIDDEN_KEYS.has(key))
+            throw new SubstitutionError(`refusing removal of ${String(key)}`);
+        if (key in sub.fields)
+            throw new SubstitutionError(`substitution field ${key} is also listed for removal`);
+    }
+    for (const [key, value] of Object.entries(sub.fields))
+        node[key] = value;
+    for (const key of remove)
+        if (Object.prototype.hasOwnProperty.call(node, key))
+            delete node[key];
+    return JSON.stringify(parsed);
+}
+export { SubstitutionError, substituteEncryptedFields };