@agent-cards/sdk 0.20.0 → 0.21.0

package/dist/gmo.js

@@ -0,0 +1,119 @@
+// GMO Payment Gateway, PG Multipayment token v2 (mp-token.js), as the SDK sees it.
+//
+// A GMO merchant page that calls Multipayment.init(shopId) with one argument (teamLab's ticket
+// sites do) sends the card as mp-token.js's getToken: one fetch POST to
+// https://token.mul-pay.jp/payment/CreateToken.json (test host stg.token.mul-pay.jp), as
+// application/json with X-MP-Client-Type: js-legacy, whose body is AES ciphertext of the card with
+// its key wrapped under GMO's shared public key. The agent's page encrypts the placeholder card, so
+// nothing in the paused body can be filled in. The cardholder's device rebuilds the whole envelope
+// with the real card and sends it to GMO itself, and the page receives only GMO's answer: one
+// single-use token, valid 30 minutes and spendable only by the shop's own site (token mode).
+//
+// The registry entry ships dark (capability gmo_shared_pk). This build declares the capability on
+// syncRegistry, and the API serves the entry only to an org Agentcard enabled for GMO, so for every
+// other org nothing here fires: isCardRequest never recognizes a GMO URL and GMO's requests go
+// through untouched, exactly as before.
+//
+// For an org in the dark launch, a POST the registry recognizes on a GMO token host is judged by
+// payment-core's one guard (gmo.generated.ts isGmoSharedPkRequest), the check the API runs at
+// create and the device runs before it rebuilds anything:
+//   - mp-token.js's SHARED_PK getToken for one token pauses for approval;
+//   - anything else on that URL can never be paid by the vault: UNIQUE_PK (a merchant-registered
+//     key nobody can check), GMO Elements (js-iframe), several tokens, a shop id of the other
+//     environment's shape, or any serialization mp-token.js does not write. It is aborted as an
+//     unsupported checkout before any create or prompt.
+// Token v1 (ext/js/token.js) sends the card as a JSONP GET that no vault mode covers. It is aborted
+// the same way, so the placeholder is never tokenized silently.
+import { GMO_PSP, GMO_TOKEN_URLS, isGmoSharedPkRequest, isGmoTokenHost, sanitizeGmoTokenResponse, } from './gmo.generated.js';
+export { GMO_PSP, isGmoTokenHost };
+/** The dark-launch capability a build declares when it pauses only what isGmoSharedPkRequest accepts. */
+export const GMO_CAPABILITY = 'gmo_shared_pk';
+/** The hosts GMO token v1 (ext/js/token.js) sends its JSONP GET to: production, then test. */
+const GMO_TOKEN_V1_HOSTS = ['p01.mul-pay.jp', 'stg.token.mul-pay.jp'];
+const GMO_TOKEN_V1_PATH = '/ext/api/gettoken';
+/**
+ * Fetch interception patterns for GMO token v1's JSONP GET, armed only for an org the API served GMO
+ * to. A CDP pattern matches the URL as written, path case included, while isGmoTokenV1Request
+ * accepts any path case, a trailing dot on the host and any port. So each v1 host is armed whole,
+ * in those four spellings, and the pre-claim gate classifies every paused request with
+ * isGmoTokenV1Request: the v1 GET is aborted, and anything else on the host continues untouched.
+ * Chrome writes the host in lower case, and it blocks a subresource URL that carries credentials.
+ */
+export const GMO_TOKEN_V1_PATTERNS = GMO_TOKEN_V1_HOSTS.flatMap((host) => [`https://${host}/*`, `https://${host}:*`, `https://${host}./*`, `https://${host}.:*`]);
+/**
+ * Whether the vault's current registry recognizes GMO's card request: true only after
+ * syncRegistry() for an org the API serves the dark entry to.
+ */
+export function recognizesGmo(vault) {
+    if (!vault || typeof vault.isCardRequest !== 'function')
+        return false;
+    try {
+        return vault.isCardRequest(GMO_TOKEN_URLS.production, 'POST') || vault.isCardRequest(GMO_TOKEN_URLS.sandbox, 'POST');
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * GMO token v1's card request: a GET (or, with no method, a URL a route matcher is asked about)
+ * to /ext/api/getToken on either v1 host, in any case or with a trailing dot, since the servers
+ * behind it need not care.
+ */
+export function isGmoTokenV1Request(rawUrl, method) {
+    if (method !== undefined && method.toUpperCase() !== 'GET')
+        return false;
+    let url;
+    try {
+        url = new URL(rawUrl);
+    }
+    catch {
+        return false;
+    }
+    if (url.protocol !== 'https:')
+        return false;
+    const host = url.hostname.toLowerCase().replace(/\.$/, '');
+    return GMO_TOKEN_V1_HOSTS.includes(host) && url.pathname.toLowerCase() === GMO_TOKEN_V1_PATH;
+}
+/**
+ * Whether a POST the registry recognized on a GMO token host is anything but mp-token.js's
+ * SHARED_PK getToken for one token: null when the guard accepts it (it pauses for approval), else
+ * the reason it is aborted. A guard that throws refuses.
+ */
+export function gmoRequestRefusal(request) {
+    try {
+        return isGmoSharedPkRequest({ url: request.url, method: request.method.toUpperCase(), headers: request.headers ?? {}, body: request.body })
+            ? null : 'unsupported_gmo_request';
+    }
+    catch {
+        return 'unsupported_gmo_request';
+    }
+}
+/**
+ * The shop a GMO token request names (encryptionParameters.apiKey), as part of that request's
+ * identity. GMO mints a token for that one shop, so a retry that names another shop is a new
+ * question and never takes the first request's approval. Undefined when the URL is not a GMO token
+ * host; null when the body names no shop that can be read.
+ */
+export function gmoRequestShop(url, body) {
+    if (!isGmoTokenHost(url))
+        return undefined;
+    try {
+        const shop = JSON.parse(body)?.encryptionParameters?.apiKey;
+        return typeof shop === 'string' ? shop : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The only answer the page may receive for an approved GMO request: status 200, and GMO's body
+ * reduced to the five fields mp-token.js reads with exactly one 64-hex token
+ * (sanitizeGmoTokenResponse), under a JSON content type. Null for anything else, including
+ * several tokens, which one approval never pays for.
+ */
+export function gmoTokenAnswer(status, body) {
+    if (status !== 200)
+        return null;
+    const sanitized = sanitizeGmoTokenResponse(body);
+    return sanitized ? { status: 200, headers: { 'content-type': 'application/json' }, body: sanitized } : null;
+}

package/dist/index.d.ts

@@ -1,7 +1,9 @@
 export { Agentcard, Agentcard as VaultClient, CheckoutModule } from './agentcard.js';
 export type { CheckoutAttachOptions } from './agentcard.js';
-export { CardEncryptedError, UnsupportedModeError, PreparationRequiredError, ApprovalTimeoutError, ApprovalDeclinedError, AmountMismatchError, PresetRefusedError, PRESET_REFUSAL_REASONS, IntentNotConfirmableError, ProcessorRefusedError, CheckoutApiError, CheckoutAuthError, redactUrl, SUPPORTED_MODES, PaymentOutcomeUnknownError, CheckoutCancelledError, CheckoutPreparationError, AdyenTestPlatformRefusedError, MerchantTotalError, } from './client.js';
-export type { PausedRequest, ReplayResponse, TokenReplay, CseReplay, MerchantHostedReplay, HostedFormReplay, AmountAuthority, AuthorizeInput, VaultClientOptions, AgentcardOptions, AdyenTestPlatformRefusal, MerchantTotalRefusal, PrepareCheckoutOptions, PrepareCheckoutInput, PreparedCheckout, RazorpayProcessorError, RuntimeCancelReason, ExecutionMetadata, } from './client.js';
+export { CardEncryptedError, UnsupportedModeError, UnsupportedCapabilityError, PreparationRequiredError, AmountRequiredError, ApprovalTimeoutError, ApprovalDeclinedError, AmountMismatchError, PresetRefusedError, PRESET_REFUSAL_REASONS, IntentNotConfirmableError, ProcessorRefusedError, CheckoutApiError, CheckoutAuthError, redactUrl, SUPPORTED_MODES, SUPPORTED_CAPABILITIES, PaymentOutcomeUnknownError, CheckoutCancelledError, CheckoutPreparationError, AdyenTestPlatformRefusedError, MerchantTotalError, PlaceholderCardError, } from './client.js';
+export type { GmoUnsupportedReason } from './gmo.js';
+export type { PausedRequest, ReplayResponse, TokenReplay, CseReplay, MerchantHostedReplay, HostedFormReplay, AmountAuthority, AuthorizeInput, VaultClientOptions, AgentcardOptions, AdyenTestPlatformRefusal, MerchantTotalRefusal, PrepareCheckoutOptions, PrepareCheckoutInput, PreparedCheckout, RazorpayProcessorError, RuntimeCancelReason, ExecutionMetadata, PlaceholderCard, } from './client.js';
+export type { MicroformField, MicroformSidecar } from './cybersource-flex.js';
 export { attachToCdp, attachToPlaywright, corsHeadersFor, corsDecision, withCorsHeaders } from './cdp.js';
 export { CheckoutAttachmentError } from './attachment.js';
 export type { CdpLike, AttachOptions, CorsOutcome } from './cdp.js';

package/dist/index.js

@@ -1,7 +1,7 @@
 // The one client and its modules. `VaultClient` is the client's older name and
 // stays importable for one release; it constructs the same object.
 export { Agentcard, Agentcard as VaultClient, CheckoutModule } from './agentcard.js';
-export { CardEncryptedError, UnsupportedModeError, PreparationRequiredError, ApprovalTimeoutError, ApprovalDeclinedError, AmountMismatchError, PresetRefusedError, PRESET_REFUSAL_REASONS, IntentNotConfirmableError, ProcessorRefusedError, CheckoutApiError, CheckoutAuthError, redactUrl, SUPPORTED_MODES, PaymentOutcomeUnknownError, CheckoutCancelledError, CheckoutPreparationError, AdyenTestPlatformRefusedError, MerchantTotalError, } from './client.js';
+export { CardEncryptedError, UnsupportedModeError, UnsupportedCapabilityError, PreparationRequiredError, AmountRequiredError, ApprovalTimeoutError, ApprovalDeclinedError, AmountMismatchError, PresetRefusedError, PRESET_REFUSAL_REASONS, IntentNotConfirmableError, ProcessorRefusedError, CheckoutApiError, CheckoutAuthError, redactUrl, SUPPORTED_MODES, SUPPORTED_CAPABILITIES, PaymentOutcomeUnknownError, CheckoutCancelledError, CheckoutPreparationError, AdyenTestPlatformRefusedError, MerchantTotalError, PlaceholderCardError, } from './client.js';
 export { attachToCdp, attachToPlaywright, corsHeadersFor, corsDecision, withCorsHeaders } from './cdp.js';
 export { CheckoutAttachmentError } from './attachment.js';
 export { substituteEncryptedFields, SubstitutionError } from './substitute.js';

package/dist/lifecycle.d.ts

@@ -1,6 +1,7 @@
 import { CheckoutPreparationError, type PrepareCheckoutOptions, type PreparedCheckout, type ReplayResponse } from './client.js';
 import type { CheckoutMode } from './registry.js';
 import type { Substitutions } from './substitute.js';
+import type { GmoUnsupportedReason } from './gmo.js';
 /** The application's resolver confirmed the payment for this checkout authorization. */
 export interface MerchantPaymentConfirmation {
     kind: 'merchant_payment';
@@ -183,10 +184,14 @@ export declare class CheckoutLifecycle implements CheckoutController {
     /**
      * A card request this SDK cannot pay was aborted. `reason`: an unrecognized
      * declared payment endpoint (the default), a merchant profile Agentcard has not
-     * turned on (merchant_profile_observe), or a card request the profile cannot
-     * finish (merchant_request_unsupported).
+     * turned on (merchant_profile_observe), a card request the profile cannot
+     * finish (merchant_request_unsupported), a recognized processor's request in
+     * a form its gate refuses (GMO's unsupported_gmo_request and
+     * unsupported_gmo_token_v1), or a CyberSource Flex request that is not a
+     * reviewed Microform v2 card field's (microform_unsupported,
+     * cybersource-flex.ts).
      */
-    unsupported(reason?: 'unrecognized_payment_endpoint' | 'merchant_profile_observe' | 'merchant_request_unsupported'): void;
+    unsupported(reason?: 'unrecognized_payment_endpoint' | 'merchant_profile_observe' | 'merchant_request_unsupported' | GmoUnsupportedReason | 'microform_unsupported'): 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

@@ -132,8 +132,12 @@ export class CheckoutLifecycle {
     /**
      * A card request this SDK cannot pay was aborted. `reason`: an unrecognized
      * declared payment endpoint (the default), a merchant profile Agentcard has not
-     * turned on (merchant_profile_observe), or a card request the profile cannot
-     * finish (merchant_request_unsupported).
+     * turned on (merchant_profile_observe), a card request the profile cannot
+     * finish (merchant_request_unsupported), a recognized processor's request in
+     * a form its gate refuses (GMO's unsupported_gmo_request and
+     * unsupported_gmo_token_v1), or a CyberSource Flex request that is not a
+     * reviewed Microform v2 card field's (microform_unsupported,
+     * cybersource-flex.ts).
      */
     unsupported(reason = 'unrecognized_payment_endpoint') {
         this.held = true;

package/dist/pre-claim.d.ts

@@ -3,6 +3,7 @@ import { MercadoCheckoutGate } from './mercado-checkout.js';
 import type { CheckoutLifecycle } from './lifecycle.js';
 import { type MerchantProfile } from './merchant-hosted.js';
 import type { MerchantHandoffWatch } from './merchant-handoff.js';
+import { type CybersourceFlexDecision, type CybersourceFlexPause, type FlexRequest } from './cybersource-flex.js';
 /** The native Stripe step the gate claimed, or null when none was: exactly what StripeCheckoutGate.claim returns. */
 type StripeStep = ReturnType<StripeCheckoutGate['claim']>;
 /** A synthetic response a gate fulfills locally. The effect applies CORS and encoding. */
@@ -17,7 +18,8 @@ type PreClaimEvent = {
     detail?: unknown;
 };
 /** How the request was resolved. continue/answer/abort are already performed by the
- * time the decision is returned; only pause hands work back to the adapter. */
+ * time the decision is returned; only pause hands work back to the adapter, with the
+ * CyberSource Flex sidecar when the Flex gate paused it. */
 export type PreClaimDecision = {
     kind: 'continue';
 } | {
@@ -27,6 +29,7 @@ export type PreClaimDecision = {
 } | {
     kind: 'pause';
     stripeStep: StripeStep;
+    cybersourceFlex?: CybersourceFlexPause;
 };
 /** The adapter mechanics a gate performs. Each is awaited where the inline code
  * awaited it; none swallow their own transport failure (a gate adds a .catch
@@ -94,6 +97,14 @@ export interface PreClaimContext {
     stripeStep: StripeStep;
     /** The merchant-hosted hand-off this attachment made, if any (merchant-handoff.ts). */
     merchantHandoff?: Pick<MerchantHandoffWatch, 'retried'>;
+    /**
+     * The adapter's reader of the Microform field iframe that sent a request (cybersource-flex.ts):
+     * CDP judges from the committed frame URLs it recorded, Playwright from request.frame().url().
+     * Absent, no CyberSource Flex request can pause: each one the registry recognizes is refused.
+     */
+    cybersourceFlex?: {
+        judge(request: FlexRequest): CybersourceFlexDecision | Promise<CybersourceFlexDecision>;
+    };
 }
 /**
  * The URL an event may name for a request. For an armed merchant profile's

package/dist/pre-claim.js

@@ -3,9 +3,12 @@
 // Before a paused request is claimed for the vault, a small set of processor
 // gates inspect it: Mercado Pago's native Checkout Pro configuration and
 // association, Braintree's shared /graphql endpoint, native Stripe Checkout,
-// and Fiserv's card capture. 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 added in both places.
+// Fiserv's card capture, GMO's CreateToken.json, which also carries requests
+// the vault can never pay, and CyberSource Flex Microform's field iframes (whose
+// capture context rides into the pause). 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
+// added in both places.
 //
 // dispatchPreClaim runs the gates in order and resolves the request to one of:
 //   - continue: let the request through untouched, or with a body the gate
@@ -38,8 +41,10 @@
 import { PaymentOutcomeUnknownError, redactUrl } from './client.js';
 import { classifyBraintreeRequest } from './braintree.js';
 import { StripeCheckoutClaimConflictError, stripeCheckoutReadinessError } from './stripe-checkout.js';
+import { gmoRequestRefusal, isGmoTokenHost, isGmoTokenV1Request, recognizesGmo } from './gmo.js';
 import { classifyProfileRequest, merchantBodyKeyPathSha256, profileTemplatedUrl } from './merchant-hosted.js';
 import { isFiservCaptureHost, isFiservPausableBody } from './fiserv.js';
+import { CYBERSOURCE_FLEX_PSP, isCybersourceFlexHost } from './cybersource-flex.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
@@ -104,10 +109,15 @@ async function mercadoContinuation(ctx) {
 // a Braintree POST is classified the same as an empty one, so both adapters
 // reach the same verdict. The configuration continue swallows a transport
 // failure, as the inline CDP path did (the Playwright path never reaches a
-// failing route here).
+// failing route here). The body is read only for a Braintree host:
+// classifyBraintreeRequest answers undefined for any other host before it looks
+// at a body, so another processor's request is never read here, and a body read
+// that throws (Playwright's postData() can) stays with the gate that owns it.
 const braintreePreClaim = (ctx) => {
-    const { url, method, body } = ctx.request;
-    const braintree = method.toUpperCase() === 'POST' ? classifyBraintreeRequest(url, method, body) : undefined;
+    const { url, method } = ctx.request;
+    if (method.toUpperCase() !== 'POST' || classifyBraintreeRequest(url, method, null) === undefined)
+        return undefined;
+    const braintree = classifyBraintreeRequest(url, method, ctx.request.body);
     if (braintree === 'configuration')
         return braintreeContinue(ctx);
     if (braintree === 'invalid')
@@ -311,10 +321,13 @@ async function merchantHostedUnsupported(ctx, profile, url, category, reason) {
 // Synchronous until it must continue or abort, like every gate. Exported for the
 // gate registry's tests.
 export const fiservPreClaim = (ctx) => {
-    const { url, method, body } = ctx.request;
+    const { url, method } = ctx.request;
     if (String(method).toUpperCase() !== 'POST' || !isFiservCaptureHost(url) || !ctx.vault.isCardRequest(url, method))
         return undefined;
-    if (!isFiservPausableBody(body))
+    // The body is read only here, on a capture host, since reading it may throw: another processor's
+    // request whose body the adapter cannot read then reaches the gate that owns it (GMO's aborts
+    // that request alone) or the arbiter, as it did before this gate joined the list.
+    if (!isFiservPausableBody(ctx.request.body))
         return fiservContinue(ctx);
     const idle = ctx.attachmentReady() && !ctx.stripeAttachmentBusy() && !ctx.interceptionAborted() && !ctx.terminal()
         && !ctx.lifecycle.isBlocked() && !ctx.awaitingApproval();
@@ -333,6 +346,119 @@ async function fiservPreparationRequired(ctx) {
     await ctx.effects.abort();
     return { kind: 'abort' };
 }
+// GMO token v2 and v1 (gmo.ts). GMO's CreateToken.json also carries requests the vault can never
+// pay, so a POST the registry recognizes on a GMO token host is judged here, before the terminal
+// arbiter would pause it, by the whole-request guard the API runs at create:
+//   - mp-token.js's SHARED_PK getToken for one token defers, and the arbiter pauses it;
+//   - anything else (UNIQUE_PK, GMO Elements, several tokens, a shop id of the other
+//     environment's shape, another serialization) aborts as an unsupported checkout,
+//     `unsupported_checkout` with reason `unsupported_gmo_request`, with no claim, create or
+//     prompt. The attachment then reads `unsupported` and holds: the merchant's configuration
+//     decides that shape, so the page's next request would be the same.
+// GMO token v1's JSONP GET to /ext/api/getToken aborts the same way (`unsupported_gmo_token_v1`),
+// so the agent's placeholder is never tokenized silently. Nothing is decided without the registry:
+// an SDK the API did not serve GMO (a build without the capability, or an org Agentcard has not
+// enabled) recognizes neither, so the gate defers and every GMO request continues as before. The
+// preflight OPTIONS and every other method on those URLs continue through the arbiter.
+// A body the adapter could not read says nothing about the page's configuration, so that request
+// alone is aborted with a `blocked` event, `unreadable_gmo_request`, and the attachment is not held.
+// A body or headers whose read throws (Playwright's postData() can) is that same unread request:
+// it is aborted here rather than rejecting the route handler with the request left undecided.
+// Synchronous until the abort, so a card request pauses with no await. A guard that throws
+// refuses the request rather than letting it reach a prompt.
+const gmoPreClaim = (ctx) => {
+    const { url, method } = ctx.request;
+    if (method.toUpperCase() === 'POST' && isGmoTokenHost(url) && ctx.vault.isCardRequest(url, method)) {
+        let body;
+        let headers;
+        try {
+            body = ctx.request.body;
+            headers = ctx.request.headers;
+        }
+        catch {
+            return gmoUnreadable(ctx);
+        }
+        if (body === null)
+            return gmoUnreadable(ctx);
+        const reason = gmoRequestRefusal({ url, method, headers, body });
+        return reason === null ? undefined : gmoUnsupported(ctx, reason);
+    }
+    if (isGmoTokenV1Request(url, method) && recognizesGmo(ctx.vault))
+        return gmoUnsupported(ctx, 'unsupported_gmo_token_v1');
+    return undefined;
+};
+async function gmoUnreadable(ctx) {
+    ctx.onEvent?.({ type: 'blocked', detail: 'unreadable_gmo_request' });
+    await ctx.effects.abort();
+    return { kind: 'abort' };
+}
+async function gmoUnsupported(ctx, reason) {
+    const { url, method } = ctx.request;
+    ctx.preparationGate.invalidate('unsupported_checkout');
+    ctx.lifecycle.unsupported(reason);
+    ctx.onEvent?.({ type: 'unsupported_checkout', detail: { url: redactUrl(url), method, reason } });
+    await ctx.effects.abort();
+    return { kind: 'abort' };
+}
+// CyberSource Flex Microform (cybersource-flex.ts). A POST to a Flex host that the registry
+// recognizes is this gate's to judge before the terminal arbiter, which would pause every one of
+// them: the same tokens URL carries Microform v0.x and Flex API direct traffic, and only the
+// field iframe's URL fragment says which card field sent it and under which capture context.
+//   - a check (eCheck) Microform: continue untouched, it carries no card;
+//   - not a field iframe's sealed card, a frame read and found to be no Microform field, an
+//     unreviewed version, or fields the device cannot rebuild: abort as unsupported, before any
+//     authorization, and hold the attachment (the page's next request would be judged the same way);
+//   - a capture context that does not verify, has expired, names another URL, or did not seal
+//     this body, a body the adapter could not read, or a frame it could not read: abort this
+//     request only, since the page's next request can pass (a freshly minted context, a frame
+//     read on the next try);
+//   - otherwise pause, carrying the sidecar the create sends and the request's retry shape.
+// Nothing is decided without the registry: an SDK that did not sync with the capability, or whose
+// org Agentcard has not enabled for CyberSource Flex (the API withholds the recognizer), never
+// recognizes a Flex host, so the gate defers and the request continues as before. Synchronous
+// once the context's verification settled (the adapters start it when the field iframe loads).
+const FLEX_UNREADABLE = { kind: 'refuse', reason: 'microform_frame_unread' };
+const cybersourceFlexPreClaim = (ctx) => {
+    const { url, method } = ctx.request;
+    if (method.toUpperCase() !== 'POST' || !isCybersourceFlexHost(url) || !ctx.vault.isCardRequest(url, method))
+        return undefined;
+    let decision;
+    try {
+        decision = ctx.cybersourceFlex ? ctx.cybersourceFlex.judge(ctx.request) : FLEX_UNREADABLE;
+    }
+    catch {
+        decision = FLEX_UNREADABLE;
+    }
+    return decision instanceof Promise
+        ? decision.then((settled) => cybersourceFlexResolve(ctx, settled), () => cybersourceFlexResolve(ctx, FLEX_UNREADABLE))
+        : cybersourceFlexResolve(ctx, decision);
+};
+function cybersourceFlexResolve(ctx, decision) {
+    if (decision.kind === 'pause')
+        return { kind: 'pause', stripeStep: ctx.stripeStep, cybersourceFlex: decision.flex };
+    if (decision.kind === 'continue')
+        return cybersourceFlexContinue(ctx);
+    if (decision.kind === 'unsupported')
+        return cybersourceFlexUnsupported(ctx, decision.reason);
+    return cybersourceFlexRefuse(ctx, decision.reason);
+}
+async function cybersourceFlexContinue(ctx) {
+    await ctx.effects.continueRequest().catch(() => { });
+    return { kind: 'continue' };
+}
+async function cybersourceFlexUnsupported(ctx, reason) {
+    const { url, method } = ctx.request;
+    ctx.preparationGate.invalidate('unsupported_checkout');
+    ctx.lifecycle.unsupported('microform_unsupported');
+    ctx.onEvent?.({ type: 'unsupported_checkout', detail: { url: redactUrl(url), method, processor: CYBERSOURCE_FLEX_PSP, reason } });
+    await ctx.effects.abort();
+    return { kind: 'abort' };
+}
+async function cybersourceFlexRefuse(ctx, reason) {
+    ctx.onEvent?.({ type: 'blocked', detail: reason });
+    await ctx.effects.abort();
+    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
@@ -366,7 +492,7 @@ 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 = [mercadoPreClaim, braintreePreClaim, stripePreClaim, merchantHostedPreClaim, fiservPreClaim];
+export const PSP_PRE_CLAIM_GATES = [mercadoPreClaim, braintreePreClaim, stripePreClaim, merchantHostedPreClaim, fiservPreClaim, gmoPreClaim, cybersourceFlexPreClaim];
 /** 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

@@ -2293,6 +2293,64 @@
       "hostname_pattern": "^p01\\.mul-pay\\.jp$",
       "pathname_pattern": "^\\/link\\/"
     },
+    {
+      "id": "cybersource-flex-microform-script",
+      "psp": "cybersource_flex",
+      "kinds": [
+        "script"
+      ],
+      "origin": "https://flex.cybersource.com",
+      "path_pattern": "/microform/bundle/v2{,.:minor.:patch}/flex-microform.min.js",
+      "sources": [
+        {
+          "kind": "primary_source",
+          "reference": "https://flex.cybersource.com/microform/bundle/v2.12.1/flex-microform.min.js",
+          "reviewed_on": "2026-09-23"
+        },
+        {
+          "kind": "primary_source",
+          "reference": "https://flex.cybersource.com/microform/bundle/v2.12.1/iframe.min.js",
+          "reviewed_on": "2026-09-23"
+        },
+        {
+          "kind": "official_documentation",
+          "reference": "https://developer.cybersource.com/docs/cybs/en-us/digital-accept-flex-api/developer/ctv/rest/flex-api/microform-integ-v2/microform-integ-getting-started-v2/creating-server-side-context-v2.html",
+          "reviewed_on": "2026-09-23"
+        }
+      ],
+      "hostname_pattern": "^flex\\.cybersource\\.com$",
+      "pathname_pattern": "^\\/microform\\/bundle\\/v2(?:\\.[0-9]+\\.[0-9]+)?\\/flex-microform\\.min\\.js$"
+    },
+    {
+      "id": "cybersource-flex-microform-field",
+      "psp": "cybersource_flex",
+      "kinds": [
+        "frame",
+        "iframe",
+        "document"
+      ],
+      "origin": "https://flex.cybersource.com",
+      "path_pattern": "/microform/bundle/v:version/iframe.html",
+      "sources": [
+        {
+          "kind": "primary_source",
+          "reference": "https://flex.cybersource.com/microform/bundle/v2.12.1/flex-microform.min.js",
+          "reviewed_on": "2026-09-23"
+        },
+        {
+          "kind": "primary_source",
+          "reference": "https://flex.cybersource.com/microform/bundle/v2.12.1/iframe.min.js",
+          "reviewed_on": "2026-09-23"
+        },
+        {
+          "kind": "official_documentation",
+          "reference": "https://developer.cybersource.com/docs/cybs/en-us/digital-accept-flex-api/developer/ctv/rest/flex-api/microform-integ-v2/microform-integ-getting-started-v2/creating-server-side-context-v2.html",
+          "reviewed_on": "2026-09-23"
+        }
+      ],
+      "hostname_pattern": "^flex\\.cybersource\\.com$",
+      "pathname_pattern": "^\\/microform\\/bundle\\/v2\\.[0-9]+\\.[0-9]+\\/iframe\\.html$"
+    },
     {
       "id": "gmo-mp-token-script-test",
       "psp": "gmo_pg",
@@ -2383,6 +2441,64 @@
       "hostname_pattern": "^pt01\\.mul-pay\\.jp$",
       "pathname_pattern": "^\\/link\\/"
     },
+    {
+      "id": "cybersource-flex-microform-script-test",
+      "psp": "cybersource_flex",
+      "kinds": [
+        "script"
+      ],
+      "origin": "https://testflex.cybersource.com",
+      "path_pattern": "/microform/bundle/v2{,.:minor.:patch}/flex-microform.min.js",
+      "sources": [
+        {
+          "kind": "primary_source",
+          "reference": "https://flex.cybersource.com/microform/bundle/v2.12.1/flex-microform.min.js",
+          "reviewed_on": "2026-09-23"
+        },
+        {
+          "kind": "primary_source",
+          "reference": "https://flex.cybersource.com/microform/bundle/v2.12.1/iframe.min.js",
+          "reviewed_on": "2026-09-23"
+        },
+        {
+          "kind": "official_documentation",
+          "reference": "https://developer.cybersource.com/docs/cybs/en-us/digital-accept-flex-api/developer/ctv/rest/flex-api/microform-integ-v2/microform-integ-getting-started-v2/creating-server-side-context-v2.html",
+          "reviewed_on": "2026-09-23"
+        }
+      ],
+      "hostname_pattern": "^testflex\\.cybersource\\.com$",
+      "pathname_pattern": "^\\/microform\\/bundle\\/v2(?:\\.[0-9]+\\.[0-9]+)?\\/flex-microform\\.min\\.js$"
+    },
+    {
+      "id": "cybersource-flex-microform-field-test",
+      "psp": "cybersource_flex",
+      "kinds": [
+        "frame",
+        "iframe",
+        "document"
+      ],
+      "origin": "https://testflex.cybersource.com",
+      "path_pattern": "/microform/bundle/v:version/iframe.html",
+      "sources": [
+        {
+          "kind": "primary_source",
+          "reference": "https://flex.cybersource.com/microform/bundle/v2.12.1/flex-microform.min.js",
+          "reviewed_on": "2026-09-23"
+        },
+        {
+          "kind": "primary_source",
+          "reference": "https://flex.cybersource.com/microform/bundle/v2.12.1/iframe.min.js",
+          "reviewed_on": "2026-09-23"
+        },
+        {
+          "kind": "official_documentation",
+          "reference": "https://developer.cybersource.com/docs/cybs/en-us/digital-accept-flex-api/developer/ctv/rest/flex-api/microform-integ-v2/microform-integ-getting-started-v2/creating-server-side-context-v2.html",
+          "reviewed_on": "2026-09-23"
+        }
+      ],
+      "hostname_pattern": "^testflex\\.cybersource\\.com$",
+      "pathname_pattern": "^\\/microform\\/bundle\\/v2\\.[0-9]+\\.[0-9]+\\/iframe\\.html$"
+    },
     {
       "id": "square-web-sdk-sandbox",
       "psp": "square",

package/dist/preflight-schemas.json

@@ -473,10 +473,14 @@
                 "gmo-token-v1-script",
                 "gmo-elements-card-frame",
                 "gmo-link-hosted-page",
+                "cybersource-flex-microform-script",
+                "cybersource-flex-microform-field",
                 "gmo-mp-token-script-test",
                 "gmo-token-v1-script-test",
                 "gmo-elements-card-frame-test",
                 "gmo-link-hosted-page-test",
+                "cybersource-flex-microform-script-test",
+                "cybersource-flex-microform-field-test",
                 "square-web-sdk-sandbox",
                 "paysafe-js-test",
                 "worldpay-checkout-sdk-try",
@@ -1010,10 +1014,14 @@
                       "gmo-token-v1-script",
                       "gmo-elements-card-frame",
                       "gmo-link-hosted-page",
+                      "cybersource-flex-microform-script",
+                      "cybersource-flex-microform-field",
                       "gmo-mp-token-script-test",
                       "gmo-token-v1-script-test",
                       "gmo-elements-card-frame-test",
                       "gmo-link-hosted-page-test",
+                      "cybersource-flex-microform-script-test",
+                      "cybersource-flex-microform-field-test",
                       "square-web-sdk-sandbox",
                       "paysafe-js-test",
                       "worldpay-checkout-sdk-try",

package/dist/preflight.generated.js

@@ -1,5 +1,5 @@
 // Generated from @agent-cards/payment-core. Do not edit.
-// source-sha256: 667b42af10e827f2c772927b1ff5491e5775a7d6b397ca72c8ddd093cdce2005
+// source-sha256: 3a36f98936b5a93687dd4a052d1d4513935a093736b19475f023b5a0847c6b4a
 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';
@@ -86,12 +86,26 @@ RULES.push({ id: 'gmo-mp-token-script', psp: 'gmo_pg', kinds: ['script'], hostna
     variant_unverified: 'GMO Elements takes the card in GMO\'s own iframes and encrypts it under a merchant-registered key; it is not admitted.' }, { id: 'gmo-link-hosted-page', psp: 'gmo_pg', kinds: ['document', 'frame', 'iframe', 'form'], hostname: /^p01\.mul-pay\.jp$/, pathname: /^\/link\//, origin: 'https://p01.mul-pay.jp', path_pattern: '/link/*',
     sources: [{ kind: 'official_documentation', reference: 'https://docs.gmo-pg.com/mulpay/docs/developer-support/test-environment/overview', reviewed_on: '2026-09-25' }],
     variant_unverified: 'A GMO Link-type payment page takes the card on GMO\'s own hosted page; it is not admitted.' });
+// CyberSource Flex Microform v2 (dark: its processor declares a capability, so the bundled
+// catalog does not list it and these signals stay unknown until a client opts in). The loader
+// is served as /microform/bundle/v2/ and v2.x.y/; each card field is its own iframe document.
+// Sources: the reviewed v2.12.1 bundles (loader sha256 32151372...32f6, field iframe 8429ebae...8327).
+const cybersourceSources = [
+    { kind: 'primary_source', reference: 'https://flex.cybersource.com/microform/bundle/v2.12.1/flex-microform.min.js', reviewed_on: '2026-09-23' },
+    { kind: 'primary_source', reference: 'https://flex.cybersource.com/microform/bundle/v2.12.1/iframe.min.js', reviewed_on: '2026-09-23' },
+    { kind: 'official_documentation', reference: 'https://developer.cybersource.com/docs/cybs/en-us/digital-accept-flex-api/developer/ctv/rest/flex-api/microform-integ-v2/microform-integ-getting-started-v2/creating-server-side-context-v2.html', reviewed_on: '2026-09-23' },
+];
+RULES.push({ id: 'cybersource-flex-microform-script', psp: 'cybersource_flex', kinds: ['script'], hostname: /^flex\.cybersource\.com$/, pathname: /^\/microform\/bundle\/v2(?:\.[0-9]+\.[0-9]+)?\/flex-microform\.min\.js$/, origin: 'https://flex.cybersource.com', path_pattern: '/microform/bundle/v2{,.:minor.:patch}/flex-microform.min.js',
+    sources: cybersourceSources }, { id: 'cybersource-flex-microform-field', psp: 'cybersource_flex', kinds: ['frame', 'iframe', 'document'], hostname: /^flex\.cybersource\.com$/, pathname: /^\/microform\/bundle\/v2\.[0-9]+\.[0-9]+\/iframe\.html$/, origin: 'https://flex.cybersource.com', path_pattern: '/microform/bundle/v:version/iframe.html',
+    sources: cybersourceSources });
 // Keep sandbox evidence truthful instead of labelling it with a production origin.
 for (const [baseId, suffix, hostname, origin] of [
     ['gmo-mp-token-script', 'test', /^stg\.static\.mul-pay\.jp$/, 'https://stg.static.mul-pay.jp'],
     ['gmo-token-v1-script', 'test', /^stg\.static\.mul-pay\.jp$/, 'https://stg.static.mul-pay.jp'],
     ['gmo-elements-card-frame', 'test', /^stg\.static\.mul-pay\.jp$/, 'https://stg.static.mul-pay.jp'],
     ['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'],
     ['square-web-sdk', 'sandbox', /^sandbox\.web\.squarecdn\.com$/, 'https://sandbox.web.squarecdn.com'],
     ['paysafe-js', 'test', /^hosted\.test\.paysafe\.com$/, 'https://hosted.test.paysafe.com'],
     ['worldpay-checkout-sdk', 'try', /^try\.access\.worldpay\.com$/, 'https://try.access.worldpay.com'],

package/dist/prepared-processor.d.ts

@@ -1,4 +1,4 @@
-export type PreparationProcessor = 'square' | 'braintree' | 'worldpay' | 'bambora' | 'mercado_pago' | 'recurly' | 'spreedly' | 'adyen' | 'checkout_com' | 'paysafe' | 'fiserv';
+export type PreparationProcessor = 'square' | 'braintree' | 'worldpay' | 'bambora' | 'mercado_pago' | 'recurly' | 'spreedly' | 'adyen' | 'checkout_com' | 'paysafe' | 'fiserv' | 'cybersource_flex';
 export type PreparationEnvironment = 'production' | 'sandbox' | 'shared';
 /**
  * How the approved card reaches the processor: the device's own request (token), or
@@ -10,7 +10,9 @@ export declare function preparationMode(psp: string): PreparationMode;
 /**
  * Shared endpoint processors cannot attest test/live mode from their URL or key prefix.
  * Adyen can: test and live are separate hosts and key prefixes. Fiserv's are separate
- * hosts too: connect (production) and connect-cert (sandbox).
+ * hosts too: connect (production) and connect-cert (sandbox). So are CyberSource
+ * Flex's: flex.cybersource.com is live, testflex.cybersource.com is test, and each has
+ * its own signing keys.
  */
 export declare function validPreparationEnvironment(psp: string, environment: string): boolean;
 export declare function preparationEndpoint(psp: PreparationProcessor, environment: PreparationEnvironment): string;