@agent-cards/sdk 0.23.4 → 0.23.6

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+- Pause a Worldpay eProtect registration whatever Worldpay key its page names. Worldpay rotates its production eProtect key daily (`26457000011` on 2026-10-08), and 0.23.3 refused every registration whose `publicKeyId` was not `26455500012`, the key it shipped, so an attached checkout at any eProtect merchant read `unsupported`. The SDK now takes any key id in Worldpay's digits; the cardholder's device encrypts the card under the key it reads from Worldpay's own `eProtect-api3.js` and writes that key's id into its copy, so no later rotation needs an SDK release. SmartPak Equine (paypageId `zhs8KzuRAryaq4cs` at `https://www.smartpakequine.com`) and Nordstrom (`fL33BPkRvbRqJ29S` at `https://www.nordstrom.com`) are reviewed eProtect merchants: a live checkout there passes `merchant: 'SmartPak Equine'` or `merchant: 'Nordstrom'` exactly, and `prepare()` refuses another name with `merchant_profile_mismatch` before any network call. eProtect stays dark for every org Agentcard has not enabled, and a payment also needs the matching API and Vault releases.
+
+- Stop the card your agent typed from reaching CyberSource through Secure Acceptance's Silent Order POST. A merchant that takes the card in its own form, such as Arrow Electronics, has its server sign the order fields, then posts them with the card fields (`card_number`, `card_expiry_date`, `card_cvn`) to a `/silent/` path on `secureacceptance.cybersource.com` (`testsecureacceptance.cybersource.com` in CyberSource's test environment, `secureacceptance.in.cybersource.com` in India); Arrow submits that form into a hidden iframe. No Agentcard payment takes that post over, and earlier releases let it through, so CyberSource received the dummy card. Both adapters now stop it for every company, whatever `syncRegistry()` served: a form the page submits as a page load, in the page or in a frame, gets the page that says Agentcard stopped the payment before the card reached CyberSource, and a fetch or an XHR fails. A `card_number` in the URL's query, as a form with method GET sends it, stops the request the same way. The controller reads `unsupported` with reason `unsupported_cybersource_secure_acceptance` and holds, like every `unsupported` reason: to pay another way on the same page, attach again. A post with no `card_number`, or an empty one, such as a payment with a stored `payment_token`, continues untouched, and so does Hosted Checkout, the same hosts without `/silent/`, where your agent types the card on CyberSource's own page. The SDK stops a post whose body it cannot read with a `blocked` event, `unreadable_cybersource_secure_acceptance_request`, and does not hold the checkout. TypeScript: the controller's `unsupported()` reasons gain `unsupported_cybersource_secure_acceptance`; code that switches exhaustively over them needs the new case.
+
+- Name CyberSource Secure Acceptance's Silent Order POST in a preflight inspection. A form, a frame or a document on a `/silent/` path of `secureacceptance.cybersource.com`, `testsecureacceptance.cybersource.com` or `secureacceptance.in.cybersource.com` now names `cybersource_secure_acceptance`, and the result stays `unknown`: `processor_variant_unverified` for a visible form, and `payment_signal_inactive` for a hidden one such as Arrow's. The catalog's `catalog_sha256` changes; `catalog_version` stays `2026-09-15.1`.
+
 - Stop PayPal's legacy Hosted Fields from sending the card your agent typed to PayPal's payment confirm. A checkout that loads PayPal's JS SDK with `components=hosted-fields`, such as Planet Golf UK's PayPal Checkout, takes the card in frames on `assets.braintreegateway.com` and sends it to `https://cors.api.paypal.com/v2/checkout/orders/{id}/confirm-payment-source` (`cors.api.sandbox.paypal.com` in PayPal's sandbox). No Agentcard payment takes that request over, and earlier releases let it through, so PayPal received the dummy card and declined it. Both adapters now fail that request in the browser for every company, whatever `syncRegistry()` served, and the controller reads `unsupported` with reason `unsupported_paypal_hosted_fields` and holds, like every `unsupported` reason: to pay another way on the same page, attach again. A confirm with no card number, such as a PayPal wallet payment, 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 merchant that turns on PayPal's card installments also has the card number field send each typed number to PayPal's installment lookup, `/v1/credit/calculated-financing-options`; the SDK leaves that lookup alone, and it pays nothing. TypeScript: the controller's `unsupported()` reasons gain `unsupported_paypal_hosted_fields`; code that switches exhaustively over them needs the new case.
 
 - Name PayPal's legacy Hosted Fields as PayPal in a preflight inspection, not as Braintree. Their card fields are braintree-web builds whose version carries `-payments-sdk` (`3.32.0-payments-sdk-dev` on Planet Golf UK), and inspection read the page as `braintree` with status `supported`. The frames now name `paypal`, and the result stays `unknown` with `processor_variant_unverified`. A braintree-web script from a `-payments-sdk` build is no longer Braintree evidence either, and a variant seen in several frames lists its limitation once. The catalog's `catalog_sha256` changes; `catalog_version` stays `2026-09-15.1`.

package/PREFLIGHT.md

@@ -209,6 +209,8 @@ The catalog also carries reviewed hosted, regional, and versioned variants obser
 
 PayPal's legacy Hosted Fields (`paypal`) are identified from the card fields PayPal's JS SDK renders with `components=hosted-fields`: braintree-web builds whose version carries `-payments-sdk`, such as `3.32.0-payments-sdk-dev`, served from `assets.braintreegateway.com` as `hosted-fields-input-frame.min.html` and `hosted-fields-payments-sdk-tokenization-frame.min.html`. PayPal's frames send the card to PayPal, not to Braintree, so a page that shows them names `paypal` and returns `unknown` with `processor_variant_unverified`, and no braintree-web file from a `-payments-sdk` build counts as Braintree evidence. The SDK fails the card request those frames send; see the PayPal Hosted Fields row in the [README's processor table](./README.md#supported-processors).
 
+An inspection identifies CyberSource Secure Acceptance's Silent Order POST (`cybersource_secure_acceptance`) from the form a merchant's own page posts the card from, and from a frame or a document on the same path: a `/silent/` path, such as `/silent/pay` or `/silent/embedded/token/create`, on `secureacceptance.cybersource.com`, `testsecureacceptance.cybersource.com` or `secureacceptance.in.cybersource.com`. No Vault mode takes that post over, so a page that shows the form names `cybersource_secure_acceptance` and returns `unknown`: with `processor_variant_unverified` when the form is visible, and with `payment_signal_inactive` when it is hidden, as on Arrow Electronics' checkout. An inspection does not name Hosted Checkout, the same hosts without `/silent/`. The SDK stops the card post; see the CyberSource Secure Acceptance row in the [README's processor table](./README.md#supported-processors).
+
 Adyen's `supported` covers the Sessions payment request on Adyen's own hosts. Some Adyen merchants post the four encrypted fields to their own server instead, and their pages load the same secured fields, so an inspection identifies Adyen on both and cannot tell the two flows apart. The SDK pays a merchant's own endpoint only through a merchant profile Agentcard reviewed for it; the reviewed profiles (Dunelm and Cinemark) are in `observe`, so the SDK aborts their card requests and nothing is charged. The `actual_payment_request_validation` requirement is where that difference shows: check the paused request's host before treating an Adyen result as payable.
 
 Authorize.Net Direct Post Method and SIM ship dark. The SDK pauses their `transact.dll` card form only for an org Agentcard enabled for them (capability `authorize_net_dpm_form`), and the bundled catalog leaves them out, so the table above does not list them and inspection answers for their forms exactly as it did before: the SIM hosted form on `secure.authorize.net` identifies Authorize.Net and returns `unknown` with `processor_variant_unverified`.

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 |
+| CyberSource Secure Acceptance Silent Order POST (the merchant's own card form posted to CyberSource; Arrow Electronics) | not supported: no Agentcard payment takes over the card a merchant's page posts to a `/silent/` path on `secureacceptance.cybersource.com` (`testsecureacceptance.cybersource.com` in CyberSource's test environment, `secureacceptance.in.cybersource.com` in India). The SDK stops that post for every company, 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 |
 | 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 |
 | ACI Worldwide COPYandPAY (Halfords) | dark launch: served only after `syncRegistry()` and only for an org Agentcard enabled; prepared checkout only. The card-number request is replayed from the cardholder's device, the page's own CVC and expiry requests are answered locally, and `/payment` continues once. See [Pay an ACI COPYandPAY checkout](#pay-an-aci-copyandpay-checkout) |
 | Tranzila | supported (mode `hosted_form`): the cardholder finishes on Tranzila's own page; the paused form navigation resolves to a synthetic page, and you poll the merchant's order state |
@@ -1937,7 +1938,8 @@ eProtect traffic exactly as it found it, as it does before a sync.
 
 The merchant's script gives up on the registration 10 to 15 seconds after Pay,
 and re-sends it to a failover host after 5, which is too soon for a prompt that
-waits on a person. An eProtect checkout is therefore always prepared:
+waits on a person (SmartPak Equine's card form sets neither, so its script
+waits). An eProtect checkout is therefore always prepared:
 
 ```ts
 const checkout = await attachToPlaywright(page, {
@@ -1954,8 +1956,10 @@ await page.getByRole('button', { name: 'Place order', exact: true }).click();
   registration is for, which is also the merchant Worldpay lets charge the card
   again. It is fixed before the page sends anything, so a registration naming
   another paypageId never spends the approval. The Worldpay iframe names it in
-  its URL (`/eProtect/payframe_<paypageId>_...`); a JS API merchant carries it
-  in its eProtect configuration.
+  its URL (`/eProtect/payframe_<paypageId>_...`, or the `paypageid` query of
+  `/eProtect/eProtect.html`, as at Nordstrom); a JS API merchant carries it in
+  its eProtect configuration (SmartPak Equine's page keeps it in a hidden
+  `PayPageId` input).
 - `cardId` is required, and the approval is locked to that card. Worldpay never
   receives an expiry: the merchant sends the one typed into its form with the
   registration. The agent types a placeholder number of the stored card's
@@ -1964,9 +1968,12 @@ await page.getByRole('button', { name: 'Place order', exact: true }).click();
   prepares.
 
 After Pay, the SDK pauses the registration and binds it to the preparation.
-The cardholder's device, still on the approval page, encrypts the approved card
-under Worldpay's key into that same query and sends it through Agentcard's
-encrypted relay. The SDK then answers the paused script as Worldpay would:
+Worldpay rotates its production key daily, so the SDK pauses a registration
+whatever Worldpay key id its page names. The cardholder's device, still on the
+approval page, reads Worldpay's key from Worldpay's own `eProtect-api3.js` on
+the connection that carries the card, encrypts the approved card under it into
+that same query, writes that key's id into `publicKeyId`, and sends it through
+Agentcard's encrypted relay. The SDK then answers the paused script as Worldpay would:
 the registration in the script's own callback, under Worldpay's script type,
 with only the fields the merchant needs (no first six or last four digits).
 The SDK reads the authorization every 500 ms for 15 seconds, so the answer
@@ -2000,8 +2007,16 @@ one the approval shows. The API refuses another name with
 `merchant_profile_mismatch` and a paypageId with no pin with
 `unsupported_checkout`, before any preparation exists; when this release pins
 the paypageId too, the SDK refuses another name first, before any network call.
-Agentcard has pinned no production merchant yet, so the API refuses every live
-eProtect checkout today; the pre-live host needs no pin. An approved answer that is not a
+This release pins two production merchants, and the API refuses every other
+live eProtect checkout; the pre-live host needs no pin:
+
+| `merchant` | `paypageId` | Merchant origin |
+| --- | --- | --- |
+| `SmartPak Equine` | `zhs8KzuRAryaq4cs` | `https://www.smartpakequine.com` |
+| `Nordstrom` | `fL33BPkRvbRqJ29S` | `https://www.nordstrom.com` |
+
+The merchant origin is the checkout page's own, the top page that frames
+Worldpay's iframe at Nordstrom. An approved answer that is not a
 registration for the paused request raises `PaymentOutcomeUnknownError` with
 reason `eprotect_registration_unconfirmed`: the device may have registered the
 card, so reconcile the merchant before trying again.

package/dist/card-endpoint-page.d.ts

@@ -1,6 +1,7 @@
 /**
  * The page a paused card form navigation is answered with when Agentcard stops it
- * (card-endpoint.ts, a profile whose `navigation` is 'top' or 'frame').
+ * (card-endpoint.ts, a profile whose `navigation` is 'top' or 'frame', and a form a
+ * merchant's page posts to CyberSource Secure Acceptance, cybersource-secure-acceptance.ts).
  *
  * A merchant's form that the page submits as a page load leaves the agent's browser
  * waiting for a page, so an aborted request is the wrong answer: it renders an error
@@ -24,7 +25,8 @@
  * Self-contained HTML: no external resource, no script that runs (the one `<script>` is
  * `application/json`), readable by a person in one paragraph and by an agent through the
  * meta tag, the header and the JSON block. It never carries the endpoint URL, the paused
- * body or the merchant's answer: only the profile's own merchant name, escaped.
+ * body or the merchant's answer: only the profile's own merchant name, or CyberSource for a
+ * Secure Acceptance post, escaped.
  */
 import type { SyntheticPage } from './hosted-form.js';
 import type { CheckoutState } from './lifecycle.js';
@@ -45,7 +47,7 @@ export declare function refusedNavigationOutcome(state: {
 export interface CardEndpointStoppedPageInput {
     outcome: CardEndpointStoppedOutcome;
     reason: CardEndpointStoppedReason;
-    /** The profile's own merchant name (never the integrator's or the page's). */
+    /** The profile's own merchant name, or CyberSource for a Secure Acceptance post (never the integrator's or the page's). */
     merchant: string;
     /** The authorization, once one exists. */
     authorizationId?: string | null;

package/dist/cdp.js

@@ -13,6 +13,7 @@ import { DatatransRepeats } from './datatrans.js';
 import { SHIJI_STS_COMPANION_WINDOW_MS, ShijiStsCompanions, ShijiStsError, isShijiStsHost, shijiStsTokenContinuation, } from './shiji-sts.js';
 import { isArmedEkashuUrl } from './ekashu.js';
 import { PAYPAL_HOSTED_FIELDS_PATTERNS, isPaypalHostedFieldsConfirm } from './paypal-hosted-fields.js';
+import { CYBERSOURCE_SECURE_ACCEPTANCE_PATTERNS, isCybersourceSecureAcceptanceUrl } from './cybersource-secure-acceptance.js';
 import { CheckoutAttachmentError, attachmentDeadline, attachmentFailure, withinAttachmentDeadline } from './attachment.js';
 import { cseBody } from './cse-body.js';
 import { STRIPE_SETUP_INTENT_CONFIRM, setupConfirmPayingWith } from './stripe-setup.js';
@@ -1913,10 +1914,12 @@ 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).
+    // CyberSource Secure Acceptance's /silent/ paths are armed the same way, form
+    // navigations included (see cybersource-secure-acceptance.ts).
     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])];
+            ...(payrails ? PAYRAILS_GUARD_PATTERNS : []), ...PAYPAL_HOSTED_FIELDS_PATTERNS, ...CYBERSOURCE_SECURE_ACCEPTANCE_PATTERNS])];
     const arm = async (sessionId, resume = false, worker = false) => {
         const key = sessionId ?? '__root__';
         if (armed.has(key))
@@ -3189,7 +3192,9 @@ export async function attachToPlaywright(page, opts) {
             // host: the card page's post and its 3-D Secure calls reach the NMI gate and fail.
             || isArmedEkashuUrl(opts.vault, url.toString())
             // PayPal's legacy Hosted Fields confirm, for every org, as attachToCdp arms it (paypal-hosted-fields.ts).
-            || isPaypalHostedFieldsConfirm(url.toString()), async (route) => {
+            || isPaypalHostedFieldsConfirm(url.toString())
+            // CyberSource Secure Acceptance's /silent/ paths, for every org, as attachToCdp arms them (cybersource-secure-acceptance.ts).
+            || isCybersourceSecureAcceptanceUrl(url.toString()), async (route) => {
             const request = route.request();
             // When this request paused, and the page it came from: the merchant's total is read as of now.
             const pausedAt = Date.now();

package/dist/cybersource-secure-acceptance.d.ts

@@ -0,0 +1,78 @@
+/**
+ * CyberSource Secure Acceptance's Silent Order POST, which this SDK refuses for every company.
+ *
+ * CyberSource's Secure Acceptance Checkout API, formerly Silent Order POST, takes the card from a form
+ * on the merchant's own page. The merchant's server signs the order fields, and the shopper's browser
+ * posts them, with the card fields left unsigned, to a /silent/ path on one of CyberSource's Secure
+ * Acceptance hosts: /silent/pay, /silent/token/create, /silent/token/update, and the iframe form of
+ * each under /silent/embedded/ (CyberSource's endpoint table, read 2026-10-08). Arrow Electronics'
+ * checkout (its public bundles, read 2026-10-08; no card was sent) builds that form once its server
+ * has signed the fields and submits it into a hidden iframe:
+ *
+ *   <iframe name="secureAcceptanceiFrame" style="display:none">
+ *   <form action="https://secureacceptance.cybersource.com/silent/embedded/token/create" method="post"
+ *     target="secureAcceptanceiFrame">: access_key, profile_id, transaction_type=create_payment_token,
+ *     amount=0 and the other signed fields with their signature, then card_type, card_number,
+ *     card_expiry_date (MM-YYYY) and card_cvn
+ *
+ * No Vault mode takes this post over, so no company can pay it, and an SDK without this guard let the
+ * card the agent typed reach CyberSource. Both adapters arm /silent/ on the three hosts whatever the
+ * synced registry serves, over https and http, each host also spelled with the trailing dot of a fully
+ * qualified name, and the pre-claim gate (cybersourceSecureAcceptancePreClaim, pre-claim.ts) judges
+ * each request there, whether a fetch, an XHR or a form navigation of the page or of a frame sent it,
+ * by its body and by its URL's query (cybersourceSecureAcceptanceRequest):
+ *   - a card_number that holds a value: stop it, so CyberSource never receives the card. A form
+ *     navigation is answered with the stopped page (card-endpoint-page.ts), which names CyberSource,
+ *     since an aborted page load renders nothing and invites another click on Pay; any other request
+ *     fails. The checkout reads `unsupported` with reason `unsupported_cybersource_secure_acceptance`
+ *     and holds, as every unsupported refusal does;
+ *   - no card_number, or an empty one, as in a payment with a stored payment_token: continue untouched;
+ *   - a body the adapter could not read: stop that request alone, since nothing proves it carries no card.
+ * A request the synced registry recognizes as a card request belongs to that recognizer instead; no
+ * build serves one today. Hosted Checkout, the same hosts without /silent/, takes the card on
+ * CyberSource's own page, and neither adapter arms it.
+ */
+export declare const CYBERSOURCE_SECURE_ACCEPTANCE_REASON: "unsupported_cybersource_secure_acceptance";
+/** Where the stopped page says the card was going. */
+export declare const CYBERSOURCE_SECURE_ACCEPTANCE_RECIPIENT = "CyberSource";
+/** CyberSource's Secure Acceptance hosts: production, test, and production in India. */
+export declare const CYBERSOURCE_SECURE_ACCEPTANCE_HOSTS: readonly string[];
+/**
+ * CDP Fetch patterns for every /silent/ path on the three hosts, armed on every attachment, over https
+ * and over http, each host also with its trailing dot: Chrome sends a URL spelled either way unchanged,
+ * and DNS reads both spellings as the same host, so a page's form posted to either reaches CyberSource.
+ * The * before silent/ also pauses a path that doubles its slash, as a base URL that ends in a slash
+ * joined to /silent/pay writes it, which a server that merges slashes reads as /silent/pay. The gate
+ * judges each path with its slashes merged (isCybersourceSecureAcceptanceUrl), and anything else the *
+ * pauses, such as /billing/silent/pay, continues untouched. A pattern matches the canonical URL Chrome
+ * sends, whose host is lower case and whose standard port is dropped; no URL without silent/ is armed.
+ */
+export declare const CYBERSOURCE_SECURE_ACCEPTANCE_PATTERNS: readonly string[];
+/**
+ * Whether this URL is a /silent/ path on one of the three hosts: https or http, the host with or without
+ * its trailing dot, on the scheme's standard port, with no credentials, and its path read with each run
+ * of slashes merged into one, as a server that merges slashes reads it.
+ */
+export declare function isCybersourceSecureAcceptanceUrl(url: string): boolean;
+/**
+ * What a request to a /silent/ path carries: 'card' when card_number holds a value in the URL's query,
+ * on any method, since a form whose method is GET puts its fields there; otherwise the body's verdict
+ * (cybersourceSecureAcceptanceBody) for a method that sends one, and 'no_card' for a GET, a HEAD or a
+ * CORS preflight.
+ */
+export declare function cybersourceSecureAcceptanceRequest(url: string, method: string, body: string | null, contentType?: string): 'card' | 'no_card' | 'unreadable';
+/**
+ * What a Silent Order POST's body carries: 'card' when any reading of it finds a field named card_number
+ * that holds a value, 'no_card' when none does, and 'unreadable' for a body the adapter could not read
+ * (null), or a multipart body whose parts cannot be read and in which no reading finds a card, a
+ * multipart content type with no boundary included.
+ *
+ * The page writes both the bytes and their content type, and a server reads the bytes by that type, so
+ * the gate trusts no one reading. It reads every body as URL-encoded pairs (split on & and line by line,
+ * which also reads a plain-text form's name=value lines), as JSON at any depth, and as a multipart form:
+ * by its parts, when its content type names a boundary or it opens with a delimiter line and a part
+ * header, and by every part header that names card_number, wherever it sits. A card in any reading stops
+ * the post, so a body whose content type names one encoding and whose bytes hold another, a URL-encoded
+ * body that also parses as JSON, say, cannot carry the card past the gate.
+ */
+export declare function cybersourceSecureAcceptanceBody(body: string | null, contentType?: string): 'card' | 'no_card' | 'unreadable';

package/dist/cybersource-secure-acceptance.js

@@ -0,0 +1,214 @@
+/**
+ * CyberSource Secure Acceptance's Silent Order POST, which this SDK refuses for every company.
+ *
+ * CyberSource's Secure Acceptance Checkout API, formerly Silent Order POST, takes the card from a form
+ * on the merchant's own page. The merchant's server signs the order fields, and the shopper's browser
+ * posts them, with the card fields left unsigned, to a /silent/ path on one of CyberSource's Secure
+ * Acceptance hosts: /silent/pay, /silent/token/create, /silent/token/update, and the iframe form of
+ * each under /silent/embedded/ (CyberSource's endpoint table, read 2026-10-08). Arrow Electronics'
+ * checkout (its public bundles, read 2026-10-08; no card was sent) builds that form once its server
+ * has signed the fields and submits it into a hidden iframe:
+ *
+ *   <iframe name="secureAcceptanceiFrame" style="display:none">
+ *   <form action="https://secureacceptance.cybersource.com/silent/embedded/token/create" method="post"
+ *     target="secureAcceptanceiFrame">: access_key, profile_id, transaction_type=create_payment_token,
+ *     amount=0 and the other signed fields with their signature, then card_type, card_number,
+ *     card_expiry_date (MM-YYYY) and card_cvn
+ *
+ * No Vault mode takes this post over, so no company can pay it, and an SDK without this guard let the
+ * card the agent typed reach CyberSource. Both adapters arm /silent/ on the three hosts whatever the
+ * synced registry serves, over https and http, each host also spelled with the trailing dot of a fully
+ * qualified name, and the pre-claim gate (cybersourceSecureAcceptancePreClaim, pre-claim.ts) judges
+ * each request there, whether a fetch, an XHR or a form navigation of the page or of a frame sent it,
+ * by its body and by its URL's query (cybersourceSecureAcceptanceRequest):
+ *   - a card_number that holds a value: stop it, so CyberSource never receives the card. A form
+ *     navigation is answered with the stopped page (card-endpoint-page.ts), which names CyberSource,
+ *     since an aborted page load renders nothing and invites another click on Pay; any other request
+ *     fails. The checkout reads `unsupported` with reason `unsupported_cybersource_secure_acceptance`
+ *     and holds, as every unsupported refusal does;
+ *   - no card_number, or an empty one, as in a payment with a stored payment_token: continue untouched;
+ *   - a body the adapter could not read: stop that request alone, since nothing proves it carries no card.
+ * A request the synced registry recognizes as a card request belongs to that recognizer instead; no
+ * build serves one today. Hosted Checkout, the same hosts without /silent/, takes the card on
+ * CyberSource's own page, and neither adapter arms it.
+ */
+export const CYBERSOURCE_SECURE_ACCEPTANCE_REASON = 'unsupported_cybersource_secure_acceptance';
+/** Where the stopped page says the card was going. */
+export const CYBERSOURCE_SECURE_ACCEPTANCE_RECIPIENT = 'CyberSource';
+/** CyberSource's Secure Acceptance hosts: production, test, and production in India. */
+export const CYBERSOURCE_SECURE_ACCEPTANCE_HOSTS = Object.freeze([
+    'secureacceptance.cybersource.com', 'testsecureacceptance.cybersource.com', 'secureacceptance.in.cybersource.com',
+]);
+/**
+ * CDP Fetch patterns for every /silent/ path on the three hosts, armed on every attachment, over https
+ * and over http, each host also with its trailing dot: Chrome sends a URL spelled either way unchanged,
+ * and DNS reads both spellings as the same host, so a page's form posted to either reaches CyberSource.
+ * The * before silent/ also pauses a path that doubles its slash, as a base URL that ends in a slash
+ * joined to /silent/pay writes it, which a server that merges slashes reads as /silent/pay. The gate
+ * judges each path with its slashes merged (isCybersourceSecureAcceptanceUrl), and anything else the *
+ * pauses, such as /billing/silent/pay, continues untouched. A pattern matches the canonical URL Chrome
+ * sends, whose host is lower case and whose standard port is dropped; no URL without silent/ is armed.
+ */
+export const CYBERSOURCE_SECURE_ACCEPTANCE_PATTERNS = Object.freeze(CYBERSOURCE_SECURE_ACCEPTANCE_HOSTS.flatMap((host) => ['https', 'http'].flatMap((scheme) => [`${scheme}://${host}/*silent/*`, `${scheme}://${host}./*silent/*`])));
+/**
+ * Whether this URL is a /silent/ path on one of the three hosts: https or http, the host with or without
+ * its trailing dot, on the scheme's standard port, with no credentials, and its path read with each run
+ * of slashes merged into one, as a server that merges slashes reads it.
+ */
+export function isCybersourceSecureAcceptanceUrl(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return false;
+    }
+    return (parsed.protocol === 'https:' || parsed.protocol === 'http:') && !parsed.port && !parsed.username && !parsed.password
+        && CYBERSOURCE_SECURE_ACCEPTANCE_HOSTS.includes(parsed.hostname.toLowerCase().replace(/\.$/, ''))
+        && parsed.pathname.replace(/\/{2,}/g, '/').startsWith('/silent/');
+}
+/** Methods that send no body: only the URL's query can carry a card on them. */
+const BODILESS = new Set(['GET', 'HEAD', 'OPTIONS']);
+/**
+ * What a request to a /silent/ path carries: 'card' when card_number holds a value in the URL's query,
+ * on any method, since a form whose method is GET puts its fields there; otherwise the body's verdict
+ * (cybersourceSecureAcceptanceBody) for a method that sends one, and 'no_card' for a GET, a HEAD or a
+ * CORS preflight.
+ */
+export function cybersourceSecureAcceptanceRequest(url, method, body, contentType) {
+    let query = '';
+    try {
+        query = new URL(url).search;
+    }
+    catch {
+        query = '';
+    }
+    if (carriesCardNumber(formFields(query)))
+        return 'card';
+    return BODILESS.has(String(method).toUpperCase()) ? 'no_card' : cybersourceSecureAcceptanceBody(body, contentType);
+}
+/**
+ * What a Silent Order POST's body carries: 'card' when any reading of it finds a field named card_number
+ * that holds a value, 'no_card' when none does, and 'unreadable' for a body the adapter could not read
+ * (null), or a multipart body whose parts cannot be read and in which no reading finds a card, a
+ * multipart content type with no boundary included.
+ *
+ * The page writes both the bytes and their content type, and a server reads the bytes by that type, so
+ * the gate trusts no one reading. It reads every body as URL-encoded pairs (split on & and line by line,
+ * which also reads a plain-text form's name=value lines), as JSON at any depth, and as a multipart form:
+ * by its parts, when its content type names a boundary or it opens with a delimiter line and a part
+ * header, and by every part header that names card_number, wherever it sits. A card in any reading stops
+ * the post, so a body whose content type names one encoding and whose bytes hold another, a URL-encoded
+ * body that also parses as JSON, say, cannot carry the card past the gate.
+ */
+export function cybersourceSecureAcceptanceBody(body, contentType) {
+    if (typeof body !== 'string')
+        return 'unreadable';
+    const delimiter = multipartDelimiter(body, typeof contentType === 'string' ? contentType : '');
+    const parts = delimiter === undefined ? [] : delimiter === null ? null : multipartFields(body, delimiter);
+    if (carriesCardNumber(formFields(body)) || carriesCardNumber(jsonFields(body)) || carriesCardNumber(parts ?? [])
+        || multipartNamesCardNumber(body, delimiter ?? undefined))
+        return 'card';
+    return parts === null ? 'unreadable' : 'no_card';
+}
+/**
+ * Whether a field named card_number holds a value. The name matches in any case and every occurrence
+ * counts; an empty value, or one of whitespace only, holds no card.
+ */
+function carriesCardNumber(fields) {
+    return fields.some(([name, value]) => name.trim().toLowerCase() === 'card_number'
+        && value !== undefined && value !== null && !(typeof value === 'string' && value.trim() === ''));
+}
+/**
+ * The delimiter line of a multipart body: the one its content type names, or, whatever its content type
+ * says, the one it opens with when a part header follows. Undefined for a body that is not multipart,
+ * and null for a multipart content type that names no boundary.
+ */
+function multipartDelimiter(body, contentType) {
+    if (/^\s*multipart\//i.test(contentType)) {
+        const boundary = /;\s*boundary=(?:"([^"]+)"|([^;\s]+))/i.exec(contentType);
+        return boundary ? `--${boundary[1] ?? boundary[2]}` : null;
+    }
+    return /^(--[^\r\n]+)\r?\n[^\s:]+:/.exec(body)?.[1];
+}
+/**
+ * A multipart body's named parts, or null when a body with content never names its delimiter or one
+ * of its parts has no blank line after its headers. A part takes every name its headers give it.
+ */
+function multipartFields(body, delimiter) {
+    if (!body.includes(delimiter))
+        return body.trim() === '' ? [] : null;
+    const fields = [];
+    for (const part of body.split(delimiter).slice(1)) {
+        if (part.startsWith('--'))
+            break; // the closing delimiter
+        const blank = /\r?\n\r?\n/.exec(part);
+        if (!blank)
+            return null;
+        const value = part.slice(blank.index + blank[0].length).replace(/\r?\n$/, '');
+        for (const name of headerNames(part.slice(0, blank.index)))
+            fields.push([name, value]);
+    }
+    return fields;
+}
+/** Every name a part's headers give it, quoted or bare, whichever header carries it. */
+function headerNames(headers) {
+    return [...headers.matchAll(/;\s*name\s*=\s*(?:"([^"]*)"|([^;\s"]*))/gi)].map((match) => match[1] ?? match[2]);
+}
+/**
+ * Whether a part named card_number holds a value, read without trusting where the body splits into
+ * parts: each header line that names card_number, wherever it sits, opens a part whose value runs from
+ * the blank line after its headers to the next delimiter line (the body's own, or any line that opens
+ * with -- when it names none). A server that splits the parts elsewhere, at a delimiter written inside
+ * another part's value, say, finds no card this reading misses.
+ */
+function multipartNamesCardNumber(body, delimiter) {
+    const lines = body.split(/\r?\n/);
+    const ends = (line) => (delimiter === undefined ? line.startsWith('--') : [delimiter, `${delimiter}--`].includes(line.trimEnd()));
+    for (let i = 0; i < lines.length; i++) {
+        if (!/^[^\s:]+:/.test(lines[i]) || !headerNames(lines[i]).some((name) => name.trim().toLowerCase() === 'card_number'))
+            continue;
+        let j = i + 1;
+        while (j < lines.length && lines[j].trim() !== '')
+            j++;
+        for (j++; j < lines.length && !ends(lines[j]); j++)
+            if (lines[j].trim() !== '')
+                return true;
+    }
+    return false;
+}
+/** Every key of a JSON body, at any depth, with its value; none for a body that is not JSON. */
+function jsonFields(body) {
+    if (!/^\s*[[{]/.test(body))
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        return [];
+    }
+    const fields = [];
+    const walk = (node, depth) => {
+        if (node === null || typeof node !== 'object' || depth > 64)
+            return;
+        for (const [name, value] of Object.entries(node)) {
+            fields.push([name, value]);
+            walk(value, depth + 1);
+        }
+    };
+    walk(parsed, 0);
+    return fields;
+}
+/**
+ * URL-encoded pairs, split on & as a server splits a form, and again line by line: a plain-text form
+ * sends name=value lines, and no raw line break survives URL encoding, so a line break in a URL-encoded
+ * body only comes from a page that wrote one there.
+ */
+function formFields(body) {
+    const fields = [...new URLSearchParams(body)];
+    for (const line of body.split(/[\r\n]+/))
+        for (const pair of new URLSearchParams(line))
+            fields.push(pair);
+    return fields;
+}

package/dist/eprotect.d.ts

@@ -18,8 +18,8 @@ export interface EprotectMerchantPin {
  * (merchant_profile_mismatch) before any preparation exists. When this build pins the paypageId
  * too, it refuses another name first, before any network call, as a Fiserv checkout must name its
  * key pin's merchant. A paypageId this build does not pin is the API's to judge (unsupported_checkout
- * with no pin); none is pinned on either side yet. The pre-live host takes only the guide's test
- * cards and needs no pin. `pins` is for tests.
+ * with no pin). This build pins SmartPak Equine and Nordstrom, under those exact names. The pre-live
+ * host takes only the guide's test cards and needs no pin. `pins` is for tests.
  */
 export declare function eprotectCheckoutRefusal(input: {
     environment: string;

package/dist/eprotect.generated.d.ts

@@ -4,22 +4,61 @@ declare var EPROTECT_HOSTS: Readonly<{
     sandbox: "request.eprotect.vantivprelive.com";
 }>;
 declare var EPROTECT_SECONDARY_HOST: string;
-declare var EPROTECT_KEYS: Readonly<{
-    production: Readonly<{
-        keyId: "26455500012";
-        exponent: "10001";
-        modulus: "b9c7095ff203475347a932a6e11bacbb61cfb66a877158683634e5fb1dbf9923401bd7f82c21b67ffd3c82bdc64797c5e2ba4b57c68b1aaccb7fbe847da7234a21df910dfcc0aebacbbd4d36b35c0c35f7ee27358610d2e2fb2aa87d359deda0b5f4d77e31ac5ab98741da5b6052cb657087da05ad496154b8954939ee6fd463301ff15ebca94f210f4627a255a95ca8833728c1ab80b6cc3a874e4d3dce5d40f66c043ba1b042717bb9cc5d89434fa489a51c2ba9a3843b310df58c9e8a54c36cdd5fd66e76651b6fc88850b60e0739abfcf7d0d0cb44beb7e768da3bcea7e743b8c2d57edef59643f54432ccf60c49d4f5f84410ecf9c5a7af19bc5e792801";
-    }>;
-    sandbox: Readonly<{
-        keyId: "1";
-        exponent: "10001";
-        modulus: "bc637dd74ba76507dad5af1c7ad6f97dbef5298c3b9f74caea7301347db7b4a8c37f26491863100667246fd45071f3346bf62239f9b117d06fb67861b66ad0d158beeddd2f6f28be93d846f4c8f9ba1bd7e8f186f36cab0e432f22b3d732c221a9ff00a9bfacb88b24503e2695fd7237835d4936477b21289478906a49b164f52503c20eb29f11fcbda2af94deb9a0bfde5a4589276897436315c5d664d60bf10650164f509283aed39747ad5d6cb2bbe54e1b42306e5db37dfd42dcbfcc689e0ddfe3bc9cb22ae7018e5a4a1ff39813584ac7bd6d6d65ca763f0a672da454081ea20e8b1d403316d80b9353ba396bea8962b1a7d2f775c76612d857c1f7594f";
-    }>;
-}>;
+declare var EPROTECT_KEY_SOURCES: any;
+declare var EPROTECT_KEY_SCRIPT_MAX_BYTES: number;
 declare var EPROTECT_TEST_PANS: Readonly<Set<unknown>>;
 declare var EPROTECT_REFUSAL_CODES: readonly string[];
 declare function eprotectEnvironment(hostname: any): "production" | "sandbox" | null;
 declare function eprotectPreparationUrl(environment: any): string;
+declare function eprotectKeySourceUrl(environment: any): string;
+declare function eprotectScriptFacts(bytes: any): {
+    literals: number;
+    keyId?: undefined;
+    modulus?: undefined;
+    exponent?: undefined;
+    modulusSha256?: undefined;
+    maskedSha256?: undefined;
+} | {
+    literals: number;
+    keyId: string;
+    modulus: string;
+    exponent: string;
+    modulusSha256: string;
+    maskedSha256: string;
+};
+declare function eprotectKeyScriptVerdict(environment: any, bytes: any, sources?: any): {
+    ok: boolean;
+    reason: string;
+    maskedSha256?: undefined;
+    keyId?: undefined;
+    modulus?: undefined;
+    modulusSha256?: undefined;
+} | {
+    ok: boolean;
+    reason: string;
+    maskedSha256: string | undefined;
+    keyId?: undefined;
+    modulus?: undefined;
+    modulusSha256?: undefined;
+} | {
+    ok: boolean;
+    keyId: string;
+    modulus: string;
+    modulusSha256: string;
+    maskedSha256: string;
+    reason?: undefined;
+};
+declare function readEprotectKeyScript(environment: any, bytes: any, sources?: any): Readonly<{
+    environment: any;
+    keyId: string | undefined;
+    modulus: string | undefined;
+    exponent: "10001";
+    modulusSha256: string | undefined;
+}>;
+declare function eprotectKeyReport(key: any): Readonly<{
+    key_id: any;
+    modulus_sha256: any;
+}>;
 declare function isEprotectTokenRequest(url: any, method: any): boolean;
 declare function isEprotectRequest(request: any): boolean;
 declare function eprotectRequestFacts(url: any): {
@@ -35,7 +74,7 @@ declare function eprotectSecondaryAttempt(url: any): {
     paypageId: any;
     id: any;
 } | null;
-declare function isEprotectDeviceRequest(templateUrl: any, deviceUrl: any): boolean;
+declare function isEprotectDeviceRequest(templateUrl: any, deviceUrl: any, sessionKeyId: any): boolean;
 declare function isPreparedEprotectRequest(url: any, method: any, body: any, environment: any, paypageId: any): boolean;
 declare var EPROTECT_MERCHANT_PINS: any;
 declare function eprotectMerchantPin(paypageId: any, merchantOrigin: any, pins?: any): any;
@@ -43,7 +82,7 @@ declare function eprotectMerchantRefusal(environment: any, paypageId: any, merch
 declare function defaultRandom(bytes: any): void;
 declare function eprotectEncrypt(text: any, key: any, random?: typeof defaultRandom): string;
 declare function eprotectCardRefusal(environment: any, cardNumber: any): "unsupported_environment" | "sandbox_host_requires_documented_test_card" | "invalid_card_number" | "live_host_refuses_documented_test_card" | null;
-declare function eprotectDeviceRequest(templateUrl: any, card: any, random?: typeof defaultRandom): {
+declare function eprotectDeviceRequest(templateUrl: any, card: any, sessionKey: any, random?: typeof defaultRandom): {
     url: string;
     method: string;
     headers: {};
@@ -74,4 +113,4 @@ declare function eprotectGiveUp(url: any): {
     code: any;
 } | null;
 declare function eprotectRefusalCode(bodyText: any): any;
-export { EPROTECT_HOSTS, EPROTECT_KEYS, EPROTECT_MERCHANT_PINS, EPROTECT_PATH, EPROTECT_REFUSAL_CODES, EPROTECT_SECONDARY_HOST, EPROTECT_TEST_PANS, eprotectCardRefusal, eprotectDeviceRequest, eprotectEncrypt, eprotectEnvironment, eprotectGiveUp, eprotectJsonp, eprotectMerchantPin, eprotectMerchantRefusal, eprotectOutcome, eprotectPreparationUrl, eprotectRefusalCode, eprotectRequestFacts, eprotectSecondaryAttempt, isEprotectDeviceRequest, isEprotectRequest, isEprotectTokenRequest, isPreparedEprotectRequest, sanitizeEprotectRegistration };
+export { EPROTECT_HOSTS, EPROTECT_KEY_SCRIPT_MAX_BYTES, EPROTECT_KEY_SOURCES, EPROTECT_MERCHANT_PINS, EPROTECT_PATH, EPROTECT_REFUSAL_CODES, EPROTECT_SECONDARY_HOST, EPROTECT_TEST_PANS, eprotectCardRefusal, eprotectDeviceRequest, eprotectEncrypt, eprotectEnvironment, eprotectGiveUp, eprotectJsonp, eprotectKeyReport, eprotectKeyScriptVerdict, eprotectKeySourceUrl, eprotectMerchantPin, eprotectMerchantRefusal, eprotectOutcome, eprotectPreparationUrl, eprotectRefusalCode, eprotectRequestFacts, eprotectScriptFacts, eprotectSecondaryAttempt, isEprotectDeviceRequest, isEprotectRequest, isEprotectTokenRequest, isPreparedEprotectRequest, readEprotectKeyScript, sanitizeEprotectRegistration };