@agent-cards/sdk 0.23.14 → 0.23.15

package/CHANGELOG.md

@@ -18,6 +18,8 @@
 - Pay a Lyra payment form (PayZen, Systempay or Sogecommerce) for a company Agentcard turned Lyra on for (dark launch): the SDK declares `lyra_krypton_payment`, pauses the form's card payment and hands the form Lyra's answer with the payment id its 3-D Secure step needs.
 - Keep a Lyra payment's session id out of your events and error messages. Lyra's Krypton payment form (PayZen, Systempay, Sogecommerce, Lyra Collect) sends its payment to `/api-payment/V4/Charge/Public/ProcessPayment/2;jsessionid=<id>` on the brand's API host, and that id, with the form token the page holds, continues the payment on Lyra's side. `redactUrl`, every event and every error message show it as `{session}`, as in `https://api.systempay.fr/api-payment/V4/Charge/Public/ProcessPayment/2;jsessionid={session}`. Lyra stays dark for every company Agentcard has not turned it on for, and no API or Vault release is needed.
 
+- Stop PayPal's Card Fields and PayPal's guest card form from sending the card your agent typed to PayPal. A checkout that loads PayPal's JS SDK with `components=card-fields`, such as a WooCommerce PayPal Payments store's "Debit & Credit Cards" option, takes the card in frames on `www.paypal.com/smart/card-field` and sends it to `https://www.paypal.com/v2/checkout/orders/{id}/confirm-payment-source`; PayPal's v6 SDK sends the same request to `api-m.paypal.com`, and PayPal's sandbox uses `www.sandbox.paypal.com` and `api-m.sandbox.paypal.com`. PayPal's black "Debit or Credit Card" button takes the card on PayPal's own guest form, which sends it to `https://www.paypal.com/graphql?OnboardGuestMutation`, and Card Fields saves a card with no purchase through `graphql?UpdateVaultSetupToken`. No Agentcard payment took any of these over, and earlier releases let them through, so PayPal received the dummy card and declined it. Both adapters now fail each of them in the browser for every company, and the controller reads `unsupported` with reason `unsupported_paypal_card_fields`, or `unsupported_paypal_guest_checkout` for the guest form, and holds: to pay another way on the same page, attach again. A request with no card in it, such as a PayPal wallet confirm or the buttons' other GraphQL calls, continues untouched. A confirm whose body the SDK cannot read is failed with a `blocked` event, `unreadable_paypal_request`, and the checkout is not held; a GraphQL post it cannot read is failed the same way only when its URL names one of the two card operations. A guest form that PayPal opens in a popup window runs in another page, which the SDK covers only when you attach it to that page as well. Events and error messages now name a PayPal order as `{order}`, as in `https://www.paypal.com/v2/checkout/orders/{order}/confirm-payment-source`, on every PayPal host, legacy Hosted Fields' `cors.api.paypal.com` included: an order id opens PayPal's own checkout page for that order to anyone who holds it. TypeScript: the controller's `unsupported()` reasons gain `unsupported_paypal_card_fields` and `unsupported_paypal_guest_checkout`; code that switches exhaustively over them needs the new cases.
+
 - Keep a Rapyd hosted page's id and a Stripe Checkout Session's id out of your events and error messages. Rapyd's checkout page sends the card to `/v1/checkout/checkout_<id>` on `api.rapyd.net` (a card page to `/v1/hosted/collect/card/hp_card_<id>/payment_method`) with no auth header, so the page's id is the only credential that request needs: anyone who holds it can read the page and post a card to it until it expires. Stripe Checkout confirms a session at `/v1/payment_pages/<session id>/confirm` with the merchant's publishable key, which is public, so the session id is what lets anyone confirm a payment on it. Earlier releases named both ids in the `card_request_paused` event and in the errors `authorize()` throws, so they reached your `onEvent` handler and every log that recorded the event or the error. `redactUrl`, every event and every error message now show them as `{token}` and `{session}`, as in `https://api.rapyd.net/v1/checkout/{token}` and `https://api.stripe.com/v1/payment_pages/{session}/confirm`. `redactUrl` also masks an ACI checkout id in the shapes it used to keep: a host with a trailing dot, an escaped or doubled slash, and a string that is not a URL. A PaymentIntent or SetupIntent id stays, since confirming one also needs its client_secret. No API or Vault release is needed.
 
 - Pay a store on Paysafe Checkout's current build, 1.16.1. The loader Paysafe tells merchants to include, `checkout/v1/latest`, now runs version 1.16.1, and that build sends the card to `api.paysafe.com/checkout/api/v1/tokenize` (`api.test.paysafe.com` in its test environment), where 1.8.0 sent it to `hosted.paysafe.com`. Earlier releases did not recognize that request, so it was never paused and the agent's placeholder card reached Paysafe. The SDK now pauses it and keeps the three headers the build sends beside its credential: `X-Internal-Correlation-Id`, `X-App-Version` and `X-TransactionSource`. Paysafe.js latest sends the same three, and its replay keeps them too. `prepare({ psp: 'paysafe' })` binds a request only to a Checkout build Agentcard read, by the version the request names: 1.8.0 on `hosted.paysafe.com`, or 1.16.1 on `api.paysafe.com`, each with its own headers. A request from any other build stops with `checkout_changed`, and nothing is sent. An SDK that syncs its registry pauses the 1.16.1 request once the API release deploys; a prepared 1.16.1 checkout needs this release. Both need a Vault release after 0.6.2.
@@ -135,6 +137,8 @@
 
 - Pay a live Pelecard checkout, for a company Agentcard turned Pelecard on for. Pelecard's test and live terminals share `gateway21.pelecard.biz` and `gateway20.pelecard.biz`, and neither the payment page nor its request says which kind a page is on, so the API refused every live Pelecard create with `400 pelecard_live_unsupported`, before any row or prompt. On 2026-10-11 Agentcard accepted that a live payment page could sit on one of Pelecard's public test terminals, and a live create now parks like a test one. The cardholder approves under Pelecard's note, which says the merchant may have Pelecard keep the card, since a merchant can set `CreateToken` when it creates the payment page, and only a card the cardholder stored pays: the API refuses a card a company added as `card_not_stored`. A test-mode checkout still takes only a documented test card. No SDK upgrade is needed. A payment also needs the matching API, Vault and checkout relay releases, with `CHECKOUT_PELECARD_RELAY_ENABLED` on and the company listed for Pelecard.
 
+- Pay a Wix checkout whose card goes to Wix's own tokenizer, from Agentcard's own account only for now (dark launch): Agentcard turns it on for another company once it checks that the site instance Wix's card frame sends belongs to the reviewed store. Every Wix checkout mounts Wix Cashier's card frame, and for Wix Payments and classic Stripe on Wix that frame posts the card to `https://cashier-pci.wixapps.net/_api/payment-gateway-web/tokenize/v2/tokens`. Wix's payment widget fails the payment 30 seconds after it asks the frame for a token, too soon for an approval after Pay, so the SDK pays a Wix checkout only through `prepare({ psp: 'wix_payments', environment: 'production' })`, at a store Agentcard reviewed (ParaHouse Magazine, Psalms & Potions and Alexandra Hagel today), with `amount` and `currency`, the total the cardholder approves: the request names none. Wix has no test environment, so a test client's `prepare()` fails with `live_host_on_sandbox_row`. The sync now also asks for `capabilities=wix_payments_tokenize`. Once the cardholder approves, the frame's request pauses, the cardholder's device sends the card through the checkout relay, and the frame receives Wix's token. The frame sends its card request once more under a fresh site instance after Wix answers 401 or 403: the SDK refuses that second request in the browser and never answers it from the first approval. The SDK fails a paused request the cardholder's device has not sent 20 seconds after the pause, of the 30 seconds Wix waits, with reason `wix_payments_send_window_closed`, as it fails a prepared Secure Acceptance token create, and the device sends nothing past its own earlier boundary.
+
 ## 0.23.0
 
 ### Upgrading from 0.22.0

package/PREFLIGHT.md

@@ -203,6 +203,8 @@ WSPay Components (`wspay`) is identified from its component scripts and its card
 
 Shiji STS (`shiji_sts`), the card leg of MyCheck Wallet V3 at La Quinta by Wyndham, is identified from the in-page wallet script `wallet-sdk-v3.mycheckapp.com/{version}/static/js/main.js` (and its `-sandbox` and `-test` hosts) and from Shiji's proxy `cdn.shijipayment.com/sts/sts.proxy.v2.1.js` (and its `cdn.shijipayment.dev` copy), but it is not in this table. It launches dark: the direct SDK acts on it only after `syncRegistry()` and only for an org Agentcard has enabled, and even then it refuses every card request as card on file (`shiji_sts_keep_on_file`) until Agentcard can ask the cardholder to let a hotel keep the card, so the bundled catalog leaves it out and a Shiji checkout stays `unknown`. MyCheck's iframe wallet (`sdk.js`, `wallet-iframe.html`) and Shiji's `shijipayments.latest.min.js` name their processor and return `unknown` with `processor_variant_unverified`. Read the [Shiji STS section of the README](./README.md#shiji-sts-mycheck-wallet-v3).
 
+Wix Payments (`wix_payments`) has no discovery rule in this table. Wix Cashier's card frame on `cashier-pci.wixapps.net` is the same for every provider a Wix site connects, and for Square and Wix's Stripe Gateway it sends the card to the processor's own SDK rather than to Wix's tokenizer, so the frame on a page is no evidence of this lane, and a Wix checkout stays `unknown`. The direct SDK pauses the card request the frame sends to Wix's tokenizer only after `syncRegistry()`, only through a prepared checkout, and only for an org Agentcard has enabled. Read the Wix row of the [README](./README.md) processor table.
+
 Gravy Secure Fields (`gravy`) is identified from the loader its merchants load, `/secure-fields/latest/secure-fields.js` on `cdn.<merchant>.gr4vy.app` (or `cdn.sandbox.<merchant>.gr4vy.app`), but it is not in this table. It launches dark: the direct SDK pauses Gravy's card request, a `PUT` from Gravy's controller frame, only after `syncRegistry()` and only for an org Agentcard has enabled, so the bundled catalog leaves it out and a Gravy checkout stays `unknown`.
 
 Paddle (`paddle_vgs`) has no discovery rule in this table. Paddle's checkout frame on `buy.paddle.com` names the tokenizer it sends the card through only after the buyer's first step, and Paddle can name another one for each checkout, so nothing on the page before that step says which one a checkout uses, and a Paddle checkout stays `unknown`. The direct SDK pauses the card request a VGS checkout sends to `vault.paddle.com/cards` only after `syncRegistry()`, only through a prepared checkout, and only for an org Agentcard has enabled. Read the Paddle row of the [README](./README.md) processor table for what the SDK covers.

package/README.md

@@ -255,6 +255,7 @@ Coverage is specific to the processor request format, merchant setup, browser tr
 | Mercado Pago | Card tokenization and prepared checkout are implemented. Guest Checkout Pro in Mexico also corrects the issuer for one native card association when the selected card has the same brand and type. One live MXN 40 Lotería Chida purchase with published SDK 0.10.0 completed automatically through Pay; the merchant confirmed paid status and PDF fulfillment. The historical SDK result remains unknown because the private receipt adapter rejected a relative download URL; a separate read with the corrected adapter confirms that same paid receipt. Independent processor capture/settlement and other country or integration paths remain unverified. |
 | VGS Collect (Very Good Security; Wolt) | not supported: VGS's proxy aliases only submissions from its own iframe, so a replay from the cardholder's device is refused by the merchant (verified on Wolt, 2026-09-03). Not recognized, so the agent's browser is not paused there |
 | PayPal Hosted Fields (the legacy card fields of PayPal's JS SDK; Planet Golf UK) | not supported: no Agentcard payment takes over the card these fields send to `cors.api.paypal.com`. The SDK fails that request for every company, so PayPal's payment confirm never receives the dummy card, and the controller reads `unsupported` with reason `unsupported_paypal_hosted_fields` and holds the attachment until you attach again; a PayPal wallet payment continues untouched |
+| PayPal Card Fields (PayPal JS SDK `components=card-fields`, v5 and v6) and PayPal's guest card form (the "Debit or Credit Card" button) | not supported: no Agentcard payment takes over the card these send to `www.paypal.com` or `api-m.paypal.com`. The SDK fails each card request for every company, so PayPal never receives the dummy card, and the controller reads `unsupported` with reason `unsupported_paypal_card_fields` (or `unsupported_paypal_guest_checkout` for the guest form) and holds the attachment until you attach again; a PayPal wallet payment continues untouched |
 | CyberSource Secure Acceptance Silent Order POST (the merchant's own card form posted to CyberSource; Arrow Electronics) | dark launch: prepared checkout only, for an org Agentcard enabled. After `syncRegistry()`, for such an org, the SDK pauses the token create a merchant's form posts into a hidden iframe (`/silent/embedded/token/create` on `secureacceptance.cybersource.com`, or `testsecureacceptance.cybersource.com` in CyberSource's test environment), the cardholder's device sends the card to CyberSource, and the iframe gets CyberSource's own reply page. See [Pay a CyberSource Secure Acceptance checkout](#pay-a-cybersource-secure-acceptance-checkout-dark-launch). For every other company, and for every other card post to a `/silent/` path on those hosts or on `secureacceptance.in.cybersource.com` (India), no Agentcard payment takes the card over, and the SDK stops the post so CyberSource never receives the dummy card: a form the page submits as a page load, in the page or in a frame, ends on the page that says Agentcard stopped the payment, and a fetch or an XHR fails. The controller reads `unsupported` with reason `unsupported_cybersource_secure_acceptance` and holds the attachment until you attach again; a post with no `card_number`, such as a payment with a stored `payment_token`, continues untouched. The SDK does not stop Hosted Checkout, where your agent types the card on CyberSource's own page |
 | EBANX (EBANX.js and EBANX's hosted payment page; Nuuvem Colombia) | supported for the token request (`POST /ws/token`): the SDK pauses it, and the cardholder's device sends the card there. EBANX's page then sends the card again. 3-D Secure's `/ws/threedsecureserver-generateToken`, `-authentications` and `-authentication-results` carry the card. The hosted page's confirm, `/ws/checkout-v2/confirm`, carries the card code. For a company Agentcard turned it on for, the approval's read names until when it covers those sends (`followUpsUntil`). While the Vault page stays open, the cardholder's device sends each covered one, bound to the approved request. The cardholder sees no second prompt. The page receives EBANX's answer. The confirm is covered only once 3-D Secure succeeded for the invoice it pays. It pays in one instalment and keeps no card for one-click payments. A card checkout that runs no 3-D Secure, picks instalments or saves the card fails in the browser. Every other such send fails in the browser too, for every company. EBANX never receives the dummy card or code. The page shows its own payment error. The controller reads `unsupported` with reason `unsupported_ebanx_card_resend` and holds the attachment until you attach again. After one such send fails or is refused, the SDK sends nothing more on that attachment. It also sends nothing once the checkout no longer names that approval: a final merchant result such as `completed` or `failed`, a new token request, or a new attempt after a merchant failure, and nothing while a reconciliation runs. While a send is out, `reconcile()` and `retryAfterMerchantFailure()` throw, and a new card request fails in the browser. A confirm with no card code, such as a PSE bank transfer, continues untouched |
 | Adyen | supported (mode `cse`): the vault encrypts the card for Adyen on the cardholder's device and your browser sends it. Sessions flow: the paused request is `/checkoutshopper/v1/sessions/{id}/payments` on Adyen's own hosts. A merchant that posts the encrypted fields to its own server pauses only when Agentcard reviewed it as a merchant profile. Cinemark and Dick's Sporting Goods' own storefront take payments for a company Agentcard turned them on for; every other reviewed merchant is in `observe`, so its card requests are reported and aborted and nothing pays there yet (see "Adyen merchants that take the card on their own server"). Without a preparation, approval starts at Pay and must land before Adyen Web's own request timeout (observed at 60 seconds on Adyen Web 6.41 and 6.44; not enforced by the SDK); `prepare({ psp: 'adyen' })` moves the approval before Pay |
@@ -278,6 +279,7 @@ Coverage is specific to the processor request format, merchant setup, browser tr
 | Moneris Hosted Tokenization (Moneris's card frame; Raisin donation pages) | dark launch: after `vault.syncRegistry()`, and only for an org Agentcard has enabled, the SDK pauses the frame's post to `/HPPtoken/request.php` on `www3.moneris.com` or `gateway.moneris.com` (`esqa.moneris.com` for a test row) when it carries the card number, expiry and CVD, always with the cardholder's approval. A live payment needs a merchant Agentcard reviewed: the profile id the frame names must be one pinned for the checkout page's origin (Jack.org's Raisin page today), or the create answers `unsupported_checkout`. A frame that leaves the expiry or CVD to the merchant's page, or a post to any other `request.php` URL, fails in the browser with a `blocked` event, `request_without_card`. The cardholder's device sends the card through the checkout relay, and the page gets Moneris's temporary token, which the merchant charges from its own server: pass `amount` and `currency`, the total the cardholder approves. Moneris Checkout (`/chkt/`, `/chktv2/`) is not supported |
 | WSPay Components (WSPay's build of Monri Components) | dark launch: the card frame's confirm of a new card, after `vault.syncRegistry()`, with `amount` and `currency`, and only for an org Agentcard has enabled; for any other org the SDK leaves WSPay's requests alone. The cardholder's device sends the card to WSPay and the frame receives WSPay's answer. A confirm that asks WSPay to keep the card on file, as Valamar's does on every booking, is paid only as a hotel's EUR 1.00 card guarantee with a card the cardholder stored. Validated in local Chromium against a model of the card frame; no WSPay sandbox run or live merchant purchase yet. See [Pay a WSPay Components checkout](#pay-a-wspay-components-checkout) |
 | Shiji STS (MyCheck Wallet V3; Wyndham's booking pages) | dark launch, mode `cse` under a pinned key, and only for an org Agentcard has enabled. The card token a hotel booking mints guarantees the stay, so the cardholder approves with a card they stored, under a line that says the hotel can keep it on file. See [Shiji STS](#shiji-sts-mycheck-wallet-v3) |
+| Wix checkout (Wix Cashier's card frame; Wix Payments and classic Stripe on Wix) | dark launch: only in Agentcard's own account for now, after `vault.syncRegistry()`, and only through `prepare({ psp: 'wix_payments', environment: 'production' })` at a store Agentcard reviewed, with `amount` and `currency`. The frame's post to `cashier-pci.wixapps.net/_api/payment-gateway-web/tokenize/v2/tokens` pauses, the cardholder's device sends the card through the checkout relay, and the frame receives Wix's token. Wix has no test environment. The SDK refuses the frame's second card request after a 401 or 403 in the browser, and fails a request still unsent 20 seconds after the pause, before the card leaves (`wix_payments_send_window_closed`) |
 | Amadeus Checkout (Air France, KLM) | dark: only for an org Agentcard enabled, and only through `prepare({ psp: 'amadeus_checkout', cardId })`. The Checkout Web SDK's card add pauses; every other action on its URL continues. Air France and KLM keep the expiry in their own form, so the agent types the stored card's real expiry there and the checkout pays only with that card. Every Data Collection Page store is refused as `amadeus_dcp_field_config_unreviewed`. No live purchase yet. See "Prepare an Amadeus Checkout card step" |
 | Paddle checkout (Paddle's card vault; Rectangle Pro) | dark launch: only in Agentcard's own account for now, after `vault.syncRegistry()`, and only through `prepare({ psp: 'paddle_vgs', environment: 'production' })` (`'sandbox'` for Paddle's sandbox) on an attachment whose `cardId` names the paying card; without one, `prepare()` fails with `card_required`. On a Paddle checkout whose card method names VGS, the frame's post to `vault.paddle.com/cards` pauses, the cardholder's device sends the card itself, and the frame receives the stored card's id; its second request after its 10-second timeout gets the same answer. Type `placeholderCard()`'s facts for that card into Paddle's form, and pass `amount` and `currency`, the total the cardholder approves. Only Visa, Mastercard and American Express cards are paid (`paddle_vgs_card_unsupported` otherwise), and a typed expiry or placeholder that is not the card's fails the create with `paddle_vgs_card_mismatch`. On the live vault only a reviewed seller at its reviewed page is paid (Rectangle Pro at `https://rectangleapp.com`), and the approval says that seller can keep the card on file. Paddle's `/pay` that follows names the approved card's first six and last four digits, expiry and brand: the SDK writes them over the ones Paddle's form read from the placeholder, and aborts a `/pay` that names another stored card or comes more than a minute later. A Paddle checkout that sends the card through TokenEx or Spreedly is not supported, and no live payment has gone through this route yet |
 

package/dist/amadeus.d.ts

@@ -1,5 +1,7 @@
 /** How long after the pause a paused Amadeus SDK add may still be sent. */
 export declare const AMADEUS_SEND_WINDOW_MS = 20000;
+/** How long after the pause a paused Wix tokenize request may still be sent, of the 30 seconds Wix's widget waits. */
+export declare const WIX_PAYMENTS_SEND_WINDOW_MS = 20000;
 /**
  * True when a request the adapters refuse must fail as a network error (ERR_FAILED) rather than as
  * the cancellation (ERR_ABORTED) they use elsewhere. An XMLHttpRequest reports a cancellation only
@@ -9,12 +11,13 @@ export declare const AMADEUS_SEND_WINDOW_MS = 20000;
  */
 export declare function failsAsNetworkError(url: string): boolean;
 /** The processor a send window's events and stop cause name. */
-export type SendWindowProcessor = 'amadeus' | 'secure_acceptance';
+export type SendWindowProcessor = 'amadeus' | 'secure_acceptance' | 'wix_payments';
 /** Why a send window stopped its attempt: the API confirmed the card never left the device and never can. */
 export type SendWindowClosed = `${SendWindowProcessor}_send_window_closed`;
 /**
  * The send window for a request paused under a preparation for `psp`, or null when it has none: a
- * prepared Amadeus SDK add, and a prepared CyberSource Secure Acceptance token create, each 20 seconds.
+ * prepared Amadeus SDK add, a prepared CyberSource Secure Acceptance token create and a prepared Wix
+ * tokenize request, each 20 seconds.
  */
 export declare function preparedSendWindowMs(psp: string | undefined, url: string): number | null;
 /** The processor a prepared request's send window names in its events, or null when it has none. */

package/dist/amadeus.js

@@ -14,6 +14,11 @@
 // without a word. A token CyberSource creates after that point is one the page never reads, so a
 // paused token create gets the same 20 second window (cybersource-secure-acceptance.ts).
 //
+// Wix's payment widget fails the payment 30 seconds after it asks Wix Cashier's card frame for a
+// token (cashier-payments-widget 1.4964.0), and the merchant's page charges only a token the frame
+// handed back in time. A token Wix mints after that point is one no charge ever names, so a paused
+// tokenize request gets the same 20 second window.
+//
 // So when the window closes and no answer is being handed to the page yet, the adapter asks for that
 // cancel. Confirmed: nothing was sent and nothing can be, so the attempt stops, the page's request
 // fails (a Secure Acceptance frame gets the stopped page), and the checkout reads failed. Not
@@ -24,13 +29,17 @@
 // request can bind it, nothing can be sent; when a request already holds it, that authorization gets
 // the same cancel and the same rule, and when the API confirms neither, the attempt keeps waiting. The
 // Data Collection Page's store has no client timeout and gets no window. The window's events name the
-// processor: `amadeus_send_window_closed` and `amadeus_send_window_unconfirmed`, or
-// `secure_acceptance_send_window_closed` and `secure_acceptance_send_window_unconfirmed`.
+// processor: `amadeus_send_window_closed` and `amadeus_send_window_unconfirmed`,
+// `secure_acceptance_send_window_closed` and `secure_acceptance_send_window_unconfirmed`, or
+// `wix_payments_send_window_closed` and `wix_payments_send_window_unconfirmed`.
 import { amadeusCardUrl } from './amadeus-checkout.generated.js';
 import { isSecureAcceptanceTokenRequest } from './cybersource-secure-acceptance.generated.js';
 import { SECURE_ACCEPTANCE_PSP, SECURE_ACCEPTANCE_SEND_WINDOW_MS } from './cybersource-secure-acceptance.js';
+import { WIX_PAYMENTS_PSP, isWixPaymentsTokenizeUrl } from './wix-payments.generated.js';
 /** How long after the pause a paused Amadeus SDK add may still be sent. */
 export const AMADEUS_SEND_WINDOW_MS = 20_000;
+/** How long after the pause a paused Wix tokenize request may still be sent, of the 30 seconds Wix's widget waits. */
+export const WIX_PAYMENTS_SEND_WINDOW_MS = 20_000;
 /**
  * True when a request the adapters refuse must fail as a network error (ERR_FAILED) rather than as
  * the cancellation (ERR_ABORTED) they use elsewhere. An XMLHttpRequest reports a cancellation only
@@ -43,7 +52,8 @@ export function failsAsNetworkError(url) {
 }
 /**
  * The send window for a request paused under a preparation for `psp`, or null when it has none: a
- * prepared Amadeus SDK add, and a prepared CyberSource Secure Acceptance token create, each 20 seconds.
+ * prepared Amadeus SDK add, a prepared CyberSource Secure Acceptance token create and a prepared Wix
+ * tokenize request, each 20 seconds.
  */
 export function preparedSendWindowMs(psp, url) {
     if (psp === 'amadeus_checkout')
@@ -58,10 +68,14 @@ export function preparedSendWindowMs(psp, url) {
         }
         return tokenCreate ? SECURE_ACCEPTANCE_SEND_WINDOW_MS : null;
     }
+    if (psp === WIX_PAYMENTS_PSP)
+        return isWixPaymentsTokenizeUrl(url) ? WIX_PAYMENTS_SEND_WINDOW_MS : null;
     return null;
 }
 /** The processor a prepared request's send window names in its events, or null when it has none. */
 export function sendWindowProcessor(psp) {
+    if (psp === WIX_PAYMENTS_PSP)
+        return 'wix_payments';
     return psp === 'amadeus_checkout' ? 'amadeus' : psp === SECURE_ACCEPTANCE_PSP ? 'secure_acceptance' : null;
 }
 /** The send window for a prepared Amadeus SDK add, or null: preparedSendWindowMs for Amadeus alone. */

package/dist/card-fields.generated.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 // Generated from @agent-cards/payment-core. Do not edit.
-// artifact-sha256: 0fd8db3c00fa0c1aea085fd184efe4b3ebc67c57673b69d2daec5a912991e181
+// artifact-sha256: d16bc471bdb814eb3e7b9da3834c9cbb5b1db7089ce91d3bbfb2215f81c1958d
 // src/card-number-key.js
 var CARD_NUMBER_KEY = /^(number|card_number|cardnumber|cardNum|card_num|pan)$/i;
 // src/json-path.js
@@ -658,10 +658,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 {
@@ -673,7 +673,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)
@@ -1233,10 +1233,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" };

package/dist/cdp.js

@@ -19,6 +19,7 @@ import { isArmedEkashuUrl } from './ekashu.js';
 import { isArmedRedsysUrl } from './redsys.js';
 import { PAYPAL_HOSTED_FIELDS_PATTERNS, isPaypalHostedFieldsConfirm } from './paypal-hosted-fields.js';
 import { EBANX_RESEND_PATTERNS, EbanxFollowUps, isEbanxResendUrl } from './ebanx.js';
+import { PAYPAL_CARD_FORM_PATTERNS, isPaypalCardFormUrl } from './paypal-card-forms.js';
 import { CYBERSOURCE_SECURE_ACCEPTANCE_PATTERNS, CYBERSOURCE_SECURE_ACCEPTANCE_RECIPIENT, SecureAcceptanceFollowUpWatch, isCybersourceSecureAcceptanceUrl, secureAcceptanceFollowUp, secureAcceptanceFrameAnswer, secureAcceptanceReplyLast4, } from './cybersource-secure-acceptance.js';
 import { CheckoutAttachmentError, attachmentDeadline, attachmentFailure, withinAttachmentDeadline } from './attachment.js';
 import { cseBody } from './cse-body.js';
@@ -1382,11 +1383,12 @@ function merchantAttempt(lifecycle, survives) {
     let rebound = false;
     let delivering = false;
     let bound = null;
-    // A send window (an Amadeus SDK add's, a Secure Acceptance token create's) closes only once the API
-    // confirms the card never left the device and never can (amadeus.ts): a known non-payment, so the
-    // prepared checkout ends failed with that reason, and a fresh attachment can prepare again. Every
-    // other stop leaves the outcome unknown.
+    // A send window (an Amadeus SDK add's, a Secure Acceptance token create's, a Wix tokenize request's)
+    // closes only once the API confirms the card never left the device and never can (amadeus.ts): a
+    // known non-payment, so the prepared checkout ends failed with that reason, and a fresh attachment can
+    // prepare again. Every other stop leaves the outcome unknown.
     const error = () => reason === 'amadeus_send_window_closed' || reason === 'secure_acceptance_send_window_closed'
+        || reason === 'wix_payments_send_window_closed'
         ? new CheckoutPreparationError(lifecycle.getState().preparationId ?? null, reason)
         : new PaymentOutcomeUnknownError(lifecycle.getState().authorizationId, reason);
     const attempt = {
@@ -1616,8 +1618,8 @@ function pauseForBusiness(opts, lifecycle, attemptSignal, request, pageOrigin) {
 }
 /**
  * Arm the send window of a request paused under a preparation, when its processor sets one: a
- * prepared Amadeus SDK add and a prepared Secure Acceptance token create do (amadeus.ts
- * preparedSendWindowMs). Returns the disarm function, or null with no window. lifecycle.begin()
+ * prepared Amadeus SDK add, a prepared Secure Acceptance token create and a prepared Wix tokenize
+ * request do (amadeus.ts preparedSendWindowMs). Returns the disarm function, or null with no window. lifecycle.begin()
  * cleared the authorization ID, so the one the window reads is this attempt's.
  */
 function armWindowFor(opts, lifecycle, attempt, preparation, url, delivering) {
@@ -2060,6 +2062,10 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
     // PayPal's legacy Hosted Fields confirm is armed for every org, whatever the
     // registry serves: one that carries the typed card is paused only to be
     // refused, and one with no card continues (see paypal-hosted-fields.ts).
+    // PayPal's Card Fields confirm and GraphQL on www.paypal.com are armed the
+    // same way: a card the guard refuses is paused only to be refused, a
+    // confirm the registry recognizes pauses for its recognizer, and a request
+    // with no card continues (see paypal-card-forms.ts).
     // CyberSource Secure Acceptance's /silent/ paths are armed the same way, form
     // navigations included (see cybersource-secure-acceptance.ts), and so are
     // EBANX's 3-D Secure calls and hosted confirm, which send the typed card again
@@ -2068,8 +2074,8 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
     const urlPatterns = [...new Set([...(derived.length > 0 ? derived : FALLBACK_CARD_PATTERNS), ...guards.patterns,
             ...(stripeCheckout.isEnabled() ? ['https://api.stripe.com/*'] : []), MERCADO_CHECKOUT_PATTERN, ...merchantPatterns,
             ...(recognizesGmo(opts.vault) ? GMO_TOKEN_V1_PATTERNS : []), ...juspayCheckout.urlPatterns(), ...cardEndpointPatterns(),
-            ...(payrails ? PAYRAILS_GUARD_PATTERNS : []), ...PAYPAL_HOSTED_FIELDS_PATTERNS, ...CYBERSOURCE_SECURE_ACCEPTANCE_PATTERNS,
-            ...(recognizesPaddleVgs(opts.vault) ? PADDLE_VGS_PAY_PATTERNS : []), ...EBANX_RESEND_PATTERNS])];
+            ...(payrails ? PAYRAILS_GUARD_PATTERNS : []), ...PAYPAL_HOSTED_FIELDS_PATTERNS, ...PAYPAL_CARD_FORM_PATTERNS,
+            ...CYBERSOURCE_SECURE_ACCEPTANCE_PATTERNS, ...(recognizesPaddleVgs(opts.vault) ? PADDLE_VGS_PAY_PATTERNS : []), ...EBANX_RESEND_PATTERNS])];
     const arm = async (sessionId, resume = false, worker = false) => {
         const key = sessionId ?? '__root__';
         if (armed.has(key))
@@ -3450,6 +3456,8 @@ export async function attachToPlaywright(page, opts) {
             || isArmedRedsysUrl(opts.vault, url.toString())
             // PayPal's legacy Hosted Fields confirm, for every org, as attachToCdp arms it (paypal-hosted-fields.ts).
             || isPaypalHostedFieldsConfirm(url.toString())
+            // PayPal's Card Fields confirm and GraphQL on www.paypal.com, for every org, as attachToCdp arms them (paypal-card-forms.ts).
+            || isPaypalCardFormUrl(url.toString())
             // CyberSource Secure Acceptance's /silent/ paths, for every org, as attachToCdp arms them (cybersource-secure-acceptance.ts).
             || isCybersourceSecureAcceptanceUrl(url.toString())
             // Paddle's checkout services, routed only for an org the API served Paddle VGS to (see attachToCdp).

package/dist/client.d.ts

@@ -241,6 +241,14 @@ export declare const SUPPORTED_REGISTRY_FEATURES: readonly string[];
  * 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 declare const SUPPORTED_CAPABILITIES: readonly string[];
 /**
@@ -1164,6 +1172,8 @@ export declare class CheckoutAuthError extends Error {
  * 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.
  * A string that is not a URL keeps the part before any `?` or `#`, with the
  * same segments masked.
  */

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
@@ -1108,6 +1119,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 +1140,7 @@ 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 },
 ];
 /**
  * A URL as it may appear in an error message: origin + path only. A paused
@@ -1138,6 +1161,8 @@ 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.
  * A string that is not a URL keeps the part before any `?` or `#`, with the
  * same segments masked.
  */
@@ -1226,17 +1251,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 +1952,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;