@visa/cli 4.1.0-rc.29 → 4.1.0-rc.291

package/dist/checkout-engine/receipt.d.ts

@@ -1,7 +1,8 @@
 import type { EvidenceStep } from './evidence.js';
 import type { CheckoutMode, CheckoutOutcome, CheckoutResult, CredentialLifecycle, CredentialTiming } from './executor.js';
 import type { VicConfirmationReport } from './vic-confirmation.js';
-export type CheckoutReceipt = {
+/** Published v1 artifact shape. Retained so patch releases remain readable/typable. */
+export type CheckoutReceiptV1 = {
     schema: 'checkout-agent-receipt/v1';
     recordedAt: string;
     mode: CheckoutMode;
@@ -32,6 +33,55 @@ export type CheckoutReceipt = {
         snapshotSummary: string | null;
     };
 };
+export type CheckoutReceiptV2 = {
+    schema: 'checkout-agent-receipt/v2';
+    recordedAt: string;
+    /** Correlates terminal pre-review observations that have no reviewId yet. */
+    observationId?: string;
+    /** Explicitly distinguishes pre-submit review observations from payment attempts. */
+    phase?: 'review';
+    merchant: {
+        name: string;
+        host: string;
+        checkoutUrl: string | null;
+    };
+    transaction: {
+        amount: string;
+        amountMinor: number;
+        currency: string;
+    };
+    outcome: CheckoutOutcome;
+    agent: {
+        name: string;
+    } | null;
+    rail: {
+        type: 'card';
+        cardLast4: string | null;
+    };
+    network: {
+        confirmation: 'APPROVED' | 'DECLINED' | null;
+    };
+    /**
+     * Capability evidence for unsuccessful checkout surfaces. Optional so
+     * previously published v2 receipt producers remain source-compatible.
+     */
+    capability?: {
+        failureCode: string | null;
+        detectedRoles: string[];
+        requiresAdapter: string[];
+    };
+    /** Local reviewed-attempt identifier. Keeps filenames stable across schema versions. */
+    receiptId: string | null;
+    /** Merchant confirmation reference only; never substituted with an internal review id. */
+    reference: string | null;
+    recovery: {
+        required: boolean;
+        retrySafe: boolean;
+        action: string;
+        actions: string[];
+    };
+};
+export type CheckoutReceipt = CheckoutReceiptV1 | CheckoutReceiptV2;
 export type ReceiptWriteReport = {
     written: true;
     path: string;
@@ -43,9 +93,11 @@ export type ReceiptWriteReport = {
 export declare function buildReceipt(input: {
     mode: CheckoutMode;
     reviewId: string | null;
+    observationId?: string;
     merchant: {
         name: string;
         host: string;
+        url?: string;
     };
     transaction: {
         amount: string;
@@ -54,9 +106,11 @@ export declare function buildReceipt(input: {
     };
     result: CheckoutResult;
     vicConfirmation: VicConfirmationReport | null;
+    agentName?: string;
+    cardLast4?: string;
     /** Injectable for tests; defaults to now. */
     recordedAt?: Date;
-}): CheckoutReceipt;
+}): CheckoutReceiptV2;
 /**
  * Defense-in-depth scrub before anything touches disk: any standalone
  * 12–19-digit run that passes Luhn is replaced — contiguous OR separated by

package/dist/checkout-engine/receipt.js

@@ -1,11 +1,12 @@
 import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { KNOWN_MERCHANT_IDENTITIES } from './known-merchants.js';
 import { submitClickedWithoutConfirmation } from './live-fill-approval.js';
 /**
  * What the operator still owes after this run. Empty for a clean dry-run fill
  * and for a definitive submit outcome whose VIC confirmation posted.
  */
-function reconciliationFor(result, vicConfirmation) {
+function reconciliationFor(result, vicConfirmation, mode) {
     const reasons = [];
     if (submitClickedWithoutConfirmation(result)) {
         reasons.push('the pay control was clicked but no definitive outcome was observed — ' +
@@ -21,7 +22,7 @@ function reconciliationFor(result, vicConfirmation) {
         reasons.push('confirmed without a merchant confirmation reference — ' +
             'record the order number from the merchant dashboard');
     }
-    if (result.outcome === 'action-required') {
+    if (mode === 'submit' && result.outcome === 'action-required') {
         reasons.push('an issuer verification challenge was shown and not completed — ' +
             'finish the purchase manually if still wanted, or confirm with the merchant that no order exists');
     }
@@ -29,23 +30,60 @@ function reconciliationFor(result, vicConfirmation) {
 }
 export function buildReceipt(input) {
     const { result } = input;
+    const reconciliation = reconciliationFor(result, input.vicConfirmation, input.mode);
+    const fallbackAction = input.mode === 'dry-run'
+        ? 'Dry run only — nothing was submitted; safe to run again.'
+        : result.outcome === 'confirmed'
+            ? 'No action needed.'
+            : result.outcome === 'declined'
+                ? 'Review the decline before trying again.'
+                : result.outcome === 'unverified'
+                    ? // Defensive: reconciliationFor() already pushes the richer
+                        // submit-clicked reason for this outcome, so this line is only
+                        // reached if that ever stops firing. It must still not invite a
+                        // retry.
+                        'The charge may have gone through. Confirm with the merchant before retrying.'
+                    : result.outcome === 'partial-fill'
+                        ? // A v2 receipt carries no evidence log, so this line is the only
+                            // place the CAUSE survives — which field refused and why. An
+                            // operator opening this a week later can act on it; "could not
+                            // be filled" alone means reproducing a live merchant to learn
+                            // anything.
+                            `${result.detail ?? 'Nothing was submitted and nothing was charged.'} Safe to try again once the checkout can be filled.`
+                        : 'Review this outcome before retrying.';
+    const recoveryActions = reconciliation.reasons.length > 0 ? reconciliation.reasons : [fallbackAction];
+    const cardLast4 = input.cardLast4 && /^\d{4}$/.test(input.cardLast4) ? input.cardLast4 : null;
+    const checkoutUrl = input.merchant.url && KNOWN_MERCHANT_IDENTITIES[input.merchant.url] ? input.merchant.url : null;
+    const networkConfirmation = input.vicConfirmation?.posted === true ? input.vicConfirmation.transactionStatus : null;
+    const capability = result.failureCode || result.requiresAdapter.length > 0
+        ? {
+            failureCode: result.failureCode ?? null,
+            detectedRoles: Object.keys(result.fields).sort(),
+            requiresAdapter: [...result.requiresAdapter].sort(),
+        }
+        : null;
     return {
-        schema: 'checkout-agent-receipt/v1',
+        schema: 'checkout-agent-receipt/v2',
         recordedAt: (input.recordedAt ?? new Date()).toISOString(),
-        mode: input.mode,
-        reviewId: input.reviewId,
-        merchant: { name: input.merchant.name, host: input.merchant.host },
+        ...(input.observationId ? { observationId: input.observationId } : {}),
+        ...(input.observationId && input.reviewId === null ? { phase: 'review' } : {}),
+        merchant: { name: input.merchant.name, host: input.merchant.host, checkoutUrl },
         transaction: input.transaction,
         outcome: result.outcome,
-        detail: result.detail ?? null,
-        confirmationRef: result.confirmationRef ?? null,
-        vicConfirmation: input.vicConfirmation,
-        credentialLifecycle: result.credentialLifecycle,
-        credentialTiming: result.credentialTiming,
-        detectedRoles: Object.keys(result.fields),
-        requiresAdapter: [...result.requiresAdapter],
-        reconciliation: reconciliationFor(result, input.vicConfirmation),
-        evidence: result.evidence.toObject(),
+        agent: input.agentName ? { name: input.agentName } : null,
+        rail: { type: 'card', cardLast4 },
+        network: { confirmation: networkConfirmation },
+        ...(capability ? { capability } : {}),
+        receiptId: input.reviewId,
+        reference: result.confirmationRef ?? null,
+        recovery: {
+            required: reconciliation.required,
+            // A clean dry-run did not submit anything, so repeating inspection is
+            // safe. Every submit outcome requires either no retry or owner review.
+            retrySafe: input.mode === 'dry-run' && !reconciliation.required,
+            action: recoveryActions[0],
+            actions: recoveryActions,
+        },
     };
 }
 function luhnValid(digits) {
@@ -88,7 +126,8 @@ export function serializeReceipt(receipt) {
 }
 export function receiptFileName(receipt) {
     const ts = receipt.recordedAt.replace(/[:.]/g, '-');
-    const review = (receipt.reviewId ?? 'no-review').replace(/[^A-Za-z0-9-]/g, '');
+    const receiptId = receipt.schema === 'checkout-agent-receipt/v1' ? receipt.reviewId : receipt.receiptId;
+    const review = (receiptId ?? 'no-review').replace(/[^A-Za-z0-9-]/g, '');
     return `receipt-${ts}-${review || 'no-review'}.json`;
 }
 /**

package/dist/checkout-engine/shopify-primary-domain.d.ts

@@ -0,0 +1,25 @@
+import type { Response } from 'playwright-core';
+export type NavigationRedirectEvidence = {
+    sourceUrl: string;
+    status: number;
+    location: string | null;
+    redirectReason: string | null;
+    poweredBy: string | null;
+};
+/**
+ * Resolve Shopify's permanent `*.myshopify.com` identity to its configured
+ * primary storefront host using evidence from the navigation redirect chain.
+ *
+ * This deliberately does not treat a generic redirect, matching HTML, DNS, or
+ * a shared Shopify CDN as merchant ownership proof. The only accepted cross-host
+ * hop must originate on the mandate-bound `myshopify.com` host over HTTPS and
+ * carry Shopify's exact `primary_domain_redirection` response signal directly
+ * to the final checkout host.
+ */
+export declare function shopifyPrimaryDomainAlias(args: {
+    mandateHost: string | undefined;
+    initialUrl: string;
+    finalUrl: string;
+    redirects: readonly NavigationRedirectEvidence[];
+}): string | null;
+export declare function navigationRedirectEvidence(finalResponse: Response | null): Promise<NavigationRedirectEvidence[]>;

package/dist/checkout-engine/shopify-primary-domain.js

@@ -0,0 +1,96 @@
+const MYSHOPIFY_HOST = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.myshopify\.com$/;
+function hostname(value) {
+    try {
+        return new URL(value).hostname.toLowerCase();
+    }
+    catch {
+        try {
+            return new URL(`https://${value}`).hostname.toLowerCase();
+        }
+        catch {
+            return null;
+        }
+    }
+}
+function redirectTargetHost(redirect) {
+    if (!redirect.location)
+        return null;
+    try {
+        return new URL(redirect.location, redirect.sourceUrl).hostname.toLowerCase();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve Shopify's permanent `*.myshopify.com` identity to its configured
+ * primary storefront host using evidence from the navigation redirect chain.
+ *
+ * This deliberately does not treat a generic redirect, matching HTML, DNS, or
+ * a shared Shopify CDN as merchant ownership proof. The only accepted cross-host
+ * hop must originate on the mandate-bound `myshopify.com` host over HTTPS and
+ * carry Shopify's exact `primary_domain_redirection` response signal directly
+ * to the final checkout host.
+ */
+export function shopifyPrimaryDomainAlias(args) {
+    if (!args.mandateHost)
+        return null;
+    let initial;
+    let final;
+    try {
+        initial = new URL(args.initialUrl);
+        final = new URL(args.finalUrl);
+    }
+    catch {
+        return null;
+    }
+    if (initial.protocol !== 'https:' || final.protocol !== 'https:')
+        return null;
+    const mandateHost = hostname(args.mandateHost);
+    const initialHost = initial.hostname.toLowerCase();
+    const finalHost = final.hostname.toLowerCase();
+    if (!mandateHost || mandateHost !== initialHost || !MYSHOPIFY_HOST.test(initialHost))
+        return null;
+    if (initialHost === finalHost)
+        return null;
+    const crossHostRedirects = args.redirects.filter((redirect) => {
+        const sourceHost = hostname(redirect.sourceUrl);
+        const targetHost = redirectTargetHost(redirect);
+        return sourceHost !== null && targetHost !== null && sourceHost !== targetHost;
+    });
+    if (crossHostRedirects.length !== 1)
+        return null;
+    const redirect = crossHostRedirects[0];
+    const source = new URL(redirect.sourceUrl);
+    const target = redirect.location ? new URL(redirect.location, source) : null;
+    if (source.protocol !== 'https:' ||
+        source.hostname.toLowerCase() !== initialHost ||
+        !target ||
+        target.protocol !== 'https:' ||
+        target.hostname.toLowerCase() !== finalHost ||
+        ![301, 302, 307, 308].includes(redirect.status) ||
+        redirect.redirectReason?.toLowerCase() !== 'primary_domain_redirection' ||
+        redirect.poweredBy?.toLowerCase() !== 'shopify') {
+        return null;
+    }
+    return finalHost;
+}
+export async function navigationRedirectEvidence(finalResponse) {
+    const redirects = [];
+    let request = finalResponse?.request().redirectedFrom() ?? null;
+    while (request) {
+        const response = await request.response();
+        if (response) {
+            const headers = response.headers();
+            redirects.push({
+                sourceUrl: request.url(),
+                status: response.status(),
+                location: headers.location ?? null,
+                redirectReason: headers['x-redirect-reason'] ?? null,
+                poweredBy: headers['powered-by'] ?? null,
+            });
+        }
+        request = request.redirectedFrom();
+    }
+    return redirects.reverse();
+}

package/dist/checkout-engine/trace-handles.d.ts

@@ -0,0 +1,8 @@
+export declare function safeTraceHandle(value: unknown): string | undefined;
+export declare function traceHandleFields(value: {
+    vgsTraceId?: unknown;
+    networkCorrelationId?: unknown;
+}): {
+    vgsTraceId?: string;
+    networkCorrelationId?: string;
+};

package/dist/checkout-engine/trace-handles.js

@@ -0,0 +1,12 @@
+const SAFE_TRACE_HANDLE_RE = /^[A-Za-z0-9._:-]{1,128}$/;
+export function safeTraceHandle(value) {
+    return typeof value === 'string' && SAFE_TRACE_HANDLE_RE.test(value) ? value : undefined;
+}
+export function traceHandleFields(value) {
+    const vgsTraceId = safeTraceHandle(value.vgsTraceId);
+    const networkCorrelationId = safeTraceHandle(value.networkCorrelationId);
+    return {
+        ...(vgsTraceId ? { vgsTraceId } : {}),
+        ...(networkCorrelationId ? { networkCorrelationId } : {}),
+    };
+}

package/dist/checkout-engine/types.d.ts

@@ -1,5 +1,4 @@
-export type Contact = {
-    email?: string;
+export type PostalAddress = {
     firstName?: string;
     lastName?: string;
     fullName?: string;
@@ -10,6 +9,11 @@ export type Contact = {
     postalCode?: string;
     country?: string;
 };
+export type Contact = PostalAddress & {
+    email?: string;
+    phone?: string;
+    billingAddress?: PostalAddress;
+};
 export type FilledField = {
     role: string;
     locator: string;
@@ -19,10 +23,19 @@ export type FilledField = {
     value: string;
     ok: boolean;
     error?: string;
+    /**
+     * The detected node was gone by the time this field's turn came (the merchant
+     * re-mounted that part of the form mid-fill) and a fresh detection pass was
+     * used to find it again. Worth surfacing: a merchant that re-mounts is a
+     * merchant whose fills are order-sensitive, which is the first thing to know
+     * when one of them later refuses.
+     */
+    relocated?: boolean;
 };
 export type FillResult = {
     ok: boolean;
     filled: FilledField[];
+    detail?: string;
 };
 export type OtpRequest = {
     /** ISO watermark captured BEFORE the click that triggers the OTP email. */

package/dist/checkout-engine/unresolved-charges.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Outcomes whose receipt cannot rule out a charge.
+ *
+ * Both of these record a run where the pay control was clicked and no
+ * definitive answer came back:
+ *   - `unverified`      — no confirmation or decline observed before the deadline
+ *   - `action-required` — an issuer challenge appeared, which happens AFTER the
+ *                         click, so the authorization may already exist
+ *
+ * Everything else is either definitive (`confirmed`, `declined`) or provably
+ * pre-click (`reviewed-dry-run`, `partial-fill`, `failed`, ...). Widening this
+ * set blocks legitimate retries; narrowing it lets a double charge through, so
+ * an outcome earns a place here only by being genuinely post-click.
+ */
+export declare const MAY_HAVE_CHARGED_OUTCOMES: ReadonlySet<string>;
+/** One local attempt that may have taken money and was never resolved. */
+export type UnresolvedCharge = {
+    recordedAt: string;
+    host: string;
+    amount: string;
+    amountMinor: number;
+    currency: string;
+    outcome: string;
+    /** Receipt file basename, so a caller can name the evidence a human must check. */
+    receiptFile: string;
+};
+/**
+ * Local attempts that may have charged, newest first.
+ *
+ * Never throws: a missing directory (nothing has ever been checked out here)
+ * and an unreadable one both read as "no unresolved charges". The caller
+ * decides what an empty answer means — see the fail-open note at its call site.
+ */
+export declare function readUnresolvedCharges(receiptDir?: string): Promise<UnresolvedCharge[]>;

package/dist/checkout-engine/unresolved-charges.js

@@ -0,0 +1,134 @@
+// "Did this device already submit this exact purchase?", read back from the
+// checkout receipts on disk.
+//
+// The engine now reports a submitted-but-unobserved checkout as `unverified`
+// instead of `failed`, and pay_merchant tells the caller not to retry it. This
+// module is the belt to that suspenders: even a caller that ignores the words
+// can be stopped, because the previous attempt left a receipt.
+//
+// It answers one question — which local receipts record an attempt that MAY
+// HAVE CHARGED and was never resolved — and deliberately answers nothing else.
+// The matching (same merchant, same amount, recent enough) lives in the caller,
+// which owns the policy; this side owns only the read.
+//
+// Sibling of confirmed-merchants.ts and loaded through the same seam: it
+// imports node built-ins and types only, so reading receipts never pulls
+// playwright into the CLI process.
+//
+// Reading is best-effort by construction. The receipts directory is an operator
+// artifact that anything on the box can touch, so an unreadable or malformed
+// file is skipped rather than failing the whole read.
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { RECEIPT_DIR } from './receipt-dir.js';
+/**
+ * Outcomes whose receipt cannot rule out a charge.
+ *
+ * Both of these record a run where the pay control was clicked and no
+ * definitive answer came back:
+ *   - `unverified`      — no confirmation or decline observed before the deadline
+ *   - `action-required` — an issuer challenge appeared, which happens AFTER the
+ *                         click, so the authorization may already exist
+ *
+ * Everything else is either definitive (`confirmed`, `declined`) or provably
+ * pre-click (`reviewed-dry-run`, `partial-fill`, `failed`, ...). Widening this
+ * set blocks legitimate retries; narrowing it lets a double charge through, so
+ * an outcome earns a place here only by being genuinely post-click.
+ */
+export const MAY_HAVE_CHARGED_OUTCOMES = new Set([
+    'unverified',
+    'action-required',
+]);
+/**
+ * Every field this module reads, validated. Deliberately permissive about
+ * everything else: older and newer engines only have to carry these.
+ *
+ * Both receipt schemas expose all of them at the same paths, so unlike
+ * confirmed-merchants.ts there is nothing here that needs a per-schema branch.
+ */
+function parseUnresolved(json, receiptFile) {
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== 'object' || parsed === null)
+        return null;
+    const receipt = parsed;
+    if (receipt.schema !== 'checkout-agent-receipt/v1' &&
+        receipt.schema !== 'checkout-agent-receipt/v2') {
+        return null;
+    }
+    // Terminal review observations are useful capability evidence, but no pay
+    // control, credential, or submission exists yet. They must never poison the
+    // double-charge ledger even when the observed page showed a Shop Pay or 3DS
+    // action-required surface.
+    if (receipt.schema === 'checkout-agent-receipt/v2' &&
+        (receipt.phase === 'review' ||
+            (typeof receipt.observationId === 'string' && receipt.receiptId === null))) {
+        return null;
+    }
+    if (typeof receipt.outcome !== 'string' || !MAY_HAVE_CHARGED_OUTCOMES.has(receipt.outcome)) {
+        return null;
+    }
+    if (typeof receipt.recordedAt !== 'string' || Number.isNaN(Date.parse(receipt.recordedAt))) {
+        return null;
+    }
+    const host = receipt.merchant?.host;
+    if (typeof host !== 'string' || host.length === 0)
+        return null;
+    const transaction = receipt.transaction;
+    if (typeof transaction?.amount !== 'string')
+        return null;
+    if (typeof transaction.currency !== 'string')
+        return null;
+    // A receipt whose amount cannot be compared cannot gate a retry on amount, and
+    // a guard that silently matched every amount would be worse than none.
+    if (typeof transaction.amountMinor !== 'number' || !Number.isFinite(transaction.amountMinor)) {
+        return null;
+    }
+    return {
+        recordedAt: receipt.recordedAt,
+        host,
+        amount: transaction.amount,
+        amountMinor: transaction.amountMinor,
+        currency: transaction.currency,
+        outcome: receipt.outcome,
+        receiptFile,
+    };
+}
+/**
+ * Local attempts that may have charged, newest first.
+ *
+ * Never throws: a missing directory (nothing has ever been checked out here)
+ * and an unreadable one both read as "no unresolved charges". The caller
+ * decides what an empty answer means — see the fail-open note at its call site.
+ */
+export async function readUnresolvedCharges(receiptDir = RECEIPT_DIR) {
+    let names;
+    try {
+        names = await readdir(receiptDir);
+    }
+    catch {
+        return [];
+    }
+    const charges = [];
+    for (const name of names) {
+        if (!name.endsWith('.json'))
+            continue;
+        let raw;
+        try {
+            raw = await readFile(join(receiptDir, name), 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const charge = parseUnresolved(raw, name);
+        if (charge)
+            charges.push(charge);
+    }
+    charges.sort((left, right) => (left.recordedAt < right.recordedAt ? 1 : -1));
+    return charges;
+}

package/dist/checkout-engine/vgs-gateway/server-mint-client.d.ts

@@ -1,3 +1,4 @@
+import { type KeyObject } from 'node:crypto';
 import type { VgsCheckoutTarget, VgsPaymentCredential } from '../vgs-live-instrument.js';
 export type ServerMintDeps = {
     /** Injectable for tests — defaults to global fetch. */
@@ -18,13 +19,57 @@ export type ServerMintDeps = {
  */
 export declare function merchantOrigin(url: string): string;
 /**
- * Optional mandate override for serverCreateIntent. Absent → the historical
- * 1:1 fresh-tap shape is preserved byte-for-byte (cap = ceil(amount)+10 min 25,
- * quantity 1, 30-day window). Present → the card-mandate (budget) layer sets a
- * CEILING decline threshold and a multi-draw quantity so one passkey approves a
- * spend ceiling and later draws pull cryptograms under it without a fresh tap.
- * Whether the network honors a ceiling-scoped assurance across multiple
- * sub-amount draws is UNPROVEN — see packages/checkout-engine/src/mandate/.
+ * A definitive refusal from the cryptogram mint route — the request will not
+ * succeed if retried unchanged.
+ *
+ * `terminal` is the load-bearing field. Draw terminality used to be decided by
+ * regex over the error MESSAGE, which made it hostage to text nobody controls:
+ * this client now interpolates the provider's own `upstream_codes` into the
+ * message for diagnosability, and a provider identifier such as
+ * `request_timeout` would match the transient matcher's unanchored
+ * `tim(e|ed)-out` alternative — flipping a permanent 422 back to "transient",
+ * skipping markUnhonored, and stranding the mandate in the exact retry-forever
+ * loop this whole change exists to kill. Terminality is therefore carried
+ * structurally, and consumers must consult it BEFORE any message matching.
+ */
+export declare class ServerCryptogramRefusedError extends Error {
+    readonly status: number;
+    readonly terminal: true;
+    constructor(status: number, detail: string);
+}
+export type ServerIntentBootstrapState = 'none' | 'pending' | 'created' | 'ambiguous' | 'conflict' | 'unknown';
+/**
+ * The budget-intent route's failure, kept structured (#8470). `status` 0 means
+ * the request never produced an HTTP response (network failure or abort), which
+ * is outcome-uncertain exactly like a 5xx: the server may have dispatched.
+ */
+export declare class ServerIntentError extends Error {
+    readonly facts: {
+        status: number;
+        errorCode: string | null;
+        retryable: boolean;
+        requestId: string | null;
+        bootstrapState: ServerIntentBootstrapState;
+        outcome: 'uncertain' | 'not_created' | 'unknown';
+    };
+    readonly code = "SERVER_INTENT_FAILED";
+    constructor(message: string, facts: {
+        status: number;
+        errorCode: string | null;
+        retryable: boolean;
+        requestId: string | null;
+        bootstrapState: ServerIntentBootstrapState;
+        outcome: 'uncertain' | 'not_created' | 'unknown';
+    });
+}
+/**
+ * Optional mandate override for serverCreateIntent. Absent → the default
+ * intent shape (cap = ceil(amount)+10 min 25, quantity 1, 30-day window).
+ * Present → the card-mandate (budget) layer sets a CEILING decline threshold
+ * and a multi-draw quantity so one passkey approves a spend ceiling and later
+ * draws pull cryptograms under it without a fresh tap. Whether the network
+ * honors a ceiling-scoped assurance across multiple sub-amount draws is
+ * UNPROVEN — see packages/checkout-engine/src/mandate/.
  */
 export type ServerIntentMandateOverride = {
     /** Wire decline-threshold amount (major-unit decimal string), e.g. "500.00". */
@@ -52,6 +97,18 @@ export declare function serverCreateIntent(base: string, mintToken: string, inpu
     intentId: string;
     status: string | null;
 }>;
+/**
+ * Read the durable budget-bootstrap state for a budget mint token via
+ * GET {base}/api/vgs/intent (#8470). A `created` answer carries the intent the
+ * server already minted under this token, so the runner registers it instead
+ * of dispatching again; `pending` and `ambiguous` are never redispatched.
+ */
+export declare function serverReadIntentBootstrap(base: string, mintToken: string, deps?: ServerMintDeps): Promise<{
+    state: ServerIntentBootstrapState;
+    intentId: string | null;
+    intentStatus: string | null;
+    requestId: string | null;
+}>;
 /**
  * Mint the FULL payment credential via POST {base}/api/vgs/payment-cryptogram.
  * The server's route does a SINGLE gateway call and 502s on a not-COMPLETED
@@ -80,3 +137,17 @@ export declare function serverPostConfirmation(base: string, mintToken: string,
 }, deps?: ServerMintDeps): Promise<{
     ok: true;
 }>;
+/** One exact protected attempt. Caller retains its delivery KeyObject across
+ * retries; it is never serialized into a request, receipt, log, or agent context. */
+/** Pins are installed with the checkout deployment, never supplied by Auth or the response. */
+export interface ProtectedCardPins {
+    executor: KeyObject;
+    issuer: KeyObject;
+}
+export declare function serverFetchProtectedCryptogram(base: string, input: {
+    financialAdmission: string;
+    request: unknown;
+    requestHash: string;
+    deliveryKey: KeyObject;
+    pins: ProtectedCardPins;
+}, deps?: ServerMintDeps): Promise<VgsPaymentCredential>;