@agent-cards/sdk 0.23.14 → 0.23.16

package/dist/client.js

@@ -16,6 +16,7 @@ import { SHIJI_STS_CAPABILITY, SHIJI_STS_PSP, isShijiStsServedCompanion, isShiji
 import { AMADEUS_CHECKOUT_CAPABILITY, AMADEUS_CHECKOUT_PSP } from './amadeus-checkout.generated.js';
 import { PADDLE_VGS_CAPABILITY, PADDLE_VGS_PSP, paddleVgsCardFactsOf } from './paddle-vgs.generated.js';
 import { PADDLE_TOKENEX_CAPABILITY, PADDLE_TOKENEX_PSP, isPaddleTokenexServedFacts, isPaddleTokenexServedSubstitution } from './paddle-tokenex.js';
+import { WIX_PAYMENTS_CAPABILITY, WIX_PAYMENTS_PSP } from './wix-payments.generated.js';
 import { classifyStripeCheckoutRequest, encodeStripeCheckoutContext, hasStripeCheckoutMarker, parseStripeCheckoutContext, parseStripeCheckoutResponse, STRIPE_CHECKOUT_CONTEXT_HEADER, } from './stripe-checkout.generated.js';
 import { VoiceModule } from './voice.js';
 import { BuyModule } from './buy.js';
@@ -224,9 +225,17 @@ export const SUPPORTED_REGISTRY_FEATURES = ['card_fields', 'checkout_sessions'];
  * card tab then runs in the agent's browser. The cardholder's device sends the card through the
  * checkout relay. Served on the same terms: only to a build that lists it, for a company
  * Agentcard turned Payfast on for.
+ *
+ * `wix_payments_tokenize`: the card request Wix Cashier's card frame sends to Wix's
+ * tokenizer (cashier-pci.wixapps.net), only through a prepared checkout: Wix's payment
+ * widget fails the payment 30 seconds after it asks the frame for a token. The
+ * cardholder's device sends the card through the checkout relay and the frame gets back
+ * Wix's token. A second card request from the frame, which Wix's frame sends after a 401
+ * or 403 under a fresh instance, is never answered from the same approval. Served on the
+ * same terms: only to a build that lists it, for a company Agentcard turned Wix on for.
  */
 export const SUPPORTED_CAPABILITIES = ['fiserv_card_capture', GMO_CAPABILITY, CYBERSOURCE_FLEX_CAPABILITY, JUSPAY_CAPABILITY, DATATRANS_CAPABILITY, 'authorize_net_dpm_form', PELECARD_CAPABILITY, ACI_CAPABILITY, 'creditguard_pps_process', PRIMER_CAPABILITY, PAYRAILS_CAPABILITY, CONVERGE_CAPABILITY, EPROTECT_CAPABILITY, WSPAY_CAPABILITY, SHIJI_STS_CAPABILITY, AMADEUS_CHECKOUT_CAPABILITY, 'worldline_mycheckout_form', 'verifone_card_capture', 'ekashu_hosted_payment_page', SECURE_ACCEPTANCE_CAPABILITY, 'gravy_session_fields_put', 'moneris_hosted_tokenization', PADDLE_VGS_CAPABILITY, PADDLE_TOKENEX_CAPABILITY,
-    'redsys_hosted_payment_page', 'lyra_krypton_payment', 'payfast_card_pay'];
+    'redsys_hosted_payment_page', 'lyra_krypton_payment', 'payfast_card_pay', WIX_PAYMENTS_CAPABILITY];
 /**
  * Processors whose paused request names no amount at all, so the pair the
  * agent passes is the amount the cardholder approves: authorize() refuses one
@@ -252,14 +261,16 @@ export const SUPPORTED_CAPABILITIES = ['fiserv_card_capture', GMO_CAPABILITY, CY
  * which the prepared checkout carries, is the total the cardholder approves. Payfast's
  * card pay carries none either: the merchant's entry bound the total to the payment,
  * so the agent sends the total Payfast's page shows, above zero (PAYFAST_PSP below),
- * and the API holds it to the payment Payfast itself reports.
+ * and the API holds it to the payment Payfast itself reports. Wix's tokenize request
+ * carries none either: the merchant's page charges Wix's token for its own order, so the
+ * agent's pair, which the prepared checkout carries, is the total the cardholder approves.
  */
 const MONERIS_PSP = 'moneris';
 const PAYFAST_PSP = 'payfast';
-const AGENT_AMOUNT_PROCESSORS = [GMO_PSP, PELECARD_PSP, WSPAY_PSP, SECURE_ACCEPTANCE_PSP, MONERIS_PSP, PADDLE_VGS_PSP, PAYFAST_PSP];
+const AGENT_AMOUNT_PROCESSORS = [GMO_PSP, PELECARD_PSP, WSPAY_PSP, SECURE_ACCEPTANCE_PSP, MONERIS_PSP, PADDLE_VGS_PSP, PAYFAST_PSP, WIX_PAYMENTS_PSP];
 /** How AmountRequiredError names a processor. */
 const PROCESSOR_NAMES = { [GMO_PSP]: 'GMO', [PELECARD_PSP]: 'Pelecard', [WSPAY_PSP]: 'WSPay',
-    [SECURE_ACCEPTANCE_PSP]: 'CyberSource Secure Acceptance', [MONERIS_PSP]: 'Moneris', [PADDLE_VGS_PSP]: 'Paddle', [PAYFAST_PSP]: 'Payfast' };
+    [SECURE_ACCEPTANCE_PSP]: 'CyberSource Secure Acceptance', [MONERIS_PSP]: 'Moneris', [PADDLE_VGS_PSP]: 'Paddle', [PAYFAST_PSP]: 'Payfast', [WIX_PAYMENTS_PSP]: 'Wix' };
 /**
  * Processors whose request and answer name no amount at all, so the total the
  * payment page shows (`pageAmount`) is the one figure that ties the agent's pair
@@ -1091,6 +1102,19 @@ const LYRA_SESSION = /;jsessionid=[^/;?#]*/gi;
 function maskLyraSession(path) {
     return path.replace(LYRA_SESSION, ';jsessionid={session}');
 }
+/**
+ * PayMongo's hosted checkout sends its card form's attach to its own page URL,
+ * https://checkout.paymongo.com/<session> (payment-core paymongo.js), and the session id is the only
+ * credential there, no cookies: with it anyone can open that checkout, its amount and its merchant, and
+ * pay it. Every route of the host is a session page, so on it any run of 24 or more letters and digits,
+ * with or without its cs_ prefix, in any case, after an escaped slash or with any character
+ * percent-encoded (a path keeps %36 where it means 6), reads {session}.
+ */
+const PAYMONGO_CHECKOUT_HOST = /^checkout\.paymongo\.com\.?$/i;
+const PAYMONGO_SESSION = /(?:cs_)?(?:[A-Za-z0-9]|%[0-9A-Fa-f]{2}){24,}/gi;
+function maskPaymongoSession(path) {
+    return path.replace(PAYMONGO_SESSION, '{session}');
+}
 /**
  * The processors whose card request carries its own credential in the URL path, with the hosts
  * that send it, the text that names those hosts in a string that is not a URL, and the mask. The
@@ -1108,6 +1132,17 @@ const REDSYS_SESSION = /((?:;|%3b)jsessionid(?:=|%3d))[^/?#;]*/gi;
 function maskRedsysSession(path) {
     return path.replace(REDSYS_SESSION, '$1{session}');
 }
+/**
+ * A PayPal order id opens PayPal's own checkout page for that order (/checkoutnow?token=<order id>) to
+ * anyone who holds it, and PayPal's card confirms carry it in the path:
+ * /v2/checkout/orders/<order id>/confirm-payment-source on www, api-m and cors.api. On PayPal's hosts the
+ * segment after /orders/, in any case or after an escaped slash, reads {order}.
+ */
+const PAYPAL_HOST = /(?:^|\.)paypal\.com\.?$/i;
+const PAYPAL_ORDER = /(\/orders(?:\/|%2f))[^/]*/gi;
+function maskPaypalOrder(path) {
+    return path.replace(PAYPAL_ORDER, '$1{order}');
+}
 const PATH_CREDENTIALS = [
     { host: CREDITGUARD_HOST, named: /creditguard\.co\.il/i, mask: maskCreditguardTxId },
     { host: GRAVY_HOST, named: /gr4vy\.app/i, mask: maskGravySession },
@@ -1118,6 +1153,8 @@ const PATH_CREDENTIALS = [
     { host: PADDLE_CHECKOUT_HOST, named: /checkout-service\.paddle\.com/i, mask: maskPaddleCheckout },
     { host: REDSYS_HOST, named: /redsys\.es/i, mask: maskRedsysSession },
     { host: LYRA_HOST, named: /(?:payzen\.eu|systempay\.fr|societegenerale\.eu|lyra\.com)/i, mask: maskLyraSession },
+    { host: PAYPAL_HOST, named: /paypal\.com/i, mask: maskPaypalOrder },
+    { host: PAYMONGO_CHECKOUT_HOST, named: /checkout\.paymongo\.com/i, mask: maskPaymongoSession },
 ];
 /**
  * A URL as it may appear in an error message: origin + path only. A paused
@@ -1138,6 +1175,9 @@ const PATH_CREDENTIALS = [
  * On Redsys's hosts the session id after `;jsessionid=` reads `{session}`:
  * https://sis.redsys.es/sis/pagoTarjeta;jsessionid={session}.
  * On Lyra's API hosts the form token's session id reads `{session}`.
+ * On PayPal's hosts an order id reads `{order}`:
+ * https://www.paypal.com/v2/checkout/orders/{order}/confirm-payment-source.
+ * On PayMongo's checkout host the session id reads `{session}`: https://checkout.paymongo.com/{session}.
  * A string that is not a URL keeps the part before any `?` or `#`, with the
  * same segments masked.
  */
@@ -1226,17 +1266,26 @@ const SECURE_ACCEPTANCE_PREPARATION_REFUSALS = [
 const PADDLE_VGS_PREPARATION_REFUSALS = [
     'processor_unavailable', 'sandbox_host_on_live_row', 'live_host_on_sandbox_row', 'merchant_profile_mismatch', 'paddle_vgs_card_unsupported',
 ];
+/**
+ * The API's refusals of a Wix Payments preparation, before any preparation exists, that prepareCheckout
+ * surfaces by name: the lane is held to Agentcard's own account (`processor_unavailable`), a test client
+ * asked for it (`live_host_on_sandbox_row`: Wix has no test environment), and a checkout's merchant is not
+ * the name the reviewed store pin carries (`merchant_profile_mismatch`). An unreviewed store answers
+ * `unsupported_checkout`, which PREPARATION_REFUSALS names for every checkout. Only for a Wix checkout.
+ */
+const WIX_PAYMENTS_PREPARATION_REFUSALS = ['processor_unavailable', 'live_host_on_sandbox_row', 'merchant_profile_mismatch'];
 /**
  * The reason the cardholder's device declines a bound prepared row with, per processor, when its own
  * send boundary passed before the card left it (the Vault's sendWindow, 12 seconds after it last saw
- * the checkout unbound): a prepared Amadeus SDK add and a prepared Secure Acceptance token create. It
- * names the same known non-payment the adapters' own send window closes on (amadeus.ts), which can
- * close later, so authorize() ends the attempt the way that window does, as a CheckoutPreparationError
- * with that reason, and never as the cardholder's "no".
+ * the checkout unbound): a prepared Amadeus SDK add, a prepared Secure Acceptance token create and a
+ * prepared Wix tokenize request. It names the same known non-payment the adapters' own send window
+ * closes on (amadeus.ts), which can close later, so authorize() ends the attempt the way that window
+ * does, as a CheckoutPreparationError with that reason, and never as the cardholder's "no".
  */
 const PREPARED_SEND_WINDOW_DECLINES = Object.freeze({
     amadeus_checkout: 'amadeus_send_window_closed',
     [SECURE_ACCEPTANCE_PSP]: 'secure_acceptance_send_window_closed',
+    [WIX_PAYMENTS_PSP]: 'wix_payments_send_window_closed',
 });
 /**
  * Refusals a CyberSource Flex preparation that tokenizes before Pay answers (4xx) before any
@@ -1918,6 +1967,7 @@ export class VaultClient {
                     || (input.psp === 'fiserv' && FISERV_PREPARATION_REFUSALS.includes(error.code))
                     || (input.psp === EPROTECT_PSP && EPROTECT_PREPARATION_REFUSALS.includes(error.code))
                     || (input.psp === PADDLE_VGS_PSP && PADDLE_VGS_PREPARATION_REFUSALS.includes(error.code))
+                    || (input.psp === WIX_PAYMENTS_PSP && WIX_PAYMENTS_PREPARATION_REFUSALS.includes(error.code))
                     || (!!flexContext && CYBERSOURCE_FLEX_PREPARATION_REFUSALS.includes(error.code))))
                     || (input.psp === 'fiserv' && error.status === 502 && error.code === 'cse_key_unavailable')))
                 throw fail(error.code);

package/dist/lifecycle.d.ts

@@ -5,6 +5,7 @@ import type { Substitutions } from './substitute.js';
 import type { GmoUnsupportedReason } from './gmo.js';
 import type { ShijiStsUnsupportedReason } from './shiji-sts.js';
 import type { PaddleVgsPayRefusal } from './paddle-vgs-pay.js';
+import type { PaypalCardFormReason } from './paypal-card-forms.js';
 /** The application's resolver confirmed the payment for this checkout authorization. */
 export interface MerchantPaymentConfirmation {
     kind: 'merchant_payment';
@@ -263,6 +264,9 @@ export declare class CheckoutLifecycle implements CheckoutController {
      * the cardholder's device can fill (processor_card_page: NMI's), a card
      * sent to PayPal's legacy Hosted Fields confirm, which no Vault mode takes
      * over (unsupported_paypal_hosted_fields, paypal-hosted-fields.ts), a card
+     * sent through PayPal's Card Fields with no recognizer to pay it, or through
+     * PayPal's guest card form (unsupported_paypal_card_fields and
+     * unsupported_paypal_guest_checkout, paypal-card-forms.ts), or a card
      * a merchant's page posts to CyberSource Secure Acceptance's Silent Order
      * POST, which no Vault mode takes over either
      * (unsupported_cybersource_secure_acceptance, cybersource-secure-acceptance.ts), a
@@ -273,7 +277,7 @@ export declare class CheckoutLifecycle implements CheckoutController {
      * send it (unsupported_ebanx_card_resend, ebanx.ts): once an approval exists the
      * state keeps it, and only the hold changes.
      */
-    unsupported(reason?: 'unrecognized_payment_endpoint' | 'merchant_profile_observe' | 'merchant_request_unsupported' | GmoUnsupportedReason | 'microform_unsupported' | 'juspay_request_unsupported' | 'merchant_card_endpoint_not_enabled' | 'merchant_card_endpoint_resend_refused' | 'creditguard_three_d_secure' | 'unsupported_primer_sdk' | 'unsupported_primer_request' | PayrailsUnsupportedReason | ShijiStsUnsupportedReason | 'processor_card_page' | 'unsupported_paypal_hosted_fields' | 'unsupported_cybersource_secure_acceptance' | PaddleVgsPayRefusal | 'unsupported_ebanx_card_resend'): void;
+    unsupported(reason?: 'unrecognized_payment_endpoint' | 'merchant_profile_observe' | 'merchant_request_unsupported' | GmoUnsupportedReason | 'microform_unsupported' | 'juspay_request_unsupported' | 'merchant_card_endpoint_not_enabled' | 'merchant_card_endpoint_resend_refused' | 'creditguard_three_d_secure' | 'unsupported_primer_sdk' | 'unsupported_primer_request' | PayrailsUnsupportedReason | ShijiStsUnsupportedReason | 'processor_card_page' | 'unsupported_paypal_hosted_fields' | PaypalCardFormReason | 'unsupported_cybersource_secure_acceptance' | PaddleVgsPayRefusal | 'unsupported_ebanx_card_resend'): void;
     /**
      * A card request that only a prepared checkout pays (an Adyen merchant
      * profile's, or a Fiserv card capture) arrived with no preparation on this

package/dist/lifecycle.js

@@ -263,6 +263,9 @@ export class CheckoutLifecycle {
      * the cardholder's device can fill (processor_card_page: NMI's), a card
      * sent to PayPal's legacy Hosted Fields confirm, which no Vault mode takes
      * over (unsupported_paypal_hosted_fields, paypal-hosted-fields.ts), a card
+     * sent through PayPal's Card Fields with no recognizer to pay it, or through
+     * PayPal's guest card form (unsupported_paypal_card_fields and
+     * unsupported_paypal_guest_checkout, paypal-card-forms.ts), or a card
      * a merchant's page posts to CyberSource Secure Acceptance's Silent Order
      * POST, which no Vault mode takes over either
      * (unsupported_cybersource_secure_acceptance, cybersource-secure-acceptance.ts), a

package/dist/paypal-card-forms.d.ts

@@ -0,0 +1,73 @@
+/**
+ * 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 declare const PAYPAL_CARD_FIELDS_REASON: "unsupported_paypal_card_fields";
+export declare const PAYPAL_GUEST_CHECKOUT_REASON: "unsupported_paypal_guest_checkout";
+export type PaypalCardFormReason = typeof PAYPAL_CARD_FIELDS_REASON | typeof PAYPAL_GUEST_CHECKOUT_REASON;
+/** The hosts Card Fields sends its confirm to: v5 on www, v6 on api-m, live and sandbox. */
+export declare const PAYPAL_CARD_FIELDS_HOSTS: readonly string[];
+/** The hosts of PayPal's own pages, whose GraphQL endpoint takes the guest form's card and a card saved with no purchase. */
+export declare const PAYPAL_GRAPHQL_HOSTS: readonly string[];
+/**
+ * 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 declare const PAYPAL_CARD_FORM_PATTERNS: readonly string[];
+/** Whether this URL is the Card Fields confirm on one of its four hosts (https, standard port, no credentials). */
+export declare function isPaypalCardFieldsConfirm(url: string): boolean;
+/** Whether this URL is GraphQL on one of PayPal's two page hosts. */
+export declare function isPaypalGraphql(url: string): boolean;
+/** Whether this URL is any request the guard judges, for the Playwright route's predicate. */
+export declare function isPaypalCardFormUrl(url: string): boolean;
+/** Whether a GraphQL URL's query names one of the two card operations (`/graphql?OnboardGuestMutation`). */
+export declare function paypalGraphqlNamesCardOperation(url: string): boolean;
+/**
+ * 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 declare function paypalGraphqlCard(body: string | null): 'guest_card' | 'saved_card' | 'no_card' | 'unreadable';
+/** What a Card Fields confirm carries: its body is the Orders v2 shape Hosted Fields also sends. */
+export declare const paypalCardFieldsBody: typeof paypalHostedFieldsBody;

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).