@astrasyncai/verification-gateway 5.14.0 → 5.16.0

package/dist/index.d.mts

@@ -1,7 +1,8 @@
-import { RequestHandler, Request, Response as Response$1 } from 'express';
+import { RequestHandler, Request as Request$1, Response as Response$1 } from 'express';
 import * as next_server from 'next/server';
 import { NextRequest } from 'next/server';
-import { JWK } from 'jose';
+import { JWK, KeyLike, JWTPayload } from 'jose';
+import { KeyObject } from 'crypto';
 
 /**
  * Maximal metadata capture — the shared, edge-safe sanitiser.
@@ -358,6 +359,30 @@ interface VerifiedAgent {
     blockchainAnchored: boolean;
     /** Agent status */
     status: 'active' | 'inactive' | 'suspended' | 'migrating' | 'terminated' | 'retired';
+    /**
+     * 5.15.0: the protocol identities the agent declared at registration (its
+     * shared signing key, UCP profile, Web Bot Auth key directory, x402 wallet,
+     * network agent ids). Bind incoming protocol requests to these — e.g.
+     * {@link checkUcpAgentBinding} rejects a `UCP-Agent` profile that isn't the
+     * agent's. Identities AstraSync failed to verify are never included.
+     */
+    protocolIdentities?: AgentProtocolIdentities;
+}
+interface AgentProtocolIdentities {
+    /** Shared signing key (AP2 / VI `cnf`, RFC 9421). `thumbprint` = RFC 7638. */
+    agentKey?: {
+        kid: string | null;
+        thumbprint: string | null;
+        jwk: Record<string, unknown>;
+    };
+    ucpProfile?: string;
+    webBotAuthKeyDirectory?: string;
+    a2aCard?: string;
+    x402Wallet?: string;
+    visaAgentId?: string;
+    mastercardAgentId?: string;
+    /** Protocols whose identity AstraSync checked successfully. */
+    verified: string[];
 }
 /**
  * Verified developer (KYD) information
@@ -498,6 +523,13 @@ interface GuidanceInfo {
 interface StepUpApprovalInfo {
     approvalId: string;
     pollUrl: string;
+    /**
+     * 5.15.0: absolute https URL of the buyer-facing approval page. A UCP
+     * merchant returns it as `continue_url` with status `requires_escalation`;
+     * after the buyer approves, complete the same checkout again and the
+     * approval is redeemed once. Absent from backends older than 27.9.
+     */
+    approvalUrl?: string;
     expiresAt: string;
 }
 /**
@@ -673,19 +705,19 @@ interface VerificationResult {
     /** Settlement voucher (present on clean merchant-mediated grants with a verified wallet). */
     settlement?: SettlementArtifact;
     /**
-     * 5.3.0 (astra-pay): sanitized first-party settlement outcome. Present
-     * INSTEAD of `settlement` when the counterparty is an AstraSync-operated
-     * storefront and the request carried `commercePhase: 'confirm'` — the
-     * backend redeemed the voucher and executed the charge server-side
-     * (charge-at-redeem), so there is no artifact to deliver, only the result.
-     * `no_instrument` = policy passed but the owner has no chargeable
-     * instrument on file (steer the user to add one via onboarding).
+     * Sanitized order outcome for a purchase leg. 5.14.1: AstraSync never
+     * charges — every purchase grant records an order and hands YOU the
+     * settlement artifact, so the status is `pending_merchant` (with
+     * `orderId`): charge the `settlementToken` (card, first-party tenant) or
+     * redeem the `settlement` voucher (stablecoin), then `reportSettlement()`.
+     * `no_instrument` = policy passed but the owner has nothing usable on file
+     * (steer the user to add one via onboarding).
      */
     settlementOutcome?: SettlementOutcomeInfo;
     /**
-     * 5.5.0 (astra-pay): interim merchant self-settlement token. Present ONLY
-     * for firstParty merchants opted into settlement_mode='self_settle' on the
-     * confirm leg — YOUR server charges with this material on the shared Stripe
+     * Card settlement token. Present on a card purchase at a first-party
+     * storefront (our Stripe tenant) — 5.14.1: always, there is no charge-here
+     * mode. YOUR server charges with this material on the shared Stripe
      * account and reports the outcome via `client.reportSettlement()`.
      * MERCHANT-ONLY lane: never expose it to the agent plane, never log it,
      * never echo it back over the bridge handoff (the bridge strips it
@@ -706,6 +738,29 @@ interface VerificationResult {
      * confirm handoff body wins over `fulfilment.email` (the platform default).
      */
     fulfilment?: FulfilmentInfo;
+    /**
+     * 5.15.0: AP2 v0.2 mandates AstraSync issued for this purchase (merchant
+     * lane — never forward to the agent). `mode: 'closed'` on a purchase leg
+     * (Checkout + Payment, bound to your `checkoutJwt`), `'open'` on a quote
+     * leg for an agent with a registered key. Verify with `verifyAp2Mandate()`
+     * against AstraSync's JWKS (`kid`).
+     */
+    mandates?: AstraSyncMandates;
+    /**
+     * 5.15.0: a KYAPay `kya+jwt` identity token AstraSync issued for this agent
+     * at your endpoint (commerce legs; merchant lane). `hid.email` is where to
+     * send the receipt. Verify with `verifyKyaPayTokens()` (issuer = the
+     * AstraSync origin, audience = your ASTRAE-id).
+     */
+    kyaToken?: string;
+    /**
+     * 5.15.0: A-Comm Evidence Protocol (AEP v1.0.3-rc.2) artifact payloads for
+     * your AEP chain — present when your endpoint lists `aep`: `policy` (section 3.4),
+     * `delegation` (section 3.9 protocol_metadata: kya_identity, consumer_authorization)
+     * and, for AstraSync bridge traffic, platform-countersigned `intents` (section 8.7).
+     * Append them with `AepChain` (your Ed25519 key). Merchant lane only.
+     */
+    aep?: AstraSyncAepEvidence;
     /** Timestamp of verification */
     verifiedAt: Date;
     /** TTL for this result (seconds) */
@@ -857,6 +912,12 @@ interface VerificationRequest {
      * key charge the owner's card at most once. Omit for raw one-shot confirms.
      */
     checkoutSessionId?: string;
+    /**
+     * 5.15.0: your signed checkout as a compact JWS (AP2 `checkout_jwt`). At a
+     * merchant whose endpoint lists `ap2`, a granted purchase leg returns
+     * `mandates` — closed AP2 Checkout + Payment mandates bound to it.
+     */
+    checkoutJwt?: string;
     /**
      * 5.3.0 (astra-pay): the checkout's authoritative line items, forwarded on
      * the confirm leg for the ORDER plane (receipts + digital-goods fulfillment
@@ -900,6 +961,8 @@ interface VerificationRequest {
     callerMetadata?: CallerMetadata;
     /** Enable runtime challenge for this request */
     enableRuntimeChallenge?: boolean;
+    /** 5.16.0: the matched route's policy for verify-access to enforce. */
+    routePolicy?: RoutePolicy;
     /** Create a verification session (returns sessionId) */
     createSession?: boolean;
     /** Counterparty type */
@@ -1144,7 +1207,29 @@ interface RouteAccessConfig {
      */
     purpose?: string;
     action?: string;
+    /**
+     * 5.16.0: only agents owned by these organisations (ASTRAO- / ASTRAD- /
+     * ASTRAI-ids) pass this route. Enforced by verify-access, which resolves
+     * the agent's owner itself — the owner is never disclosed to you.
+     */
+    allowedOwners?: string[];
+    /**
+     * 5.16.0: require the runtime challenge on this route only (the endpoint
+     * setting applies it to every route). An agent without a live callback is
+     * denied here; other routes are unaffected.
+     */
+    requiresRuntimeChallenge?: boolean;
+}
+/**
+ * 5.16.0: the matched route's policy that verify-access enforces (forwarded
+ * by the middleware from the dashboard route). Tighten-only.
+ */
+interface RoutePolicy {
+    allowedOwners?: string[];
+    requiresRuntimeChallenge?: boolean;
 }
+/** The forwardable route policy of a matched route, or undefined when it has none. */
+declare function routePolicyOf(route: Pick<RouteAccessConfig, 'allowedOwners' | 'requiresRuntimeChallenge'> | null | undefined): RoutePolicy | undefined;
 /**
  * Express middleware options.
  *
@@ -1194,7 +1279,7 @@ interface ExpressMiddlewareOptions extends GatewayConfig {
     onDenied?: (result: VerificationResult, req: unknown, res: unknown) => void;
     /** Automatically create sessions and record grant/deny decisions (default: true) */
     recordDecisions?: boolean;
-    /** Enable runtime challenge for all verify-access calls (default: true) */
+    /** Ask for a runtime challenge on every verify-access call (default: false — opt-in, round 27.8) */
     enableRuntimeChallenge?: boolean;
     /**
      * Refresh interval (ms) for the remote-fetched route policy. Default:
@@ -1291,7 +1376,7 @@ interface NextJsMiddlewareOptions extends GatewayConfig {
         message?: string;
         allowGuestAccess?: boolean;
     };
-    /** Enable runtime challenge for all verify-access calls (default: true) */
+    /** Ask for a runtime challenge on every verify-access call (default: false — opt-in, round 27.8) */
     enableRuntimeChallenge?: boolean;
     /**
      * Emit a fire-and-forget beacon for bot- and agent-shaped traffic that
@@ -1430,6 +1515,40 @@ interface VerificationInterstitialProps {
 }
 /** @deprecated Renamed VerificationInterstitialProps in 4.1.0; alias removed next major. */
 type CommerceShieldProps = VerificationInterstitialProps;
+/** 5.15.0: AP2 mandates AstraSync issued (see VerificationResult.mandates). */
+interface AstraSyncMandates {
+    kid: string;
+    mode: 'closed' | 'open';
+    /** Delegate SD-JWT: mandate.checkout.1 / mandate.checkout.open.1. */
+    checkout: string;
+    /** Delegate SD-JWT: mandate.payment.1 / mandate.payment.open.1. */
+    payment?: string;
+}
+/** 5.15.0: AstraSync's AEP evidence (see VerificationResult.aep). */
+interface AstraSyncAepEvidence {
+    spec_version: string;
+    policy: {
+        artifact_type: 'policy';
+        actor_type: 'merchant';
+        payload: Record<string, unknown>;
+    };
+    delegation?: {
+        artifact_type: 'delegation';
+        actor_type: 'agent';
+        actor_id: string;
+        payload: {
+            protocol_metadata: Record<string, unknown>;
+        };
+    };
+    intents?: Array<{
+        artifact_type: 'intent';
+        actor_type: 'agent';
+        actor_id: string;
+        payload: Record<string, unknown>;
+        /** Compact JWS (ES256) over the canonical payload; key in AstraSync's JWKS. */
+        platform_countersignature: string;
+    }>;
+}
 
 /**
  * AstraSync Universal Verification Gateway — Trust Level helpers.
@@ -1786,7 +1905,7 @@ declare global {
  * Extract extended AstraSync credentials (X-Astra-* headers) from Express request.
  * Returns null if no AstraSync headers are present.
  */
-declare function extractAstraSyncCredentials(req: Request): AstraSyncCredentials | null;
+declare function extractAstraSyncCredentials(req: Request$1): AstraSyncCredentials | null;
 /**
  * Create Express middleware for agent verification.
  *
@@ -1936,6 +2055,8 @@ declare class VerificationGatewayClient {
         currency?: string;
         checkoutSessionId?: string;
         checkoutItems?: VerificationRequest['checkoutItems'];
+        /** 5.15.0: your signed checkout (AP2 checkout_jwt) — returns `mandates` at AP2 merchants. */
+        checkoutJwt?: string;
         /** 5.12.0: the `att_…` attempt-chain id from the bridge handoff body. */
         attemptId?: string;
         /** 5.6.0: alternate receipt/delivery email (transit-only) — omit to let
@@ -1945,21 +2066,27 @@ declare class VerificationGatewayClient {
         counterpartyType?: string;
     }): Promise<VerificationResult>;
     /**
-     * 5.5.0 (astra-pay): report a self-settled charge outcome back to the
-     * platform — the other half of the `settlementToken` contract. Call after
-     * your PaymentIntent reaches a terminal state so the buyer's dashboard,
-     * /orders and the agent's poll surface reconcile. Authenticated with this
-     * client's api key (must be the merchant's own). Amounts must match the
-     * order EXACTLY (integer minor units) or the report is rejected whole
-     * (409 amount_mismatch). Replays of the same terminal state are safe.
+     * Report a settlement outcome back to the platform. 5.14.1: AstraSync never
+     * charges — EVERY merchant settles the orders it is handed (card token,
+     * stablecoin voucher, or a protocol-native credential) and reports here, so
+     * the buyer's dashboard, /orders and the agent's poll surface reconcile.
+     * Identify the order by the confirm's `sessionId` or the `orderId` from
+     * `settlementOutcome`. A settled card charge carries `processorRef` (pi_…);
+     * a settled stablecoin transfer carries `txHash` (+ `chainId`). Amounts must
+     * match the order EXACTLY (integer minor units) or the report is rejected
+     * whole (409 amount_mismatch). Replays of the same terminal state are safe.
      */
     reportSettlement(options: {
-        sessionId: string;
+        sessionId?: string;
+        orderId?: string;
         status: 'settled' | 'declined' | 'failed';
         amountMinor: number;
         currency: string;
-        /** Stripe PaymentIntent id — REQUIRED when status is 'settled'. */
+        /** Stripe PaymentIntent id (card) — this or `txHash` is required when settled. */
         processorRef?: string;
+        /** Stablecoin transfer transaction hash (0x…, 32 bytes). */
+        txHash?: string;
+        chainId?: number;
         failureCode?: string;
     }): Promise<{
         orderId: string;
@@ -2230,7 +2357,7 @@ interface ParsedRFC9421 {
  */
 declare function parseRFC9421(headers: Record<string, string | string[] | undefined>): ParsedRFC9421 | null;
 
-type RegistryName = 'mastercard' | 'visa' | 'web-bot-auth';
+type RegistryName = 'mastercard' | 'visa' | 'web-bot-auth' | 'astrasync';
 interface RegistryResolver {
     readonly name: RegistryName;
     resolve(kid: string, context?: ResolveContext): Promise<JWK | null>;
@@ -2971,9 +3098,11 @@ declare function verifyMPP(input: MPPVerifyInput): MPPVerifyResult;
  * superset of x402; this module normalizes x402 output to MPP-shape so
  * downstream pipeline code is uniform.
  *
- * Where x402 lives on the wire:
- *  - 402 response body (v2) OR `X-PAYMENT-REQUIRED` header (v1) — PaymentRequired
- *  - Request body (v2) OR `X-PAYMENT` header (v1, base64) — PaymentPayload
+ * Where x402 lives on the wire (x402 Foundation transports-v2/http.md):
+ *  - v2: `PAYMENT-REQUIRED` header (402, base64 JSON) — PaymentRequired;
+ *        `PAYMENT-SIGNATURE` request header (base64 JSON) — PaymentPayload.
+ *        Bodies are a server concern; a JSON body is accepted as a fallback.
+ *  - v1: `X-PAYMENT-REQUIRED` / `X-PAYMENT` headers (and a 402 JSON body).
  */
 type X402Kind = 'required' | 'payload' | 'error' | 'unknown';
 interface X402RequirementsSummary {
@@ -3209,7 +3338,7 @@ interface CommerceContext {
     };
     paymentToken?: {
         present: boolean;
-        type: 'stripe-spt' | 'acp-vt' | 'tempo-tx' | 'other' | null;
+        type: 'stripe-spt' | 'acp-vt' | 'tempo-tx' | 'x402-payload' | 'ap2-payment-mandate' | 'other' | null;
     };
     mppMethodsOffered?: string[];
     constraints?: ConstraintEvalResult;
@@ -3764,7 +3893,7 @@ interface McpMiddlewareOptions extends GatewayConfig {
     /** Skip verification + dedupe entirely. For testing. */
     skip?: boolean;
     /** Custom denied handler. Defaults to a structured JSON-RPC error response. */
-    onDenied?: (result: VerificationResult, req: Request, res: Response$1) => void;
+    onDenied?: (result: VerificationResult, req: Request$1, res: Response$1) => void;
     /**
      * If `true`, trust an inbound `X-Astra-Verified-Hop` header to skip
      * verify-access when it carries a recent marker for the resolved agent.
@@ -3897,7 +4026,7 @@ interface AstraSyncConfig {
  * Multi-protocol declarations the agent participates in.
  * Promoted from `metadata.protocols[]` to a first-class field in agent-registration v1.0.0.
  */
-type AgentProtocol = 'a2a' | 'acp' | 'ap2' | 'ucp' | 'mpp' | 'x402' | 'erc8004' | 'vi' | 'agentpay' | 'tap' | 'other';
+type AgentProtocol = 'a2a' | 'acp' | 'ap2' | 'ucp' | 'mpp' | 'x402' | 'erc8004' | 'vi' | 'agentpay' | 'tap' | 'webbotauth' | 'other';
 /** PDLSS purpose configuration. */
 interface PDLSSPurpose {
     categories: string[];
@@ -4284,6 +4413,32 @@ declare class RegistrationTimeoutError extends AstraSyncError {
     readonly requestId: string;
     constructor(requestId: string);
 }
+/**
+ * 5.15.0: thrown by `client.reportSettlement()`. `statusCode` is the HTTP
+ * status (0 = the request never got a response: network error / timeout);
+ * `code` is the platform's error code (e.g. `amount_mismatch`,
+ * `conflicting_report`, `conflicting_reference`, `not_your_merchant`,
+ * `unknown_session`, `unknown_order`, `VALIDATION`, `api_key_expired`).
+ * `retryable` is the safe retry decision — see isRetryableSettlementError.
+ */
+declare class SettlementReportError extends AstraSyncError {
+    readonly issues?: Array<{
+        field: string;
+        message: string;
+    }>;
+    readonly retryable: boolean;
+    constructor(message: string, statusCode: number, code?: string, issues?: Array<{
+        field: string;
+        message: string;
+    }>);
+}
+/**
+ * Retry a settlement report only on a network error / timeout (statusCode
+ * 0), 429 or 5xx. Every 4xx is a decision about this report (wrong amount,
+ * not your order, conflicting outcome …) and replaying it can't succeed.
+ * Replaying the SAME terminal outcome is always safe (200 alreadySettled).
+ */
+declare function isRetryableSettlementError(err: unknown): boolean;
 
 /**
  * Guidance envelope for credentials-required cases.
@@ -4360,6 +4515,61 @@ interface BuildGuidanceParams {
  */
 declare function buildGuidance(params: BuildGuidanceParams): GuidanceEnvelope;
 
+/**
+ * ChallengeHandler — Agent-Side Runtime Challenge Responder
+ *
+ * Handles incoming runtime challenges from AstraSync's verification service.
+ * Agents register pending counterparties before initiating contact,
+ * then this handler validates and responds to challenges.
+ */
+interface ChallengeResponse {
+    status: number;
+    body: {
+        challengeId: string;
+        acknowledged: boolean;
+        pendingCounterparties: string[];
+        respondedAt: string;
+        error?: string;
+    };
+}
+interface ChallengeHandlerConfig {
+    agentId: string;
+}
+declare class ChallengeHandler {
+    private agentId;
+    /** Counterparty → in-flight interactions (two concurrent calls to one counterparty both count). */
+    private pendingCounterparties;
+    constructor(config: ChallengeHandlerConfig);
+    /**
+     * Register a counterparty as pending (before initiating contact).
+     */
+    registerPending(counterpartyId: string): void;
+    /**
+     * Remove a counterparty from pending list (after interaction complete).
+     */
+    removePending(counterpartyId: string): void;
+    /**
+     * Get current pending counterparties list.
+     */
+    getPendingList(): string[];
+    /**
+     * Express middleware for the challenge endpoint.
+     * Mount at: app.post('/astrasync/challenge', handler.expressMiddleware())
+     */
+    expressMiddleware(): (req: {
+        body: unknown;
+    }, res: {
+        status: (code: number) => {
+            json: (body: unknown) => void;
+        };
+    }) => void;
+    /**
+     * Generic handler (framework-agnostic).
+     * Returns { status, body } for the caller to send.
+     */
+    handleChallenge(body: unknown): ChallengeResponse;
+}
+
 /**
  * AgentClient — Credential Presentation
  *
@@ -4376,15 +4586,29 @@ interface AgentClientConfig {
     apiBaseUrl?: string;
     /** API key used to authenticate ownership check + other authenticated calls. */
     apiKey?: string;
+    /**
+     * 5.16.0: the agent's runtime-challenge responder. When set, fetch()
+     * registers each call's counterparty as pending while the call is in
+     * flight, so the destination's runtime challenge passes for calls this
+     * agent is really making — and only those.
+     */
+    challengeHandler?: ChallengeHandler;
 }
 interface FetchOptions extends RequestInit {
     purpose?: string;
     action?: string;
+    /**
+     * 5.16.0: the destination's ASTRAE-id, when known. Its runtime challenge
+     * names the endpoint by ASTRAE-id (else by URL), so pass it for endpoints
+     * that require the challenge.
+     */
+    counterpartyId?: string;
 }
 declare class AgentClient {
     private credentials;
     private apiBaseUrl;
     private apiKey;
+    private challengeHandler;
     constructor(config: AgentClientConfig);
     /**
      * Async factory that validates the API key's account owns the configured
@@ -4430,60 +4654,6 @@ declare class AgentClient {
     private buildCredentials;
 }
 
-/**
- * ChallengeHandler — Agent-Side Runtime Challenge Responder
- *
- * Handles incoming runtime challenges from AstraSync's verification service.
- * Agents register pending counterparties before initiating contact,
- * then this handler validates and responds to challenges.
- */
-interface ChallengeResponse {
-    status: number;
-    body: {
-        challengeId: string;
-        acknowledged: boolean;
-        pendingCounterparties: string[];
-        respondedAt: string;
-        error?: string;
-    };
-}
-interface ChallengeHandlerConfig {
-    agentId: string;
-}
-declare class ChallengeHandler {
-    private agentId;
-    private pendingCounterparties;
-    constructor(config: ChallengeHandlerConfig);
-    /**
-     * Register a counterparty as pending (before initiating contact).
-     */
-    registerPending(counterpartyId: string): void;
-    /**
-     * Remove a counterparty from pending list (after interaction complete).
-     */
-    removePending(counterpartyId: string): void;
-    /**
-     * Get current pending counterparties list.
-     */
-    getPendingList(): string[];
-    /**
-     * Express middleware for the challenge endpoint.
-     * Mount at: app.post('/astrasync/challenge', handler.expressMiddleware())
-     */
-    expressMiddleware(): (req: {
-        body: unknown;
-    }, res: {
-        status: (code: number) => {
-            json: (body: unknown) => void;
-        };
-    }) => void;
-    /**
-     * Generic handler (framework-agnostic).
-     * Returns { status, body } for the caller to send.
-     */
-    handleChallenge(body: unknown): ChallengeResponse;
-}
-
 /**
  * PDLSS Formatter — Transport Format Conversion
  *
@@ -4605,6 +4775,28 @@ declare namespace index {
   export { index_AgentClient as AgentClient, index_AstraSyncSdkError as AstraSyncSdkError, index_ChallengeHandler as ChallengeHandler, index_OwnershipMismatchError as OwnershipMismatchError, type index_PDLSSConfig as PDLSSConfig, type index_TransportPDLSS as TransportPDLSS, index_formatPDLSSForTransport as formatPDLSSForTransport, index_parsePDLSSFromTransport as parsePDLSSFromTransport, index_recordDecision as recordDecision };
 }
 
+/**
+ * Route pattern compiler shared by every matcher of endpoint route policy:
+ * the express and Next.js middleware, the edge config and the AstraSync
+ * bridge (round 27.9 — they each had their own copy, and none understood
+ * path parameters).
+ *
+ * Pattern syntax:
+ *   - `*`       any characters, including `/` (unchanged since v1)
+ *   - `:name`   exactly one path segment (no `/`), e.g.
+ *               `/ucp/v1/checkout-sessions/:id/complete`
+ *   - anything else is literal — `.`, `?`, `+`, `(`… are escaped (they used
+ *     to be live regex syntax, so `/robots.txt` also matched `/robotsXtxt`).
+ * Anchored `^…$`. Case-sensitive unless `caseInsensitive` is set.
+ */
+declare function routePatternToRegExp(pattern: string, opts?: {
+    caseInsensitive?: boolean;
+}): RegExp | null;
+/** True when `path` matches `pattern` (see routePatternToRegExp). */
+declare function matchRoutePattern(pattern: string, path: string, opts?: {
+    caseInsensitive?: boolean;
+}): boolean;
+
 /**
  * Edge verification config — the per-endpoint policy the Trusted Agent
  * Gateway edge adapters (e.g. `@astrasyncai/adapter-lambda`) fetch from the
@@ -4704,6 +4896,13 @@ interface EdgeConfig {
      * endpoint owner explicitly configures this.
      */
     queryValueAllowlist?: string[];
+    /**
+     * 5.15.0: minimum TLS version for AGENT traffic (UCP 2026-08-25 requires
+     * TLS 1.3). Read from CloudFront-Viewer-TLS; follows the path's mode —
+     * enforce answers 426 Upgrade Required, observe only logs. Human browsers
+     * are never gated, and an unknown version never blocks. ABSENT = no check.
+     */
+    minTls?: '1.2' | '1.3';
     /**
      * 4.5.0: the EFFECTIVE failure posture is derived from the effective
      * mode — fail posture follows success posture. Observe fails open
@@ -4935,7 +5134,7 @@ declare function detectRuntime(userAgent: string | undefined | null): string | u
  * silently (never throwing), so this is a no-op there — which is correct:
  * in a browser the page's real UA is the honest identity.
  */
-declare const SDK_USER_AGENT = "astrasync-sdk/5.14.0";
+declare const SDK_USER_AGENT = "astrasync-sdk/5.16.0";
 declare const sdkFetch: typeof fetch;
 
 interface LocalPolicy {
@@ -5053,6 +5252,1126 @@ declare function parseYaml(yamlContent: string): ParseResult;
  * is fine — bumping both in the release-ceremony commit keeps them
  * lockstep.
  */
-declare const SDK_VERSION = "5.14.0";
+declare const SDK_VERSION = "5.16.0";
+
+/**
+ * 5.15.0 — the `UCP-Agent` request header (UCP 2026-08-25): an RFC 8941
+ * structured-field dictionary whose `profile` member is the URL of the calling
+ * platform's UCP profile, e.g.
+ *
+ *   UCP-Agent: profile="https://agent.example/.well-known/ucp"
+ *
+ * A UCP merchant behind AstraSync binds it to the verified agent: the profile
+ * must be the one the agent registered (gadget D, round 27.9). Without the
+ * binding, any caller could present a verified agent's id with someone
+ * else's profile and capabilities.
+ */
+
+/** The `profile` URL from a `UCP-Agent` header, or null when absent/malformed. */
+declare function parseUcpAgentHeader(header: string | string[] | null | undefined): string | null;
+type UcpAgentBinding = {
+    ok: true;
+    profile: string | null;
+} | {
+    ok: false;
+    code: 'invalid_ucp_agent' | 'ucp_agent_mismatch';
+    message: string;
+};
+/**
+ * Check a request's `UCP-Agent` header against the verified agent's registered
+ * UCP profile. Rules:
+ *  - header absent and agent has no registered profile → ok (not a UCP caller)
+ *  - header absent but agent registered one → ok, profile = the registered one
+ *  - header present but malformed / not https → `invalid_ucp_agent`
+ *  - header present and agent registered a DIFFERENT profile → `ucp_agent_mismatch`
+ *  - header present, agent registered none → `ucp_agent_mismatch` (unbound
+ *    profiles are refused; register it in the agent's protocol step)
+ */
+declare function checkUcpAgentBinding(header: string | string[] | null | undefined, identities: AgentProtocolIdentities | undefined): UcpAgentBinding;
+
+/**
+ * 5.15.0 — the business profile at `/.well-known/ucp` (UCP 2026-08-25,
+ * docs/specification/overview). `ucp.version`, `ucp.services` and
+ * `ucp.payment_handlers` are required even when empty; signing keys are the
+ * TOP-LEVEL `keys[]` (a JWK Set). Served over HTTPS, never redirected, with
+ * `Cache-Control: public, max-age >= 60`.
+ */
+
+declare const UCP_VERSION = "2026-08-25";
+interface UcpServiceEntry {
+    version: string;
+    spec: string;
+    transport: 'rest' | 'mcp' | 'a2a' | 'embedded';
+    endpoint: string;
+    schema?: string;
+}
+interface UcpCapabilityEntry {
+    version: string;
+    spec: string;
+    schema: string;
+    extends?: string;
+    config?: Record<string, unknown>;
+}
+interface UcpPaymentHandlerEntry {
+    id: string;
+    version: string;
+    spec: string;
+    schema: string;
+    available_instruments?: Array<{
+        type: string;
+        constraints?: Record<string, unknown>;
+    }>;
+    config?: Record<string, unknown>;
+}
+interface UcpProfile {
+    ucp: {
+        version: string;
+        services: Record<string, UcpServiceEntry[]>;
+        capabilities?: Record<string, UcpCapabilityEntry[]>;
+        payment_handlers: Record<string, UcpPaymentHandlerEntry[]>;
+    };
+    keys?: JWK[];
+}
+/** AstraSync payment handler declarations (spec pages hosted on astrasync.ai). */
+declare function astrasyncPaymentHandlers(handlers: string[], specBase?: string): Record<string, UcpPaymentHandlerEntry[]>;
+interface BuildProfileOptions {
+    /** REST base, e.g. https://shop.example/ucp/v1 */
+    endpoint: string;
+    /** Public signing keys (JWKs with kid). */
+    keys?: JWK[];
+    /** Payment handler ids you accept (see the endpoint's paymentHandlers). */
+    paymentHandlers?: string[];
+    /** Accept AP2 mandates (adds dev.ucp.common.payment.ap2_mandate). */
+    ap2Mandates?: boolean;
+    /** Extra capabilities beyond checkout (e.g. order). */
+    capabilities?: Record<string, UcpCapabilityEntry[]>;
+}
+declare function buildUcpProfile(opts: BuildProfileOptions): UcpProfile;
+/** A fetch-style handler for GET /.well-known/ucp. */
+declare function ucpProfileHandler(profile: UcpProfile, maxAgeSec?: number): () => Promise<Response>;
+
+type UcpDiscoveryError = {
+    ok: false;
+    status: 400 | 422 | 424;
+    code: 'invalid_profile_url' | 'profile_unreachable' | 'profile_malformed' | 'version_unsupported';
+    content: string;
+};
+type UcpProfileResult = {
+    ok: true;
+    profile: UcpProfile;
+} | UcpDiscoveryError;
+/** True for loopback / private / link-local / CGNAT / multicast / reserved addresses. */
+declare function isSpecialUseIp(ip: string): boolean;
+interface FetchProfileOptions {
+    timeoutMs?: number;
+    fetch?: typeof fetch;
+    /** Skip DNS resolution checks (tests only). */
+    skipDnsCheck?: boolean;
+    /** Bypass the cache (unknown signing key → refresh once per TTL). */
+    fresh?: boolean;
+}
+declare function fetchUcpProfile(url: string, opts?: FetchProfileOptions): Promise<UcpProfileResult>;
+interface NegotiationResult {
+    ok: boolean;
+    version: string;
+    /** Capability names both sides support (extensions only with their base). */
+    capabilities: Record<string, UcpCapabilityEntry[]>;
+    error?: UcpDiscoveryError;
+}
+/**
+ * Intersect the business's and platform's profiles. `supportedVersions` is
+ * every protocol version the business still serves (current first).
+ */
+declare function negotiateUcp(business: UcpProfile, platform: UcpProfile, supportedVersions?: string[]): NegotiationResult;
+
+/**
+ * 5.15.0 — UCP `messages[]` and response envelopes (UCP 2026-08-25
+ * shopping/checkout). Error severities: recoverable, requires_buyer_input,
+ * requires_buyer_review, unrecoverable — `requires_*` contribute to
+ * `status: 'requires_escalation'`, which MUST carry an absolute https
+ * `continue_url`.
+ */
+type UcpSeverity = 'recoverable' | 'requires_buyer_input' | 'requires_buyer_review' | 'unrecoverable';
+type UcpMessage = {
+    type: 'error';
+    code: string;
+    content: string;
+    severity: UcpSeverity;
+    path?: string;
+    content_type?: 'plain' | 'markdown';
+} | {
+    type: 'warning';
+    code: string;
+    content: string;
+    presentation?: 'notice' | 'disclosure';
+    url?: string;
+} | {
+    type: 'info';
+    content: string;
+    code?: string;
+};
+declare const ucpError: (code: string, content: string, severity?: UcpSeverity, path?: string) => UcpMessage;
+/**
+ * The AstraSync step-up → UCP escalation: the buyer approves on AstraSync's
+ * approval page (`approvalUrl`), then the platform completes again.
+ */
+declare function ucpEscalation(approvalUrl: string, content?: string): {
+    status: "requires_escalation";
+    continue_url: string;
+    messages: UcpMessage[];
+};
+/** A failed-operation envelope: `{ ucp: { version, status: 'error' }, messages, continue_url? }`. */
+declare function ucpFailure(version: string, messages: UcpMessage[], continueUrl?: string): {
+    continue_url?: string | undefined;
+    ucp: {
+        version: string;
+        status: "error";
+    };
+    messages: UcpMessage[];
+};
+
+/**
+ * 5.15.0 — UCP message signatures (UCP 2026-08-25 signatures.md): RFC 9421
+ * with
+ *   covered: "@method" "@authority" "@path" (+ "@query" when present)
+ *            + "ucp-agent" / "signature-agent" when those headers are sent
+ *            + "idempotency-key" on POST / PUT / PATCH / DELETE
+ *            + "content-digest" "content-type" when there is a body
+ *   params:  keyid (created optional; `alg` NOT included — the JWK's
+ *            kty/crv decides). ECDSA signatures are raw r||s.
+ * `keyid` resolves to a `kid` in the signer's profile `keys[]` (keys with
+ * `use: 'enc'` are skipped); an unknown kid forces one profile refresh.
+ * Responses sign ("@status" "content-digest" "content-type").
+ * Errors: signature_missing / signature_invalid / key_not_found (401),
+ * digest_mismatch / algorithm_unsupported (400).
+ */
+
+interface UcpSignableRequest {
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    body?: string;
+}
+/** The components UCP requires for this request. */
+declare function ucpRequiredComponents(req: UcpSignableRequest): string[];
+/** Sign a UCP request (platform → business, or business → platform webhook). */
+declare function signUcpRequest(req: UcpSignableRequest, key: {
+    privateKey: KeyObject | string;
+    keyId: string;
+}): Promise<Record<string, string>>;
+/** Sign a UCP response: ("@status" "content-digest" "content-type"). */
+declare function signUcpResponse(res: {
+    status: number;
+    headers: Record<string, string>;
+    body: string;
+}, key: {
+    privateKey: KeyObject | string;
+    keyId: string;
+}): Promise<Record<string, string>>;
+type UcpSignatureResult = {
+    ok: true;
+    keyId: string;
+} | {
+    ok: false;
+    status: 400 | 401;
+    code: 'signature_missing' | 'signature_invalid' | 'key_not_found' | 'digest_mismatch' | 'algorithm_unsupported';
+    content: string;
+};
+/**
+ * Verify a signed UCP request against the signer's profile keys.
+ * `getKeys(fresh)` returns the signer profile's `keys[]` (refreshed once on
+ * an unknown kid).
+ */
+declare function verifyUcpRequest(req: UcpSignableRequest, getKeys: (fresh: boolean) => Promise<JWK[]>): Promise<UcpSignatureResult>;
+interface UcpWebhookOptions {
+    url: string;
+    /** The order event body (JSON). */
+    body: unknown;
+    privateKey: KeyObject | string;
+    keyId: string;
+    /** Your business profile URL (sent as UCP-Agent). */
+    businessProfileUrl: string;
+    attempts?: number;
+    fetch?: typeof fetch;
+}
+/** Send a signed UCP order webhook with retry/backoff on network errors, 429 and 5xx. */
+declare function sendUcpWebhook(opts: UcpWebhookOptions): Promise<{
+    ok: boolean;
+    status: number;
+    attempts: number;
+}>;
+
+interface IdempotencyRecord {
+    state: 'in_progress' | 'done';
+    requestHash: string;
+    status?: number;
+    headers?: Record<string, string>;
+    body?: string;
+}
+interface IdempotencyStore {
+    get(key: string): Promise<IdempotencyRecord | null>;
+    /** Store only when absent (the lock). Returns false when the key exists. */
+    create(key: string, record: IdempotencyRecord, ttlMs: number): Promise<boolean>;
+    set(key: string, record: IdempotencyRecord, ttlMs: number): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+/** In-process store (single instance / tests). */
+declare class MemoryIdempotencyStore implements IdempotencyStore {
+    private now;
+    private map;
+    constructor(now?: () => number);
+    private live;
+    get(key: string): Promise<IdempotencyRecord | null>;
+    create(key: string, record: IdempotencyRecord, ttlMs: number): Promise<boolean>;
+    set(key: string, record: IdempotencyRecord, ttlMs: number): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+/** The subset of a Redis client this store needs (ioredis / node-redis v4 compatible). */
+interface RedisLike {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, ...args: Array<string | number>): Promise<unknown>;
+    del(key: string): Promise<unknown>;
+}
+/** Shared store across instances. */
+declare class RedisIdempotencyStore implements IdempotencyStore {
+    private redis;
+    private prefix;
+    constructor(redis: RedisLike, prefix?: string);
+    get(key: string): Promise<IdempotencyRecord | null>;
+    create(key: string, record: IdempotencyRecord, ttlMs: number): Promise<boolean>;
+    set(key: string, record: IdempotencyRecord, ttlMs: number): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+interface IdempotencyOptions {
+    store: IdempotencyStore;
+    /** 'ucp' (default) or 'acp' — see the module comment. */
+    profile?: 'ucp' | 'acp';
+    /** Default 24 h. */
+    ttlMs?: number;
+    /** Default `idempotency-key`. */
+    header?: string;
+    /** Methods covered. Default POST, PUT, PATCH, DELETE. */
+    methods?: string[];
+    /** Require the header on covered methods (400 when missing). Default false. */
+    required?: boolean;
+}
+declare const DEFAULT_IDEMPOTENCY_TTL_MS: number;
+type IdempotencyDecision = {
+    kind: 'skip';
+} | {
+    kind: 'proceed';
+    storeKey: string;
+    requestHash: string;
+} | {
+    kind: 'replay';
+    status: number;
+    headers: Record<string, string>;
+    body: string;
+} | {
+    kind: 'reject';
+    status: number;
+    code: string;
+    message: string;
+    retryAfterSec?: number;
+};
+/**
+ * SHA-256 of the request body: raw bytes for 'ucp', canonical JSON (when it
+ * parses) for 'acp'.
+ */
+declare function requestFingerprint(body: string, profile?: 'ucp' | 'acp'): string;
+/** Platform-neutral core: decide before handling a request. */
+declare function beginIdempotent(opts: IdempotencyOptions, req: {
+    method: string;
+    path: string;
+    body: string;
+    key: string | undefined;
+    auth?: string;
+}): Promise<IdempotencyDecision>;
+/** Platform-neutral core: record the outcome after handling. */
+declare function finishIdempotent(opts: IdempotencyOptions, decision: Extract<IdempotencyDecision, {
+    kind: 'proceed';
+}>, response: {
+    status: number;
+    headers: Record<string, string>;
+    body: string;
+}): Promise<void>;
+interface ExpressReq {
+    method: string;
+    originalUrl?: string;
+    url: string;
+    body?: unknown;
+    headers: Record<string, string | string[] | undefined>;
+}
+interface ExpressRes {
+    statusCode: number;
+    status(code: number): ExpressRes;
+    setHeader(name: string, value: string): unknown;
+    getHeader(name: string): unknown;
+    send(body: unknown): unknown;
+    json(body: unknown): unknown;
+    end(...args: unknown[]): unknown;
+}
+/** Express middleware. Mount after body parsing, before the checkout routes. */
+declare function idempotencyMiddleware(opts: IdempotencyOptions): (req: ExpressReq, res: ExpressRes, next: (err?: unknown) => void) => Promise<void>;
+/** Next.js / fetch-style route handler wrapper. */
+declare function withIdempotency(opts: IdempotencyOptions, handler: (req: Request) => Promise<Response>): (req: Request) => Promise<Response>;
+
+interface CatalogItem {
+    id: string;
+    title: string;
+    /** Minor units. */
+    price: number;
+}
+interface CheckoutLine {
+    id: string;
+    item: CatalogItem;
+    quantity: number;
+    totals: Array<{
+        type: string;
+        amount: number;
+    }>;
+}
+interface CheckoutSession {
+    id: string;
+    status: 'incomplete' | 'requires_escalation' | 'ready_for_complete' | 'complete_in_progress' | 'completed' | 'canceled';
+    currency: string;
+    line_items: CheckoutLine[];
+    totals: Array<{
+        type: string;
+        amount: number;
+    }>;
+    buyer?: Record<string, unknown>;
+    messages?: UcpMessage[];
+    continue_url?: string;
+    order?: {
+        id: string;
+        permalink_url?: string;
+    };
+    /** Kit state (never serialised). */
+    _platformProfile?: string;
+    _ap2?: boolean;
+    _platformKeys?: JWK[];
+    _astraOrderId?: string;
+    _attemptId?: string;
+    /** The AstraSync cart id the platform sent (X-Astra-Checkout-Session). */
+    _astraCheckoutSessionId?: string;
+    /** The attached checkout JWS behind the last merchant_authorization sent. */
+    _checkoutJwt?: string;
+}
+interface CheckoutStore {
+    get(id: string): Promise<CheckoutSession | null>;
+    put(s: CheckoutSession): Promise<void>;
+}
+declare class MemoryCheckoutStore implements CheckoutStore {
+    private m;
+    get(id: string): Promise<CheckoutSession | null>;
+    put(s: CheckoutSession): Promise<void>;
+}
+type SettleResult = {
+    status: 'settled';
+    processorRef?: string;
+    txHash?: string;
+    chainId?: number;
+} | {
+    status: 'pending';
+} | {
+    status: 'failed';
+    failureCode?: string;
+};
+interface UcpCheckoutKitOptions {
+    /** Profile inputs (endpoint, keys, paymentHandlers, ap2Mandates). */
+    profile: BuildProfileOptions;
+    currency: string;
+    /** Your catalog: the item, or null when unknown. */
+    catalog: (itemId: string) => Promise<CatalogItem | null>;
+    /** AstraSync verification of the purchase (e.g. `client.confirmCheckout`). */
+    verifyPurchase: (ctx: {
+        session: CheckoutSession;
+        /**
+         * Pass as `checkoutSessionId` to AstraSync: the platform's cart id when
+         * it sent one (an owner approval is bound to that cart), else this
+         * checkout's id.
+         */
+        checkoutSessionId: string;
+        astraId?: string;
+        attemptId?: string;
+        checkoutJwt?: string;
+        valueMajor: number;
+    }) => Promise<VerificationResult>;
+    /** Charge / redeem with YOUR processor using the artifact AstraSync handed you. */
+    settle: (ctx: {
+        session: CheckoutSession;
+        result: VerificationResult;
+        instrument?: Record<string, unknown>;
+    }) => Promise<SettleResult>;
+    /** Report the outcome to AstraSync (e.g. `client.reportSettlement`). */
+    reportSettlement?: (r: Parameters<VerificationGatewayClient['reportSettlement']>[0]) => Promise<unknown>;
+    /** Create your order once paid. */
+    fulfil: (ctx: {
+        session: CheckoutSession;
+        result: VerificationResult;
+    }) => Promise<{
+        id: string;
+        permalink_url?: string;
+    }>;
+    /** Merchant key for ap2.merchant_authorization (when ap2Mandates). */
+    signingKey?: {
+        privateKey: KeyLike | KeyObject;
+        kid: string;
+    };
+    /** Resolve an AP2 mandate signer key by kid (default: the platform profile keys). */
+    mandateKey?: (kid: string | undefined, session: CheckoutSession) => Promise<JWK | null>;
+    store?: CheckoutStore;
+    idempotencyStore?: IdempotencyStore;
+    /** Require RFC 9421 signatures on platform requests. Default false. */
+    requireSignedRequests?: boolean;
+    /** Where to send a buyer when nothing better exists (continue_url). */
+    fallbackContinueUrl?: string;
+    /** Profile fetch override (tests). */
+    fetchProfile?: (url: string, fresh: boolean) => Promise<UcpProfile | UcpDiscoveryError>;
+}
+declare function createUcpCheckoutKit(opts: UcpCheckoutKitOptions): {
+    handle: (req: Request) => Promise<Response>;
+    profile: UcpProfile;
+    profileHandler: () => Response;
+};
+
+/** RFC 8785-style canonical JSON (sorted keys, no whitespace). */
+declare function canonicalJson(value: unknown): string;
+
+/**
+ * 5.15.0 — x402 v2 (x402 Foundation, specs/transports-v2/http.md) helpers for
+ * a MERCHANT. The merchant's own facilitator verifies and settles; AstraSync
+ * never facilitates or touches the funds. All protocol data travels in
+ * headers as standard base64 JSON:
+ *   PAYMENT-REQUIRED  (server → client, with HTTP 402)  PaymentRequired
+ *   PAYMENT-SIGNATURE (client → server)                 PaymentPayload
+ *   PAYMENT-RESPONSE  (server → client)                 SettlementResponse
+ */
+interface X402ResourceInfo {
+    url: string;
+    description?: string;
+    mimeType?: string;
+    /** ≤ 32 characters. */
+    serviceName?: string;
+    /** ≤ 5 entries. */
+    tags?: string[];
+    iconUrl?: string;
+}
+interface X402PaymentRequirements {
+    scheme: string;
+    /** CAIP-2, e.g. `eip155:8453`. */
+    network: string;
+    /** Atomic token units, as a string. */
+    amount: string;
+    /** Token contract address, or ISO 4217 code for fiat. */
+    asset: string;
+    payTo: string;
+    maxTimeoutSeconds: number;
+    extra?: Record<string, unknown>;
+}
+interface X402PaymentRequired {
+    x402Version: 2;
+    error?: string;
+    resource: X402ResourceInfo;
+    accepts: X402PaymentRequirements[];
+    extensions?: Record<string, {
+        info: unknown;
+        schema?: unknown;
+    }>;
+}
+interface X402PaymentPayload {
+    x402Version: number;
+    resource?: X402ResourceInfo;
+    accepted: X402PaymentRequirements;
+    payload: Record<string, unknown>;
+    extensions?: Record<string, unknown>;
+}
+interface X402SettlementResponse {
+    success: boolean;
+    errorReason?: string;
+    payer?: string;
+    /** Empty string when settlement failed. */
+    transaction: string;
+    network: string;
+    amount?: string;
+    extensions?: Record<string, unknown>;
+}
+/** A 402 answer: status, the PAYMENT-REQUIRED header, and an empty JSON body. */
+declare function buildX402Challenge(input: Omit<X402PaymentRequired, 'x402Version'>): {
+    status: 402;
+    headers: Record<string, string>;
+    body: Record<string, never>;
+};
+/** Decode the client's PAYMENT-SIGNATURE header (null when absent/malformed). */
+declare function parseX402Payment(header: string | null | undefined): X402PaymentPayload | null;
+/** Decode a PAYMENT-REQUIRED header (agent side / tests). */
+declare function parseX402Challenge(header: string | null | undefined): X402PaymentRequired | null;
+/** The PAYMENT-RESPONSE header value for your facilitator's settlement result. */
+declare function encodeX402SettlementResponse(r: X402SettlementResponse): string;
+/**
+ * The chosen requirement must be one you offered (scheme, network, asset,
+ * payTo, amount) — check before handing the payload to your facilitator.
+ */
+declare function x402PaymentMatchesOffer(payment: X402PaymentPayload, offered: X402PaymentRequirements[]): boolean;
+
+interface MppChallenge {
+    id: string;
+    realm: string;
+    /** Lowercase ASCII, e.g. `stripe`, `tempo`. */
+    method: string;
+    /** e.g. `charge`, `session`, `subscription`. */
+    intent: string;
+    /** base64url (no padding) of the method request JSON. */
+    request: string;
+    expires?: string;
+    digest?: string;
+    description?: string;
+    opaque?: string;
+    header?: 'Payment-Authorization';
+}
+interface MppCredential {
+    challenge: MppChallenge;
+    source?: string;
+    payload: Record<string, unknown>;
+}
+interface MppReceipt {
+    status: 'success';
+    method: string;
+    timestamp: string;
+    reference: string;
+}
+/**
+ * One `WWW-Authenticate: Payment …` value. Offer several methods by sending
+ * one header per method. `request` is the method's request object
+ * (e.g. stripe: `{ amount: '5000', currency: 'usd', … }`).
+ */
+declare function buildMppChallenge(input: Omit<MppChallenge, 'id' | 'request'> & {
+    request: Record<string, unknown>;
+}, hmacSecret: string): {
+    challenge: MppChallenge;
+    header: string;
+};
+/** Decode `Authorization: Payment <…>` (or Payment-Authorization). */
+declare function parseMppCredential(header: string | null | undefined): MppCredential | null;
+/** True when the echoed challenge is one this server issued (and isn't expired). */
+declare function verifyMppChallenge(challenge: MppChallenge, hmacSecret: string, now?: Date): boolean;
+/** The decoded method request from a challenge. */
+declare function decodeMppRequest(challenge: MppChallenge): Record<string, unknown> | null;
+/** `Payment-Receipt` header value — 2xx responses only. */
+declare function encodeMppReceipt(r: MppReceipt): string;
+
+/**
+ * 5.15.0 — KYAPay token verification for a seller
+ * (draft-skyfire-oauth-kyapay-token; header `KYAPay-Token`, comma-separated
+ * JWTs). AstraSync's use is IDENTITY: by default only `kya+jwt` tokens are
+ * accepted. `pay+jwt` / `kya-pay+jwt` carry payment value (settled by the
+ * issuer, never AstraSync) and are refused unless you opt in.
+ *
+ * Validation per the draft: signature by the issuer's key (`kid`, JWKS at
+ * `{iss}/.well-known/jwks.json`), `iss`, `exp`/`iat` with 30 s skew, `jti` a
+ * UUID, `aud` = you, `env` when configured; `alg: none` refused. Issuer
+ * values differ between Skyfire's docs and examples, so `issuer` is
+ * configuration (production `https://app.skyfire.xyz` per docs.skyfire.xyz).
+ * When the token carries `cnf`, the request must also be RFC 9421-signed by
+ * that key — returned as `requiresSignatureKey` for the caller to enforce.
+ */
+
+type KyaPayTokenType = 'kya+jwt' | 'pay+jwt' | 'kya-pay+jwt';
+interface KyaPayVerifyOptions {
+    issuer: string;
+    /** Your seller id (the token's `aud`). */
+    audience: string;
+    /** Defaults to `${issuer}/.well-known/jwks.json`. */
+    jwksUrl?: string;
+    /** Pinned issuer keys instead of fetching the JWKS. */
+    keys?: JWK[];
+    /** Default ['kya+jwt'] — identity only. */
+    acceptTypes?: KyaPayTokenType[];
+    env?: 'production' | 'sandbox';
+    clockToleranceSec?: number;
+}
+interface KyaPayIdentity {
+    type: KyaPayTokenType;
+    jti: string;
+    subject: string;
+    /** Human identity (`hid`): email + any verified names. Treat as PII. */
+    human?: Record<string, unknown>;
+    /** Agent platform (`apd`). */
+    platform?: Record<string, unknown>;
+    /** Agent (`aid`). */
+    agent?: Record<string, unknown>;
+    /** The key the request must be RFC 9421-signed with (`cnf.jwk`), if any. */
+    requiresSignatureKey?: JWK;
+    claims: JWTPayload;
+}
+type KyaPayResult = {
+    ok: true;
+    tokens: KyaPayIdentity[];
+} | {
+    ok: false;
+    error: string;
+};
+declare function verifyKyaPayTokens(header: string | null | undefined, opts: KyaPayVerifyOptions): Promise<KyaPayResult>;
+
+/**
+ * 5.15.0 — A-Comm Evidence Protocol (AEP) v1.0.3-rc.2 core
+ * (github.com/A-Comm-Tech/a-comm-evidence-protocol, spec section 4).
+ *
+ * AEP is an evidence layer beside the transaction ("parallel to the
+ * transaction, never gating it"): a sequential, tamper-evident hash chain of
+ * typed artifacts, each signed Ed25519 by the implementing party. This module
+ * is the byte-level core, verified against the published conformance vectors:
+ *
+ * - Section 4.1 canonical JSON: RFC 8785 (JCS) + NFC normalization of member names
+ *   and string values; member names sorted by UTF-16 code unit at every
+ *   level; numbers MUST be integers.
+ * - current_hash = "sha256:" + hex(SHA-256(canonical(hash_input))), where the
+ *   hash input is exactly {actor_id, actor_type, artifact_type,
+ *   interaction_channel, metadata, payload, previous_hash, timestamp};
+ *   previous_hash is inside it (null for genesis).
+ * - Section 4.3 server_signature = Ed25519 over the RAW 32 digest bytes (base64).
+ * - timestamps are RFC 3339 UTC 'Z', whole seconds.
+ */
+
+declare const AEP_SPEC_VERSION = "aep-1.0.3-rc.2";
+type AepArtifactType = 'discovery' | 'referral' | 'intent' | 'delegation' | 'policy' | 'cart' | 'authorization' | 'fulfillment' | 'refund';
+type AepActorType = 'user' | 'agent' | 'merchant' | 'psp' | 'fulfillment_provider' | 'credentials_provider' | 'identity_verifier';
+interface AepHashInput {
+    actor_id: string;
+    actor_type: AepActorType;
+    artifact_type: AepArtifactType;
+    interaction_channel: 'voice' | 'text_chat' | 'voice_and_text' | null;
+    metadata: Record<string, unknown> | null;
+    payload: Record<string, unknown>;
+    previous_hash: string | null;
+    timestamp: string;
+}
+/** AEP section 4.1 canonical JSON (JCS + NFC + UTF-16 key order + integer-only numbers). */
+declare function aepCanonicalJson(value: unknown): string;
+/** "sha256:<64 lowercase hex>" of a hash input (or any canonicalizable value). */
+declare function aepHash(input: AepHashInput | unknown): string;
+/** AEP timestamp: RFC 3339 UTC 'Z', whole seconds. */
+declare function aepTimestamp(d?: Date): string;
+/** An Ed25519 private key from a 32-byte seed (base64). */
+declare function aepPrivateKeyFromSeed(seedBase64: string): KeyObject;
+/** An Ed25519 public key from its raw 32 bytes (base64). */
+declare function aepPublicKeyFromBase64(raw: string): KeyObject;
+/** The raw 32-byte public key (base64) of an Ed25519 key. */
+declare function aepRawPublicKey(key: KeyObject): string;
+/** Section 4.3: Ed25519 over the RAW 32 digest bytes; base64. */
+declare function aepSign(currentHash: string, privateKey: KeyObject): string;
+declare function aepVerifySignature(currentHash: string, signature: string, publicKey: KeyObject): boolean;
+interface AepArtifactRecord {
+    sequence_number: number;
+    artifact_type: AepArtifactType;
+    hash_input: AepHashInput;
+    current_hash: string;
+    server_signature: string;
+}
+interface AepChainVerification {
+    ok: boolean;
+    /** The first failing artifact's sequence number and why. */
+    failure?: {
+        sequence_number: number;
+        reason: string;
+    };
+    /** current_hash of the authorization artifact (the seal, section 2.5), if present. */
+    sealedHash?: string;
+}
+/** Section 4.3 verification steps for every artifact, in order. */
+declare function verifyAepChain(records: AepArtifactRecord[], publicKey: KeyObject): AepChainVerification;
+interface AepChainOptions {
+    privateKey: KeyObject;
+    /** Your published key id (signing_key_id at chain level). */
+    keyId: string;
+    merchantId: string;
+    chainId?: string;
+    /** Section 2.7 HMAC-SHA256 of your session token with a per-merchant salt. */
+    sessionIdHash?: string;
+    /** Extra hash-input metadata on every artifact (protocol, sdk_version…). */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * An AEP chain for one transaction. Append artifacts in order; each gets
+ * previous_hash, current_hash and server_signature. After the
+ * authorization artifact (the seal) only fulfillment / refund may follow.
+ */
+declare class AepChain {
+    private opts;
+    readonly records: AepArtifactRecord[];
+    readonly chainId: string;
+    private sealed;
+    constructor(opts: AepChainOptions);
+    append(a: {
+        artifact_type: AepArtifactType;
+        actor_type: AepActorType;
+        actor_id: string;
+        interaction_channel?: AepHashInput['interaction_channel'];
+        payload: Record<string, unknown>;
+        timestamp?: string;
+    }): AepArtifactRecord;
+    /** Chain-level fields (section 2.7) + records, for export. */
+    toBundle(): {
+        artifacts: AepArtifactRecord[];
+        session_id_hash?: string | undefined;
+        chain_id: string;
+        merchant_id: string;
+        spec_version: string;
+        signing_key_id: string;
+    };
+}
+/**
+ * The document to serve at /.well-known/aep-public-key (section 4.3: "tagged with a
+ * key_id"; keep a replaced key ≥ 90 days; list revocations). AEP rc.2 fixes
+ * no field names for it — this shape is AstraSync's.
+ */
+declare function aepPublicKeyDocument(keys: Array<{
+    keyId: string;
+    publicKey: KeyObject;
+    notBefore?: string;
+    notAfter?: string;
+}>, revocations?: Array<{
+    keyId: string;
+    revokedAt: string;
+}>): {
+    spec_version: string;
+    keys: {
+        not_after?: string | undefined;
+        not_before?: string | undefined;
+        key_id: string;
+        alg: string;
+        public_key_base64: string;
+    }[];
+    revocations: {
+        key_id: string;
+        revoked_at: string;
+    }[];
+};
+
+declare const ACP_API_VERSION = "2026-04-17";
+type AcpStatus = 'not_ready_for_payment' | 'ready_for_payment' | 'pending_approval' | 'complete_in_progress' | 'completed' | 'canceled';
+interface AcpMessage {
+    type: 'error' | 'info' | 'warning';
+    code?: string;
+    content: string;
+    severity?: 'info' | 'low' | 'medium' | 'high' | 'critical';
+    resolution?: 'recoverable' | 'requires_buyer_input' | 'requires_buyer_review';
+    param?: string | null;
+}
+interface AcpCheckoutSession {
+    id: string;
+    status: AcpStatus;
+    currency: string;
+    line_items: Array<{
+        id: string;
+        item: {
+            id: string;
+            name: string;
+            unit_amount: number;
+        };
+        quantity: number;
+        name: string;
+        unit_amount: number;
+        totals: Array<{
+            type: string;
+            amount: number;
+        }>;
+    }>;
+    totals: Array<{
+        type: string;
+        amount: number;
+    }>;
+    messages: AcpMessage[];
+    continue_url?: string;
+    order?: Record<string, unknown>;
+    _caller?: string;
+    _astraCheckoutSessionId?: string;
+}
+interface AcpCheckoutKitOptions {
+    currency: string;
+    /** Payment handlers you accept (endpoint paymentHandlers), e.g. ['ai.astrasync.voucher']. */
+    paymentHandlers: string[];
+    catalog: (itemId: string) => Promise<CatalogItem | null>;
+    verifyPurchase: (ctx: {
+        session: AcpCheckoutSession;
+        /** Pass as `checkoutSessionId` to AstraSync (the platform's cart id when sent). */
+        checkoutSessionId: string;
+        astraId?: string;
+        attemptId?: string;
+        valueMajor: number;
+    }) => Promise<VerificationResult>;
+    settle: (ctx: {
+        session: AcpCheckoutSession;
+        result: VerificationResult;
+        paymentData?: Record<string, unknown>;
+    }) => Promise<SettleResult>;
+    reportSettlement?: (r: Parameters<VerificationGatewayClient['reportSettlement']>[0]) => Promise<unknown>;
+    fulfil: (ctx: {
+        session: AcpCheckoutSession;
+        result: VerificationResult;
+    }) => Promise<{
+        id: string;
+        permalink_url?: string;
+    }>;
+    /** Base path the kit is mounted at (default ''). */
+    basePath?: string;
+    store?: {
+        get(id: string): Promise<AcpCheckoutSession | null>;
+        put(s: AcpCheckoutSession): Promise<void>;
+    };
+    idempotencyStore?: IdempotencyStore;
+    fallbackContinueUrl?: string;
+}
+declare function createAcpCheckoutKit(opts: AcpCheckoutKitOptions): {
+    handle: (req: Request) => Promise<Response>;
+};
+
+interface IssueDelegateOptions {
+    /** The mandate object (e.g. `{ vct: 'mandate.checkout.1', … }`). */
+    mandate: Record<string, unknown>;
+    /** Top-level mandate fields to make selectively disclosable (e.g. ['checkout_jwt']). */
+    sdFields?: string[];
+    privateKey: KeyLike;
+    kid: string;
+    alg?: 'ES256' | 'ES384';
+    /** Header `typ`. AP2 leaves the root's unspecified; omitted by default. */
+    typ?: string;
+    /** Extra signed claims on the token (KB hops: iat / aud / nonce / sd_hash). */
+    claims?: Record<string, unknown>;
+}
+/** Sign a delegate SD-JWT; returns `jwt~disclosure~…~`. */
+declare function issueDelegateSdJwt(opts: IssueDelegateOptions): Promise<string>;
+type RootKeyResolver = (kid: string | undefined, header: Record<string, unknown>) => Promise<JWK | null>;
+interface VerifiedChain {
+    /** Mandates of the LAST hop (what was finally authorised). */
+    mandates: Record<string, unknown>[];
+    /** Mandates of every hop, root first. */
+    hops: Array<{
+        header: Record<string, unknown>;
+        payload: Record<string, unknown>;
+        mandates: Record<string, unknown>[];
+    }>;
+}
+/**
+ * Verify an AP2 delegate chain: the root against `resolveRootKey(kid)`, each
+ * KB hop against the previous hop's `cnf.jwk` with its `sd_hash` /
+ * `issuer_jwt_hash` binding; terminal hops carry no `cnf`.
+ */
+declare function verifyDelegateChain(chain: string, resolveRootKey: RootKeyResolver, opts?: {
+    expectedAud?: string;
+    expectedNonce?: string;
+}): Promise<VerifiedChain>;
+
+declare const AP2_VCT: {
+    readonly checkout: "mandate.checkout.1";
+    readonly checkoutOpen: "mandate.checkout.open.1";
+    readonly payment: "mandate.payment.1";
+    readonly paymentOpen: "mandate.payment.open.1";
+};
+interface Ap2Party {
+    id: string;
+    name?: string;
+    website?: string;
+}
+/** b64url(SHA-256(ascii(checkout_jwt))) — also the payment mandate's transaction_id. */
+declare function checkoutHash(checkoutJwt: string): string;
+declare function closedCheckoutMandate(checkoutJwt: string, ttlSec?: number, now?: number): {
+    vct: "mandate.checkout.1";
+    checkout_jwt: string;
+    checkout_hash: string;
+    iat: number;
+    exp: number;
+};
+declare function closedPaymentMandate(input: {
+    transactionId: string;
+    payee: Ap2Party;
+    amountMinor: number;
+    currency: string;
+    instrument: {
+        id: string;
+        type: string;
+        description?: string;
+    };
+    ttlSec?: number;
+}, now?: number): {
+    vct: "mandate.payment.1";
+    transaction_id: string;
+    payee: Ap2Party;
+    payment_amount: {
+        amount: number;
+        currency: string;
+    };
+    payment_instrument: {
+        id: string;
+        type: string;
+        description?: string;
+    };
+    iat: number;
+    exp: number;
+};
+declare function openCheckoutMandate(input: {
+    agentJwk: JWK;
+    merchants: Ap2Party[];
+    lineItems: Array<{
+        id: string;
+        acceptableItems: Array<{
+            id: string;
+            title?: string;
+        }>;
+        quantity: number;
+    }>;
+    ttlSec?: number;
+}, now?: number): {
+    vct: "mandate.checkout.open.1";
+    constraints: ({
+        type: string;
+        items: {
+            id: string;
+            acceptable_items: {
+                id: string;
+                title?: string;
+            }[];
+            quantity: number;
+        }[];
+        allowed?: undefined;
+    } | {
+        type: string;
+        allowed: Ap2Party[];
+        items?: undefined;
+    })[];
+    cnf: {
+        jwk: JWK;
+    };
+    iat: number;
+    exp: number;
+};
+declare function openPaymentMandate(input: {
+    agentJwk: JWK;
+    payees: Ap2Party[];
+    currency: string;
+    maxMinor: number;
+    /** Digest binding this to the open checkout mandate (payment.reference). */
+    conditionalTransactionId: string;
+    ttlSec?: number;
+}, now?: number): {
+    vct: "mandate.payment.open.1";
+    constraints: ({
+        type: string;
+        currency: string;
+        max: number;
+        min: number;
+        allowed?: undefined;
+        conditional_transaction_id?: undefined;
+    } | {
+        type: string;
+        allowed: Ap2Party[];
+        currency?: undefined;
+        max?: undefined;
+        min?: undefined;
+        conditional_transaction_id?: undefined;
+    } | {
+        type: string;
+        conditional_transaction_id: string;
+        currency?: undefined;
+        max?: undefined;
+        min?: undefined;
+        allowed?: undefined;
+    })[];
+    cnf: {
+        jwk: JWK;
+    };
+    iat: number;
+    exp: number;
+};
+/** Sign a root mandate (AstraSync as trusted agent provider). */
+declare function signRootMandate(mandate: Record<string, unknown>, key: {
+    privateKey: KeyLike;
+    kid: string;
+}): Promise<string>;
+/**
+ * The digest of a root mandate's delegate disclosure — used as the open
+ * payment mandate's `payment.reference.conditional_transaction_id`.
+ */
+declare function rootMandateDigest(rootToken: string): string;
+/**
+ * Agent side: close an open mandate with a KB hop signed by the agent key in
+ * its `cnf` (terminal: the closed mandate carries no cnf).
+ */
+declare function createKbHop(prevToken: string, closedMandate: Record<string, unknown>, agentKey: {
+    privateKey: KeyLike;
+    kid?: string;
+}, aud: string, nonce?: string): Promise<string>;
+interface VerifyAp2Options {
+    /** Resolve the root signer's key (e.g. AstraSync's JWKS by kid). */
+    resolveRootKey: RootKeyResolver;
+    /** The vct you expect in the final hop. */
+    expectedVct: string;
+    /** For closed checkout mandates: the checkout JWT you signed. */
+    checkoutJwt?: string;
+    /** For closed payment mandates: the checkout hash it must reference. */
+    transactionId?: string;
+    expectedAud?: string;
+    expectedNonce?: string;
+    now?: number;
+}
+type Ap2VerifyResult = {
+    ok: true;
+    mandate: Record<string, unknown>;
+    chainLength: number;
+} | {
+    ok: false;
+    code: 'mandate_invalid_signature' | 'mandate_expired' | 'mandate_scope_mismatch';
+    error: string;
+};
+/** Verify an AP2 mandate (root or chain) end to end. */
+declare function verifyAp2Mandate(token: string, opts: VerifyAp2Options): Promise<Ap2VerifyResult>;
+
+/**
+ * 5.15.0 — RFC 9421 HTTP Message Signatures: signing.
+ *
+ * Signs an outbound request (agent → merchant, platform → merchant webhook)
+ * with an ES256 or Ed25519 private key. Covered components default to
+ * `@method`, `@authority`, `@path` (+ `content-digest` when there's a body,
+ * computed per RFC 9530). Protocol profiles (Web Bot Auth, Visa TAP,
+ * Mastercard Agent Pay, UCP) pass their own `components`, `tag` and
+ * parameters. Verification is transport/rfc9421-verify.
+ */
+
+type HttpSignatureAlgorithm = 'ecdsa-p256-sha256' | 'ed25519';
+interface SignHttpRequestOptions {
+    /** Private key (Node KeyObject / PEM). */
+    privateKey: KeyObject | string;
+    keyId: string;
+    alg?: HttpSignatureAlgorithm;
+    /** Covered components. Default @method @authority @path (+ content-digest with a body). */
+    components?: string[];
+    /** Signature label. Default `sig1`. */
+    label?: string;
+    /** `tag` parameter (profile name, e.g. a Web Bot Auth or TAP tag). */
+    tag?: string;
+    /** `nonce` parameter: a value, or true for 32 random bytes (base64url). */
+    nonce?: string | true;
+    /** Lifetime in seconds (expires = created + this). Default 300. */
+    expiresInSec?: number;
+    /** Include the `alg` parameter. Default false (key type implies it). */
+    includeAlg?: boolean;
+    /** Include `expires`. Default true (UCP: keyid only, created optional). */
+    includeExpires?: boolean;
+    now?: () => Date;
+}
+interface SignableRequest {
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    body?: string;
+}
+/** RFC 9530 Content-Digest (sha-256) of a body. */
+declare function contentDigest(body: string): string;
+/**
+ * Returns the request's headers plus `Signature-Input`, `Signature` (and
+ * `Content-Digest` when a body is covered). Never mutates the input.
+ */
+declare function signHttpRequest(req: SignableRequest, opts: SignHttpRequestOptions): Promise<Record<string, string>>;
 
-export { AgentClient, type AgentCredentials, type AgentProtocol, type AgentRecord, AstraSync, type AstraSyncConfig, type AstraSyncCredentials, AstraSyncError, type AttemptOutcome, type AttemptReport, AuthenticationError, type BuildGuidanceParams, CAPTURE_SCHEMA_VERSION, type CallerMetadata, ChallengeHandler, type CommerceArtifactsPayload, type CommerceContext, type CommercePipelineInput, type CommerceShieldProps, type ConsiderationItem, type ConsiderationSet, type CounterpartyType, DECLARED_SOURCE_MAX, DEFAULT_EDGE_CONFIG, type DynamicPlatformFingerprint, type EdgeConfig, type EdgeMode, type EdgePathRule, type EdgeVerificationDepth, type EnhancedVerificationResult, type ExpressMiddlewareOptions, type FetchEdgeConfigResult, type FetchEdgeConfigSuccess, type FiatSettlementBinding, type FrameworkConfig, type FulfilmentInfo, type GatewayConfig, type GuidanceEnvelope, type GuidanceInfo, type HealthResponse, KYDRequiredError, type ParseResult as LocalPolicyParseResult, type ValidationError as LocalPolicyValidationError, type ValidationResult as LocalPolicyValidationResult, MAX_HEADERS, MAX_HEADER_VALUE_BYTES, MAX_TOTAL_BYTES, MCP_VERIFIED_HOP_HEADER, MCP_VERIFIED_HOP_MAX_AGE_MS, type McpMiddlewareOptions, type MerchantSettlementToken, type ModelConfig, type NextJsMiddlewareOptions, type ObservedMetadata, type PDLSSConfig$1 as PDLSSConfig, type PDLSSDuration, type PDLSSInfo, type PDLSSLimits, type PDLSSPurpose, type PDLSSScope, type PDLSSSelfInstantiation, PLATFORM_AGENT_SIGNATURES, type PendingRegistrationResponse, type PlatformAgentVendor, type PlatformDetectionInput, type PlatformFingerprint, type PlatformSignatureDef, type PollRegistrationResult, type ProtocolTransport, RUNTIME_SIGNATURES, type RegisterOptions, type RegisterResult, RegistrationDeniedError, RegistrationExpiredError, type RegistrationResponse, RegistrationTimeoutError, type ReportAttemptOptions, type RouteAccessConfig, type RuntimeChallengeResult, type RuntimeSignature, type SDKOptions, SDK_USER_AGENT, type SanitizeHeadersResult, type SettlementArtifact, type SettlementArtifactBinding, type SettlementArtifactBindingBase, type SettlementDecision, type SettlementOutcomeInfo, type SettlementRequest, type StablecoinSettlementBinding, type StepUpApprovalInfo, type StepUpApprovalStatus, type StepUpOutcome, TRUST_LEVEL_RANGES, type TokenGuidance, type ToolGate, type ToolGateConfig, type TrustLevel, VERIFICATION_STATUS_HEADER, SDK_VERSION as VERSION, type VerificationInterstitialProps, type VerificationRequest, type VerificationResult, type VerifiedAgent, type VerifiedDeveloper, type VerifiedHopMarker, type VerifiedOrganization, type VerifyOptions, type VerifyResponse, type WaitForApprovalOptions, type WellKnownAgenticCommerce, _resetEdgeConfigCache, index as agent, authorizeSettlement, awaitStepUpApproval, buildGuidance, buildSdkObservedMetadata, buildVerificationUnavailableBody, clearCache, createMcpMiddleware, degradeToObserve, denyStatusFor, deriveConnectionFromHeaders, detectPlatformFingerprint, detectRuntime, express, extractApiKeyFormat, extractCredentials, extractMcpCredentials, extractPlatformHeaders, fetchEdgeConfig, fetchRoutes, getCachedWellKnownUrls, getEdgeConfig, getTrustLevel, getWellKnownUrls, hasCredentials, isEdgeConfig, isRejectedIdentityClaim, isVerificationUnavailable, isVerifiedHopValidFor, matchEdgePathRule, matchPlatformSignature, nextjs, normalizeDeclaredSource, parseYaml as parseLocalPolicyYaml, parseVerifiedHop, pollStepUpStatus, prefetchWellKnown, quickVerify, recordDecision, reportAttempt, reportUnregisteredAttempt, sanitizeHeaders, sdk, sdkFetch, serializeVerifiedHop, setMcpMeta, index$1 as transport, unavailableRetryAfterSeconds, validatePolicy as validateLocalPolicy, verify };
+export { ACP_API_VERSION, AEP_SPEC_VERSION, AP2_VCT, type AcpCheckoutKitOptions, type AcpCheckoutSession, type AepActorType, type AepArtifactRecord, type AepArtifactType, AepChain, type AepChainOptions, type AepChainVerification, type AepHashInput, AgentClient, type AgentCredentials, type AgentProtocol, type AgentProtocolIdentities, type AgentRecord, type Ap2Party, type Ap2VerifyResult, AstraSync, type AstraSyncAepEvidence, type AstraSyncConfig, type AstraSyncCredentials, AstraSyncError, type AstraSyncMandates, type AttemptOutcome, type AttemptReport, AuthenticationError, type BuildGuidanceParams, CAPTURE_SCHEMA_VERSION, type CallerMetadata, ChallengeHandler, type CommerceArtifactsPayload, type CommerceContext, type CommercePipelineInput, type CommerceShieldProps, type ConsiderationItem, type ConsiderationSet, type CounterpartyType, DECLARED_SOURCE_MAX, DEFAULT_EDGE_CONFIG, DEFAULT_IDEMPOTENCY_TTL_MS, type DynamicPlatformFingerprint, type EdgeConfig, type EdgeMode, type EdgePathRule, type EdgeVerificationDepth, type EnhancedVerificationResult, type ExpressMiddlewareOptions, type FetchEdgeConfigResult, type FetchEdgeConfigSuccess, type FiatSettlementBinding, type FrameworkConfig, type FulfilmentInfo, type GatewayConfig, type GuidanceEnvelope, type GuidanceInfo, type HealthResponse, type HttpSignatureAlgorithm, type IdempotencyOptions, type IdempotencyRecord, type IdempotencyStore, KYDRequiredError, type KyaPayIdentity, type KyaPayResult, type KyaPayTokenType, type KyaPayVerifyOptions, type ParseResult as LocalPolicyParseResult, type ValidationError as LocalPolicyValidationError, type ValidationResult as LocalPolicyValidationResult, MAX_HEADERS, MAX_HEADER_VALUE_BYTES, MAX_TOTAL_BYTES, MCP_VERIFIED_HOP_HEADER, MCP_VERIFIED_HOP_MAX_AGE_MS, type McpMiddlewareOptions, MemoryCheckoutStore, MemoryIdempotencyStore, type MerchantSettlementToken, type ModelConfig, type MppChallenge, type MppCredential, type MppReceipt, type NegotiationResult, type NextJsMiddlewareOptions, type ObservedMetadata, type PDLSSConfig$1 as PDLSSConfig, type PDLSSDuration, type PDLSSInfo, type PDLSSLimits, type PDLSSPurpose, type PDLSSScope, type PDLSSSelfInstantiation, PLATFORM_AGENT_SIGNATURES, type PendingRegistrationResponse, type PlatformAgentVendor, type PlatformDetectionInput, type PlatformFingerprint, type PlatformSignatureDef, type PollRegistrationResult, type ProtocolTransport, RUNTIME_SIGNATURES, RedisIdempotencyStore, type RedisLike, type RegisterOptions, type RegisterResult, RegistrationDeniedError, RegistrationExpiredError, type RegistrationResponse, RegistrationTimeoutError, type ReportAttemptOptions, type RootKeyResolver, type RouteAccessConfig, type RoutePolicy, type RuntimeChallengeResult, type RuntimeSignature, type SDKOptions, SDK_USER_AGENT, type SanitizeHeadersResult, type SettlementArtifact, type SettlementArtifactBinding, type SettlementArtifactBindingBase, type SettlementDecision, type SettlementOutcomeInfo, SettlementReportError, type SettlementRequest, type SignHttpRequestOptions, type SignableRequest, type StablecoinSettlementBinding, type StepUpApprovalInfo, type StepUpApprovalStatus, type StepUpOutcome, TRUST_LEVEL_RANGES, type TokenGuidance, type ToolGate, type ToolGateConfig, type TrustLevel, UCP_VERSION, type UcpAgentBinding, type CatalogItem as UcpCatalogItem, type UcpCheckoutKitOptions, type CheckoutSession as UcpCheckoutSession, type CheckoutStore as UcpCheckoutStore, type UcpMessage, type UcpProfile, type UcpProfileResult, type SettleResult as UcpSettleResult, type UcpSeverity, type UcpSignatureResult, VERIFICATION_STATUS_HEADER, SDK_VERSION as VERSION, type VerificationInterstitialProps, type VerificationRequest, type VerificationResult, type VerifiedAgent, type VerifiedDeveloper, type VerifiedHopMarker, type VerifiedOrganization, type VerifyAp2Options, type VerifyOptions, type VerifyResponse, type WaitForApprovalOptions, type WellKnownAgenticCommerce, type X402PaymentPayload, type X402PaymentRequired, type X402PaymentRequirements, type X402ResourceInfo, type X402SettlementResponse, _resetEdgeConfigCache, aepCanonicalJson, aepHash, aepPrivateKeyFromSeed, aepPublicKeyDocument, aepPublicKeyFromBase64, aepRawPublicKey, aepSign, aepTimestamp, aepVerifySignature, index as agent, astrasyncPaymentHandlers, authorizeSettlement, awaitStepUpApproval, beginIdempotent, buildGuidance, buildMppChallenge, buildSdkObservedMetadata, buildUcpProfile, buildVerificationUnavailableBody, buildX402Challenge, canonicalJson, checkUcpAgentBinding, checkoutHash, clearCache, closedCheckoutMandate, closedPaymentMandate, contentDigest, createAcpCheckoutKit, createKbHop, createMcpMiddleware, createUcpCheckoutKit, decodeMppRequest, degradeToObserve, denyStatusFor, deriveConnectionFromHeaders, detectPlatformFingerprint, detectRuntime, encodeMppReceipt, encodeX402SettlementResponse, express, extractApiKeyFormat, extractCredentials, extractMcpCredentials, extractPlatformHeaders, fetchEdgeConfig, fetchRoutes, fetchUcpProfile, finishIdempotent, getCachedWellKnownUrls, getEdgeConfig, getTrustLevel, getWellKnownUrls, hasCredentials, idempotencyMiddleware, isEdgeConfig, isRejectedIdentityClaim, isRetryableSettlementError, isSpecialUseIp, isVerificationUnavailable, isVerifiedHopValidFor, issueDelegateSdJwt, matchEdgePathRule, matchPlatformSignature, matchRoutePattern, negotiateUcp, nextjs, normalizeDeclaredSource, openCheckoutMandate, openPaymentMandate, parseYaml as parseLocalPolicyYaml, parseMppCredential, parseUcpAgentHeader, parseVerifiedHop, parseX402Challenge, parseX402Payment, pollStepUpStatus, prefetchWellKnown, quickVerify, recordDecision, reportAttempt, reportUnregisteredAttempt, requestFingerprint, rootMandateDigest, routePatternToRegExp, routePolicyOf, sanitizeHeaders, sdk, sdkFetch, sendUcpWebhook, serializeVerifiedHop, setMcpMeta, signHttpRequest, signRootMandate, signUcpRequest, signUcpResponse, index$1 as transport, ucpError, ucpEscalation, ucpFailure, ucpProfileHandler, ucpRequiredComponents, unavailableRetryAfterSeconds, validatePolicy as validateLocalPolicy, verify, verifyAepChain, verifyAp2Mandate, verifyDelegateChain, verifyKyaPayTokens, verifyMppChallenge, verifyUcpRequest, withIdempotency, x402PaymentMatchesOffer };