@adcp/sdk 15.9.1 → 16.0.0-beta.2

package/dist/lib/signing/parser.mjs

@@ -1,4 +1,4 @@
-import { ParseError, parseDictionary, serializeInnerList } from "structured-headers";
+import { ParseError, parseDictionary, serializeInnerList, serializeItem } from "structured-headers";
 import { RequestSignatureError } from "./errors.mjs";
 import { isPaddedStandardBase64 } from "./content-digest.mjs";
 const STRING_PARAMS = /* @__PURE__ */ new Set(["nonce", "keyid", "alg", "tag"]);
@@ -6,7 +6,7 @@ const INTEGER_PARAMS = /* @__PURE__ */ new Set(["created", "expires"]);
 function malformed(message) {
   throw new RequestSignatureError("request_signature_header_malformed", 1, message);
 }
-function parseSignatureInput(headerValue) {
+function parseSignatureInput(headerValue, expectedLabel) {
   rejectDuplicateDictionaryKeys(headerValue, "Signature-Input");
   let dict;
   try {
@@ -16,7 +16,8 @@ function parseSignatureInput(headerValue) {
     throw e;
   }
   if (dict.size === 0) malformed("Signature-Input header is empty");
-  const label = dict.has("sig1") ? "sig1" : dict.keys().next().value;
+  const label = expectedLabel ?? (dict.has("sig1") ? "sig1" : dict.keys().next().value);
+  if (!dict.has(label)) malformed("Signature-Input label is missing");
   const entry = dict.get(label);
   if (!isInnerList(entry)) {
     malformed("Signature-Input value must be a parenthesized component list");
@@ -24,7 +25,8 @@ function parseSignatureInput(headerValue) {
   const components = [];
   for (const [bare, itemParams] of entry[0]) {
     if (typeof bare !== "string") malformed("Signature-Input components must all be strings");
-    components.push(itemParams instanceof Map && itemParams.get("req") === true ? `${bare};req` : bare);
+    const serialized = serializeItem([bare, itemParams]);
+    components.push(`${bare}${serialized.slice(serialized.indexOf('"', 1) + 1)}`);
   }
   const params = {};
   for (const [key, value] of entry[1]) {
@@ -84,85 +86,101 @@ function isInnerList(entry) {
   return Array.isArray(entry) && Array.isArray(entry[0]);
 }
 function rejectDuplicateDictionaryKeys(headerValue, headerName) {
-  const keys = extractTopLevelDictKeys(headerValue);
-  const seen = /* @__PURE__ */ new Set();
-  for (const key of keys) {
-    if (seen.has(key)) {
-      malformed(`${headerName} header declares key "${key}" more than once`);
-    }
-    seen.add(key);
-  }
+  const duplicate = findDuplicateStructuredKey(headerValue);
+  if (duplicate?.kind === "member") malformed(`${headerName} header declares key "${duplicate.key}" more than once`);
+  if (duplicate) malformed(`${headerName} header declares parameter "${duplicate.key}" more than once`);
 }
-function extractTopLevelDictKeys(input) {
-  const keys = [];
+function findDuplicateStructuredKey(input) {
   let i = 0;
-  const len = input.length;
-  let atEntryStart = true;
-  while (i < len) {
-    if (atEntryStart) {
-      while (i < len && (input[i] === " " || input[i] === "	")) i++;
-      const keyStart = i;
-      while (i < len && /[A-Za-z0-9_*-]/.test(input[i])) i++;
-      if (i > keyStart) keys.push(input.slice(keyStart, i).toLowerCase());
-      atEntryStart = false;
-      continue;
+  const n = input.length;
+  const ows = () => {
+    while (i < n && (input[i] === " " || input[i] === "	")) i++;
+  };
+  const key = () => {
+    const start = i;
+    while (i < n && /[A-Za-z0-9_.*-]/.test(input[i])) i++;
+    return input.slice(start, i).toLowerCase();
+  };
+  const bareItem = () => {
+    if (input[i] === "%" && input[i + 1] === '"') {
+      i += 2;
+      while (i < n && input[i] !== '"') i++;
+      i++;
+      return;
     }
-    const ch = input[i];
-    if (ch === '"') {
+    if (input[i] === '"') {
       i++;
-      while (i < len) {
-        if (input[i] === "\\" && i + 1 < len) {
+      while (i < n) {
+        if (input[i] === "\\") {
           i += 2;
           continue;
         }
-        if (input[i] === '"') {
-          i++;
-          break;
-        }
-        i++;
+        if (input[i++] === '"') return;
       }
-      continue;
+      return;
     }
-    if (ch === ":") {
+    if (input[i] === ":") {
       i++;
-      while (i < len && input[i] !== ":") i++;
-      if (i < len) i++;
-      continue;
+      while (i < n && input[i] !== ":") i++;
+      i++;
+      return;
     }
-    if (ch === "(") {
+    while (i < n && !/[;,()\s"]/.test(input[i])) i++;
+  };
+  const parameters = () => {
+    const seen = /* @__PURE__ */ new Set();
+    while (i < n && input[i] === ";") {
       i++;
-      let depth = 1;
-      while (i < len && depth > 0) {
-        const c = input[i];
-        if (c === '"') {
-          i++;
-          while (i < len) {
-            if (input[i] === "\\" && i + 1 < len) {
-              i += 2;
-              continue;
-            }
-            if (input[i] === '"') {
-              i++;
-              break;
-            }
-            i++;
-          }
-          continue;
-        }
-        if (c === "(") depth++;
-        else if (c === ")") depth--;
+      ows();
+      const k = key();
+      if (!k) return void 0;
+      if (seen.has(k)) return k;
+      seen.add(k);
+      if (input[i] === "=") {
         i++;
+        bareItem();
       }
-      continue;
     }
-    if (ch === ",") {
-      atEntryStart = true;
+    return void 0;
+  };
+  const members = /* @__PURE__ */ new Set();
+  while (i < n) {
+    ows();
+    const k = key();
+    if (!k) return void 0;
+    if (members.has(k)) return { kind: "member", key: k };
+    members.add(k);
+    let duplicate;
+    if (input[i] === "=") {
       i++;
-      continue;
-    }
+      if (input[i] === "(") {
+        i++;
+        for (; ; ) {
+          while (i < n && input[i] === " ") i++;
+          if (i >= n) return void 0;
+          if (input[i] === ")") {
+            i++;
+            break;
+          }
+          const before = i;
+          bareItem();
+          duplicate = parameters();
+          if (duplicate) return { kind: "parameter", key: `${k}: ${duplicate}` };
+          if (i === before) return void 0;
+        }
+        duplicate = parameters();
+      } else {
+        bareItem();
+        duplicate = parameters();
+      }
+    } else duplicate = parameters();
+    if (duplicate) return { kind: "parameter", key: `${k}: ${duplicate}` };
+    ows();
+    if (i >= n) return void 0;
+    if (input[i] !== ",") return void 0;
     i++;
   }
-  return keys;
+  return void 0;
 }
 function normalizeByteSequenceBase64(input) {
   let out = "";

package/dist/lib/signing/revocation.d.mts

@@ -1,10 +1,13 @@
+import type { RevocationDetail } from '../identity-3.3/types.mjs';
 import type { RevocationSnapshot } from './types.mjs';
 export interface RevocationStore {
     isRevoked(keyid: string): Promise<boolean>;
 }
 export declare class InMemoryRevocationStore implements RevocationStore {
-    private revokedKids;
+    private readonly revokedKids;
+    private readonly details;
     constructor(snapshot?: RevocationSnapshot);
     load(snapshot: RevocationSnapshot): void;
+    getDetails(keyid: string): RevocationDetail | undefined;
     isRevoked(keyid: string): Promise<boolean>;
 }

package/dist/lib/signing/revocation.d.ts

@@ -1,10 +1,13 @@
+import type { RevocationDetail } from '../identity-3.3/types';
 import type { RevocationSnapshot } from './types';
 export interface RevocationStore {
     isRevoked(keyid: string): Promise<boolean>;
 }
 export declare class InMemoryRevocationStore implements RevocationStore {
-    private revokedKids;
+    private readonly revokedKids;
+    private readonly details;
     constructor(snapshot?: RevocationSnapshot);
     load(snapshot: RevocationSnapshot): void;
+    getDetails(keyid: string): RevocationDetail | undefined;
     isRevoked(keyid: string): Promise<boolean>;
 }

package/dist/lib/signing/revocation.js

@@ -18,22 +18,55 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var revocation_exports = {};
 __export(revocation_exports, {
-  InMemoryRevocationStore: () => InMemoryRevocationStore
+  InMemoryRevocationStore: () => InMemoryRevocationStore,
+  mergeRevocationDetails: () => mergeRevocationDetails
 });
 module.exports = __toCommonJS(revocation_exports);
 class InMemoryRevocationStore {
   revokedKids = /* @__PURE__ */ new Set();
+  details = /* @__PURE__ */ new Map();
   constructor(snapshot) {
     if (snapshot) this.load(snapshot);
   }
   load(snapshot) {
-    this.revokedKids = new Set(snapshot.revoked_kids);
+    if ((/* @__PURE__ */ new Set([...this.revokedKids, ...snapshot.revoked_kids])).size > 1e5)
+      throw new RangeError("Revocation store capacity exceeded");
+    for (const kid of snapshot.revoked_kids) {
+      this.revokedKids.add(kid);
+      const detail = snapshot.revocation_details?.[kid];
+      this.details.set(kid, mergeRevocationDetails(this.details.get(kid), detail ?? {}));
+    }
+  }
+  getDetails(keyid) {
+    const detail = this.details.get(keyid);
+    return detail && { ...detail };
   }
   async isRevoked(keyid) {
     return this.revokedKids.has(keyid);
   }
 }
+const REASONS = [
+  "removeFromCRL",
+  "unspecified",
+  "superseded",
+  "cessationOfOperation",
+  "affiliationChanged",
+  "certificateHold",
+  "privilegeWithdrawn",
+  "aACompromise",
+  "cACompromise",
+  "keyCompromise"
+];
+function mergeRevocationDetails(prior, detail) {
+  const reason = REASONS.indexOf(detail.reason ?? "unspecified") > REASONS.indexOf(prior?.reason ?? "unspecified") ? detail.reason : prior?.reason ?? detail.reason;
+  const hasValidDate = (entry) => !!entry?.invalidity_date && Number.isFinite(Date.parse(entry.invalidity_date));
+  if (reason === "keyCompromise" && [prior, detail].some((entry) => entry?.reason === "keyCompromise" && !hasValidDate(entry)))
+    return { reason };
+  const dates = [prior?.invalidity_date, detail.invalidity_date].filter((s) => !!s && Number.isFinite(Date.parse(s))).sort((a, b) => Date.parse(a) - Date.parse(b));
+  return { ...reason ? { reason } : {}, ...dates[0] ? { invalidity_date: dates[0] } : {} };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  InMemoryRevocationStore
+  InMemoryRevocationStore,
+  mergeRevocationDetails
 });

package/dist/lib/signing/revocation.mjs

@@ -1,15 +1,47 @@
 class InMemoryRevocationStore {
   revokedKids = /* @__PURE__ */ new Set();
+  details = /* @__PURE__ */ new Map();
   constructor(snapshot) {
     if (snapshot) this.load(snapshot);
   }
   load(snapshot) {
-    this.revokedKids = new Set(snapshot.revoked_kids);
+    if ((/* @__PURE__ */ new Set([...this.revokedKids, ...snapshot.revoked_kids])).size > 1e5)
+      throw new RangeError("Revocation store capacity exceeded");
+    for (const kid of snapshot.revoked_kids) {
+      this.revokedKids.add(kid);
+      const detail = snapshot.revocation_details?.[kid];
+      this.details.set(kid, mergeRevocationDetails(this.details.get(kid), detail ?? {}));
+    }
+  }
+  getDetails(keyid) {
+    const detail = this.details.get(keyid);
+    return detail && { ...detail };
   }
   async isRevoked(keyid) {
     return this.revokedKids.has(keyid);
   }
 }
+const REASONS = [
+  "removeFromCRL",
+  "unspecified",
+  "superseded",
+  "cessationOfOperation",
+  "affiliationChanged",
+  "certificateHold",
+  "privilegeWithdrawn",
+  "aACompromise",
+  "cACompromise",
+  "keyCompromise"
+];
+function mergeRevocationDetails(prior, detail) {
+  const reason = REASONS.indexOf(detail.reason ?? "unspecified") > REASONS.indexOf(prior?.reason ?? "unspecified") ? detail.reason : prior?.reason ?? detail.reason;
+  const hasValidDate = (entry) => !!entry?.invalidity_date && Number.isFinite(Date.parse(entry.invalidity_date));
+  if (reason === "keyCompromise" && [prior, detail].some((entry) => entry?.reason === "keyCompromise" && !hasValidDate(entry)))
+    return { reason };
+  const dates = [prior?.invalidity_date, detail.invalidity_date].filter((s) => !!s && Number.isFinite(Date.parse(s))).sort((a, b) => Date.parse(a) - Date.parse(b));
+  return { ...reason ? { reason } : {}, ...dates[0] ? { invalidity_date: dates[0] } : {} };
+}
 export {
-  InMemoryRevocationStore
+  InMemoryRevocationStore,
+  mergeRevocationDetails
 };

package/dist/lib/signing/server.d.mts

@@ -30,5 +30,5 @@ export { createWebhookVerifier, isWebhookLoopbackHost, verifyWebhookSignature, W
 export { createExpressVerifier, type ExpressLike, type ExpressMiddlewareOptions } from './middleware.mjs';
 export { finalizeResponseSignature, prepareResponseSignature, signResponse, type PreparedResponseSignature, type SignedResponse, type SignResponseOptions, } from './signer.mjs';
 export { signResponseAsync } from './signer-async.mjs';
-export { resolveAgent, ResolvedAgentJwksResolver, getAgentJwks, createAgentJwksSet, AgentResolverError, attackerInfluencedFields, ATTACKER_INFLUENCED, readBrandJsonUrl, readIdentityPosture, type AgentResolution, type AgentProtocol, type AuthorizedOperatorScope, type DelegatedOperatorAuthorizationContext, type AgentResolverErrorCode, type AgentResolverErrorDetail, type AgentEntry, type AgentJwksResult, type CapabilitiesWithBrandJsonUrl, type CreateAgentJwksSetOptions, type FetchCapabilitiesFn, type GetAgentJwksOptions, type IdentityKeyOriginPurpose, type IdentityKeyOrigins, type IdentityPosture, type ResolveAgentOptions, type ResolvedAgentJwksResolverOptions, type TraceStep, } from './agent-resolver/index.mjs';
+export { resolveAgent, ResolvedAgentJwksResolver, canonicalAgentOrigin, CanonicalizeError, getAgentJwks, createAgentJwksSet, AgentResolverError, attackerInfluencedFields, ATTACKER_INFLUENCED, readBrandJsonUrl, readIdentityPosture, type AgentResolution, type AgentProtocol, type AuthorizedOperatorScope, type DelegatedOperatorAuthorizationContext, type AgentResolverErrorCode, type AgentResolverErrorDetail, type AgentEntry, type AgentJwksResult, type CapabilitiesWithBrandJsonUrl, type CreateAgentJwksSetOptions, type FetchCapabilitiesFn, type GetAgentJwksOptions, type IdentityKeyOriginPurpose, type IdentityKeyOrigins, type IdentityPosture, type ResolveAgentOptions, type ResolvedAgentJwksResolverOptions, type TraceStep, } from './agent-resolver/index.mjs';
 export type { PublisherSigningKeyPin } from './publisher-pins.mjs';

package/dist/lib/signing/server.d.ts

@@ -30,5 +30,5 @@ export { createWebhookVerifier, isWebhookLoopbackHost, verifyWebhookSignature, W
 export { createExpressVerifier, type ExpressLike, type ExpressMiddlewareOptions } from './middleware';
 export { finalizeResponseSignature, prepareResponseSignature, signResponse, type PreparedResponseSignature, type SignedResponse, type SignResponseOptions, } from './signer';
 export { signResponseAsync } from './signer-async';
-export { resolveAgent, ResolvedAgentJwksResolver, getAgentJwks, createAgentJwksSet, AgentResolverError, attackerInfluencedFields, ATTACKER_INFLUENCED, readBrandJsonUrl, readIdentityPosture, type AgentResolution, type AgentProtocol, type AuthorizedOperatorScope, type DelegatedOperatorAuthorizationContext, type AgentResolverErrorCode, type AgentResolverErrorDetail, type AgentEntry, type AgentJwksResult, type CapabilitiesWithBrandJsonUrl, type CreateAgentJwksSetOptions, type FetchCapabilitiesFn, type GetAgentJwksOptions, type IdentityKeyOriginPurpose, type IdentityKeyOrigins, type IdentityPosture, type ResolveAgentOptions, type ResolvedAgentJwksResolverOptions, type TraceStep, } from './agent-resolver';
+export { resolveAgent, ResolvedAgentJwksResolver, canonicalAgentOrigin, CanonicalizeError, getAgentJwks, createAgentJwksSet, AgentResolverError, attackerInfluencedFields, ATTACKER_INFLUENCED, readBrandJsonUrl, readIdentityPosture, type AgentResolution, type AgentProtocol, type AuthorizedOperatorScope, type DelegatedOperatorAuthorizationContext, type AgentResolverErrorCode, type AgentResolverErrorDetail, type AgentEntry, type AgentJwksResult, type CapabilitiesWithBrandJsonUrl, type CreateAgentJwksSetOptions, type FetchCapabilitiesFn, type GetAgentJwksOptions, type IdentityKeyOriginPurpose, type IdentityKeyOrigins, type IdentityPosture, type ResolveAgentOptions, type ResolvedAgentJwksResolverOptions, type TraceStep, } from './agent-resolver';
 export type { PublisherSigningKeyPin } from './publisher-pins';

package/dist/lib/signing/server.js

@@ -24,6 +24,7 @@ __export(server_exports, {
   BrandJsonJwksResolver: () => import_brand_jwks.BrandJsonJwksResolver,
   BrandJsonResolverError: () => import_brand_jwks.BrandJsonResolverError,
   CLOCK_SKEW_TOLERANCE_SECONDS: () => import_types.CLOCK_SKEW_TOLERANCE_SECONDS,
+  CanonicalizeError: () => import_agent_resolver.CanonicalizeError,
   HttpsJwksResolver: () => import_jwks_https.HttpsJwksResolver,
   HttpsRevocationStore: () => import_revocation_https.HttpsRevocationStore,
   InMemoryReplayStore: () => import_replay.InMemoryReplayStore,
@@ -48,6 +49,7 @@ __export(server_exports, {
   attackerInfluencedFields: () => import_agent_resolver.attackerInfluencedFields,
   buildResponseSignatureBase: () => import_canonicalize.buildResponseSignatureBase,
   buildSignatureBase: () => import_canonicalize.buildSignatureBase,
+  canonicalAgentOrigin: () => import_agent_resolver.canonicalAgentOrigin,
   canonicalAuthority: () => import_canonicalize.canonicalAuthority,
   canonicalMethod: () => import_canonicalize.canonicalMethod,
   canonicalTargetUri: () => import_canonicalize.canonicalTargetUri,
@@ -114,6 +116,7 @@ var import_agent_resolver = require('./agent-resolver/index.js');
   BrandJsonJwksResolver,
   BrandJsonResolverError,
   CLOCK_SKEW_TOLERANCE_SECONDS,
+  CanonicalizeError,
   HttpsJwksResolver,
   HttpsRevocationStore,
   InMemoryReplayStore,
@@ -138,6 +141,7 @@ var import_agent_resolver = require('./agent-resolver/index.js');
   attackerInfluencedFields,
   buildResponseSignatureBase,
   buildSignatureBase,
+  canonicalAgentOrigin,
   canonicalAuthority,
   canonicalMethod,
   canonicalTargetUri,

package/dist/lib/signing/server.mjs

@@ -74,6 +74,8 @@ import { signResponseAsync } from "./signer-async.mjs";
 import {
   resolveAgent,
   ResolvedAgentJwksResolver,
+  canonicalAgentOrigin,
+  CanonicalizeError,
   getAgentJwks,
   createAgentJwksSet,
   AgentResolverError,
@@ -89,6 +91,7 @@ export {
   BrandJsonJwksResolver,
   BrandJsonResolverError,
   CLOCK_SKEW_TOLERANCE_SECONDS,
+  CanonicalizeError,
   HttpsJwksResolver,
   HttpsRevocationStore,
   InMemoryReplayStore,
@@ -113,6 +116,7 @@ export {
   attackerInfluencedFields,
   buildResponseSignatureBase,
   buildSignatureBase,
+  canonicalAgentOrigin,
   canonicalAuthority,
   canonicalMethod,
   canonicalTargetUri,

package/dist/lib/signing/types.d.mts

@@ -1,5 +1,7 @@
 export type ContentDigestPolicy = 'required' | 'forbidden' | 'either';
 export interface VerifierCapability {
+    profiles?: ('adcp/request-signing/v1' | 'web-bot-auth')[];
+    wba_draft_revision?: string;
     supported: boolean;
     covers_content_digest: ContentDigestPolicy;
     required_for: string[];
@@ -46,6 +48,7 @@ export interface RevocationSnapshot {
     next_update: string;
     revoked_kids: string[];
     revoked_jtis: string[];
+    revocation_details?: Record<string, import('../identity-3.3/types.mjs').RevocationDetail>;
 }
 /**
  * Narrow "successfully verified" shape. Middleware sets `req.verifiedSigner`

package/dist/lib/signing/types.d.ts

@@ -1,5 +1,7 @@
 export type ContentDigestPolicy = 'required' | 'forbidden' | 'either';
 export interface VerifierCapability {
+    profiles?: ('adcp/request-signing/v1' | 'web-bot-auth')[];
+    wba_draft_revision?: string;
     supported: boolean;
     covers_content_digest: ContentDigestPolicy;
     required_for: string[];
@@ -46,6 +48,7 @@ export interface RevocationSnapshot {
     next_update: string;
     revoked_kids: string[];
     revoked_jtis: string[];
+    revocation_details?: Record<string, import('../identity-3.3/types').RevocationDetail>;
 }
 /**
  * Narrow "successfully verified" shape. Middleware sets `req.verifiedSigner`

package/dist/lib/signing/verifier.js

@@ -239,7 +239,7 @@ async function verifyRequestSignature(request, options) {
       "Delegated operator authorization expired during verification"
     );
   }
-  const remaining = parsedInput.params.expires - now + import_types.CLOCK_SKEW_TOLERANCE_SECONDS;
+  const remaining = parsedInput.params.expires - now + import_types.CLOCK_SKEW_TOLERANCE_SECONDS + 1;
   const ttl = Math.max(remaining, import_types.MAX_SIGNATURE_WINDOW_SECONDS + import_types.CLOCK_SKEW_TOLERANCE_SECONDS);
   const insertResult = await options.replayStore.insert(jwk.kid, replayScope, parsedInput.params.nonce, ttl, now);
   if (insertResult === "replayed") {

package/dist/lib/signing/verifier.mjs

@@ -228,7 +228,7 @@ async function verifyRequestSignature(request, options) {
       "Delegated operator authorization expired during verification"
     );
   }
-  const remaining = parsedInput.params.expires - now + CLOCK_SKEW_TOLERANCE_SECONDS;
+  const remaining = parsedInput.params.expires - now + CLOCK_SKEW_TOLERANCE_SECONDS + 1;
   const ttl = Math.max(remaining, MAX_SIGNATURE_WINDOW_SECONDS + CLOCK_SKEW_TOLERANCE_SECONDS);
   const insertResult = await options.replayStore.insert(jwk.kid, replayScope, parsedInput.params.nonce, ttl, now);
   if (insertResult === "replayed") {

package/dist/lib/signing/web-bot-auth.d.mts

@@ -0,0 +1,191 @@
+import { type SsrfFetchOptions } from '../net/index.mjs';
+import { type RequestLike, type ResponseLike } from './canonicalize.mjs';
+import { type ParsedSignatureInput } from './parser.mjs';
+import type { JwksResolver } from './jwks.mjs';
+import type { ReplayStore } from './replay.mjs';
+import type { AdcpJsonWebKey } from './types.mjs';
+import type { SigningProvider } from './provider.mjs';
+export declare const WEB_BOT_AUTH_PROFILE: "web-bot-auth";
+export declare const WEB_BOT_AUTH_DRAFT_REVISION: "draft-ietf-webbotauth-httpsig-protocol-00";
+export declare const SIGNATURE_DIRECTORY_PATH = "/.well-known/http-message-signatures-directory";
+export declare const SIGNATURE_DIRECTORY_MEDIA_TYPE = "application/http-message-signatures-directory+json";
+/**
+ * Signature-path outcome (WBA §4, DR-0023): 400 for a field that does not
+ * parse, 403 for a signature that does not verify (with `Accept-Signature`
+ * unless the key is revoked), 429 for a replay. Any AdCP body is the generic
+ * authentication error; signature-specific detail stays in `reason` (logs).
+ * Infrastructure the verifier depends on is reported separately by
+ * {@link WebBotAuthUnavailableError}.
+ */
+export declare class WebBotAuthError extends Error {
+    readonly status: 400 | 403 | 429;
+    readonly reason: string;
+    readonly headers: Record<string, string>;
+    get body(): Record<string, unknown>;
+    /**
+     * The signer's identity could not be established because key discovery
+     * failed (WBA §6.10) or its revocation status is unknown. The request is
+     * unverified; servers apply their unverified-request policy.
+     */
+    get unverified(): boolean;
+    constructor(status: 400 | 403 | 429, reason: string);
+}
+/**
+ * Infrastructure the verifier depends on failed (replay store, revocation
+ * history store). Not a signature outcome and never answered as one: the
+ * application layer decides how to report the outage (the SDK's server
+ * integrations answer 503 SERVICE_UNAVAILABLE).
+ */
+export declare class WebBotAuthUnavailableError extends Error {
+    readonly reason: string;
+    constructor(reason: string, cause?: unknown);
+}
+export declare function selectSignatureProfile(request: Pick<RequestLike, 'headers'>): 'web-bot-auth' | 'rfc9421';
+/**
+ * RFC 7638 JWK SHA-256 thumbprint, synchronous. Byte-identical to jose's
+ * `calculateJwkThumbprint` for OKP, EC and RSA keys (tested).
+ */
+export declare function jwkThumbprint(jwk: Partial<Pick<AdcpJsonWebKey, 'kty' | 'crv' | 'x' | 'y'>> & {
+    n?: unknown;
+    e?: unknown;
+}): string;
+/** Reject authority normalization differentials on received identifiers. */
+export declare function receivedAgentOrigin(value: string): string;
+/** RFC 9421 dictionary-member extraction, including relay member coverage. */
+export declare function buildWebBotAuthSignatureBase(input: ParsedSignatureInput, request: RequestLike, response?: ResponseLike): string;
+export declare function getWebBotAuthLegacyOriginGate(resolver: Function | undefined): ((origin: string) => Promise<void>) | undefined;
+export interface WebBotAuthAuthorizationFailure {
+    code: 'PERMISSION_DENIED' | 'SERVICE_UNAVAILABLE';
+    message: string;
+    recovery: 'correctable' | 'transient';
+}
+declare const AUTHORIZATION_FAILURE_MESSAGES: {
+    readonly key_revoked: "Agent identity key is revoked";
+    readonly identity_not_bound: "Agent identity is not onboarded for this operation";
+    readonly revocation_unavailable: "Identity revocation information is unavailable";
+    readonly authorization_failed: "Agent authorization failed";
+    readonly authorization_unavailable: "Agent authorization is temporarily unavailable";
+};
+export declare function createWebBotAuthAuthorizationFailure(reason: keyof typeof AUTHORIZATION_FAILURE_MESSAGES): WebBotAuthAuthorizationFailure;
+export declare function getWebBotAuthAuthorizationFailure(extra: Record<string, unknown> | undefined): WebBotAuthAuthorizationFailure | undefined;
+export declare function webBotAuthToolFailure(failure: WebBotAuthAuthorizationFailure, version?: string): {
+    isError: true;
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+};
+export declare function isVerifiedWebBotSigner(value: unknown): value is VerifiedWebBotSigner;
+export interface VerifiedWebBotSigner {
+    profile: 'web-bot-auth';
+    origin: string;
+    keyid: string;
+    label: string;
+    verified_at: number;
+    authorizationFailure?: WebBotAuthAuthorizationFailure;
+}
+export interface VerifyWebBotAuthOptions {
+    /** Key discovery (WBA §5.5). The only network dependency of verification. */
+    directory: SignatureDirectoryResolver;
+    /** Published fixture keys are allowed only outside production. */
+    allowTestKeys?: boolean;
+    /** Atomic, shared across endpoints and replicas. Nonce scope is the identity origin, not the rotating kid. */
+    replayStore: ReplayStore;
+    now?: () => number;
+    /** Older #7894 vector draft expects 403; ratified R2 defaults to 429. */
+    replayStatus?: 403 | 429;
+    /**
+     * @deprecated Revocation is an identity and authorization check, not part of
+     * signature verification: call `OriginRevocationResolver.status()` after
+     * verification (`createIdentity33PrincipalResolver({ revocation })` does).
+     * When supplied it is still consulted: a revoked key is a 403 without
+     * `Accept-Signature`, unknown status leaves the identity unverified, and a
+     * history-store failure is a {@link WebBotAuthUnavailableError}.
+     */
+    isRevoked?: (origin: string, keyid: string) => Promise<boolean>;
+    /** @deprecated Only affects the deprecated `isRevoked` path: `false` tolerates unknown status. */
+    requireFreshRevocation?: boolean;
+    /** @deprecated No effect; revocation outcomes are no longer deferred into tool errors. */
+    deferAuthorizationErrors?: boolean;
+}
+export declare function verifyWebBotAuth(request: RequestLike, options: VerifyWebBotAuthOptions): Promise<VerifiedWebBotSigner[]>;
+export interface VerifiedSignatureDirectory {
+    keys: AdcpJsonWebKey[];
+    /** Signed: the earliest proof expiry. Unsigned: verification time plus the unsigned-age bound. */
+    expires: number;
+    /** Whether every key carried an Appendix B signature. */
+    signed: boolean;
+    /** Preserve exact bytes and response headers for auditing. */
+    proof: ResponseLike;
+}
+/**
+ * Verify a key directory response (draft-meunier-http-message-signatures-directory).
+ * Appendix B signatures are a SHOULD there: a directory without
+ * `Signature-Input` is accepted as a plain JWKS unless `requireSigned`, with
+ * every key checked against its RFC 7638 thumbprint. When signatures are
+ * present, every key must carry a valid one.
+ */
+export declare function verifyKeyDirectory(response: ResponseLike, now?: number, options?: {
+    allowTestKeys?: boolean;
+    requireSigned?: boolean;
+    maxUnsignedAgeSeconds?: number;
+}): VerifiedSignatureDirectory;
+/** Signed directories only (Appendix B). Prefer {@link verifyKeyDirectory}. */
+export declare function verifySignatureDirectory(response: ResponseLike, now?: number, allowTestKeys?: boolean): VerifiedSignatureDirectory;
+export interface SignatureDirectoryResolverOptions {
+    now?: () => number;
+    fetchOptions?: Pick<SsrfFetchOptions, 'lookup' | 'trustedFetchFn'>;
+    allowTestKeys?: boolean;
+    maxOrigins?: number;
+    /** Globally bound concurrency across attacker-selected origins. */
+    maxConcurrentFetches?: number;
+    /** Refuse plain JWKS directories without Appendix B signatures. Default false. */
+    requireSignedDirectories?: boolean;
+    /** How long an unsigned directory may keep verifying after a failed refresh (seconds). Default 86400. */
+    maxUnsignedDirectoryAgeSeconds?: number;
+}
+/**
+ * Multi-origin key discovery. Cache keys never collapse origins sharing a
+ * kid. A failed refresh (any transport error or non-200, 404/410 included) is
+ * a discovery failure: it never evicts a cached, unexpired directory, which
+ * keeps verifying (WBA §6.10). Without one, the request is unverified.
+ */
+export declare class SignatureDirectoryResolver implements JwksResolver {
+    private readonly options;
+    private readonly cache;
+    private readonly failures;
+    private readonly keyMissCooldown;
+    private readonly pending;
+    constructor(options?: SignatureDirectoryResolverOptions);
+    resolve(keyid: string, signerOrigin?: string): Promise<AdcpJsonWebKey | null>;
+    private fetch;
+    get allowsTestKeys(): boolean;
+    /** The directory currently used to verify `origin`, including one kept through a failed refresh. */
+    getVerifiedDirectory(origin: string): VerifiedSignatureDirectory | undefined;
+    getAuditProof(origin: string): ResponseLike | undefined;
+}
+export interface WebBotSigningOptions {
+    origin: string;
+    label?: string;
+    now?: () => number;
+    nonce?: string;
+    windowSeconds?: number;
+    relay?: boolean;
+}
+export type WebBotSigningKey = {
+    privateKey: AdcpJsonWebKey;
+} | {
+    publicKey: AdcpJsonWebKey;
+    provider: SigningProvider;
+};
+export declare function signWebBotAuth(request: RequestLike, key: WebBotSigningKey, options: WebBotSigningOptions): Promise<Record<string, string>>;
+/** Regenerate after rotation and periodically before proofs expire. No private material is published. */
+export declare function createSignedSignatureDirectory(originUrl: string, signingKeys: WebBotSigningKey[], options?: {
+    now?: () => number;
+    lifetimeSeconds?: number;
+}): Promise<ResponseLike>;
+/** Inject into the official MCP/A2A transport; signs the final outgoing bytes. */
+export declare function createWebBotAuthFetch(upstream: typeof fetch, key: WebBotSigningKey, options: WebBotSigningOptions & {
+    shouldSign?: (url: string, init?: RequestInit) => boolean;
+}): typeof fetch;
+export {};