@agent-cards/sdk 0.23.14 → 0.23.15

package/dist/paypal-card-forms.js

@@ -0,0 +1,126 @@
+/**
+ * PayPal's Card Fields and PayPal's guest card form, which this SDK refuses for every company until a
+ * synced recognizer takes the request.
+ *
+ * Read 2026-10-15 from PayPal's public bundles and card-free page reads (WooCommerce PayPal Payments
+ * 4.1.3 checkouts on PayPal JS SDK 5.0.582, card-field client 1.270.0; web-sdk v6 6.68.0):
+ *
+ *   Card Fields v5 (components=card-fields): each field is a frame on www.paypal.com/smart/card-field,
+ *   and at submit the number frame sends the typed card as plaintext JSON, a same-origin XHR:
+ *     POST https://www.paypal.com/v2/checkout/orders/<order id>/confirm-payment-source
+ *     {"payment_source":{"card":{"number","expiry":"YYYY-MM","security_code","name"?,"billing_address"?}}}
+ *   Card Fields v6 (web-sdk v6): the same request, sent to api-m.paypal.com.
+ *   Card Fields saving a card with no purchase: POST https://www.paypal.com/graphql?UpdateVaultSetupToken,
+ *     the card at variables.paymentSource.card.
+ *   PayPal's guest card form, behind the black "Debit or Credit Card" button: PayPal's checkout page
+ *     sends the card as POST https://www.paypal.com/graphql?OnboardGuestMutation, the number at
+ *     variables.card.cardNumber.
+ *   PayPal's sandbox serves each on www.sandbox.paypal.com and api-m.sandbox.paypal.com.
+ *
+ * An SDK without this guard let the agent's placeholder card reach PayPal there, and PayPal declined it.
+ * Both adapters arm these paths whatever the synced registry serves, and the pre-claim gate
+ * (paypalCardFormsPreClaim, pre-claim.ts) judges each POST:
+ *   - a Card Fields confirm whose body carries a number at payment_source.card.number aborts, reason
+ *     `unsupported_paypal_card_fields`, unless the synced registry recognizes it as a card request: an
+ *     org Agentcard turned PayPal Card Fields on for pauses and pays that confirm through the recognizer,
+ *     which judges the body itself;
+ *   - a GraphQL operation carrying a card aborts whatever the registry serves, since no recognizer pays
+ *     one: the guest form's card as `unsupported_paypal_guest_checkout`, a card saved with no purchase as
+ *     `unsupported_paypal_card_fields`;
+ *   - a body with no card (a PayPal wallet confirm, a saved card, every other GraphQL operation the
+ *     buttons send) continues untouched;
+ *   - a confirm the adapter could not read aborts that request alone, since nothing proves it carries no
+ *     card. A GraphQL post it could not read aborts only when its query names one of the two card
+ *     operations: PayPal's buttons send many others, and failing them would break PayPal's own wallet.
+ * Each abort holds the attachment as every unsupported refusal does: the page's next submit would carry
+ * the card again, so another way to pay needs a new attachment.
+ *
+ * A guest form PayPal opens in a popup window runs in another page, which an attachment covers only when
+ * the agent attaches the SDK to that page as well. PayPal's BIN lookup (/v2/payments/find-bin-details)
+ * reads the first digits the agent types and pays nothing; neither adapter intercepts it.
+ */
+import { paypalHostedFieldsBody } from './paypal-hosted-fields.js';
+export const PAYPAL_CARD_FIELDS_REASON = 'unsupported_paypal_card_fields';
+export const PAYPAL_GUEST_CHECKOUT_REASON = 'unsupported_paypal_guest_checkout';
+/** The hosts Card Fields sends its confirm to: v5 on www, v6 on api-m, live and sandbox. */
+export const PAYPAL_CARD_FIELDS_HOSTS = Object.freeze(['www.paypal.com', 'www.sandbox.paypal.com',
+    'api-m.paypal.com', 'api-m.sandbox.paypal.com']);
+/** The hosts of PayPal's own pages, whose GraphQL endpoint takes the guest form's card and a card saved with no purchase. */
+export const PAYPAL_GRAPHQL_HOSTS = Object.freeze(['www.paypal.com', 'www.sandbox.paypal.com']);
+const CONFIRM_PATH = /^\/v2\/checkout\/orders\/[^/]+\/confirm-payment-source\/?$/;
+const GRAPHQL_PATH = /^\/graphql\/?$/;
+/** The two GraphQL operations that carry a card, as PayPal's clients name them in the query string. */
+const CARD_OPERATIONS = ['OnboardGuestMutation', 'UpdateVaultSetupToken'];
+/**
+ * CDP Fetch patterns, armed on every attachment: the confirm on its four hosts and GraphQL on PayPal's
+ * two page hosts. Chrome sends the canonical URL, whose host is lower case, and the trailing `*` keeps a
+ * query or a trailing slash paused. Nothing else on www.paypal.com is armed.
+ */
+export const PAYPAL_CARD_FORM_PATTERNS = Object.freeze([
+    ...PAYPAL_CARD_FIELDS_HOSTS.map((host) => `https://${host}/v2/checkout/orders/*/confirm-payment-source*`),
+    ...PAYPAL_GRAPHQL_HOSTS.map((host) => `https://${host}/graphql*`),
+]);
+function paypalUrl(url, hosts, path) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return null;
+    }
+    return parsed.protocol === 'https:' && !parsed.port && !parsed.username && !parsed.password
+        && hosts.includes(parsed.hostname.toLowerCase()) && path.test(parsed.pathname) ? parsed : null;
+}
+/** Whether this URL is the Card Fields confirm on one of its four hosts (https, standard port, no credentials). */
+export function isPaypalCardFieldsConfirm(url) {
+    return paypalUrl(url, PAYPAL_CARD_FIELDS_HOSTS, CONFIRM_PATH) !== null;
+}
+/** Whether this URL is GraphQL on one of PayPal's two page hosts. */
+export function isPaypalGraphql(url) {
+    return paypalUrl(url, PAYPAL_GRAPHQL_HOSTS, GRAPHQL_PATH) !== null;
+}
+/** Whether this URL is any request the guard judges, for the Playwright route's predicate. */
+export function isPaypalCardFormUrl(url) {
+    return isPaypalCardFieldsConfirm(url) || isPaypalGraphql(url);
+}
+/** Whether a GraphQL URL's query names one of the two card operations (`/graphql?OnboardGuestMutation`). */
+export function paypalGraphqlNamesCardOperation(url) {
+    const parsed = paypalUrl(url, PAYPAL_GRAPHQL_HOSTS, GRAPHQL_PATH);
+    return parsed !== null && CARD_OPERATIONS.some((name) => parsed.searchParams.has(name));
+}
+const record = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const present = (value) => value !== undefined && value !== null && value !== '';
+/**
+ * What a GraphQL post carries, read as PayPal reads it (the last of a repeated key wins in both), for one
+ * operation or a batch of them: 'guest_card' when an operation's variables.card.cardNumber holds anything
+ * but null or an empty string, 'saved_card' when an operation's variables.paymentSource.card is an object,
+ * 'no_card' for any other JSON object or array of them, and 'unreadable' for a body the adapter could not
+ * read (null), an empty one, or one that is neither.
+ */
+export function paypalGraphqlCard(body) {
+    if (typeof body !== 'string' || body === '')
+        return 'unreadable';
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        return 'unreadable';
+    }
+    const operations = Array.isArray(parsed) ? parsed : [parsed];
+    if (operations.length === 0 || !operations.every(record))
+        return 'unreadable';
+    let carried = 'no_card';
+    for (const operation of operations) {
+        const variables = operation.variables;
+        if (!record(variables))
+            continue;
+        if (record(variables.card) && present(variables.card.cardNumber))
+            return 'guest_card';
+        if (record(variables.paymentSource) && record(variables.paymentSource.card))
+            carried = 'saved_card';
+    }
+    return carried;
+}
+/** What a Card Fields confirm carries: its body is the Orders v2 shape Hosted Fields also sends. */
+export const paypalCardFieldsBody = paypalHostedFieldsBody;

package/dist/pre-claim.d.ts

@@ -252,6 +252,7 @@ export declare function isArmedCreditguardCall(vault: {
 export declare const ekashuPreClaim: PreClaimGate;
 export declare const redsysPreClaim: PreClaimGate;
 export declare const paypalHostedFieldsPreClaim: PreClaimGate;
+export declare const paypalCardFormsPreClaim: PreClaimGate;
 export declare const cybersourceSecureAcceptancePreClaim: PreClaimGate;
 export declare const worldlineMyCheckoutPreClaim: PreClaimGate;
 export declare const paddleVgsPayPreClaim: PreClaimGate;

package/dist/pre-claim.js

@@ -16,8 +16,9 @@
 // card-saving bodies, WSPay's confirm URL, which also carries bodies with
 // no new card, Shiji STS's getTokenId and getCvvId, which also carry
 // requests the vault must never pay, PayPal's legacy Hosted Fields
-// confirm and CyberSource Secure Acceptance's Silent Order POST, whose card
-// no Vault mode takes over, Worldline MyCheckout's card form, held to the
+// confirm, PayPal's Card Fields and guest card form, and CyberSource Secure
+// Acceptance's Silent Order POST, whose card no Vault mode takes over until a
+// recognizer does, Worldline MyCheckout's card form, held to the
 // card product its page chose, and EBANX's 3-D Secure calls and hosted confirm,
 // which send the card again after its token and leave only from the
 // cardholder's device, under the token request's approval.
@@ -80,6 +81,7 @@ import { classifyVerifoneProfileRequest, verifoneTemplatedUrl } from './verifone
 import { ekashuEntryUrl, isEkashuEntry, isEkashuHost } from './ekashu.js';
 import { isRedsysEntry, isRedsysHost, redsysEntryUrl } from './redsys.js';
 import { PAYPAL_HOSTED_FIELDS_REASON, isPaypalHostedFieldsConfirm, paypalHostedFieldsBody } from './paypal-hosted-fields.js';
+import { PAYPAL_CARD_FIELDS_REASON, PAYPAL_GUEST_CHECKOUT_REASON, isPaypalCardFieldsConfirm, isPaypalGraphql, paypalCardFieldsBody, paypalGraphqlCard, paypalGraphqlNamesCardOperation, } from './paypal-card-forms.js';
 import { CYBERSOURCE_SECURE_ACCEPTANCE_REASON, CYBERSOURCE_SECURE_ACCEPTANCE_RECIPIENT, cybersourceSecureAcceptanceRequest, isCybersourceSecureAcceptanceUrl, isSecureAcceptanceFramePost, } from './cybersource-secure-acceptance.js';
 import { isWorldlineMyCheckoutEndpoint } from './worldline-mycheckout.js';
 import { paddleVgsPayEventUrl } from './paddle-vgs-pay.js';
@@ -1671,6 +1673,60 @@ async function paypalHostedFieldsUnreadable(ctx) {
     await ctx.effects.abort();
     return { kind: 'abort' };
 }
+// PayPal's Card Fields and guest card form (paypal-card-forms.ts). Every company's adapters hand each
+// POST to the Card Fields confirm (www and api-m, live and sandbox) and to GraphQL on www (live and
+// sandbox) to this gate:
+//   - a confirm with a card number at payment_source.card.number aborts as an unsupported checkout,
+//     reason `unsupported_paypal_card_fields`, with no claim, create or prompt, unless the synced
+//     registry recognizes it as a card request: then it defers, and the PayPal Card Fields lane pauses
+//     it for the cardholder's approval, judging the body itself;
+//   - a GraphQL operation with a card aborts the same way whatever the registry serves:
+//     `unsupported_paypal_guest_checkout` for the guest form's variables.card.cardNumber,
+//     `unsupported_paypal_card_fields` for a card saved with no purchase (variables.paymentSource.card);
+//   - a confirm the adapter could not read, and a GraphQL post it could not read whose query names one
+//     of the two card operations, abort that request alone with a `blocked` event,
+//     `unreadable_paypal_request`, and do not hold the attachment;
+//   - anything else (a PayPal wallet confirm, a saved card, the buttons' other GraphQL operations, a GET
+//     or a preflight) defers, and the arbiter continues it untouched.
+// Synchronous until it must abort, like every gate. Exported for the gate registry's tests.
+export const paypalCardFormsPreClaim = (ctx) => {
+    const { url, method } = ctx.request;
+    if (String(method).toUpperCase() !== 'POST')
+        return undefined;
+    const confirm = isPaypalCardFieldsConfirm(url);
+    if (!confirm && !isPaypalGraphql(url))
+        return undefined;
+    if (confirm && ctx.vault.isCardRequest(url, method))
+        return undefined;
+    let body;
+    // A reader that throws (Playwright's postData() can) proves nothing either way.
+    try {
+        body = ctx.request.body;
+    }
+    catch {
+        body = null;
+    }
+    if (confirm) {
+        const carried = paypalCardFieldsBody(body);
+        if (carried === 'no_card')
+            return undefined;
+        return carried === 'card' ? paypalCardFormAbort(ctx, PAYPAL_CARD_FIELDS_REASON) : paypalHostedFieldsUnreadable(ctx);
+    }
+    const carried = paypalGraphqlCard(body);
+    if (carried === 'guest_card')
+        return paypalCardFormAbort(ctx, PAYPAL_GUEST_CHECKOUT_REASON);
+    if (carried === 'saved_card')
+        return paypalCardFormAbort(ctx, PAYPAL_CARD_FIELDS_REASON);
+    return carried === 'unreadable' && paypalGraphqlNamesCardOperation(url) ? paypalHostedFieldsUnreadable(ctx) : undefined;
+};
+async function paypalCardFormAbort(ctx, reason) {
+    const { url, method } = ctx.request;
+    ctx.preparationGate.invalidate('unsupported_checkout');
+    ctx.lifecycle.unsupported(reason);
+    ctx.onEvent?.({ type: 'unsupported_checkout', detail: { url: eventUrl(ctx.vault, url), method, reason } });
+    await ctx.effects.abort();
+    return { kind: 'abort' };
+}
 // CyberSource Secure Acceptance's Silent Order POST (cybersource-secure-acceptance.ts). The merchant's
 // page posts the card the agent typed, beside the fields its server signed, to a /silent/ path on
 // CyberSource's Secure Acceptance hosts, which no Vault mode takes over, so every company's adapters
@@ -2092,7 +2148,7 @@ async function unsupportedContinue(ctx) {
  * after Stripe is never offered a step Stripe claimed: Stripe answers, aborts or
  * pauses each one itself. */
 export const PSP_PRE_CLAIM_GATES = [cardEndpointResendPreClaim, cardEndpointPreClaim, mercadoPreClaim, juspayPreClaim, braintreePreClaim, stripePreClaim, merchantHostedPreClaim, verifonePreClaim, fiservPreClaim, gmoPreClaim, cybersourceFlexPreClaim, datatransPreClaim, pelecardPreClaim, aciPreClaim, creditguardPreClaim, primerPreClaim, payrailsPreClaim, convergePreClaim, eprotectPreClaim, wspayPreClaim, shijiStsPreClaim, ekashuPreClaim, redsysPreClaim, paypalHostedFieldsPreClaim,
-    cybersourceSecureAcceptancePreClaim, worldlineMyCheckoutPreClaim, paddleVgsPayPreClaim, ebanxPreClaim];
+    paypalCardFormsPreClaim, cybersourceSecureAcceptancePreClaim, worldlineMyCheckoutPreClaim, paddleVgsPayPreClaim, ebanxPreClaim];
 /** Run each gate in order; the first to return a decision wins. If none does,
  * the terminal arbiter decides between continue, abort (unsupported) and pause.
  * Returns synchronously while every gate defers synchronously (an ordinary card

package/dist/prepared-processor.d.ts

@@ -20,8 +20,12 @@
  * paddle_vgs: prepared only. Paddle's checkout frame aborts its card request to its VGS card vault 10
  * seconds after Pay and sends it once more, too soon for an approval after Pay. Its environments are its
  * two card URLs: vault.paddle.com (production) and sandbox-vault.paddle.com (sandbox).
+ *
+ * wix_payments: prepared only. Wix's payment widget fails the payment 30 seconds after it asks Wix
+ * Cashier's card frame for a token, too soon for an approval after Pay. Its one environment is
+ * production: Wix's tokenizer has no test host.
  */
-export type PreparationProcessor = 'square' | 'braintree' | 'worldpay' | 'bambora' | 'mercado_pago' | 'recurly' | 'spreedly' | 'adyen' | 'checkout_com' | 'paysafe' | 'fiserv' | 'cybersource_flex' | 'aci' | 'creditguard' | 'worldpay_eprotect' | 'amadeus_checkout' | 'verifone' | 'cybersource_secure_acceptance' | 'paddle_vgs';
+export type PreparationProcessor = 'square' | 'braintree' | 'worldpay' | 'bambora' | 'mercado_pago' | 'recurly' | 'spreedly' | 'adyen' | 'checkout_com' | 'paysafe' | 'fiserv' | 'cybersource_flex' | 'aci' | 'creditguard' | 'worldpay_eprotect' | 'amadeus_checkout' | 'verifone' | 'cybersource_secure_acceptance' | 'paddle_vgs' | 'wix_payments';
 export type PreparationEnvironment = 'production' | 'sandbox' | 'shared';
 /**
  * How the approved card reaches the processor: the device's own request (token), or

package/dist/prepared-processor.js

@@ -14,6 +14,7 @@ import { amadeusEnvironment, amadeusPreparationUrls, amadeusRequestRefusal, isPr
 import { isPreparedVerifoneRequest } from './verifone.js';
 import { isPreparedSecureAcceptanceRequest, secureAcceptanceEnvironment, secureAcceptancePreparationUrl, secureAcceptanceRequestRefusal, } from './cybersource-secure-acceptance.generated.js';
 import { PADDLE_VGS_CARDS_URLS, isPreparedPaddleVgsRequest } from './paddle-vgs.generated.js';
+import { WIX_PAYMENTS_TOKENIZE_URL, isPreparedWixPaymentsRequest } from './wix-payments.generated.js';
 export function preparationMode(psp) {
     return psp === 'adyen' || psp === 'fiserv' || psp === 'verifone' ? 'cse' : 'token';
 }
@@ -53,6 +54,9 @@ export function preparedApprovalAnswersRetry(psp) {
 export function validPreparationEnvironment(psp, environment) {
     if (psp === 'bambora' || psp === 'mercado_pago' || psp === 'recurly' || psp === 'spreedly')
         return environment === 'shared';
+    // Wix Payments has production alone: its tokenizer has no test host.
+    if (psp === 'wix_payments')
+        return environment === 'production';
     return ['square', 'braintree', 'worldpay', 'adyen', 'checkout_com', 'paysafe', 'fiserv', 'cybersource_flex', 'aci', 'creditguard', 'worldpay_eprotect', 'amadeus_checkout', 'verifone',
         'cybersource_secure_acceptance', 'paddle_vgs'].includes(psp) && ['production', 'sandbox'].includes(environment);
 }
@@ -99,6 +103,9 @@ export function preparationEndpoint(psp, environment) {
     // Paddle VGS: the environment's one card URL, the only URL the claim takes for it.
     if (psp === 'paddle_vgs')
         return PADDLE_VGS_CARDS_URLS[environment];
+    // Wix Payments: the tokenize URL, the only URL the claim takes for it.
+    if (psp === 'wix_payments')
+        return WIX_PAYMENTS_TOKENIZE_URL;
     // A Verifone endpoint is its reviewed profile's leg, never one per environment (verifone.ts).
     if (psp === 'verifone')
         throw new Error('unsupported_preparation_processor');
@@ -252,6 +259,10 @@ export function matchesPreparedRequest(psp, environment, requestUrl, method, bod
     // the JSON:API content type and the frame's body), the rule the API and the Vault bind with too.
     if (psp === 'paddle_vgs')
         return isPreparedPaddleVgsRequest(requestUrl, method.toUpperCase(), body ?? null, environment, headers ?? {});
+    // Wix Payments: production, the tokenize URL and payment-core's whole request rule (a JSON content type, the
+    // site's app instance and the card frame's body), the rule the API and the Vault bind with too.
+    if (psp === 'wix_payments')
+        return isPreparedWixPaymentsRequest(requestUrl, method.toUpperCase(), body ?? null, environment, headers ?? {});
     if (psp === 'creditguard')
         return matchesPreparedCreditguard(environment, requestUrl, body, headers, binding);
     // A Verifone request is judged only through the profile its preparation names (matchesPreparation).

package/dist/primer.generated.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 // Generated from @agent-cards/payment-core. Do not edit.
-// artifact-sha256: 7d04123b22f392dd6a11848e8cf59b62efb1669527938a7dd1c83a34cb315621
+// artifact-sha256: 1d05273d23008e96c38c3be306ab215212b654fc275b96cf11e6452dee60c0d7
 // src/card-number-key.js
 var CARD_NUMBER_KEY = /^(number|card_number|cardnumber|cardNum|card_num|pan)$/i;
 // src/json-path.js
@@ -666,10 +666,10 @@ var TYPED_ARRAY = Object.getPrototypeOf(Uint8Array.prototype);
 var typedArrayName = Object.getOwnPropertyDescriptor(TYPED_ARRAY, Symbol.toStringTag).get;
 function parseRsaPublicKey(key) {
     const spki = key && typeof key === "object" ? key.spki : void 0;
-    const pin3 = key && typeof key === "object" ? key.sha256 : void 0;
+    const pin4 = key && typeof key === "object" ? key.sha256 : void 0;
     if (typeof spki !== "string" || spki.length > 1024 || spki.length % 4 !== 0 || !BASE64.test(spki))
         throw refuse6("key");
-    if (typeof pin3 !== "string" || !SHA256_HEX.test(pin3))
+    if (typeof pin4 !== "string" || !SHA256_HEX.test(pin4))
         throw refuse6("key");
     let binary;
     try {
@@ -681,7 +681,7 @@ function parseRsaPublicKey(key) {
     if (btoa(binary) !== spki)
         throw refuse6("key");
     const der = Uint8Array.from(binary, (c) => c.charCodeAt(0));
-    if (sha256Hex(der) !== pin3)
+    if (sha256Hex(der) !== pin4)
         throw refuse6("key");
     const outer = readElement(der, 0, 48);
     if (outer.end !== der.length || outer.start + RSA_ALGORITHM.length > der.length)
@@ -1241,10 +1241,93 @@ var LYRA_MERCHANT_PINS = /* @__PURE__ */ Object.freeze([
         hosts: Object.freeze(["api.systempay.fr"])
     })
 ]);
+// src/wix-payments.js
+var WIX_PAYMENTS_PSP = "wix_payments";
+var WIX_PAYMENTS_TOKENIZE_URL = "https://cashier-pci.wixapps.net/_api/payment-gateway-web/tokenize/v2/tokens";
+var BODY_LIMIT5 = 8192;
+var ROOT_KEYS3 = /* @__PURE__ */ Object.freeze(["cvv", "creditCard"]);
+var CARD_KEYS5 = /* @__PURE__ */ Object.freeze(["number", "expiration", "additionalInformation", "billingAddress"]);
+var EXPIRATION_KEYS = /* @__PURE__ */ Object.freeze(["month", "year"]);
+var HOLDER_KEYS = /* @__PURE__ */ Object.freeze(["holderName"]);
+var CARD_NUMBER6 = /^[0-9]{12,19}$/;
+var SECURITY_CODE5 = /^[0-9]{3,4}$/;
+var FIRST_YEAR = 2e3;
+var LAST_YEAR = 2099;
+var FIELD_NAME = /^[A-Za-z][A-Za-z0-9]{0,63}$/;
+var MAX_FIELDS = 32;
+var MAX_NESTED_FIELDS = 8;
+var TEXT_LIMIT = 256;
+var CONTROL4 = /[\u0000-\u001f\u007f]/;
+var record6 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var sameKeys3 = (value, keys) => {
+    const own = Object.keys(value);
+    return own.length === keys.length && own.every((key, at) => key === keys[at]);
+};
+var plainText = (value) => typeof value === "string" && value.length <= TEXT_LIMIT && !CONTROL4.test(value) && (value.match(/[0-9]/g) ?? []).length < 12;
+var refuse9 = (code) => Object.freeze({ verdict: "refuse", code });
+var CARD8 = /* @__PURE__ */ Object.freeze({ verdict: "card" });
+function isWixPaymentsTokenizeUrl(url) {
+    return url === WIX_PAYMENTS_TOKENIZE_URL;
+}
+function readBody3(body) {
+    if (typeof body !== "string" || body === "" || body.length > BODY_LIMIT5)
+        return null;
+    let value;
+    try {
+        value = JSON.parse(body);
+        if (!record6(value) || JSON.stringify(value) !== body)
+            return null;
+    }
+    catch {
+        return null;
+    }
+    return value;
+}
+var billingText = (value) => value === null || plainText(value);
+function billingFields(value) {
+    if (!record6(value))
+        return false;
+    const names = Object.keys(value);
+    if (names.length > MAX_FIELDS)
+        return false;
+    return names.every((name) => {
+        const field = value[name];
+        if (!FIELD_NAME.test(name))
+            return false;
+        if (!record6(field))
+            return billingText(field);
+        const nested = Object.keys(field);
+        return nested.length <= MAX_NESTED_FIELDS && nested.every((key) => FIELD_NAME.test(key) && billingText(field[key]));
+    });
+}
+function wixPaymentsBodyVerdict(body) {
+    const value = readBody3(body);
+    if (value === null || !sameKeys3(value, ROOT_KEYS3) || !record6(value.creditCard) || !sameKeys3(value.creditCard, CARD_KEYS5)) {
+        return refuse9("wix_payments_body_unsupported");
+    }
+    const card = value.creditCard;
+    const expiration = card.expiration;
+    const holder = card.additionalInformation;
+    if (typeof value.cvv !== "string" || !SECURITY_CODE5.test(value.cvv) || typeof card.number !== "string" || !CARD_NUMBER6.test(card.number) || !record6(expiration) || !sameKeys3(expiration, EXPIRATION_KEYS) || !Number.isInteger(expiration.month) || expiration.month < 1 || expiration.month > 12 || !Number.isInteger(expiration.year) || expiration.year < FIRST_YEAR || expiration.year > LAST_YEAR || !record6(holder) || !sameKeys3(holder, HOLDER_KEYS) || !plainText(holder.holderName) || !billingFields(card.billingAddress)) {
+        return refuse9("wix_payments_body_unsupported");
+    }
+    return CARD8;
+}
+var pin3 = (fields) => Object.freeze({ ...fields, origins: Object.freeze([...fields.origins]) });
+var WIX_PAYMENTS_MERCHANT_PINS = /* @__PURE__ */ Object.freeze([
+    pin3({ id: "parahouse_magazine", merchant: "ParaHouse Magazine", origins: ["https://www.parahousemagazine.com"] }),
+    pin3({ id: "psalms_and_potions", merchant: "Psalms & Potions", origins: ["https://www.psalmsandpotions.com"] }),
+    pin3({ id: "alexandra_hagel", merchant: "Alexandra Hagel, LLC", origins: ["https://www.alexandrahagel.com"] })
+]);
 // src/card-fields.js
 function processorGate(recognizer, url, body) {
     if (recognizer && recognizer.psp === LYRA_PSP)
         return lyraBodyVerdict(body, url);
+    if (recognizer && recognizer.psp === WIX_PAYMENTS_PSP) {
+        if (url !== void 0 && !isWixPaymentsTokenizeUrl(url))
+            return { verdict: "refuse", code: "wix_payments_url_refused" };
+        return wixPaymentsBodyVerdict(body);
+    }
     if (recognizer && recognizer.psp === PADDLE_VGS_PSP) {
         if (url !== void 0 && !isPaddleVgsCardsUrl(url))
             return { verdict: "refuse", code: "paddle_vgs_url_refused" };
@@ -1381,12 +1464,12 @@ var KEEP_ON_FILE_REFUSAL = "Refusing to pay: this Primer payment would keep the
 var UNSUPPORTED_SDK_REFUSAL = "Refusing to pay: this checkout uses a Primer SDK Agentcard does not support yet. Nothing was sent.";
 var NETWORK_MISMATCH_REFUSAL = "Refusing to pay: this Primer payment names a card network that is not your card's. Nothing was sent.";
 var FILL_REFUSAL = "Could not fill the card fields for Primer. Nothing was sent.";
-var BODY_LIMIT5 = 16384;
+var BODY_LIMIT6 = 16384;
 var RESPONSE_LIMIT = 32768;
-var ROOT_KEYS3 = ["paymentInstrument", "userDescription", "tokenType", "paymentFlow"];
+var ROOT_KEYS4 = ["paymentInstrument", "userDescription", "tokenType", "paymentFlow"];
 var INSTRUMENT_KEYS = ["number", "cvv", "expirationMonth", "expirationYear", "cardholderName", "preferredNetwork"];
 var REQUIRED_INSTRUMENT_KEYS = ["number", "cvv", "expirationMonth", "expirationYear"];
-var record6 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var record7 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 var owns5 = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
 var exact = (pattern, value) => typeof value === "string" && pattern.exec(value)?.[0] === value;
 var text2 = (value, max) => typeof value === "string" && value.length <= max && !/[\u0000-\u001f\u007f]/.test(value);
@@ -1409,7 +1492,7 @@ function isPrimerTokenizeUrl(url, method = "POST") {
     return parsed.href === url && parsed.protocol === "https:" && !parsed.port && !parsed.username && !parsed.password && !parsed.search && !parsed.hash && PRIMER_PCI_HOSTS.includes(parsed.hostname) && parsed.pathname === PRIMER_TOKENIZE_PATH;
 }
 function judgeBody2(body) {
-    if (typeof body !== "string" || body === "" || body.length > BODY_LIMIT5)
+    if (typeof body !== "string" || body === "" || body.length > BODY_LIMIT6)
         return null;
     let value;
     try {
@@ -1418,12 +1501,12 @@ function judgeBody2(body) {
     catch {
         return null;
     }
-    if (!record6(value) || !roundTrips(value, body))
+    if (!record7(value) || !roundTrips(value, body))
         return null;
-    if (!Object.keys(value).every((key) => ROOT_KEYS3.includes(key)) || !owns5(value, "paymentInstrument"))
+    if (!Object.keys(value).every((key) => ROOT_KEYS4.includes(key)) || !owns5(value, "paymentInstrument"))
         return null;
     const instrument = value.paymentInstrument;
-    if (!record6(instrument) || !Object.keys(instrument).every((key) => INSTRUMENT_KEYS.includes(key)) || !REQUIRED_INSTRUMENT_KEYS.every((key) => owns5(instrument, key)))
+    if (!record7(instrument) || !Object.keys(instrument).every((key) => INSTRUMENT_KEYS.includes(key)) || !REQUIRED_INSTRUMENT_KEYS.every((key) => owns5(instrument, key)))
         return null;
     if (!digits(instrument.number, 12, 19) || !digits(instrument.cvv, 3, 4) || !exact(MONTH3, instrument.expirationMonth) || !exact(YEAR3, instrument.expirationYear))
         return null;
@@ -1451,7 +1534,7 @@ var CLIENT_TOKEN = /^[A-Za-z0-9._~+/=-]{16,4096}$/;
 var REQUEST_ID = /^[A-Za-z0-9-]{1,64}$/;
 var API_VERSION = /^2\.[0-9]{1,2}$/;
 function readHeaders(headers) {
-    if (!record6(headers))
+    if (!record7(headers))
         return null;
     const folded = /* @__PURE__ */ new Map();
     for (const [name, value] of Object.entries(headers)) {
@@ -1498,7 +1581,7 @@ function onTokenizePath(url) {
     }
 }
 function primerTokenizeRefusal(request) {
-    if (!record6(request) || request.method !== "POST" || !isPrimerTokenizeUrl(request.url))
+    if (!record7(request) || request.method !== "POST" || !isPrimerTokenizeUrl(request.url))
         return "unsupported";
     return headersRefusal(request.headers) ?? primerBodyRefusal(request.body);
 }
@@ -1513,7 +1596,7 @@ function primerCardOnFileRefusal(url, options, policy = PRIMER_SESSION_CARD_ON_F
         return "unsupported";
     if (new URL(url).hostname !== LIVE_PCI_HOST)
         return null;
-    return primerCardOnFileDisclosure(url, policy) && record6(options) && options.keepOnFile === true ? null : "keep_on_file";
+    return primerCardOnFileDisclosure(url, policy) && record7(options) && options.keepOnFile === true ? null : "keep_on_file";
 }
 function primerRefusalMessage(reason) {
     if (reason === "keep_on_file")
@@ -1597,7 +1680,7 @@ function readAnswer(body) {
         return null;
     try {
         const value = JSON.parse(body);
-        return record6(value) ? value : null;
+        return record7(value) ? value : null;
     }
     catch {
         return null;
@@ -1606,16 +1689,16 @@ function readAnswer(body) {
 var tokenValue = (value) => exact(TOKEN2, value) && !panLike(value);
 var optional = (value, key, check) => !owns5(value, key) || value[key] === null || check(value[key]);
 function cardDetails(data) {
-    if (!record6(data) || !exact(/^[0-9]{4}$/, data.last4Digits))
+    if (!record7(data) || !exact(/^[0-9]{4}$/, data.last4Digits))
         return null;
-    if (!optional(data, "first6Digits", (v) => exact(/^[0-9]{6}$/, v)) || !optional(data, "expirationMonth", (v) => exact(RESPONSE_MONTH, v)) || !optional(data, "expirationYear", (v) => exact(RESPONSE_YEAR, v)) || !optional(data, "cardholderName", (v) => plain(v, 256)) || !optional(data, "network", (v) => exact(NETWORK_NAME, v)) || !optional(data, "isNetworkTokenized", (v) => typeof v === "boolean") || !optional(data, "binData", record6))
+    if (!optional(data, "first6Digits", (v) => exact(/^[0-9]{6}$/, v)) || !optional(data, "expirationMonth", (v) => exact(RESPONSE_MONTH, v)) || !optional(data, "expirationYear", (v) => exact(RESPONSE_YEAR, v)) || !optional(data, "cardholderName", (v) => plain(v, 256)) || !optional(data, "network", (v) => exact(NETWORK_NAME, v)) || !optional(data, "isNetworkTokenized", (v) => typeof v === "boolean") || !optional(data, "binData", record7))
         return null;
     const safe = { last4Digits: data.last4Digits };
     for (const key of ["first6Digits", "expirationMonth", "expirationYear", "cardholderName", "network", "isNetworkTokenized"]) {
         if (owns5(data, key) && data[key] !== null)
             safe[key] = data[key];
     }
-    if (record6(data.binData)) {
+    if (record7(data.binData)) {
         const bin = {};
         for (const key of BIN_KEYS) {
             if (!owns5(data.binData, key) || data.binData[key] === null)
@@ -1631,7 +1714,7 @@ function cardDetails(data) {
 function threeDsSummary(value) {
     if (value === void 0 || value === null)
         return null;
-    if (!record6(value) || !exact(CODE, value.responseCode) || !optional(value, "reasonCode", (v) => exact(CODE, v)) || !optional(value, "reasonText", (v) => plain(v, 256)) || !optional(value, "protocolVersion", (v) => v === "" || exact(PROTOCOL, v)) || !optional(value, "challengeIssued", (v) => typeof v === "boolean"))
+    if (!record7(value) || !exact(CODE, value.responseCode) || !optional(value, "reasonCode", (v) => exact(CODE, v)) || !optional(value, "reasonText", (v) => plain(v, 256)) || !optional(value, "protocolVersion", (v) => v === "" || exact(PROTOCOL, v)) || !optional(value, "challengeIssued", (v) => typeof v === "boolean"))
         return void 0;
     const safe = { responseCode: value.responseCode };
     for (const key of ["reasonCode", "reasonText", "protocolVersion", "challengeIssued"]) {
@@ -1659,7 +1742,7 @@ function rebuildToken(value) {
 }
 function primerErrorId(body) {
     const value = readAnswer(body);
-    const id = value && record6(value.error) ? value.error.errorId : null;
+    const id = value && record7(value.error) ? value.error.errorId : null;
     return exact(ERROR_ID, id) && !panLike(id) ? id : null;
 }
 function matchesCard(details, card) {

package/dist/stripe-checkout.generated.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 // Generated from @agent-cards/payment-core. Do not edit.
-// artifact-sha256: eaa31e10104ec55a9914d5b874f25cb17e713de912b48ef41d7f987786e65785
+// artifact-sha256: ce4887768a0ee59bbca5f329bce47a2831a24b06d7bea1d5517335f7afad75e0
 // src/deep-freeze.js
 function deepFreeze(value) {
     if (value && typeof value === "object" && !Object.isFrozen(value)) {
@@ -1660,6 +1660,31 @@ var PROCESSOR_DEFINITIONS = deepFreeze([
         passthroughHeaders: [],
         jsonCardFields: [["paymentForm", "pan"]],
         passWithoutCard: "api(?:\\.payzen\\.eu|\\.systempay\\.fr|-sogecommerce\\.societegenerale\\.eu|\\.lyra\\.com)/api-payment/V4/Charge/Public/ProcessPayment/2(?:;jsessionid=[A-Za-z0-9._-]{1,128})?"
+    },
+    {
+        psp: "wix_payments",
+        // Wix Cashier's card frame (cashier-pci.wixapps.net/card-form), which every Wix checkout mounts: for
+        // Wix Payments and classic Stripe on Wix it posts the card as one JSON body to Wix's own tokenizer,
+        // under the site's signed app instance. PAN@ creditCard.number, CVV@ cvv at the root, the expiry as
+        // creditCard.expiration.month and .year (numbers, the year in four digits). wix-payments.js holds the
+        // request rule the pause decision, the API's create, the prepared bind and the device all read: exactly
+        // this URL (never /v2/credit-cards, which saves a card, or a saved card's token URL), a JSON
+        // Content-Type, the instance, and the frame's body byte for byte. Wix's payment widget fails the
+        // payment 30 seconds after it asks the frame for a token, so the lane is prepared only
+        // (preparationRequired): the cardholder approves before the agent clicks Pay. The tokenizer answers no
+        // browser origin, so the card leaves the cardholder's device only through the checkout relay. Wix's
+        // other headers ride beside the instance, as the frame sends them. No sandbox host: a Wix site in test
+        // mode answers inside the frame with a fake token and sends nothing, so the lane takes production only,
+        // and the API refuses a test-mode client before any row (wix-payments.js wixPaymentsMerchantRefusal).
+        // Ships dark: served only to a client that declares `wix_payments_tokenize`, gated off for every org
+        // until an operator lists one (`wix_payments:<org>`), and autopilot never sends this request
+        // (autopilot.js DEVICE_REPLAY_REFUSED_OPERATIONS).
+        capability: "wix_payments_tokenize",
+        match: "cashier-pci\\.wixapps\\.net/_api/payment-gateway-web/tokenize/v2/tokens",
+        hosts: ["^cashier-pci\\.wixapps\\.net$"],
+        preparationRequired: true,
+        encoding: "json",
+        passthroughHeaders: ["^authorization$", "^x-wix-client-artifact-id$", "^commonconfig$", "^x-wix-brand$", "^consent-policy$", "^x-wix-linguist$"]
     }
 ]);
 var PSP_RECOGNIZERS = deepFreeze(PROCESSOR_DEFINITIONS.map(({ compose, encryptedCardFields, deviceSteps, deviceEncrypt, ...definition }) => definition));
@@ -1817,6 +1842,13 @@ var LYRA_MERCHANT_PINS = /* @__PURE__ */ Object.freeze([
         hosts: Object.freeze(["api.systempay.fr"])
     })
 ]);
+// src/wix-payments.js
+var pin3 = (fields) => Object.freeze({ ...fields, origins: Object.freeze([...fields.origins]) });
+var WIX_PAYMENTS_MERCHANT_PINS = /* @__PURE__ */ Object.freeze([
+    pin3({ id: "parahouse_magazine", merchant: "ParaHouse Magazine", origins: ["https://www.parahousemagazine.com"] }),
+    pin3({ id: "psalms_and_potions", merchant: "Psalms & Potions", origins: ["https://www.psalmsandpotions.com"] }),
+    pin3({ id: "alexandra_hagel", merchant: "Alexandra Hagel, LLC", origins: ["https://www.alexandrahagel.com"] })
+]);
 // src/cybersource-secure-acceptance.js
 var SA_BODY_LIMIT = 32 * 1024;
 var SA_REPLY_LIMIT = 64 * 1024;

package/dist/wix-payments.generated.d.ts

@@ -0,0 +1,42 @@
+declare var WIX_PAYMENTS_PSP: string;
+declare var WIX_PAYMENTS_CAPABILITY: string;
+declare var WIX_PAYMENTS_OPERATION: string;
+declare var WIX_PAYMENTS_HOST: string;
+declare var WIX_PAYMENTS_TOKENIZE_URL: string;
+declare var WIX_PAYMENTS_REFUSAL_CODES: readonly string[];
+declare function isWixPaymentsTokenizeUrl(url: any): boolean;
+declare function wixPaymentsBodyVerdict(body: any): Readonly<{
+    verdict: "refuse";
+    code: any;
+}> | Readonly<{
+    verdict: "card";
+}>;
+declare function wixPaymentsRequestRefusal(request: any): any;
+declare function isPreparedWixPaymentsRequest(url: any, method: any, body: any, environment: any, headers: any): boolean;
+declare var WIX_PAYMENTS_MERCHANT_PINS: readonly any[];
+declare function wixPaymentsMerchantPin(merchantOrigin: any, pins?: readonly any[]): any;
+declare function wixPaymentsMerchantRefusal(environment: any, merchantOrigin: any, pins?: readonly any[]): "unsupported_environment" | "wix_payments_merchant_unreviewed" | null;
+declare function wixPaymentsRefusalMessage(code: any): any;
+declare function injectWixPaymentsCard(body: any, card: any): {
+    body: string;
+    where: string[];
+};
+declare function isWixPaymentsDeviceRequest(templateBody: any, deviceBody: any): boolean;
+declare function wixPaymentsRefusalCode(text: any): string | null;
+declare function wixPaymentsAnswerOutcome(status: any, text: any, card: any): {
+    outcome: string;
+    reason: string;
+    code?: undefined;
+    body?: undefined;
+} | {
+    outcome: string;
+    code: string;
+    reason?: undefined;
+    body?: undefined;
+} | {
+    outcome: string;
+    body: string;
+    reason?: undefined;
+    code?: undefined;
+};
+export { WIX_PAYMENTS_CAPABILITY, WIX_PAYMENTS_HOST, WIX_PAYMENTS_MERCHANT_PINS, WIX_PAYMENTS_OPERATION, WIX_PAYMENTS_PSP, WIX_PAYMENTS_REFUSAL_CODES, WIX_PAYMENTS_TOKENIZE_URL, injectWixPaymentsCard, isPreparedWixPaymentsRequest, isWixPaymentsDeviceRequest, isWixPaymentsTokenizeUrl, wixPaymentsAnswerOutcome, wixPaymentsBodyVerdict, wixPaymentsMerchantPin, wixPaymentsMerchantRefusal, wixPaymentsRefusalCode, wixPaymentsRefusalMessage, wixPaymentsRequestRefusal };