@agent-cards/sdk 0.20.0 → 0.22.0

package/dist/pre-claim.js

@@ -3,9 +3,24 @@
 // 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, CyberSource Flex Microform's field iframes (whose
+// capture context rides into the pause), Datatrans Secure Fields, whose
+// card URL also carries card posts the device could never fill and card posts
+// it already answered, and Pelecard's card submission URL, which also carries
+// saved-token, wallet and keep-on-file bodies, Primer's
+// /payment-instruments, which also carries requests the vault can never pay,
+// Payrails, whose save needs the session key the page captured and whose
+// hosts also carry card payments the vault can never pay, and Elavon
+// Converge's hpp/process URL, which also carries wallet, debit, follow-up and
+// card-saving bodies, WSPay's confirm URL, which also carries bodies with
+// no new card, and Shiji STS's getTokenId and getCvvId, which also carry
+// requests the vault must never pay.
+// 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.
+// Juspay's tokenize and /txns joined later as one more entry.
 //
 // 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 +53,24 @@
 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 { JUSPAY_PSP } from './juspay-gate.js';
+import { datatransPauseDecision, isDatatransHost } from './datatrans.js';
+import { DATATRANS_INVALID_REQUEST } from './datatrans.generated.js';
+import { isPelecardHost, pelecardRefusal } from './pelecard.js';
+import { ACI_CHECKOUT_REUSED } from './aci.js';
+import { ACI_EXPIRY_UNSTRIPPABLE } from './aci.generated.js';
+import { CREDITGUARD_PPS_HOSTS, classifyCreditguardRequest, creditguardNuveiRefusal, creditguardProcessRefusal } from './creditguard.generated.js';
+import { isPrimerPciHost, primerRequestVerdict } from './primer.js';
+import { convergeRefusal, isConvergeHost } from './elavon-converge.js';
+import { isWspayHost, wspayRefusal } from './wspay.js';
+import { isShijiStsHost, shijiStsVerdict } from './shiji-sts.js';
 import { classifyProfileRequest, merchantBodyKeyPathSha256, profileTemplatedUrl } from './merchant-hosted.js';
 import { isFiservCaptureHost, isFiservPausableBody } from './fiserv.js';
+import { CYBERSOURCE_FLEX_PSP, isCybersourceFlexHost } from './cybersource-flex.js';
+import { cardEndpointDetail, cardEndpointFor, cardEndpointLive } from './card-endpoint.js';
+import { PAYRAILS_HOLDING_REASONS, PAYRAILS_SESSION_MESSAGE, isPayrailsHost, isPayrailsStaticHost, payrailsKeyRefusal, payrailsRequestKind, payrailsSaveRefusal, } from './payrails.js';
+import { classifyVerifoneProfileRequest, verifoneTemplatedUrl } from './verifone.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
@@ -55,8 +86,40 @@ export function eventUrl(vault, url) {
         }
         catch { /* not a profile this build reviewed */ }
     }
+    // A Verifone merchant's origin: its origin and, for a leg, the leg's path template (verifone.ts).
+    const verifone = typeof vault?.verifoneProfileOf === 'function' ? vault.verifoneProfileOf(url) : null;
+    if (verifone) {
+        try {
+            return verifoneTemplatedUrl(verifone.id, url);
+        }
+        catch { /* not a profile this build reviewed */ }
+    }
     return redactUrl(url);
 }
+// A reviewed merchant's own card endpoint (card-endpoint.ts). It runs first: its URLs
+// are merchant origins no processor gate claims, and one never reaches another gate. A
+// POST that is exactly a profile's card request pauses for the claim flow, carrying the
+// profile, when this build's copy of the profile takes payments. In any other status
+// (observe, a fact only a HAR can pin, no reviewed HAR, a recurring charge) it aborts as
+// an unsupported checkout, synchronously and before any create, so the placeholder card
+// never reaches the merchant; the event names the profile and the endpoint origin, never
+// the URL's path or query, which carry the merchant's cart and booking ids. Anything
+// else, a GET or a CORS preflight to the same URL included, defers.
+const cardEndpointPreClaim = (ctx) => {
+    const profile = cardEndpointFor(ctx.request.url, ctx.request.method);
+    if (!profile)
+        return undefined;
+    if (cardEndpointLive(profile))
+        return { kind: 'pause', stripeStep: null, cardEndpoint: profile };
+    return cardEndpointUnsupported(ctx, profile);
+};
+async function cardEndpointUnsupported(ctx, 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' } });
+    await ctx.effects.abort();
+    return { kind: 'abort' };
+}
 // Mercado Pago's native Checkout Pro shares one origin between its BIN-lookup
 // configuration and its card association. A request that is not for that origin
 // defers synchronously; a POST to it is handled asynchronously (a document read
@@ -104,10 +167,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')
@@ -285,6 +353,71 @@ async function merchantHostedUnsupported(ctx, profile, url, category, reason) {
     await ctx.effects.abort();
     return { kind: 'abort' };
 }
+// Verifone merchants (verifone.ts). A request to an armed Verifone profile's endpoint origin is
+// the profile's to judge before the terminal arbiter, which would otherwise continue it (no
+// processor recognizes a merchant's own server). verifone.js sends the card, encrypted in the
+// page, in the merchant's own requests, so every request to that origin is read:
+//   - no verifone.js blob (a basket query, a GET, a preflight, a page load, a request with no
+//     body at all): defer, and the request is judged as it was before any profile existed. The
+//     profile arms the merchant's whole origin, where a bodiless POST or DELETE (a session
+//     refresh, a cart edit, an empty beacon) is routine, so only a body the adapter could not read
+//     counts as unread, never a missing one;
+//   - a body the adapter knows is there and could not read (CDP: a blob or a file), on anything
+//     but a GET, HEAD or OPTIONS: not proven to carry no card, so it is judged as a card body the
+//     profile cannot finish, as for a merchant-hosted profile. Playwright reports such a body as
+//     no body (PreClaimContext.request), so only attachToCdp refuses it;
+//   - a card request to a profile this attachment already handed a card to: the page's retry
+//     carries the agent's placeholder and the approval is spent, so it aborts;
+//   - a profile in observe: report the request's shape (the SHA-256 of its key paths, never a
+//     value) with the verdict, then abort as unsupported, so the placeholder never reaches the
+//     merchant and no authorization exists;
+//   - a blob the profile cannot pay (a BIN lookup, a gift card, a saved card's CVV, a second
+//     card entry, a key nobody reviewed, a body the leg did not review): abort as unsupported,
+//     with the reason;
+//   - the reviewed leg, on an enabled profile, with no preparation on this attachment: abort as
+//     preparation_required before any pause, prompt or authorization;
+//   - the same request with a preparation: pause for the claim flow, where only a ready
+//     preparation for this profile pays it.
+// A reader that throws on the body is not proof it carries no card either: the request is judged
+// as an unreadable card body and aborted. Synchronous until it must abort, like every gate.
+export const verifonePreClaim = (ctx) => {
+    const { url, method } = ctx.request;
+    const profile = typeof ctx.vault.verifoneProfileOf === 'function' ? ctx.vault.verifoneProfileOf(url) : null;
+    if (!profile)
+        return undefined;
+    const body = ctx.request.body;
+    const unread = body === null;
+    let verdict;
+    try {
+        verdict = !unread ? classifyVerifoneProfileRequest(profile, url, method, body)
+            : UNREAD_BODY_METHODS.has(String(method).toUpperCase()) ? { verdict: 'pass' } : { verdict: 'abort', reason: MERCHANT_BODY_UNREADABLE };
+    }
+    catch {
+        verdict = { verdict: 'abort', reason: MERCHANT_BODY_UNREADABLE };
+    }
+    if (verdict.verdict === 'pass')
+        return undefined;
+    const templated = verifoneTemplatedUrl(profile.id, url);
+    if (ctx.merchantHandoff?.retried(profile.id))
+        return merchantHostedAbort(ctx);
+    if (profile.status !== 'enabled') {
+        ctx.onEvent?.({ type: 'verifone_profile_observed', detail: { profile: profile.id, url: templated, method, verdict: verdict.verdict,
+                ...(verdict.verdict === 'abort' ? { reason: verdict.reason } : {}), keyPathSha256: unread ? null : keyPathSha256Of(body) } });
+        return verifoneUnsupported(ctx, profile.id, templated, 'merchant_profile_observe', 'Agentcard has not turned on payments to this merchant yet');
+    }
+    if (verdict.verdict === 'abort')
+        return verifoneUnsupported(ctx, profile.id, templated, 'merchant_request_unsupported', verdict.reason);
+    if (!ctx.preparationGate.isEngaged())
+        return merchantHostedPreparationRequired(ctx);
+    return { kind: 'pause', stripeStep: ctx.stripeStep };
+};
+async function verifoneUnsupported(ctx, profile, url, category, reason) {
+    ctx.preparationGate.invalidate('unsupported_checkout');
+    ctx.lifecycle.unsupported(category);
+    ctx.onEvent?.({ type: 'unsupported_checkout', detail: { url, method: ctx.request.method, profile, reason } });
+    await ctx.effects.abort();
+    return { kind: 'abort' };
+}
 // Fiserv Commerce Hub card capture (fiserv.ts). A POST the registry recognizes on
 // one of Fiserv's two card-capture hosts is this gate's to judge before any claim:
 //   - only a capture that carries no Vault card (Fastlane's PaymentToken, ACH's
@@ -311,10 +444,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 +469,848 @@ 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' };
+}
+// Juspay Express Checkout (juspay-gate.ts; payment-core juspay.js holds the
+// rules). While the attachment serves the Juspay recognizer, every request to a
+// Juspay host is this gate's: the terminal arbiter would continue the page's
+// placeholder tokenize (no recognizer names it) and pause any /txns.
+//   - answer_tokenize: the placeholder tokenize is answered here with a
+//     synthetic token, remembered for the /txns that follows. Nothing reaches
+//     Juspay. The answer runs inside the gate's own try, so a failed fulfill
+//     forgets the token and aborts the request; an attachment that is not
+//     ready, was cancelled or has latched a terminal failure answers nothing.
+//   - pause: the /txns on a token this attachment issued, in the reviewed
+//     shape. Synchronous, so the claim flow still sets activeRequest in the
+//     paused request's own microtask.
+//   - continue: a request that carries no card of the vault's (net banking,
+//     UPI, a saved card, the bank's pay/start redirect, a preflight, a read).
+//   - abort, this request only: the placeholder's fingerprint lookup (the page
+//     carries on without it), a /txns on a synthetic token this attachment
+//     never issued, and a body the adapter could not read.
+//   - abort as unsupported: every other card-bearing request (save card, EMI,
+//     a direct card, a sibling host), before any authorization, holding the
+//     attachment the way an unrecognized payment endpoint does.
+const JUSPAY_REFUSED_ALONE = new Set(['placeholder_fingerprint', 'unknown_synthetic_token', 'request_body_unreadable']);
+const juspayPreClaim = (ctx) => {
+    const gate = ctx.juspay;
+    const decision = gate?.classify(ctx.request);
+    if (!gate || !decision)
+        return undefined;
+    if (decision.decision === 'pause')
+        return { kind: 'pause', stripeStep: ctx.stripeStep };
+    if (decision.decision === 'answer_tokenize')
+        return juspayAnswer(ctx, gate, decision.host, decision.merchantId);
+    if (decision.decision === 'continue')
+        return juspayContinue(ctx);
+    return JUSPAY_REFUSED_ALONE.has(decision.reason) ? juspayRefuse(ctx, decision.reason) : juspayUnsupported(ctx, decision.reason);
+};
+async function juspayAnswer(ctx, gate, host, merchantId) {
+    if (!ctx.attachmentReady() || ctx.interceptionAborted() || ctx.lifecycleAborted() || ctx.terminal()) {
+        ctx.onEvent?.({ type: 'blocked', detail: 'checkout_interception_not_ready' });
+        await ctx.effects.abort();
+        return { kind: 'abort' };
+    }
+    const { token, response } = gate.issue(host, merchantId);
+    try {
+        await ctx.effects.answer(response);
+    }
+    catch {
+        gate.forget(token);
+        ctx.onEvent?.({ type: 'blocked', detail: 'juspay_tokenize_answer_failed' });
+        await ctx.effects.abort();
+        return { kind: 'abort' };
+    }
+    ctx.onEvent?.({ type: 'checkout_prepared', detail: { processor: JUSPAY_PSP } });
+    return { kind: 'answer' };
+}
+async function juspayContinue(ctx) {
+    await ctx.effects.continueRequest().catch(() => { });
+    return { kind: 'continue' };
+}
+async function juspayRefuse(ctx, reason) {
+    ctx.onEvent?.({ type: 'blocked', detail: `juspay_${reason}` });
+    await ctx.effects.abort();
+    return { kind: 'abort' };
+}
+async function juspayUnsupported(ctx, reason) {
+    const { url, method } = ctx.request;
+    ctx.preparationGate.invalidate('unsupported_checkout');
+    ctx.lifecycle.unsupported('juspay_request_unsupported');
+    ctx.onEvent?.({ type: 'unsupported_checkout', detail: { url: redactUrl(url), method, processor: JUSPAY_PSP, reason } });
+    await ctx.effects.abort();
+    return { kind: 'abort' };
+}
+// Datatrans Secure Fields (datatrans.ts). The card-number iframe's card URL also takes posts the
+// device could never fill, and British Airways's page submits the same form again on every blur
+// and expiry change, so a POST the registry recognizes on a Datatrans pay host is judged here,
+// before the terminal arbiter would pause it, by payment-core's own pause decision under the
+// card-on-file policy the API served with the recognizer (VaultClient.cardOnFilePolicy):
+//   - a sound TOKENIZE card post defers, and the arbiter pauses it for approval, unless the same
+//     frame's same form was already answered with an approved token (the repeat rule) and that
+//     approval is still the one being handed off (datatransRepeatApproval): then that stored answer
+//     is fulfilled here, with no claim, create or prompt. Once the answer reached the page, the
+//     application's merchant resolver must first report the order still pending
+//     (datatransRepeatAfterHandoff);
+//   - a card post the API would refuse at create aborts with a `blocked` event that names the
+//     API's own code, `invalid_datatrans_request` or `datatrans_card_on_file_refused` (the latter
+//     only while the served policy refuses card on file), before anything is claimed, created or
+//     prompted. Like Braintree's unsupported operation it neither holds the attachment nor changes
+//     its state, so the page's next post is judged afresh;
+//   - a post with no card number (a wallet, bank-account or CVV-only post) defers, and continues
+//     untouched through the recognizer's passWithoutCard.
+// Nothing is decided without the registry: an SDK the API did not serve the datatrans recognizer
+// never recognizes a pay host, so the gate defers and every Datatrans request continues as before.
+// paymentField/cardInfo (the BIN lookup) and the iframe documents are not card requests and never
+// reach it. Synchronous until an effect, so a card post pauses with no await. A check that throws
+// blocks the request as invalid rather than letting it reach a prompt.
+const datatransPreClaim = (ctx) => {
+    const { url, method } = ctx.request;
+    if (method.toUpperCase() !== 'POST' || !isDatatransHost(url) || !ctx.vault.isCardRequest(url, method))
+        return undefined;
+    let decision;
+    try {
+        decision = datatransPauseDecision({ url, headers: ctx.request.headers, body: ctx.request.body }, ctx.vault.cardOnFilePolicy?.(url, method));
+    }
+    catch {
+        decision = DATATRANS_INVALID_REQUEST;
+    }
+    if (decision === null)
+        return undefined;
+    if (decision !== 'card')
+        return datatransBlock(ctx, decision);
+    const approval = datatransRepeatApproval(ctx);
+    const repeat = approval === null ? null : ctx.datatrans?.answerFor(ctx.frame, url, ctx.request.body, approval) ?? null;
+    if (!repeat)
+        return undefined;
+    return ctx.lifecycle.getState().status === 'awaiting_merchant' ? datatransRepeatAfterHandoff(ctx, repeat) : datatransRepeat(ctx, repeat);
+};
+/**
+ * The approval whose stored Datatrans answer a repeat may still receive, or null. A stored token
+ * answers a re-submit only while the approval it came from is still being handed off: the lifecycle
+ * names it and reads awaiting_approval (its answer is being delivered) or awaiting_merchant (the
+ * merchant has not confirmed yet), and nothing latched, tore down or cancelled the attachment. The
+ * order completing or failing, an unknown outcome, a decline, a hold for the cardholder, a retry
+ * after a merchant failure and a new authorization all end it, and the re-submit is then a new
+ * question for the terminal arbiter, which holds or pauses it like any card post: TOKENIZE binds no
+ * amount, so one approval never answers for a later purchase. Once the answer reached the page
+ * (awaiting_merchant), the gate also reconciles before it answers (datatransRepeatAfterHandoff), and
+ * the stored answer itself ends once its form goes quiet (DatatransRepeats, DATATRANS_REPEAT_IDLE_MS).
+ */
+function datatransRepeatApproval(ctx) {
+    if (ctx.terminal() || ctx.interceptionAborted() || ctx.lifecycleAborted())
+        return null;
+    const { status, authorizationId } = ctx.lifecycle.getState();
+    return status === 'awaiting_approval' || status === 'awaiting_merchant' ? authorizationId : null;
+}
+/**
+ * A re-submit after the approved answer reached the page. The merchant can already hold an order paid
+ * with that token, and the post names no amount and no order, so nothing in the browser tells the same
+ * checkout's re-submit from a later purchase in the same form. The gate asks the application's merchant
+ * resolver first (lifecycle.merchantOrderPending()), and the stored answer goes out only while the
+ * resolver reports this approval's order still pending and the checkout still awaits the merchant for
+ * it. A completed, failed or unknown order, a resolver that throws or has not answered within
+ * MERCHANT_ORDER_READ_MS, and a request in flight make the re-submit a new question for the terminal
+ * arbiter, and so does every re-submit on an attachment with no resolver: a later purchase never
+ * receives an earlier token without the cardholder, and the paused post never waits on a stalled read.
+ */
+function datatransRepeatAfterHandoff(ctx, repeat) {
+    if (!ctx.lifecycle.hasMerchantResolver())
+        return undefined;
+    return datatransPendingRepeat(ctx, repeat);
+}
+async function datatransPendingRepeat(ctx, repeat) {
+    if (!await ctx.lifecycle.merchantOrderPending())
+        return undefined;
+    // The resolver answered asynchronously: the checkout must still be handing off this approval.
+    if (ctx.lifecycle.getState().status !== 'awaiting_merchant' || datatransRepeatApproval(ctx) !== repeat.authorizationId)
+        return undefined;
+    return datatransRepeat(ctx, repeat);
+}
+async function datatransBlock(ctx, reason) {
+    ctx.onEvent?.({ type: 'blocked', detail: reason });
+    await ctx.effects.abort();
+    return { kind: 'abort' };
+}
+async function datatransRepeat(ctx, repeat) {
+    try {
+        await ctx.effects.answer(repeat.response);
+    }
+    catch {
+        ctx.onEvent?.({ type: 'blocked', detail: 'datatrans_repeat_unanswered' });
+        await ctx.effects.abort();
+        return { kind: 'abort' };
+    }
+    ctx.onEvent?.({ type: 'repeat_answered', detail: { psp: 'datatrans', authorizationId: repeat.authorizationId } });
+    return { kind: 'answer' };
+}
+// Pelecard Iframe/Redirect 2.0 (pelecard.ts). The payment page's card URL, POST
+// /PaymentGW/Transaction on gateway21 or gateway20.pelecard.biz, also carries the wallet, Bit,
+// PIN pad and bank tabs with no card, and card-shaped bodies the device could never fill: a saved
+// token, a card track, a phone authorization, installments, a buyer-typed total. So a POST the
+// registry recognizes on a Pelecard host that carries a card is judged here, before the terminal
+// arbiter would pause it, by the whole-request check the API runs at create:
+//   - the page's own one-time new-card submission defers, and the arbiter pauses it for approval;
+//   - anything else aborts with a `blocked` event that names why, with no claim, create or
+//     prompt: `invalid_pelecard_request`, or `pelecard_keep_on_file_unsupported` for a
+//     submission that asks Pelecard to keep the card on file. Like Braintree's unsupported
+//     operation it neither holds the attachment nor changes its state, so the page's next
+//     submission (the buyer unticks "save my card") is judged afresh.
+// A body with no card defers too, and the adapter continues it untouched in every state
+// (passWithoutCard); so does a body the adapter could not read, which the adapter fails on its
+// own as unreadable, that request only. Nothing is decided without the registry: an SDK that did
+// not sync with the pelecard_transaction capability, or whose org Agentcard has not enabled for
+// Pelecard (the API then serves no pelecard recognizer), never recognizes a Pelecard host, so the
+// gate defers and the request continues as before. Synchronous until the abort, so a card
+// submission pauses with no await. A check that throws blocks the request as invalid rather than
+// letting it reach a prompt.
+const pelecardPreClaim = (ctx) => {
+    const { url, method } = ctx.request;
+    if (method.toUpperCase() !== 'POST' || !isPelecardHost(url) || !ctx.vault.isCardRequest(url, method))
+        return undefined;
+    if (ctx.request.body == null || ctx.vault.withoutCard?.(url, ctx.request.body) === 'continue')
+        return undefined;
+    let reason;
+    try {
+        reason = pelecardRefusal({ url, headers: ctx.request.headers, body: ctx.request.body });
+    }
+    catch {
+        reason = 'invalid_pelecard_request';
+    }
+    return reason === null ? undefined : pelecardBlock(ctx, reason);
+};
+async function pelecardBlock(ctx, reason) {
+    ctx.onEvent?.({ type: 'blocked', detail: reason });
+    await ctx.effects.abort();
+    return { kind: 'abort' };
+}
+// ACI COPYandPAY, once the registry serves it (a synced build that declares its
+// capability); for every other client the gate defers on everything, so nothing
+// changes. On a POST to one of ACI's checkouts (aci.ts, payment-core aci.js):
+//   - the card-number request defers to the arbiter, which pauses it for the
+//     vault claim flow (a prepared checkout only: an unprepared one is refused
+//     there with PreparationRequiredError before any create), unless its
+//     checkout's card-number request is running or was answered here: that one
+//     is refused as aci_checkout_reused before it claims anything;
+//   - the page's CVC and expiry requests are held until that request's
+//     approval ends, then answered with its answer, never forwarded; they fail
+//     when it failed or never began;
+//   - the holder request continues untouched;
+//   - the /payment submission continues once per answered card-number request,
+//     as a frame navigation, with the placeholder expiry a classic-mode page
+//     puts there removed (only where the browser sends a replaced navigation
+//     body, else aci_expiry_unstrippable), or is refused with the judge's code;
+//   - anything else is refused with payment-core's code: a request that asks ACI
+//     to keep the card or pay with a stored one (aci_card_on_file_refused, which
+//     also retires a ready preparation) or one the widget never sends.
+// Everything else on ACI's hosts (the widget script, /bins, /v1/collect, GETs)
+// is not a POST to a checkout and defers. Synchronous for the card-number
+// request, so it pauses in the microtask it paused in.
+const aciPreClaim = (ctx) => {
+    const leg = ctx.aci?.classify(ctx.request.url, ctx.request.method, ctx.request.body);
+    if (!leg)
+        return undefined;
+    if (leg.leg === 'refuse') {
+        ctx.aci.refused(leg);
+        return aciRefuse(ctx, leg.code);
+    }
+    if (leg.leg === 'pass')
+        return aciContinue(ctx);
+    if (leg.leg === 'absorb')
+        return aciHold(ctx, leg);
+    if (leg.leg === 'continuation')
+        return aciPayment(ctx);
+    // The card-number request: the arbiter pauses it for the vault claim flow,
+    // unless this checkout already has one running or answered (AciGate.begin).
+    if (ctx.aci.reused(leg))
+        return aciRefuse(ctx, ACI_CHECKOUT_REUSED);
+    return undefined;
+};
+async function aciContinue(ctx) {
+    await ctx.effects.continueRequest().catch(() => { });
+    return { kind: 'continue' };
+}
+async function aciHold(ctx, leg) {
+    const answer = await ctx.aci.hold(leg);
+    if (answer && !ctx.interceptionAborted() && !ctx.lifecycleAborted()) {
+        try {
+            await ctx.effects.answer(answer);
+            ctx.onEvent?.({ type: 'aci_leg_absorbed', detail: { url: redactUrl(ctx.request.url) } });
+            return { kind: 'answer' };
+        }
+        catch { /* the page's request is gone; nothing was forwarded */ }
+    }
+    ctx.onEvent?.({ type: 'blocked', detail: 'aci_leg_unanswered' });
+    await ctx.effects.abort();
+    return { kind: 'abort' };
+}
+async function aciPayment(ctx) {
+    const { url, method, body } = ctx.request;
+    const stopped = () => ctx.interceptionAborted() || ctx.lifecycleAborted() || ctx.terminal();
+    let verdict = stopped() ? { outcome: 'refuse', code: 'checkout_interception_not_ready' }
+        : ctx.aci.payment(url, method, body, { navigation: ctx.request.navigation === true });
+    // A classic-mode body continues only where the replaced body is known to
+    // reach ACI on a navigation; elsewhere the placeholder expiry would, so it is
+    // refused and the reservation stays taken. That check can wait on the
+    // browser, so the stop conditions are read again after it.
+    if (verdict.outcome === 'continue' && verdict.stripped && !(await replacesNavigationBody(ctx))) {
+        verdict = { outcome: 'refuse', code: ACI_EXPIRY_UNSTRIPPABLE };
+    }
+    if (verdict.outcome === 'continue' && stopped())
+        verdict = { outcome: 'refuse', code: 'checkout_interception_not_ready' };
+    if (verdict.outcome === 'refuse') {
+        ctx.onEvent?.({ type: 'blocked', detail: verdict.code });
+        await ctx.effects.abort();
+        return { kind: 'abort' };
+    }
+    // A classic-mode body continues with the placeholder expiry taken out; an
+    // untouched one continues exactly as the page sent it. The reservation stays
+    // taken either way, so a failed continue is never followed by a second post.
+    try {
+        await ctx.effects.continueRequest(verdict.stripped ? verdict.body : undefined);
+    }
+    catch {
+        ctx.onEvent?.({ type: 'blocked', detail: 'aci_payment_unsent' });
+        return { kind: 'continue' };
+    }
+    ctx.onEvent?.({ type: 'aci_payment_continued', detail: { authorizationId: verdict.authorizationId, stripped: verdict.stripped } });
+    return { kind: 'continue' };
+}
+/** Whether this browser sends the body the SDK replaced on a navigation; an absent or failing answer is no. */
+async function replacesNavigationBody(ctx) {
+    try {
+        return (await ctx.replacesNavigationBody?.()) === true;
+    }
+    catch {
+        return false;
+    }
+}
+async function aciRefuse(ctx, code) {
+    // A card that may not be kept on file can never pay this checkout: a ready
+    // preparation is retired with that reason rather than left to expire.
+    if (code === 'aci_card_on_file_refused')
+        ctx.preparationGate.invalidate(code);
+    ctx.onEvent?.({ type: 'blocked', detail: code });
+    await ctx.effects.abort();
+    return { kind: 'abort' };
+}
+// CreditGuard's hosted payment page (Hyp PPS), in two parts the generic card
+// path cannot judge. Every other request on the PPS hosts (the page, its
+// transaction read, /card/details, /cg3ds, assets) and the stock new-card
+// submit defer, synchronously, and the terminal arbiter continues or pauses
+// them; the pause then needs a ready preparation for this page's transaction.
+//   - A /process submit the cardholder's device would not fill (a saved card,
+//     a wallet, "save my card", installments, DCC, an Israeli ID, a gift card,
+//     another method, an unreadable body or other headers) is aborted with the device's own
+//     reason, before any claim, create or prompt. A ready preparation stays
+//     ready, so the page's corrected submit can still pay.
+//   - PPS runs 3-D Secure itself, sending the placeholder card to Nuvei from
+//     inside its frame. The nuvei recognizer would pause that as a Nuvei
+//     payment. A request to a Nuvei host that a PPS document sent, or that any
+//     frame inside a PPS document sent, is aborted instead, the checkout
+//     becomes unsupported and any preparation is retired: the page's flow is
+//     one the Vault refuses. See nuveiPreClaim for which requests wait on a
+//     frame lookup; no request to another host ever does.
+const PPS_DOCUMENT = 'https://pps.creditguard.co.il/';
+const sendsToNuvei = (url) => creditguardNuveiRefusal(url, PPS_DOCUMENT) !== null;
+const headerValue = (headers, name) => Object.entries(headers).find(([key]) => key.toLowerCase() === name)?.[1];
+const onPpsHost = (url) => {
+    try {
+        return CREDITGUARD_PPS_HOSTS.includes(new URL(url).hostname.toLowerCase());
+    }
+    catch {
+        return false;
+    }
+};
+// ctx.request.headers is read only once a request is CreditGuard's or Nuvei's: the adapters read
+// headers lazily, and a request mock without them must still pass every other gate.
+const creditguardPreClaim = (ctx) => {
+    const { url, method } = ctx.request;
+    if (sendsToNuvei(url))
+        return nuveiPreClaim(ctx);
+    // The body is read only for a request to a PPS host, as every gate reads one only on its own hosts:
+    // the adapters read it lazily, and a body they cannot read still reaches the rest of the list.
+    if (!onPpsHost(url))
+        return undefined;
+    const { body } = ctx.request;
+    // Any method reaches the /process check: payment-core blocks a non-POST, a query or an unreadable
+    // body there as well, so nothing but the stock POST ever continues to CreditGuard.
+    const verb = method.toUpperCase();
+    const verdict = classifyCreditguardRequest(url, verb, body ?? '', undefined);
+    if (verdict === null)
+        return undefined;
+    const refusal = creditguardProcessRefusal({ url, method: verb, headers: ctx.request.headers, body: body ?? '' }, undefined);
+    if (verdict === 'card' && refusal === null)
+        return undefined;
+    return creditguardBlock(ctx, refusal ?? 'malformed_body');
+};
+/**
+ * Who sent a request to a Nuvei host, as far as it decides the request:
+ *   1. The browser sets Origin and Referer, and no page can make either name another page's
+ *      document, so one that names PPS settles it at once, for any request.
+ *   2. Only a card request the nuvei recognizer would pause can be approved as a Nuvei payment.
+ *      Anything else (a GET, another Nuvei path) continues as it always has, with no lookup.
+ *   3. Otherwise the frames that sent it are read, up to the top, and a PPS document anywhere among
+ *      them refuses the request, whichever page its Origin names: the sender may be the merchant's
+ *      own page running Nuvei's Web SDK, one of Nuvei's own frames, which sends for whichever page
+ *      frames it, or any other frame, and only the frames above it say whether PPS framed it. With
+ *      an adapter that reads the chain at once (Playwright) the decision still comes in the
+ *      request's own microtask. A chain the adapter cannot read leaves the request to the nuvei
+ *      recognizer, as before; the prepare-time refusal of a 3-D Secure transaction still keeps the
+ *      CreditGuard payment from starting.
+ */
+function nuveiPreClaim(ctx) {
+    const { url, method, headers } = ctx.request;
+    if ([headerValue(headers, 'origin'), headerValue(headers, 'referer')].some(sender => creditguardNuveiRefusal(url, sender) !== null))
+        return creditguardThreeDSecure(ctx);
+    if (!ctx.vault.isCardRequest(url, method))
+        return undefined;
+    const decide = (frames) => frames?.some(frame => creditguardNuveiRefusal(url, frame) !== null) ? creditguardThreeDSecure(ctx) : undefined;
+    let frames;
+    try {
+        frames = ctx.initiatorFrames?.();
+    }
+    catch {
+        frames = undefined;
+    }
+    return frames instanceof Promise ? frames.then(decide, () => undefined) : decide(frames);
+}
+async function creditguardBlock(ctx, refusal) {
+    ctx.onEvent?.({ type: 'blocked', detail: { reason: 'creditguard_request_unsupported', refusal } });
+    await ctx.effects.abort();
+    return { kind: 'abort' };
+}
+async function creditguardThreeDSecure(ctx) {
+    const { url, method } = ctx.request;
+    ctx.preparationGate.invalidate('creditguard_three_d_secure');
+    ctx.lifecycle.unsupported('creditguard_three_d_secure');
+    ctx.onEvent?.({ type: 'unsupported_checkout', detail: { url: redactUrl(url), method, processor: 'creditguard', reason: 'creditguard_three_d_secure' } });
+    await ctx.effects.abort();
+    return { kind: 'abort' };
+}
+// Primer (primer.ts). Primer's /payment-instruments also carries requests the vault can never pay,
+// so a POST the registry recognizes on a Primer pci host is judged here, before the terminal
+// arbiter would pause it, by payment-core's own pause decision (classifyPrimerRequest), the rule
+// the API runs at create:
+//   - a one-time new card from the legacy v2 controller defers, and the arbiter pauses it; a body
+//     with no card (PayPal, Apple Pay, Google Pay, Klarna) defers too, and the card-field rule
+//     after the pause continues it untouched;
+//   - a body that asks Primer to keep the card is aborted alone with a `blocked` event,
+//     `primer_keep_on_file`: a save-card choice on the page decides it, so the attachment is not
+//     held and the next request is judged again;
+//   - Primer Checkout (primer-js) and any other shape the legacy controller would not send abort as
+//     an unsupported checkout, `unsupported_checkout` with reason `unsupported_primer_sdk` or
+//     `unsupported_primer_request`, with no claim, create or prompt. The attachment then reads
+//     `unsupported` and holds: the merchant's integration decides that shape.
+// Nothing is decided without the registry: an SDK the API did not serve Primer (a build without the
+// capability, or an org Agentcard has not enabled) recognizes no Primer URL, so the gate defers and
+// every Primer request continues as before. The preflight OPTIONS and every other method continue
+// through the arbiter. A body the adapter could not read says nothing about the page, so that
+// request alone is aborted (`unreadable_primer_request`). Synchronous until the abort, so a card
+// request pauses with no await.
+const primerPreClaim = (ctx) => {
+    const { url, method } = ctx.request;
+    if (method.toUpperCase() !== 'POST' || !isPrimerPciHost(url) || !ctx.vault.isCardRequest(url, method))
+        return undefined;
+    const verdict = primerRequestVerdict(ctx.request);
+    if (verdict.kind === 'block')
+        return primerBlocked(ctx, verdict.reason);
+    if (verdict.kind === 'unsupported')
+        return primerUnsupported(ctx, verdict.reason);
+    return undefined;
+};
+async function primerBlocked(ctx, reason) {
+    ctx.onEvent?.({ type: 'blocked', detail: reason });
+    await ctx.effects.abort();
+    return { kind: 'abort' };
+}
+async function primerUnsupported(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' };
+}
+// Payrails web SDK v6 (payrails.ts). The adapter captures Payrails sessions only while the synced
+// registry pauses Payrails' card save (an org the API served the dark entry to); otherwise
+// ctx.payrails is null, this gate defers, and every Payrails request continues as before. For a
+// POST to a Payrails host:
+//   - a POST that carries no body the gate can read aborts that request alone
+//     (`unreadable_payrails_request`): no body, an empty one, or one the adapter could not read.
+//     CDP reports '' for the first two and null for the third (a streamed upload, for one);
+//     Playwright reports null for all three, and no Playwright call tells them apart. So the gate
+//     refuses '' and null alike: both adapters then agree, and a streamed card-form payment cannot
+//     pass unread on Playwright. payrails.js 6.5.0 never posts without a body (its request helper
+//     sends JSON.stringify(body || {}) on every POST), and the secure frame v6 posts JSON. Payrails'
+//     static host (assets.payrails.io) is the one exception: it serves the SDK's and the secure
+//     frame's files and takes no payment, so another script's bodyless POST there continues
+//     untouched on both adapters;
+//   - a payment that carries an encrypted card inside paymentComposition (the card form paying,
+//     a stored card with a CVC field) aborts as an unsupported checkout,
+//     `unsupported_payrails_card_payment`, and the attachment holds;
+//   - a card save the registry recognizes is judged first by payment-core's guard and its
+//     card-on-file policy: a refusal aborts as an unsupported checkout with that code, and the
+//     attachment holds. Then it is bound to the one captured session its token, URL,
+//     holderReference and providerConfigId name, and the session's key is checked against the key
+//     the page's frame wrapped. A miss aborts that request alone (`payrails_session_unavailable`,
+//     or the key's code) with a message to reload the checkout, and the attachment does not hold,
+//     so the save after a reload is judged afresh. A bound save pauses carrying the key;
+//   - anything else defers to the arbiter: a save with no card pauses there and the claim flow
+//     continues it (passWithoutCard), and every other request continues.
+// Synchronous unless answer bodies are still being read (the save then waits for them, briefly)
+// or the request aborts.
+const payrailsPreClaim = (ctx) => {
+    const capture = ctx.payrails;
+    const { url, method } = ctx.request;
+    if (!capture || method.toUpperCase() !== 'POST' || !isPayrailsHost(url))
+        return undefined;
+    const body = ctx.request.body;
+    if (body === null || body === '')
+        return isPayrailsStaticHost(url) ? undefined : payrailsUnreadable(ctx);
+    const kind = payrailsRequestKind(url, method, body);
+    if (kind === 'card_payment')
+        return payrailsUnsupported(ctx, 'unsupported_payrails_card_payment');
+    if (kind !== 'card' || !ctx.vault.isCardRequest(url, method))
+        return undefined;
+    const refusal = payrailsSaveRefusal(body);
+    if (refusal)
+        return payrailsUnsupported(ctx, refusal);
+    return capture.pending ? capture.settle().then(() => payrailsBind(ctx, capture, body)) : payrailsBind(ctx, capture, body);
+};
+function payrailsBind(ctx, capture, body) {
+    const key = capture.keyFor({ url: ctx.request.url, headers: ctx.request.headers, body });
+    if (key === null)
+        return payrailsUnsupported(ctx, 'payrails_session_unavailable');
+    const refusal = payrailsKeyRefusal(key, body);
+    if (refusal)
+        return payrailsUnsupported(ctx, refusal);
+    return { kind: 'pause', stripeStep: ctx.stripeStep, payrails: { encryption_public_key: key } };
+}
+async function payrailsUnreadable(ctx) {
+    ctx.onEvent?.({ type: 'blocked', detail: 'unreadable_payrails_request' });
+    await ctx.effects.abort();
+    return { kind: 'abort' };
+}
+async function payrailsUnsupported(ctx, reason) {
+    const { url, method } = ctx.request;
+    const holds = PAYRAILS_HOLDING_REASONS.includes(reason);
+    if (holds) {
+        ctx.preparationGate.invalidate('unsupported_checkout');
+        ctx.lifecycle.unsupported(reason);
+    }
+    ctx.onEvent?.({ type: 'unsupported_checkout', detail: { url: redactUrl(url), method, reason,
+            ...(holds ? {} : { message: PAYRAILS_SESSION_MESSAGE }) } });
+    await ctx.effects.abort();
+    return { kind: 'abort' };
+}
+// Elavon Converge's Hosted Payment Page (elavon-converge.ts). Its card URL, POST
+// /hosted-payments/service/payment/hpp/process on api.convergepay.com or
+// api.demo.convergepay.com, also carries electronic check and financing payments
+// with no card, and card-shaped bodies the Vault never pays: a wallet with a card
+// number the server supplied, the debit, gift card and push-to-card tabs, the
+// follow-ups after a 3-D Secure, Pay Defense or surcharge step, a CAPTCHA, a
+// service fee, recurring or installment fields, card saving, a tip, another
+// currency. So a POST the registry recognizes on a Converge host that carries a
+// card is judged here, before the terminal arbiter would pause it, by the
+// whole-request check the API runs at create:
+//   - the page's own first credit card sale defers, and the arbiter pauses it
+//     for approval;
+//   - anything else aborts with a `blocked` event naming payment-core's code
+//     (converge_wallet_refused, converge_3ds_follow_up_refused, and so on), with
+//     no claim, create or prompt. Like Braintree's unsupported operation it
+//     neither holds the attachment nor changes its state, so the page's next
+//     payment (the buyer leaves Google Pay for the card form) is judged afresh.
+// A body with no card defers too, and the adapter continues it untouched in every
+// state (passWithoutCard); so does a body the adapter could not read, which the
+// adapter fails on its own as unreadable, that request only. Nothing is decided
+// without the registry: an SDK that did not sync with the converge_hpp_process
+// capability, or whose org Agentcard has not enabled for Converge (the API then
+// serves no elavon_converge recognizer), never recognizes a Converge host, so the
+// gate defers and the request continues as before. Synchronous until the abort,
+// so a card request pauses with no await. A check that throws blocks the request
+// as not the page's own rather than letting it reach a prompt.
+const convergePreClaim = (ctx) => {
+    const { url, method } = ctx.request;
+    if (method.toUpperCase() !== 'POST' || !isConvergeHost(url) || !ctx.vault.isCardRequest(url, method))
+        return undefined;
+    if (ctx.request.body == null || ctx.vault.withoutCard?.(url, ctx.request.body) === 'continue')
+        return undefined;
+    let reason;
+    try {
+        reason = convergeRefusal({ url, headers: ctx.request.headers, body: ctx.request.body });
+    }
+    catch {
+        reason = 'converge_body_malformed';
+    }
+    return reason === null ? undefined : convergeBlock(ctx, reason);
+};
+async function convergeBlock(ctx, reason) {
+    ctx.onEvent?.({ type: 'blocked', detail: reason });
+    await ctx.effects.abort();
+    return { kind: 'abort' };
+}
+// Worldpay eProtect, once the registry serves it (a synced build that declares
+// its capability, for an org the API enabled); for every other client the gate
+// defers on everything, so nothing changes. On eProtect's hosts:
+//   - the registration GET the recognizer admits defers to the arbiter, which
+//     pauses it for the vault claim flow; one the registry does not cover aborts
+//     as unsupported instead of reaching Worldpay;
+//   - any other request on /eProtect/paypage (a CVV-only, PIN, wallet or
+//     private-label variant, the native-app Mobile API form post) aborts as an
+//     unsupported checkout, so the placeholder's ciphertext never leaves;
+//   - the vendor's failover re-send of a registration this attachment saw
+//     aborts quietly: it repeats the placeholder's ciphertext and never prompts
+//     or claims a preparation. A re-send of nothing seen means the registration
+//     went somewhere this SDK does not cover, and aborts as unsupported;
+//   - the vendor's give-up report (/eProtect/ppstats 900 or 901) ends the
+//     approval running for its registration, then continues to Worldpay as the
+//     page's own telemetry;
+//   - everything else there (the scripts, the payframe) continues.
+// Synchronous for a registration, so it pauses in the microtask it paused in.
+const eprotectPreClaim = (ctx) => {
+    const request = ctx.eprotect?.classify(ctx.request.url, ctx.request.method);
+    if (!request || request.kind === 'sibling')
+        return undefined;
+    if (request.kind === 'registration') {
+        ctx.eprotect.saw(request);
+        return ctx.vault.isCardRequest(ctx.request.url, ctx.request.method) ? undefined : unsupportedAbort(ctx);
+    }
+    if (request.kind === 'give_up')
+        return eprotectGiveUp(ctx, request, request.code);
+    if (request.kind === 'failover' && ctx.eprotect.repeats(request))
+        return eprotectFailoverAbort(ctx);
+    return unsupportedAbort(ctx);
+};
+async function eprotectFailoverAbort(ctx) {
+    ctx.onEvent?.({ type: 'blocked', detail: 'eprotect_failover_aborted' });
+    await ctx.effects.abort();
+    return { kind: 'abort' };
+}
+async function eprotectGiveUp(ctx, attempt, code) {
+    const ended = ctx.eprotect.gaveUp(attempt);
+    if (ended)
+        ctx.onEvent?.({ type: 'merchant_request_abandoned', detail: { processor: 'worldpay_eprotect', code, answered: ended === 'answered' } });
+    await ctx.effects.continueRequest().catch(() => { });
+    return { kind: 'continue' };
+}
+// WSPay Components (wspay.ts). The card frame's confirm URL also carries saved_card and
+// temp_card_id bodies with no new card, and the page builds the transaction object itself, so a
+// POST the registry recognizes on a WSPay host is judged here, before the terminal arbiter would
+// pause it, by the whole-request check the API runs at create:
+//   - a new card for a one-time payment defers, and the arbiter pauses it for approval;
+//   - anything else aborts with a `blocked` event that names why, with no claim, create or
+//     prompt: `unsupported_wspay_payment_method`, or `wspay_keep_on_file_unsupported` for a
+//     confirm that asks WSPay to keep the card on file. Like Braintree's unsupported operation
+//     it neither holds the attachment nor changes its state, so the page's next confirm (a new
+//     card instead of a saved one) is judged afresh.
+// Nothing is decided without the registry: an SDK that did not sync with the wspay_confirm
+// capability, or whose org Agentcard has not enabled for WSPay (the API then serves no WSPay
+// recognizer), never recognizes a WSPay host, so the gate defers and the request continues as
+// before. GET /show and /status and POST /pan-info are not card requests and continue through
+// the arbiter. Synchronous until the abort, so a card confirm pauses with no await. A check that
+// throws blocks the request as unsupported rather than letting it reach a prompt.
+const wspayPreClaim = (ctx) => {
+    const { url, method } = ctx.request;
+    if (method.toUpperCase() !== 'POST' || !isWspayHost(url) || !ctx.vault.isCardRequest(url, method))
+        return undefined;
+    let reason;
+    try {
+        reason = wspayRefusal({ url, headers: ctx.request.headers, body: ctx.request.body });
+    }
+    catch {
+        reason = 'unsupported_wspay_payment_method';
+    }
+    return reason === null ? undefined : wspayBlock(ctx, reason);
+};
+async function wspayBlock(ctx, reason) {
+    ctx.onEvent?.({ type: 'blocked', detail: reason });
+    await ctx.effects.abort();
+    return { kind: 'abort' };
+}
+// Shiji STS (shiji-sts.ts). Its two endpoints also carry requests the vault must never pay, so a
+// POST the registry recognizes on an STS host is judged here, before the terminal arbiter would
+// pause it, by payment-core's classifier:
+//   - a getTokenId in the proxy's shape defers, and the arbiter pauses it: the one prompt. While the
+//     card-on-file decision is open the classifier never answers that, and every getTokenId aborts
+//     as an unsupported checkout, `unsupported_checkout` with reason `shiji_sts_keep_on_file`, with
+//     no claim, create or prompt; the attachment then reads `unsupported` and holds;
+//   - a getCvvId never pauses. It continues with the device's CVV ciphertext only when the
+//     attachment's companion binding answers for it (the getTokenId it continued, same page, same
+//     accessToken, within 120 s, once), and aborts as an unsupported checkout otherwise, so the
+//     agent's placeholder CVV never rides beside a real card;
+//   - anything else on those URLs (another shape, a query, a card field under another key) aborts
+//     the same way.
+// Nothing is decided without the registry: an SDK the API did not serve Shiji (a build without the
+// capability, or an org Agentcard has not enabled) recognizes neither URL, so the gate defers and
+// every Shiji request continues as before. The preflight OPTIONS and every other method continue
+// through the arbiter. A body the adapter could not read aborts that request alone with a `blocked`
+// event, `unreadable_shiji_sts_request`, and the attachment is not held. Synchronous until the
+// abort or the companion's continue, so a card request pauses with no await.
+const shijiStsPreClaim = (ctx) => {
+    const { url, method } = ctx.request;
+    if (method.toUpperCase() !== 'POST' || !isShijiStsHost(url) || !ctx.vault.isCardRequest(url, method))
+        return undefined;
+    const body = ctx.request.body;
+    if (body === null)
+        return shijiStsUnreadable(ctx);
+    const verdict = shijiStsVerdict({ url, method, body });
+    if (verdict.kind === 'pause')
+        return undefined;
+    if (verdict.kind === 'refuse')
+        return shijiStsUnsupported(ctx, verdict.reason);
+    return shijiStsCompanion(ctx, body);
+};
+async function shijiStsUnreadable(ctx) {
+    ctx.onEvent?.({ type: 'blocked', detail: 'unreadable_shiji_sts_request' });
+    await ctx.effects.abort();
+    return { kind: 'abort' };
+}
+async function shijiStsUnsupported(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' };
+}
+async function shijiStsCompanion(ctx, body) {
+    const { url, method } = ctx.request;
+    const shiji = ctx.shijiSts;
+    if (!shiji)
+        return shijiStsUnsupported(ctx, 'shiji_sts_companion_unbound');
+    if (ctx.interceptionAborted() || ctx.lifecycleAborted()) {
+        // The checkout was cancelled or the attachment is tearing down: the CVV stays on the device's side.
+        shiji.companions.release();
+        ctx.onEvent?.({ type: 'blocked', detail: 'checkout_cancelled' });
+        await ctx.effects.abort();
+        return { kind: 'abort' };
+    }
+    const claimed = shiji.companions.claim({ url, method, body }, await shiji.page());
+    if ('reason' in claimed)
+        return shijiStsUnsupported(ctx, claimed.reason);
+    try {
+        await ctx.effects.continueRequest(claimed.body);
+    }
+    catch (error) {
+        ctx.onEvent?.({ type: 'failed', detail: ctx.failureSummary(error) });
+        await ctx.effects.abort().catch(() => { });
+        return { kind: 'abort' };
+    }
+    ctx.onEvent?.({ type: 'companion_continued', detail: { url: redactUrl(url), psp: 'shiji_sts', fields: ['cvv'] } });
+    return { kind: 'continue' };
+}
 // 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 +1344,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 = [cardEndpointPreClaim, mercadoPreClaim, juspayPreClaim, braintreePreClaim, stripePreClaim, merchantHostedPreClaim, verifonePreClaim, fiservPreClaim, gmoPreClaim, cybersourceFlexPreClaim, datatransPreClaim, pelecardPreClaim, aciPreClaim, creditguardPreClaim, primerPreClaim, payrailsPreClaim, convergePreClaim, eprotectPreClaim, wspayPreClaim, shijiStsPreClaim];
 /** 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