@agent-cards/sdk 0.23.3 → 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`.
@@ -10,6 +14,8 @@
 
 - Recognize Target Optical's card request as its checkout sends it today: a JSON `PUT` to `/wcs/resources/store/12001/cart/@self/addPayment` with the page's `nocache` query, the total in `piAmount` with five decimals (`"49.42000"`). The profile described the form post Target Optical's older checkout sent, which no request matches now, so the adapters let the dummy card reach Target Optical. The profile stays in observe: both adapters now pause that request and refuse it as `unsupported_checkout` before any authorization, let the saved-card body to the same URL through untouched, and abort the card save a signed-in shopper's page sends to `/wcs/resources/store/12001/mypayments` in every status. They also abort, in every status, a post to `/AjaxOrderChangeServicePIAddTO`, the form endpoint the older checkout used, which they refused before and which the storefront still declares in a script it serves, so moving the profile to the `PUT` leaves no path where the dummy card reaches Target Optical. `attachToPlaywright` routes a reviewed card endpoint's request by every method the profiles name; it asked only for `POST`, so a `PUT` card request or resend never reached its gates. A card endpoint create names the profile's own method in `request.method`; an API that reads every card endpoint request as a `POST` refuses a `PUT` create with `invalid_request`, so nothing is charged. TypeScript: `CardEndpointProfile.method` can be `PUT`.
 
+- Pay Cinemark and Dick's Sporting Goods' own storefront, two reviewed Adyen merchants that take the card on their own server. Both profiles, `cinemark_initiate` and `dsg_paygate_v2`, ship `enabled`, and the API serves them `enabled` only to a client of a company Agentcard turned them on for. For every other client the adapters keep pausing and aborting their card requests as `merchant_profile_observed`, as before. A payment there needs a preparation for the profile and the cardholder's approval in the Vault, and Autopilot never pays one. The create carries the merchant's own checkout total as your agent's browser read it, and the API refuses a payment whose amount is not that total. Dick's paygate at Golf Galaxy, Public Lands and Going Going Gone moves to its own profile, `dsg_other_stores_paygate_v2`, which ships in `observe`, so the adapters abort those card requests as before. Matching API and Vault releases are required.
+
 - Stop the card fields adyen-web 5 encrypts at a reviewed Adyen merchant profile. adyen-web 5 seals each field as an RSA-OAEP / A256CBC-HS512 JWE, where adyen-web 6 writes RSA-OAEP-256 / A256GCM, and the SDK read only adyen-web 6's form. So the card requests of Cathay Pacific's payment page and Dunelm's legacy checkout, and Cathay's charge request after its signing step, reached the merchant with the agent's dummy card. The adapters now read both forms as a card. Both profiles ship in `observe`, so the adapters abort each of these requests before it leaves the browser and report it as `merchant_profile_observed`. The Vault writes only adyen-web 6's form, so the API refuses a create for a card request in adyen-web 5's form with `cse_template_unsupported`, and nothing is charged.
 
 - Abort the requests in which IHG's pay page sends the typed card outside its reviewed card request, in every status, as `card_endpoint_refused` with reason `card_resend`. The page posts the same booking to IHG's enrollment service while its pre-ticked "Enroll for free" box stays ticked, posts it on other paths for more than one room, a travel agent or Business Rewards, and at a hotel that asks for 3-D Secure first posts the number to two 3-D Secure calls. The SDK let each of these reach IHG with the agent's dummy card. A booking with the box unticked reaches IHG's reviewed card request, which the adapters refuse as before while IHG is in `observe`.

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,7 +255,8 @@ 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 |
-| 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 (Dunelm and Cinemark so far); both profiles are in `observe`, so their 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 |
+| 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 |
 | Fiserv Commerce Hub | implemented (mode `cse`, prepared checkout only) and off until Agentcard turns it on for your company: the card frame's card capture on `connect.fiservapis.com` (or `connect-cert.fiservapis.com` in the sandbox), with the approved card encrypted on the cardholder's device under a key Agentcard reviewed for the merchant. A merchant whose frame posts to Fiserv's `payment-link` endpoint is not recognized. No live merchant purchase is verified yet |
@@ -1252,7 +1253,7 @@ Some Adyen merchants have adyen-web encrypt the card into four fields and post t
 
 - A request that carries no encrypted card (a basket query, a preflight) continues as before.
 - A body the browser did not hand over (a blob or a file, which neither adapter can read) is not proven card-free, so any request but a `GET`, `HEAD` or `OPTIONS` that carries one is treated as a card request the profile cannot finish. Playwright reports a missing body the same way, so an empty body is treated alike in both adapters.
-- A profile in `observe` never pays. Its card request is aborted before it reaches the merchant, and the adapters report `merchant_profile_observed` with the profile, the templated URL, the verdict and `keyPathSha256`, the SHA-256 of the body's sorted key paths (never a value; `null` for a body that was not read), then `unsupported_checkout`. The controller reads `unsupported` with reason `merchant_profile_observe`, and no authorization exists. Both reviewed profiles, `dunelm_was_graphql` and `cinemark_initiate`, ship in `observe`.
+- A profile in `observe` never pays. Its card request is aborted before it reaches the merchant, and the adapters report `merchant_profile_observed` with the profile, the templated URL, the verdict and `keyPathSha256`, the SHA-256 of the body's sorted key paths (never a value; `null` for a body that was not read), then `unsupported_checkout`. The controller reads `unsupported` with reason `merchant_profile_observe`, and no authorization exists. `cinemark_initiate` and `dsg_paygate_v2` (Dick's Sporting Goods' own storefront) ship `enabled`, and the API serves them `enabled` only to a client of a company Agentcard turned them on for. Every other reviewed profile ships in `observe`, `dunelm_was_graphql` and `dsg_other_stores_paygate_v2` (Dick's paygate at Golf Galaxy, Public Lands and Going Going Gone) among them.
 - A card request the profile cannot finish (storing the card, a stored card, another operation, three fields instead of four, a sibling endpoint, an unreadable body) is aborted with `unsupported_checkout` and the reason, and reads `unsupported` with reason `merchant_request_unsupported`.
 - The profile's own card request, once Agentcard enables the profile for your client and this build, pays only through a preparation for that profile. Without one it is aborted before any pause, prompt or authorization: the adapters report `blocked` with `preparation_required`, the controller reads `failed` with that reason, and `prepare()` is refused on that attachment, as after any first card request. Create a new attachment and prepare before Pay.
 
@@ -1266,7 +1267,7 @@ After hand-off, a `5xx` final answer (after any redirect), a network failure, or
 
 #### Testing against your own Adyen TEST account
 
-A test-mode client can run the same checkout against its own server and its own Adyen TEST account, before any reviewed profile is enabled. Declare your endpoint on the client, before any attach, as taking the card request of a profile this build reviewed:
+A test-mode client can run the same checkout against its own server and its own Adyen TEST account, whether or not Agentcard has enabled the reviewed profile. Declare your endpoint on the client, before any attach, as taking the card request of a profile this build reviewed:
 
 ```ts
 const vault = new VaultClient({ clientId, clientSecret, sandboxMerchants: [

package/dist/adyen-merchant-hosted.generated.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 // Generated from @agent-cards/payment-core. Do not edit.
-// artifact-sha256: c979802cf1a5aa95eedd5dd00949cd56c5c478ca3c637b3232b69597cc62d4a4
+// artifact-sha256: 4790fdfc656acbda50ddf8471507933ddd4938f4c5b351ec096a9549a7c8c257
 // src/deep-freeze.js
 function deepFreeze(value) {
     if (value && typeof value === "object" && !Object.isFrozen(value)) {
@@ -1086,6 +1086,118 @@ function selectMerchantExchanges(profile, stageName, input) {
     return { ok: true, responses: newestMerchantExchanges(kept) };
 }
 // src/merchant-profiles.js
+var DSG_PAYGATE_V2 = /* @__PURE__ */ deepFreeze({
+    method: "POST",
+    path: "/prod/api/paygate/v2/authorization",
+    query: {},
+    // The page sends true for every checkout its translator read, the only checkouts
+    // the amount source below maps; a legacy checkout is not this card request.
+    requires: [{ path: ["isModernOrder"], equals: true }],
+    holder: ["tenders", "encryptedCardTenders", 0],
+    fields: {
+        encryptedCardNumber: "cardNumber",
+        encryptedExpiryMonth: "expirationMonth",
+        encryptedExpiryYear: "expirationYear",
+        encryptedSecurityCode: "cvv"
+    },
+    // cardType and vinBalue describe the dummy the agent typed: the facts below
+    // write the approved card's instead, so nothing is removed.
+    remove: [],
+    refuse: [
+        { path: ["tenders", "encryptedCardTenders", 0, "saveForLater"], when: "true" },
+        // A saved card, or a second card tender the Vault never encrypted.
+        { path: ["tenders", "savedCardTender"], when: "present" },
+        { path: ["tenders", "encryptedCardTenders", 1], when: "present" },
+        // A gift card pays part of the order, so the card pays less than the total.
+        { path: ["tenders", "giftCardTenders"], when: "present" }
+    ],
+    amount: null,
+    // Read Sep 25, 2026 (research amount_source/dickssportinggoods). Every checkout call
+    // on the checkout page answers the whole checkout, camelCase on the wire: the page
+    // load's PATCH (or the create), then every address, shipping, promotion, gift card,
+    // tip and ScoreCard change. pricing.totalRemaining is what the card pays, a string
+    // with exactly two decimals ("123.45"; the page itself drops the dot for minor
+    // units). transactionReference is the checkout key, in the body and the URL. After
+    // payment the order submit and the confirmation read return the placed checkout.
+    amountSource: {
+        id: "dsg_checkout_pricing",
+        origin: "checkout",
+        format: "json",
+        responses: [
+            { method: "PATCH", path: "/api/v1/checkouts/:checkoutKey", query: {} },
+            { method: "POST", path: "/api/v1/checkouts", query: {} },
+            { method: "POST", path: "/api/v1/checkouts/:checkoutKey/addresses", queries: [{}, { type: "billing" }, { type: "shipping" }] },
+            { method: "PUT", path: "/api/v1/checkouts/:checkoutKey/shipping/selected/groups/:groupNumber/mode", query: {} },
+            { method: "PUT", path: "/api/v2/checkouts/:checkoutKey/promotion/cart", query: {} },
+            { method: "DELETE", path: "/api/v2/checkouts/:checkoutKey/promotion/cart", query: {} },
+            { method: "POST", path: "/api/v1/checkouts/:checkoutKey/gift-cards", query: {} },
+            { method: "DELETE", path: "/api/v1/checkouts/:checkoutKey/gift-cards/:giftCardIndex", query: {} },
+            { method: "PUT", path: "/api/v1/checkouts/:checkoutKey/tip", query: {} },
+            { method: "PUT", path: "/api/v1/checkouts/:checkoutKey/scorecard", query: {} },
+            { method: "DELETE", path: "/api/v1/checkouts/:checkoutKey/scorecard", query: {} },
+            { method: "DELETE", path: "/api/v1/checkouts/:checkoutKey/v2/gifts", query: {} }
+        ],
+        total: { path: ["pricing", "totalRemaining"], format: "decimal2" },
+        unit: "major",
+        currency: "USD",
+        currencyPath: ["pricing", "currency"],
+        bind: [
+            { source: ["checkoutKey"], card: ["transactionReference"] },
+            { placeholder: "checkoutKey", card: ["transactionReference"] }
+        ],
+        // The order total and the card's share are the same text. Anything that lowers the
+        // share below the total (a gift card, ScoreCard rewards) or lands in only one of them
+        // (a tip, a donation) is refused until a HAR shows which one the charge follows, so
+        // the approved amount and the placed checkout's total read after payment agree.
+        requires: [{ path: ["pricing", "total"], equalsPath: ["pricing", "totalRemaining"] }],
+        refuse: [
+            // A placed checkout is not the one being paid.
+            { path: ["orderPlacedTime"], when: "true" },
+            // Gift cards and a checkout with no address yet (tax not estimated) wait for a HAR.
+            { path: ["payment", "giftCards"], when: "nonEmpty" },
+            { path: ["addresses"], when: "empty" }
+        ],
+        maxAgeMs: 9e5,
+        afterPayment: {
+            origin: "checkout",
+            format: "json",
+            responses: [
+                { method: "POST", path: "/api/v1/checkouts/:checkoutKey", query: {} },
+                { method: "GET", path: "/api/v1/checkouts/submitted/:checkoutKey", query: {} }
+            ],
+            // The order total, which the requires rule above held equal to the card's share
+            // before payment. totalRemaining is not read here: after placement it can drop to
+            // what is still unpaid, which would hide a higher charge.
+            total: { path: ["pricing", "total"], format: "decimal2" },
+            unit: "major",
+            currency: "USD",
+            currencyPath: ["pricing", "currency"],
+            bind: [
+                { source: ["checkoutKey"], card: ["transactionReference"] },
+                { placeholder: "checkoutKey", card: ["transactionReference"] }
+            ],
+            refuse: [{ path: ["orderPlacedTime"], when: "unset" }]
+        }
+    },
+    facts: [
+        // adyen-web's brand codes, the ones the page's supported list names; Dick's own
+        // private-label (plcc, comc) cards have no Agentcard brand and are refused.
+        {
+            path: ["tenders", "encryptedCardTenders", 0, "cardType"],
+            fact: "brand",
+            map: { visa: "visa", mastercard: "mc", amex: "amex", discover: "discover", diners: "diners", jcb: "jcb" }
+        },
+        { path: ["tenders", "encryptedCardTenders", 0, "vinBalue"], fact: "bin6" }
+    ],
+    adyen: {
+        environment: "live",
+        clientKey: "live_YJLFKT47JJG2RI7QIYX6HTKKDEDOEGOH",
+        publicKeySha256: "da33611149dff3ab715be8671c0550bb8aec6112983b2473db9ee7afb829c110"
+    }
+});
+function dsgPaygateProfile(own) {
+    return { ...own, ...DSG_PAYGATE_V2 };
+}
 var MERCHANT_HOSTED_PROFILES = /* @__PURE__ */ deepFreeze([
     {
         // Read Sep 23, 2026. assets.dunelm.com checkout-page bundle: submitPayment
@@ -1181,10 +1293,13 @@ var MERCHANT_HOSTED_PROFILES = /* @__PURE__ */ deepFreeze([
         // client key from the three securedFields iframes on
         // checkoutshopper-live-us.adyen.com (adyen-web 6.x). The request body itself
         // was not captured: the guest email gate stopped the run before Pay. Public
-        // key read from checkoutshopper-live-us.adyen.com on 2026-09-25 (UTC).
+        // key read from checkoutshopper-live-us.adyen.com on 2026-09-25 (UTC). Enabled
+        // Oct 7, 2026 under D1 (amountSource, above): live checks on Sep 30 and Oct 6
+        // matched its key pin, its card request as the page's script builds it, and its
+        // checkout total.
         id: "cinemark_initiate",
         merchant: "Cinemark",
-        status: "observe",
+        status: "enabled",
         origins: [{ checkout: "https://www.cinemark.com", endpoint: "https://www.cinemark.com" }],
         method: "POST",
         path: "/api/adyen/initiatePayment",
@@ -1257,137 +1372,29 @@ var MERCHANT_HOSTED_PROFILES = /* @__PURE__ */ deepFreeze([
             publicKeySha256: "9dd5ef549c7454d60ca970ff76c8f4cac36d79f2961e59eca9116791e86cbcc5"
         }
     },
-    {
-        // Read Sep 23, 2026. payments.dickssportinggoods.com/library/dppjs/index-v2.js
-        // (adyen-web 6.39.0): Dd() builds tenders.encryptedCardTenders[0] from the Card
-        // component's four JWEs as cardNumber, expirationMonth, expirationYear and cvv,
-        // beside cardType (adyen-web's first detected brand), saveForLater (the save-card
-        // box) and vinBalue (the six digits onBinValue reports). The page posts it with
-        // transactionReference, customer.device and any giftCardTenders to
-        // <payments host>/prod/api/paygate/v2/authorization, the host picked from the
-        // page's own (Dick's, Golf Galaxy, Public Lands, Going Going Gone). The same slot
-        // carries Afterpay, CashApp and Affirm tenders with literal strings where the JWEs
-        // go, and a saved card goes to tenders.savedCardTender instead. The body names no
-        // amount: the paygate charges the cart it holds for transactionReference.
-        // mountCCForm names the client key and environment 'live'. Public key read from
-        // checkoutshopper-live.adyen.com on 2026-09-25 (UTC).
+    /* @__PURE__ */ dsgPaygateProfile({
+        // Dick's own storefront, the one live checks read on Sep 30 and Oct 6, 2026: its key
+        // pin, its card request as the page's code builds it, its card facts and its checkout
+        // pricing matched DSG_PAYGATE_V2. Enabled Oct 7, 2026 under D1 (amountSource, above).
         id: "dsg_paygate_v2",
         merchant: "Dick's Sporting Goods",
+        status: "enabled",
+        origins: [
+            { checkout: "https://www.dickssportinggoods.com", endpoint: "https://payments.dickssportinggoods.com" }
+        ]
+    }),
+    /* @__PURE__ */ dsgPaygateProfile({
+        // The same paygate on the three other storefronts its page names. No live check has
+        // read them, so their card requests stay paused and aborted in observe.
+        id: "dsg_other_stores_paygate_v2",
+        merchant: "Golf Galaxy, Public Lands and Going Going Gone",
         status: "observe",
         origins: [
-            { checkout: "https://www.dickssportinggoods.com", endpoint: "https://payments.dickssportinggoods.com" },
             { checkout: "https://www.golfgalaxy.com", endpoint: "https://payments.golfgalaxy.com" },
             { checkout: "https://www.publiclands.com", endpoint: "https://payments.publiclands.com" },
             { checkout: "https://www.goinggoinggone.com", endpoint: "https://payments.goinggoinggone.com" }
-        ],
-        method: "POST",
-        path: "/prod/api/paygate/v2/authorization",
-        query: {},
-        // The page sends true for every checkout its translator read, the only checkouts
-        // the amount source below maps; a legacy checkout is not this card request.
-        requires: [{ path: ["isModernOrder"], equals: true }],
-        holder: ["tenders", "encryptedCardTenders", 0],
-        fields: {
-            encryptedCardNumber: "cardNumber",
-            encryptedExpiryMonth: "expirationMonth",
-            encryptedExpiryYear: "expirationYear",
-            encryptedSecurityCode: "cvv"
-        },
-        // cardType and vinBalue describe the dummy the agent typed: the facts below
-        // write the approved card's instead, so nothing is removed.
-        remove: [],
-        refuse: [
-            { path: ["tenders", "encryptedCardTenders", 0, "saveForLater"], when: "true" },
-            // A saved card, or a second card tender the Vault never encrypted.
-            { path: ["tenders", "savedCardTender"], when: "present" },
-            { path: ["tenders", "encryptedCardTenders", 1], when: "present" },
-            // A gift card pays part of the order, so the card pays less than the total.
-            { path: ["tenders", "giftCardTenders"], when: "present" }
-        ],
-        amount: null,
-        // Read Sep 25, 2026 (research amount_source/dickssportinggoods). Every checkout call
-        // on the checkout page answers the whole checkout, camelCase on the wire: the page
-        // load's PATCH (or the create), then every address, shipping, promotion, gift card,
-        // tip and ScoreCard change. pricing.totalRemaining is what the card pays, a string
-        // with exactly two decimals ("123.45"; the page itself drops the dot for minor
-        // units). transactionReference is the checkout key, in the body and the URL. After
-        // payment the order submit and the confirmation read return the placed checkout.
-        amountSource: {
-            id: "dsg_checkout_pricing",
-            origin: "checkout",
-            format: "json",
-            responses: [
-                { method: "PATCH", path: "/api/v1/checkouts/:checkoutKey", query: {} },
-                { method: "POST", path: "/api/v1/checkouts", query: {} },
-                { method: "POST", path: "/api/v1/checkouts/:checkoutKey/addresses", queries: [{}, { type: "billing" }, { type: "shipping" }] },
-                { method: "PUT", path: "/api/v1/checkouts/:checkoutKey/shipping/selected/groups/:groupNumber/mode", query: {} },
-                { method: "PUT", path: "/api/v2/checkouts/:checkoutKey/promotion/cart", query: {} },
-                { method: "DELETE", path: "/api/v2/checkouts/:checkoutKey/promotion/cart", query: {} },
-                { method: "POST", path: "/api/v1/checkouts/:checkoutKey/gift-cards", query: {} },
-                { method: "DELETE", path: "/api/v1/checkouts/:checkoutKey/gift-cards/:giftCardIndex", query: {} },
-                { method: "PUT", path: "/api/v1/checkouts/:checkoutKey/tip", query: {} },
-                { method: "PUT", path: "/api/v1/checkouts/:checkoutKey/scorecard", query: {} },
-                { method: "DELETE", path: "/api/v1/checkouts/:checkoutKey/scorecard", query: {} },
-                { method: "DELETE", path: "/api/v1/checkouts/:checkoutKey/v2/gifts", query: {} }
-            ],
-            total: { path: ["pricing", "totalRemaining"], format: "decimal2" },
-            unit: "major",
-            currency: "USD",
-            currencyPath: ["pricing", "currency"],
-            bind: [
-                { source: ["checkoutKey"], card: ["transactionReference"] },
-                { placeholder: "checkoutKey", card: ["transactionReference"] }
-            ],
-            // The order total and the card's share are the same text. Anything that lowers the
-            // share below the total (a gift card, ScoreCard rewards) or lands in only one of them
-            // (a tip, a donation) is refused until a HAR shows which one the charge follows, so
-            // the approved amount and the placed checkout's total read after payment agree.
-            requires: [{ path: ["pricing", "total"], equalsPath: ["pricing", "totalRemaining"] }],
-            refuse: [
-                // A placed checkout is not the one being paid.
-                { path: ["orderPlacedTime"], when: "true" },
-                // Gift cards and a checkout with no address yet (tax not estimated) wait for a HAR.
-                { path: ["payment", "giftCards"], when: "nonEmpty" },
-                { path: ["addresses"], when: "empty" }
-            ],
-            maxAgeMs: 9e5,
-            afterPayment: {
-                origin: "checkout",
-                format: "json",
-                responses: [
-                    { method: "POST", path: "/api/v1/checkouts/:checkoutKey", query: {} },
-                    { method: "GET", path: "/api/v1/checkouts/submitted/:checkoutKey", query: {} }
-                ],
-                // The order total, which the requires rule above held equal to the card's share
-                // before payment. totalRemaining is not read here: after placement it can drop to
-                // what is still unpaid, which would hide a higher charge.
-                total: { path: ["pricing", "total"], format: "decimal2" },
-                unit: "major",
-                currency: "USD",
-                currencyPath: ["pricing", "currency"],
-                bind: [
-                    { source: ["checkoutKey"], card: ["transactionReference"] },
-                    { placeholder: "checkoutKey", card: ["transactionReference"] }
-                ],
-                refuse: [{ path: ["orderPlacedTime"], when: "unset" }]
-            }
-        },
-        facts: [
-            // adyen-web's brand codes, the ones the page's supported list names; Dick's own
-            // private-label (plcc, comc) cards have no Agentcard brand and are refused.
-            {
-                path: ["tenders", "encryptedCardTenders", 0, "cardType"],
-                fact: "brand",
-                map: { visa: "visa", mastercard: "mc", amex: "amex", discover: "discover", diners: "diners", jcb: "jcb" }
-            },
-            { path: ["tenders", "encryptedCardTenders", 0, "vinBalue"], fact: "bin6" }
-        ],
-        adyen: {
-            environment: "live",
-            clientKey: "live_YJLFKT47JJG2RI7QIYX6HTKKDEDOEGOH",
-            publicKeySha256: "da33611149dff3ab715be8671c0550bb8aec6112983b2473db9ee7afb829c110"
-        }
-    },
+        ]
+    }),
     {
         // Read Sep 25, 2026, from public code only: the WooCommerce plugin super-payments 1.40.1 and
         // cdn.superpayments.com/js/v2/payment.webcomponents.script.js as it stood on Sep 19.

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';