@agent-cards/sdk 0.23.4 → 0.23.5

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+- 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 |

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/lifecycle.d.ts

@@ -226,11 +226,14 @@ export declare class CheckoutLifecycle implements CheckoutController {
      * (`unsupported_payrails_card_payment` and the card-save refusal codes), a
      * Shiji STS request its gate refuses (shiji_sts_keep_on_file and the other
      * shiji-sts.ts reasons), a post to a processor's own card page that only
-     * the cardholder's device can fill (processor_card_page: NMI's), or a card
+     * 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).
+     * over (unsupported_paypal_hosted_fields, paypal-hosted-fields.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).
      */
-    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'): 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' | 'unsupported_cybersource_secure_acceptance'): 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

@@ -202,9 +202,12 @@ export class CheckoutLifecycle {
      * (`unsupported_payrails_card_payment` and the card-save refusal codes), a
      * Shiji STS request its gate refuses (shiji_sts_keep_on_file and the other
      * shiji-sts.ts reasons), a post to a processor's own card page that only
-     * the cardholder's device can fill (processor_card_page: NMI's), or a card
+     * 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).
+     * over (unsupported_paypal_hosted_fields, paypal-hosted-fields.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).
      */
     unsupported(reason = 'unrecognized_payment_endpoint') {
         this.held = true;

package/dist/pre-claim.d.ts

@@ -201,6 +201,7 @@ export declare const verifonePreClaim: PreClaimGate;
 export declare const fiservPreClaim: PreClaimGate;
 export declare const ekashuPreClaim: PreClaimGate;
 export declare const paypalHostedFieldsPreClaim: PreClaimGate;
+export declare const cybersourceSecureAcceptancePreClaim: PreClaimGate;
 /** The processor gates, in order. A new family adds one entry here; the terminal
  * arbiter runs after all of them and is not part of this list. A gate appended
  * after Stripe is never offered a step Stripe claimed: Stripe answers, aborts or

package/dist/pre-claim.js

@@ -16,7 +16,8 @@
 // card-saving bodies, WSPay's confirm URL, which also carries bodies with
 // no new card, Shiji STS's getTokenId and getCvvId, which also carry
 // requests the vault must never pay, and PayPal's legacy Hosted Fields
-// confirm, whose card no Vault mode takes over.
+// confirm and CyberSource Secure Acceptance's Silent Order POST, whose card
+// no Vault mode takes over.
 // The first three used to be
 // written inline in Fetch.requestPaused and again in the page.route handler, so
 // a decision could drift between the two adapters and a new family had to be
@@ -75,6 +76,7 @@ import { PAYRAILS_HOLDING_REASONS, PAYRAILS_SESSION_MESSAGE, isPayrailsHost, isP
 import { classifyVerifoneProfileRequest, verifoneTemplatedUrl } from './verifone.js';
 import { ekashuEntryUrl, isEkashuEntry, isEkashuHost } from './ekashu.js';
 import { PAYPAL_HOSTED_FIELDS_REASON, isPaypalHostedFieldsConfirm, paypalHostedFieldsBody } from './paypal-hosted-fields.js';
+import { CYBERSOURCE_SECURE_ACCEPTANCE_REASON, CYBERSOURCE_SECURE_ACCEPTANCE_RECIPIENT, cybersourceSecureAcceptanceRequest, isCybersourceSecureAcceptanceUrl, } from './cybersource-secure-acceptance.js';
 /**
  * The URL an event may name for a request. For an armed merchant profile's
  * endpoint or a sibling of it: the endpoint origin, the path TEMPLATE and the
@@ -169,14 +171,16 @@ function cardEndpointPausedBody(ctx) {
 }
 /**
  * Answer a paused card form navigation with the page that says Agentcard stopped it before
- * its card left. While an approval is outstanding, or once a payment for this checkout may
- * already exist, the page says a payment is in progress instead of that nothing was sent
- * (card-endpoint-page.ts refusedNavigationOutcome), and names that payment's authorization.
+ * its card left, naming where the card was going: a card endpoint profile's own merchant, or
+ * CyberSource for a Secure Acceptance post. While an approval is outstanding, or once a payment
+ * for this checkout may already exist, the page says a payment is in progress instead of that
+ * nothing was sent (card-endpoint-page.ts refusedNavigationOutcome), and names that payment's
+ * authorization.
  */
-async function stopNavigationBeforeSend(ctx, profile, reason) {
+async function stopNavigationBeforeSend(ctx, merchant, reason) {
     const state = ctx.lifecycle.getState();
     const outcome = refusedNavigationOutcome({ awaitingApproval: ctx.awaitingApproval(), status: state.status });
-    await ctx.effects.answer(cardEndpointStoppedPage({ outcome, reason, merchant: profile.merchant,
+    await ctx.effects.answer(cardEndpointStoppedPage({ outcome, reason, merchant,
         authorizationId: outcome === 'payment_in_progress' ? state.authorizationId : null }));
     return { kind: 'answer' };
 }
@@ -216,13 +220,13 @@ async function cardEndpointNavigationPreClaim(ctx, profile) {
     }
     if (navigation !== profile.navigation) {
         ctx.onEvent?.({ type: 'card_endpoint_refused', detail: { ...cardEndpointDetail(profile), reason: 'request_unsupported', refusal: `the card post navigates ${navigation === 'top' ? 'the page' : 'an iframe'}` } });
-        return stopNavigationBeforeSend(ctx, profile, 'request_unsupported');
+        return stopNavigationBeforeSend(ctx, profile.merchant, 'request_unsupported');
     }
     if (!cardEndpointLive(profile)) {
         ctx.preparationGate.invalidate('unsupported_checkout');
         ctx.lifecycle.unsupported('merchant_card_endpoint_not_enabled');
         ctx.onEvent?.({ type: 'unsupported_checkout', detail: { ...cardEndpointDetail(profile), reason: 'merchant_card_endpoint_not_enabled' } });
-        return stopNavigationBeforeSend(ctx, profile, 'not_enabled');
+        return stopNavigationBeforeSend(ctx, profile.merchant, 'not_enabled');
     }
     return { kind: 'pause', stripeStep: null, cardEndpoint: profile, navigation };
 }
@@ -1530,6 +1534,68 @@ async function paypalHostedFieldsUnreadable(ctx) {
     await ctx.effects.abort();
     return { kind: 'abort' };
 }
+// CyberSource Secure Acceptance's Silent Order POST (cybersource-secure-acceptance.ts). The merchant's
+// page posts the card the agent typed, beside the fields its server signed, to a /silent/ path on
+// CyberSource's Secure Acceptance hosts, which no Vault mode takes over, so every company's adapters
+// hand each request there to this gate, whether a fetch, an XHR or a form navigation sent it:
+//   - a card_number that holds a value, in the body or in the URL's query, stops the request as an
+//     unsupported checkout, reason `unsupported_cybersource_secure_acceptance`, with no claim, create or
+//     prompt, so CyberSource never receives the card. A form navigation of the page or of a frame (Arrow
+//     submits its form into a hidden iframe) is answered with the stopped page, as a card endpoint's form
+//     is, since an aborted page load renders nothing and invites another click on Pay; any other request
+//     fails. The attachment then reads `unsupported` and holds: the page's next post would carry the
+//     card again;
+//   - a body the adapter could not read stops that request alone, the same way, with a `blocked` event,
+//     `unreadable_cybersource_secure_acceptance_request`, and does not hold the attachment: nothing
+//     proves it carries no card;
+//   - any other request (a payment with a stored payment_token and no card, a GET, a CORS preflight)
+//     defers, and the arbiter continues it untouched.
+// A request the synced registry recognizes as a card request defers too, so the arbiter pauses it for
+// that recognizer; no build serves one today. A path outside /silent/ is not this gate's. Synchronous
+// until it must stop a request, like every gate. Exported for the gate registry's tests.
+export const cybersourceSecureAcceptancePreClaim = (ctx) => {
+    const { url, method } = ctx.request;
+    if (!isCybersourceSecureAcceptanceUrl(url) || ctx.vault.isCardRequest(url, method))
+        return undefined;
+    // A reader that throws (Playwright's postData() can) reads as a body the adapter could not read.
+    const { body, contentType } = cardEndpointPausedBody(ctx);
+    const carried = cybersourceSecureAcceptanceRequest(url, method, body, contentType);
+    if (carried === 'no_card')
+        return undefined;
+    return carried === 'card' ? cybersourceSecureAcceptanceUnsupported(ctx) : cybersourceSecureAcceptanceUnreadable(ctx);
+};
+async function cybersourceSecureAcceptanceUnsupported(ctx) {
+    const { url, method } = ctx.request;
+    ctx.preparationGate.invalidate('unsupported_checkout');
+    ctx.lifecycle.unsupported(CYBERSOURCE_SECURE_ACCEPTANCE_REASON);
+    ctx.onEvent?.({ type: 'unsupported_checkout', detail: { url: eventUrl(ctx.vault, url), method, reason: CYBERSOURCE_SECURE_ACCEPTANCE_REASON } });
+    return cybersourceSecureAcceptanceStop(ctx);
+}
+async function cybersourceSecureAcceptanceUnreadable(ctx) {
+    ctx.onEvent?.({ type: 'blocked', detail: 'unreadable_cybersource_secure_acceptance_request' });
+    return cybersourceSecureAcceptanceStop(ctx);
+}
+/**
+ * Stop a Secure Acceptance post: a form navigation gets the stopped page, and if the page cannot be
+ * answered, or the request is not a navigation, it fails. Either way the card never leaves.
+ */
+async function cybersourceSecureAcceptanceStop(ctx) {
+    let navigation = false;
+    try {
+        navigation = ctx.request.navigation === true;
+    }
+    catch {
+        navigation = false;
+    }
+    if (navigation) {
+        try {
+            return await stopNavigationBeforeSend(ctx, CYBERSOURCE_SECURE_ACCEPTANCE_RECIPIENT, 'request_unsupported');
+        }
+        catch { /* the page could not be answered: fail the request below */ }
+    }
+    await ctx.effects.abort().catch(() => { });
+    return { kind: 'abort' };
+}
 // The terminal arbiter, always last. A request that no gate claimed and that is
 // neither a native Stripe step nor a recognized card request continues, unless
 // it matches a declared payment endpoint we do not support (then it aborts as an
@@ -1563,7 +1629,8 @@ async function unsupportedContinue(ctx) {
  * arbiter runs after all of them and is not part of this list. A gate appended
  * after Stripe is never offered a step Stripe claimed: Stripe answers, aborts or
  * pauses each one itself. */
-export const PSP_PRE_CLAIM_GATES = [cardEndpointResendPreClaim, cardEndpointPreClaim, mercadoPreClaim, juspayPreClaim, braintreePreClaim, stripePreClaim, merchantHostedPreClaim, verifonePreClaim, fiservPreClaim, gmoPreClaim, cybersourceFlexPreClaim, datatransPreClaim, pelecardPreClaim, aciPreClaim, creditguardPreClaim, primerPreClaim, payrailsPreClaim, convergePreClaim, eprotectPreClaim, wspayPreClaim, shijiStsPreClaim, ekashuPreClaim, paypalHostedFieldsPreClaim];
+export const PSP_PRE_CLAIM_GATES = [cardEndpointResendPreClaim, cardEndpointPreClaim, mercadoPreClaim, juspayPreClaim, braintreePreClaim, stripePreClaim, merchantHostedPreClaim, verifonePreClaim, fiservPreClaim, gmoPreClaim, cybersourceFlexPreClaim, datatransPreClaim, pelecardPreClaim, aciPreClaim, creditguardPreClaim, primerPreClaim, payrailsPreClaim, convergePreClaim, eprotectPreClaim, wspayPreClaim, shijiStsPreClaim, ekashuPreClaim, paypalHostedFieldsPreClaim,
+    cybersourceSecureAcceptancePreClaim];
 /** Run each gate in order; the first to return a decision wins. If none does,
  * the terminal arbiter decides between continue, abort (unsupported) and pause.
  * Returns synchronously while every gate defers synchronously (an ordinary card

package/dist/preflight-catalog.json

@@ -2172,6 +2172,33 @@
       "hostname_pattern": "^assets\\.braintreegateway\\.com$",
       "pathname_pattern": "^\\/web\\/[0-9]+\\.[0-9]+\\.[0-9]+-payments-sdk(?:-[a-z]+)?\\/html\\/hosted-fields-(?:input-frame|payments-sdk-tokenization-frame)(?:\\.min)?\\.html$"
     },
+    {
+      "id": "cybersource-secure-acceptance-silent-order-post",
+      "psp": "cybersource_secure_acceptance",
+      "kinds": [
+        "form",
+        "document",
+        "frame",
+        "iframe"
+      ],
+      "origin": "https://secureacceptance.cybersource.com",
+      "path_pattern": "/silent/*",
+      "sources": [
+        {
+          "kind": "official_documentation",
+          "reference": "https://developer.cybersource.com/docs/cybs/en-us/sa/developer/all/sa-checkout/secure-acceptance.html",
+          "reviewed_on": "2026-10-08"
+        },
+        {
+          "kind": "saved_observation",
+          "reference": "arrow-2026-10-08:secure-acceptance-silent-embedded-token-create-hidden-form",
+          "reviewed_on": "2026-10-08"
+        }
+      ],
+      "variant_unverified": "CyberSource Secure Acceptance Silent Order POST sends the card from the merchant page to /silent/ on CyberSource's Secure Acceptance hosts; no Vault mode takes that request over.",
+      "hostname_pattern": "^secureacceptance\\.cybersource\\.com$",
+      "pathname_pattern": "^\\/silent\\/(?:[A-Za-z0-9_-]+\\/)*[A-Za-z0-9_-]+\\/?$"
+    },
     {
       "id": "fiserv-commercehub-payment-fields",
       "psp": "fiserv",
@@ -3432,6 +3459,60 @@
       "hostname_pattern": "^testflex\\.cybersource\\.com$",
       "pathname_pattern": "^\\/microform\\/bundle\\/v2\\.[0-9]+\\.[0-9]+\\/iframe\\.html$"
     },
+    {
+      "id": "cybersource-secure-acceptance-silent-order-post-test",
+      "psp": "cybersource_secure_acceptance",
+      "kinds": [
+        "form",
+        "document",
+        "frame",
+        "iframe"
+      ],
+      "origin": "https://testsecureacceptance.cybersource.com",
+      "path_pattern": "/silent/*",
+      "sources": [
+        {
+          "kind": "official_documentation",
+          "reference": "https://developer.cybersource.com/docs/cybs/en-us/sa/developer/all/sa-checkout/secure-acceptance.html",
+          "reviewed_on": "2026-10-08"
+        },
+        {
+          "kind": "saved_observation",
+          "reference": "arrow-2026-10-08:secure-acceptance-silent-embedded-token-create-hidden-form",
+          "reviewed_on": "2026-10-08"
+        }
+      ],
+      "variant_unverified": "CyberSource Secure Acceptance Silent Order POST sends the card from the merchant page to /silent/ on CyberSource's Secure Acceptance hosts; no Vault mode takes that request over.",
+      "hostname_pattern": "^testsecureacceptance\\.cybersource\\.com$",
+      "pathname_pattern": "^\\/silent\\/(?:[A-Za-z0-9_-]+\\/)*[A-Za-z0-9_-]+\\/?$"
+    },
+    {
+      "id": "cybersource-secure-acceptance-silent-order-post-in",
+      "psp": "cybersource_secure_acceptance",
+      "kinds": [
+        "form",
+        "document",
+        "frame",
+        "iframe"
+      ],
+      "origin": "https://secureacceptance.in.cybersource.com",
+      "path_pattern": "/silent/*",
+      "sources": [
+        {
+          "kind": "official_documentation",
+          "reference": "https://developer.cybersource.com/docs/cybs/en-us/sa/developer/all/sa-checkout/secure-acceptance.html",
+          "reviewed_on": "2026-10-08"
+        },
+        {
+          "kind": "saved_observation",
+          "reference": "arrow-2026-10-08:secure-acceptance-silent-embedded-token-create-hidden-form",
+          "reviewed_on": "2026-10-08"
+        }
+      ],
+      "variant_unverified": "CyberSource Secure Acceptance Silent Order POST sends the card from the merchant page to /silent/ on CyberSource's Secure Acceptance hosts; no Vault mode takes that request over.",
+      "hostname_pattern": "^secureacceptance\\.in\\.cybersource\\.com$",
+      "pathname_pattern": "^\\/silent\\/(?:[A-Za-z0-9_-]+\\/)*[A-Za-z0-9_-]+\\/?$"
+    },
     {
       "id": "worldpay-eprotect-js-api-prelive",
       "psp": "worldpay_eprotect",

package/dist/preflight-schemas.json

@@ -469,6 +469,7 @@
                 "gravy-secure-fields-script",
                 "gravy-secure-fields-script-sandbox",
                 "paypal-hosted-fields-payments-sdk",
+                "cybersource-secure-acceptance-silent-order-post",
                 "fiserv-commercehub-payment-fields",
                 "fiserv-commercehub-checkout-script",
                 "fiserv-secure-data-capture-frame",
@@ -523,6 +524,8 @@
                 "gmo-link-hosted-page-test",
                 "cybersource-flex-microform-script-test",
                 "cybersource-flex-microform-field-test",
+                "cybersource-secure-acceptance-silent-order-post-test",
+                "cybersource-secure-acceptance-silent-order-post-in",
                 "worldpay-eprotect-js-api-prelive",
                 "worldpay-eprotect-iframe-client-prelive",
                 "worldpay-eprotect-payframe-prelive",
@@ -1100,6 +1103,7 @@
                       "gravy-secure-fields-script",
                       "gravy-secure-fields-script-sandbox",
                       "paypal-hosted-fields-payments-sdk",
+                      "cybersource-secure-acceptance-silent-order-post",
                       "fiserv-commercehub-payment-fields",
                       "fiserv-commercehub-checkout-script",
                       "fiserv-secure-data-capture-frame",
@@ -1154,6 +1158,8 @@
                       "gmo-link-hosted-page-test",
                       "cybersource-flex-microform-script-test",
                       "cybersource-flex-microform-field-test",
+                      "cybersource-secure-acceptance-silent-order-post-test",
+                      "cybersource-secure-acceptance-silent-order-post-in",
                       "worldpay-eprotect-js-api-prelive",
                       "worldpay-eprotect-iframe-client-prelive",
                       "worldpay-eprotect-payframe-prelive",

package/dist/preflight.generated.js

@@ -1,5 +1,5 @@
 // Generated from @agent-cards/payment-core. Do not edit.
-// source-sha256: 9d383b5155c791fc68947784fe3e2c16d03d3056572fb353f98305358fe75bc9
+// source-sha256: fc24e6cb50ab112c3a15983c461185a9189bd0cf8c5e1ceb73e8432e6eebc37f
 import { CHECKOUT_PREFLIGHT_CAPABILITIES } from './preflight-capabilities.generated.js';
 /** Advisory page discovery. These rules never admit a payment destination. */
 export const CHECKOUT_PREFLIGHT_VERSION = '1';
@@ -79,6 +79,23 @@ RULES.push({ id: 'paypal-hosted-fields-payments-sdk', psp: 'paypal', kinds: ['fr
         paypalHostedFieldsSource('https://www.paypal.com/sdk/js?components=hosted-fields'),
         { kind: 'saved_observation', reference: 'planet-golf-uk-2026-10-06:paypal-hosted-fields-payments-sdk-frames', reviewed_on: '2026-10-07' }],
     variant_unverified: 'PayPal legacy Hosted Fields frames send the card to the Orders v2 confirm-payment-source on cors.api.paypal.com; no Vault mode takes that request over.' });
+// CyberSource Secure Acceptance's Silent Order POST (the Secure Acceptance Checkout API), reviewed 2026-10-08 from
+// CyberSource's endpoint table and Arrow Electronics' public bundles (no card was sent). The merchant's own page
+// posts the card fields, unsigned, beside the fields its server signed, to a /silent/ path on CyberSource's Secure
+// Acceptance hosts: production, test (testsecureacceptance) and production in India (secureacceptance.in), below.
+// Arrow submits that form into a hidden iframe; a merchant can also post it as the page's own form. No Vault mode
+// takes that post over, and the checkout SDK stops it (checkout/src/cybersource-secure-acceptance.ts). So the form,
+// and a frame or document on a /silent/ path, name cybersource_secure_acceptance and the result stays unknown
+// through `variant_unverified`. Hosted Checkout, the same hosts without /silent/, takes the card on CyberSource's
+// own page and is not named here.
+const secureAcceptanceSources = [
+    { kind: 'official_documentation', reference: 'https://developer.cybersource.com/docs/cybs/en-us/sa/developer/all/sa-checkout/secure-acceptance.html', reviewed_on: '2026-10-08' },
+    { kind: 'saved_observation', reference: 'arrow-2026-10-08:secure-acceptance-silent-embedded-token-create-hidden-form', reviewed_on: '2026-10-08' },
+];
+RULES.push({ id: 'cybersource-secure-acceptance-silent-order-post', psp: 'cybersource_secure_acceptance', kinds: ['form', 'document', 'frame', 'iframe'],
+    hostname: /^secureacceptance\.cybersource\.com$/, pathname: /^\/silent\/(?:[A-Za-z0-9_-]+\/)*[A-Za-z0-9_-]+\/?$/,
+    origin: 'https://secureacceptance.cybersource.com', path_pattern: '/silent/*', sources: secureAcceptanceSources,
+    variant_unverified: 'CyberSource Secure Acceptance Silent Order POST sends the card from the merchant page to /silent/ on CyberSource\'s Secure Acceptance hosts; no Vault mode takes that request over.' });
 // Fiserv Commerce Hub, read 2026-09-23 from Home Depot's OrangePay frame and Fiserv's
 // docs: payment-fields.js renders one Secure Data Capture iframe per card field, and
 // the Checkout JS SDK is Commerce Hub's other browser entry. Fiserv ships dark (its
@@ -310,6 +327,9 @@ for (const [baseId, suffix, hostname, origin] of [
     ['gmo-link-hosted-page', 'test', /^pt01\.mul-pay\.jp$/, 'https://pt01.mul-pay.jp'],
     ['cybersource-flex-microform-script', 'test', /^testflex\.cybersource\.com$/, 'https://testflex.cybersource.com'],
     ['cybersource-flex-microform-field', 'test', /^testflex\.cybersource\.com$/, 'https://testflex.cybersource.com'],
+    // Secure Acceptance's test host and its production host in India serve the same /silent/ paths.
+    ['cybersource-secure-acceptance-silent-order-post', 'test', /^testsecureacceptance\.cybersource\.com$/, 'https://testsecureacceptance.cybersource.com'],
+    ['cybersource-secure-acceptance-silent-order-post', 'in', /^secureacceptance\.in\.cybersource\.com$/, 'https://secureacceptance.in.cybersource.com'],
     ['worldpay-eprotect-js-api', 'prelive', /^request\.eprotect\.vantivprelive\.com$/, 'https://request.eprotect.vantivprelive.com'],
     ['worldpay-eprotect-iframe-client', 'prelive', /^request\.eprotect\.vantivprelive\.com$/, 'https://request.eprotect.vantivprelive.com'],
     ['worldpay-eprotect-payframe', 'prelive', /^request\.eprotect\.vantivprelive\.com$/, 'https://request.eprotect.vantivprelive.com'],

package/examples/preflight/kernel-native/inventory.json

@@ -1,7 +1,7 @@
 {
   "schema_version": 1,
   "catalog_version": "2026-09-15.1",
-  "catalog_sha256": "e570ccbce59b77166e6faef140042c068130bfe2cc4355c054e52ea2aed756e2",
+  "catalog_sha256": "a1bfa3f9da2942711afca14cfc7158a49274869c66e685abc0d36839d2e96454",
   "baseline_version": "kernel-native-docs-2026-09-11.1",
   "baseline_sha256": "d86722f49633d8223fccae54cd3d485df4375aee06aa156a273cc689b7c8507c",
   "native_build": null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-cards/sdk",
-  "version": "0.23.4",
+  "version": "0.23.5",
   "description": "Agentcard's SDK: one client, Agentcard, with two modules. checkout pauses a browser purchase and pays it with the person's own card; voice connects a person to your product once and approves a purchase by voice inside it. Card data never enters your process.",
   "type": "module",
   "main": "dist/index.js",
@@ -27,8 +27,8 @@
     "_comment_build": "The public SDK keeps zero runtime dependencies. Its build vendors deterministic metadata and substitution artifacts from the internal payment core, and the voice streaming door from packages/voice/src/core (the phone package, @agent-cards/voice, ships it to phones); TypeScript remains pinned.",
     "build": "node ../payment-core/scripts/build.mjs && node scripts/generate-payment-core.mjs && node scripts/generate-voice-stream.mjs && npx -y -p typescript@5.9.3 tsc && node scripts/generate-preflight-contract.mjs",
     "prepublishOnly": "pnpm build",
-    "test": "node test.mjs && node --test lifecycle.test.mjs merchant-abort.test.mjs preparation.test.mjs braintree.test.mjs pre-claim.test.mjs ekashu.test.mjs paypal-hosted-fields.test.mjs autopilot.test.mjs stripe-checkout.test.mjs stripe-setup.test.mjs stripe-legacy-checkout.test.mjs payment-core.test.mjs prepared-processor.test.mjs merchant-hosted.test.mjs merchant-total.test.mjs sandbox-declaration.test.mjs minimum-delay.test.mjs paysafe.test.mjs payu.test.mjs attachment.test.mjs worker-targets.test.mjs mercado-checkout.test.mjs mercado-polling.test.mjs amadeus.test.mjs pelecard.test.mjs aci.test.mjs primer.test.mjs payrails.test.mjs elavon-converge.test.mjs voice.test.mjs agentcard.test.mjs buy.test.mjs readme.test.mjs gmo.test.mjs cybersource-flex.test.mjs juspay-gate.test.mjs card-endpoint.test.mjs card-endpoint-fastspring.test.mjs card-endpoint-navigation.test.mjs merchant-session-probe.test.mjs datatrans.test.mjs authorize-net-dpm.test.mjs creditguard.test.mjs eprotect.test.mjs wspay.test.mjs shiji-sts.test.mjs worldline-mycheckout.test.mjs verifone.test.mjs && node --test preflight-package.test.mjs preflight-collector.test.mjs && node --test kernel-native-qualification.test.mjs && node --test ../vault/scripts/recurly-validation/watch-duty-sdk-result.test.mjs",
-    "test:browser": "node browser.test.mjs && node stripe-browser.test.mjs && node preparation-browser.test.mjs && node checkout-com-browser.test.mjs && node paysafe-preparation-browser.test.mjs && node owned-shop-browser.test.mjs && node spreedly-browser.test.mjs && node worker-browser.test.mjs && node amadeus-browser.test.mjs && node adyen-merchant-hosted-browser.test.mjs && node adyen-merchant-frames-browser.test.mjs && node fiserv-browser.test.mjs && node gmo-browser.test.mjs && node cybersource-flex-browser.test.mjs && node juspay-browser.test.mjs && node card-endpoint-browser.test.mjs && node datatrans-browser.test.mjs && node authorize-net-dpm-browser.test.mjs && node pelecard-browser.test.mjs && node aci-browser.test.mjs && node creditguard-browser.test.mjs && node primer-browser.test.mjs && node payrails-browser.test.mjs && node elavon-converge-browser.test.mjs && node eprotect-browser.test.mjs && node wspay-browser.test.mjs && node shiji-sts-browser.test.mjs && node worldline-mycheckout-browser.test.mjs && node paypal-hosted-fields-browser.test.mjs",
+    "test": "node test.mjs && node --test lifecycle.test.mjs merchant-abort.test.mjs preparation.test.mjs braintree.test.mjs pre-claim.test.mjs ekashu.test.mjs paypal-hosted-fields.test.mjs cybersource-secure-acceptance.test.mjs autopilot.test.mjs stripe-checkout.test.mjs stripe-setup.test.mjs stripe-legacy-checkout.test.mjs payment-core.test.mjs prepared-processor.test.mjs merchant-hosted.test.mjs merchant-total.test.mjs sandbox-declaration.test.mjs minimum-delay.test.mjs paysafe.test.mjs payu.test.mjs attachment.test.mjs worker-targets.test.mjs mercado-checkout.test.mjs mercado-polling.test.mjs amadeus.test.mjs pelecard.test.mjs aci.test.mjs primer.test.mjs payrails.test.mjs elavon-converge.test.mjs voice.test.mjs agentcard.test.mjs buy.test.mjs readme.test.mjs gmo.test.mjs cybersource-flex.test.mjs juspay-gate.test.mjs card-endpoint.test.mjs card-endpoint-fastspring.test.mjs card-endpoint-navigation.test.mjs merchant-session-probe.test.mjs datatrans.test.mjs authorize-net-dpm.test.mjs creditguard.test.mjs eprotect.test.mjs wspay.test.mjs shiji-sts.test.mjs worldline-mycheckout.test.mjs verifone.test.mjs && node --test preflight-package.test.mjs preflight-collector.test.mjs && node --test kernel-native-qualification.test.mjs && node --test ../vault/scripts/recurly-validation/watch-duty-sdk-result.test.mjs",
+    "test:browser": "node browser.test.mjs && node stripe-browser.test.mjs && node preparation-browser.test.mjs && node checkout-com-browser.test.mjs && node paysafe-preparation-browser.test.mjs && node owned-shop-browser.test.mjs && node spreedly-browser.test.mjs && node worker-browser.test.mjs && node amadeus-browser.test.mjs && node adyen-merchant-hosted-browser.test.mjs && node adyen-merchant-frames-browser.test.mjs && node fiserv-browser.test.mjs && node gmo-browser.test.mjs && node cybersource-flex-browser.test.mjs && node juspay-browser.test.mjs && node card-endpoint-browser.test.mjs && node datatrans-browser.test.mjs && node authorize-net-dpm-browser.test.mjs && node pelecard-browser.test.mjs && node aci-browser.test.mjs && node creditguard-browser.test.mjs && node primer-browser.test.mjs && node payrails-browser.test.mjs && node elavon-converge-browser.test.mjs && node eprotect-browser.test.mjs && node wspay-browser.test.mjs && node shiji-sts-browser.test.mjs && node worldline-mycheckout-browser.test.mjs && node paypal-hosted-fields-browser.test.mjs && node cybersource-secure-acceptance-browser.test.mjs",
     "check:payment-core": "node scripts/generate-payment-core.mjs --check",
     "check:voice-stream": "node scripts/generate-voice-stream.mjs --check",
     "test:preflight": "node --test preflight-package.test.mjs preflight-collector.test.mjs kernel-native-qualification.test.mjs",