@adcp/sdk 15.9.0 → 16.0.0-beta.1

package/dist/lib/signing/web-bot-auth.js

@@ -0,0 +1,660 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var web_bot_auth_exports = {};
+__export(web_bot_auth_exports, {
+  SIGNATURE_DIRECTORY_MEDIA_TYPE: () => SIGNATURE_DIRECTORY_MEDIA_TYPE,
+  SIGNATURE_DIRECTORY_PATH: () => SIGNATURE_DIRECTORY_PATH,
+  SignatureDirectoryResolver: () => SignatureDirectoryResolver,
+  WEB_BOT_AUTH_DRAFT_REVISION: () => WEB_BOT_AUTH_DRAFT_REVISION,
+  WEB_BOT_AUTH_PROFILE: () => WEB_BOT_AUTH_PROFILE,
+  WebBotAuthError: () => WebBotAuthError,
+  buildWebBotAuthSignatureBase: () => buildWebBotAuthSignatureBase,
+  createSignedSignatureDirectory: () => createSignedSignatureDirectory,
+  createWebBotAuthAuthorizationFailure: () => createWebBotAuthAuthorizationFailure,
+  createWebBotAuthFetch: () => createWebBotAuthFetch,
+  getWebBotAuthAuthorizationFailure: () => getWebBotAuthAuthorizationFailure,
+  getWebBotAuthLegacyOriginGate: () => getWebBotAuthLegacyOriginGate,
+  isVerifiedWebBotSigner: () => isVerifiedWebBotSigner,
+  jwkThumbprint: () => jwkThumbprint,
+  receivedAgentOrigin: () => receivedAgentOrigin,
+  registerWebBotAuthLegacyOriginGate: () => registerWebBotAuthLegacyOriginGate,
+  selectSignatureProfile: () => selectSignatureProfile,
+  signWebBotAuth: () => signWebBotAuth,
+  verifySignatureDirectory: () => verifySignatureDirectory,
+  verifyWebBotAuth: () => verifyWebBotAuth,
+  webBotAuthToolFailure: () => webBotAuthToolFailure
+});
+module.exports = __toCommonJS(web_bot_auth_exports);
+var import_version = require('../version.js');
+var import_crypto = require("crypto");
+var import_structured_headers = require("structured-headers");
+var import_net = require('../net/index.js');
+var import_etld = require('./agent-resolver/etld.js');
+var import_canonicalize = require('./agent-resolver/canonicalize.js');
+var import_select_agent = require('./agent-resolver/select-agent.js');
+var import_strict_json = require('./agent-resolver/strict-json.js');
+var import_canonicalize2 = require('./canonicalize.js');
+var import_content_digest = require('./content-digest.js');
+var import_crypto2 = require('./crypto.js');
+var import_parser = require('./parser.js');
+const WEB_BOT_AUTH_PROFILE = "web-bot-auth";
+const WEB_BOT_AUTH_DRAFT_REVISION = "draft-ietf-webbotauth-httpsig-protocol-00";
+const SIGNATURE_DIRECTORY_PATH = "/.well-known/http-message-signatures-directory";
+const SIGNATURE_DIRECTORY_MEDIA_TYPE = "application/http-message-signatures-directory+json";
+const DIRECTORY_TAG = "http-message-signatures-directory";
+const TEST_KIDS = /* @__PURE__ */ new Set([
+  "6WsKMCObba49V3uN0vIENnk1BKAk7c9zjBJcWKyQ9_I",
+  "hHurKlVBnPJ4AGiPyl6HWMhxgkIcRBzaC8qWwEtnuVI",
+  "ZtaFf5jj-EzorJmZn6mX3YnmK_QyZKVLbbinzIQKOjQ",
+  "1XlJ3EIte7bPOEqKQtKrKNTNy5hywTyrwFXWrMbXKqE"
+]);
+class WebBotAuthError extends Error {
+  constructor(status, reason) {
+    super(
+      status === 400 ? "Malformed Web Bot Auth message" : status === 429 ? "Web Bot Auth rate limit" : "Web Bot Auth verification failed"
+    );
+    this.status = status;
+    this.reason = reason;
+    this.name = "WebBotAuthError";
+    this.headers = status === 403 && ![
+      "key_revoked",
+      "identity_not_bound",
+      "revocation_unavailable",
+      "revocation_persistence_failed",
+      "profile_disabled"
+    ].includes(reason) ? {
+      "Accept-Signature": 'sig1=("@method" "@target-uri" "@authority" "content-type" "content-digest" "signature-agent";key="sig1");created;expires;nonce;keyid;tag="web-bot-auth"'
+    } : status === 429 ? { "Retry-After": "60" } : {};
+  }
+  status;
+  reason;
+  headers;
+  get body() {
+    if (["key_revoked", "identity_not_bound", "revocation_unavailable", "revocation_persistence_failed"].includes(
+      this.reason
+    ))
+      return {
+        adcp_error: {
+          code: this.reason.startsWith("revocation_") ? "SERVICE_UNAVAILABLE" : "PERMISSION_DENIED",
+          message: this.message,
+          recovery: this.reason.startsWith("revocation_") ? "transient" : "correctable"
+        }
+      };
+    return { error: this.message };
+  }
+}
+function bad(reason) {
+  throw new WebBotAuthError(400, reason);
+}
+function denied(reason) {
+  throw new WebBotAuthError(403, reason);
+}
+function dictionary(value, field) {
+  if (!value || value.length > 64 * 1024) return bad("headers");
+  try {
+    (0, import_parser.rejectDuplicateDictionaryKeys)(value, field);
+    return (0, import_structured_headers.parseDictionary)(value);
+  } catch {
+    return bad("structured_field");
+  }
+}
+function selectSignatureProfile(request) {
+  if ((0, import_canonicalize2.getHeaderValue)(request.headers, "signature-agent") !== void 0) return WEB_BOT_AUTH_PROFILE;
+  const input = (0, import_canonicalize2.getHeaderValue)(request.headers, "signature-input");
+  if (input && /;\s*tag\s*=\s*"web-bot-auth"/.test(input)) return WEB_BOT_AUTH_PROFILE;
+  return "rfc9421";
+}
+function jwkThumbprint(jwk) {
+  let fields;
+  if (jwk.kty === "OKP" && typeof jwk.crv === "string" && typeof jwk.x === "string")
+    fields = { crv: jwk.crv, kty: jwk.kty, x: jwk.x };
+  else if (jwk.kty === "EC" && typeof jwk.crv === "string" && typeof jwk.x === "string" && typeof jwk.y === "string")
+    fields = { crv: jwk.crv, kty: jwk.kty, x: jwk.x, y: jwk.y };
+  else return denied("unsupported_key");
+  return (0, import_crypto.createHash)("sha256").update(JSON.stringify(fields)).digest("base64url");
+}
+function algorithm(jwk) {
+  if (jwk.kty === "OKP" && jwk.crv === "Ed25519") return "ed25519";
+  if (jwk.kty === "EC" && jwk.crv === "P-256") return "ecdsa-p256-sha256";
+  return denied("unsupported_key");
+}
+function inputs(headers) {
+  const value = (0, import_canonicalize2.getHeaderValue)(headers, "signature-input");
+  return [...dictionary(value, "Signature-Input").keys()].map((label) => {
+    try {
+      return (0, import_parser.parseSignatureInput)(value, label);
+    } catch {
+      return bad("signature_input");
+    }
+  });
+}
+function receivedAgentOrigin(value) {
+  try {
+    (0, import_select_agent.canonicalAgentUrl)(value);
+    const origin = (0, import_canonicalize.canonicalAgentOrigin)(value);
+    if (value !== origin || /[^\x21-\x7e]/.test(value) || value.includes("%")) return bad("agent_origin");
+    return origin;
+  } catch {
+    return bad("agent_origin");
+  }
+}
+function buildWebBotAuthSignatureBase(input, request, response) {
+  const lines = input.components.map((component) => {
+    const bare = component.split(";", 1)[0];
+    let identifier;
+    try {
+      identifier = (0, import_structured_headers.parseItem)(`"${bare}"${component.slice(bare.length)}`);
+    } catch {
+      return bad("component");
+    }
+    const params = identifier[1];
+    for (const [key, value2] of params) {
+      if (key !== "key" && key !== "req" || key === "key" && typeof value2 !== "string" || key === "req" && value2 !== true)
+        return bad("component_parameter");
+    }
+    if (params.has("req") && !response) return bad("request_bound_component");
+    let value;
+    const source = response && !params.has("req") ? response.headers : request.headers;
+    if (bare.startsWith("@")) {
+      if (params.has("key")) return bad("derived_dictionary");
+      if (response && bare !== "@status" && !params.has("req")) return bad("response_component");
+      if (bare === "@method") value = request.method.toUpperCase();
+      else if (bare === "@target-uri") value = (0, import_canonicalize2.canonicalTargetUri)(request.url, "3.2");
+      else if (bare === "@authority") value = (0, import_canonicalize2.canonicalAuthority)(request.url, "3.2");
+      else if (bare === "@status" && response && !params.has("req")) value = String(response.status);
+      else return bad("derived_component");
+    } else {
+      value = (0, import_canonicalize2.getHeaderValue)(source, bare);
+      if (params.has("key")) {
+        const member = dictionary(value, bare).get(params.get("key"));
+        if (!member) return denied("missing_member");
+        if (Array.isArray(member[0])) {
+          const selected = (0, import_parser.parseSignatureInput)(value, params.get("key"));
+          value = selected.signatureParamsValue;
+        } else value = (0, import_structured_headers.serializeItem)(member);
+      }
+    }
+    if (value === void 0) return denied("missing_component");
+    if (/[\r\n]/.test(value)) return bad("component_value");
+    return `${(0, import_structured_headers.serializeItem)(identifier)}: ${value}`;
+  });
+  return [...lines, `"@signature-params": ${input.signatureParamsValue}`].join("\n");
+}
+function assertDigest(headers, body) {
+  const digest = (0, import_canonicalize2.getHeaderValue)(headers, "content-digest");
+  if (!digest || !(0, import_content_digest.contentDigestUsesEncoding)(digest, "rfc8941-base64") || !(0, import_content_digest.contentDigestMatches)(digest, body))
+    denied("content_digest");
+}
+function verifyBytes(input, request, jwk, response) {
+  const alg = algorithm(jwk);
+  if (input.params.alg !== void 0 && input.params.alg !== alg) denied("algorithm");
+  const signature = (0, import_canonicalize2.getHeaderValue)(response?.headers ?? request.headers, "signature");
+  let bytes;
+  try {
+    bytes = (0, import_parser.parseSignature)(signature ?? "", input.label, "rfc8941-base64").bytes;
+  } catch {
+    return bad("signature");
+  }
+  let valid = false;
+  try {
+    valid = (0, import_crypto2.verifySignature)(
+      alg,
+      (0, import_crypto2.jwkToPublicKey)(jwk),
+      Buffer.from(buildWebBotAuthSignatureBase(input, request, response)),
+      bytes
+    );
+  } catch (error) {
+    if (error instanceof WebBotAuthError) throw error;
+  }
+  if (!valid) denied("signature_invalid");
+}
+const legacyOriginGates = /* @__PURE__ */ new WeakMap();
+function registerWebBotAuthLegacyOriginGate(resolver, gate) {
+  legacyOriginGates.set(resolver, gate);
+}
+function getWebBotAuthLegacyOriginGate(resolver) {
+  return resolver && legacyOriginGates.get(resolver);
+}
+const authorizationFailures = /* @__PURE__ */ new WeakSet();
+function createWebBotAuthAuthorizationFailure(reason) {
+  const failure = Object.freeze({
+    code: reason === "revocation_unavailable" ? "SERVICE_UNAVAILABLE" : "PERMISSION_DENIED",
+    message: reason === "revocation_unavailable" ? "Identity revocation information is unavailable" : reason === "key_revoked" ? "Agent identity key is revoked" : "Agent identity is not onboarded for this operation",
+    recovery: reason === "revocation_unavailable" ? "transient" : "correctable"
+  });
+  authorizationFailures.add(failure);
+  return failure;
+}
+function getWebBotAuthAuthorizationFailure(extra) {
+  for (const value of [extra?.webBotAuthAuthorization, extra?.identity33]) {
+    const claim = value;
+    if (claim && isVerifiedWebBotSigner(claim.signer) && claim.authorizationFailure && authorizationFailures.has(claim.authorizationFailure))
+      return claim.authorizationFailure;
+  }
+  return void 0;
+}
+function webBotAuthToolFailure(failure, version) {
+  return {
+    isError: true,
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          adcp_error: failure,
+          status: "failed",
+          ...version && { adcp_version: (0, import_version.toReleasePrecisionVersion)(version) }
+        })
+      }
+    ]
+  };
+}
+const verifiedSigners = /* @__PURE__ */ new WeakSet();
+function isVerifiedWebBotSigner(value) {
+  return typeof value === "object" && value !== null && verifiedSigners.has(value);
+}
+async function verifyWebBotAuth(request, options) {
+  try {
+    if (!(options.directory instanceof SignatureDirectoryResolver)) denied("directory_unverified");
+    const now = Math.floor((options.now ?? (() => Date.now() / 1e3))());
+    if (!Number.isFinite(now)) denied("verification_unavailable");
+    const all = inputs(request.headers);
+    const candidates = all.filter((input) => input.params.tag === WEB_BOT_AUTH_PROFILE);
+    const selected = [];
+    const remaining = [...candidates];
+    while (remaining.length) {
+      const index = remaining.findIndex(
+        (input) => candidates.every(
+          (other) => !input.components.some(
+            (c) => c === `signature-input;key="${other.label}"` || c === `signature;key="${other.label}"`
+          ) || selected.some((done) => done.label === other.label)
+        )
+      );
+      if (index < 0) denied("relay_cycle");
+      selected.push(remaining.splice(index, 1)[0]);
+    }
+    if (!selected.length || selected.length > 8) denied("profile");
+    const agents = dictionary((0, import_canonicalize2.getHeaderValue)(request.headers, "signature-agent"), "Signature-Agent");
+    const verified = [];
+    const nonces = /* @__PURE__ */ new Set();
+    for (const input of selected) {
+      const { created, expires, nonce, keyid } = input.params;
+      if ([created, expires, nonce, keyid].some((value) => value === void 0)) denied("parameters_missing");
+      if (!Number.isInteger(created) || !Number.isInteger(expires) || typeof nonce !== "string" || !/^[A-Za-z0-9_+\/-]{22,256}={0,2}$/.test(nonce) || typeof keyid !== "string" || !/^[A-Za-z0-9_-]{43}$/.test(keyid))
+        bad("parameters");
+      if (expires <= created || expires - created > 300 || created > now + 60 || expires < now - 60) denied("window");
+      const agentComponents = input.components.filter(
+        (c) => c.startsWith("signature-agent;key=") && !verified.some((s) => selected.find((i) => i.label === s.label).components.includes(c))
+      );
+      if (agentComponents.length !== 1) denied("agent_not_covered");
+      const component = (0, import_structured_headers.parseItem)(`"${agentComponents[0].replace("signature-agent;", 'signature-agent";')}`);
+      const memberKey = component[1].get("key");
+      if (typeof memberKey !== "string" || memberKey !== input.label) bad("agent_member");
+      const member = agents.get(memberKey);
+      if (!member || typeof member[0] !== "string") bad("signature_agent");
+      const type = member[1].get("type");
+      if (type !== void 0 && type !== "directory") denied("agent_type");
+      const origin = receivedAgentOrigin(member[0]);
+      for (const earlier of verified) {
+        const inner = selected.find((i) => i.label === earlier.label);
+        const required = [
+          ...inner.components,
+          `signature-input;key="${inner.label}"`,
+          `signature;key="${inner.label}"`
+        ];
+        if (required.some((c) => !input.components.includes(c))) denied("relay_coverage");
+      }
+      if (new Set(input.components).size !== input.components.length || ["@method", "@target-uri", "@authority"].some((c) => !input.components.includes(c)))
+        denied("coverage");
+      if (request.body !== void 0 && request.body !== "") {
+        if (["content-type", "content-digest"].some((c) => !input.components.includes(c))) denied("body_coverage");
+        assertDigest(request.headers, request.body);
+      }
+      await options.directory.resolve(keyid, origin);
+      const proof = options.directory.getAuditProof(origin);
+      if (!proof || new URL(proof.request.url).origin !== origin) denied("directory_origin");
+      const checkedDirectory = verifySignatureDirectory(
+        proof,
+        now,
+        options.allowTestKeys ?? options.directory.allowsTestKeys
+      );
+      const key = checkedDirectory.keys.find((key2) => key2.kid === keyid);
+      if (!key || jwkThumbprint(key) !== keyid) denied("key");
+      verifyBytes(input, request, key);
+      let authorizationFailure;
+      try {
+        if (await options.isRevoked(origin, keyid)) denied("key_revoked");
+      } catch (error) {
+        if (options.requireFreshRevocation === false && error instanceof WebBotAuthError && error.reason === "revocation_unavailable") {
+        } else if (options.deferAuthorizationErrors && error instanceof WebBotAuthError && ["key_revoked", "revocation_unavailable", "revocation_persistence_failed"].includes(error.reason))
+          authorizationFailure = createWebBotAuthAuthorizationFailure(
+            error.reason === "revocation_persistence_failed" ? "revocation_unavailable" : error.reason
+          );
+        else throw error;
+      }
+      const nonceTuple = JSON.stringify([origin, nonce]);
+      if (nonces.has(nonceTuple)) throw new WebBotAuthError(options.replayStatus ?? 429, "nonce_replayed");
+      nonces.add(nonceTuple);
+      const signer = Object.freeze({
+        profile: WEB_BOT_AUTH_PROFILE,
+        origin,
+        keyid,
+        label: input.label,
+        verified_at: now,
+        ...authorizationFailure && { authorizationFailure }
+      });
+      verified.push(signer);
+    }
+    for (const signer of verified) {
+      const input = selected.find((i) => i.label === signer.label);
+      const result = await options.replayStore.insert(
+        signer.origin,
+        WEB_BOT_AUTH_PROFILE,
+        input.params.nonce,
+        Math.max(1, input.params.expires + 60 - now),
+        now
+      );
+      if (result !== "ok")
+        throw new WebBotAuthError(result === "replayed" ? options.replayStatus ?? 429 : 429, result);
+    }
+    for (const signer of verified) verifiedSigners.add(signer);
+    return verified;
+  } catch (error) {
+    if (error instanceof WebBotAuthError) {
+      if (error.headers["Accept-Signature"]) {
+        const label = inputs(request.headers)[0]?.label ?? "sig1";
+        const bodyComponents = request.body ? '"content-type" "content-digest" ' : "";
+        error.headers["Accept-Signature"] = `${label}=("@method" "@target-uri" "@authority" ${bodyComponents}"signature-agent";key="${label}");created;expires;nonce;keyid;tag="web-bot-auth"`;
+      }
+      throw error;
+    }
+    return denied("verification_unavailable");
+  }
+}
+function verifySignatureDirectory(response, now = Date.now() / 1e3, allowTestKeys = false) {
+  try {
+    if (!Number.isFinite(now)) denied("directory_invalid");
+    const origin = (0, import_canonicalize.canonicalAgentOrigin)(response.request.url);
+    if (response.request.url !== origin + SIGNATURE_DIRECTORY_PATH || response.status !== 200 || (0, import_canonicalize2.getHeaderValue)(response.headers, "content-type")?.split(";")[0]?.trim().toLowerCase() !== SIGNATURE_DIRECTORY_MEDIA_TYPE)
+      denied("directory_response");
+    const body = response.body ?? "";
+    if (Buffer.byteLength(body) > 256 * 1024) denied("directory_size");
+    assertDigest(response.headers, body);
+    const document = (0, import_strict_json.parseStrictJson)(body, 32);
+    if (!Array.isArray(document.keys) || !document.keys.length || document.keys.length > 64) denied("directory_keys");
+    const signatures = inputs(response.headers);
+    const keys = /* @__PURE__ */ new Set();
+    let expires = Infinity;
+    for (const key of document.keys) {
+      if (!key || typeof key !== "object" || typeof key.kid !== "string" || key.kid !== jwkThumbprint(key) || keys.has(key.kid) || key.d !== void 0 || Object.keys(key).some((k) => k.startsWith("_private")) || key.adcp_use !== void 0 || (!allowTestKeys || !["test", "development"].includes(process.env.NODE_ENV ?? "")) && TEST_KIDS.has(key.kid))
+        denied("directory_key");
+      keys.add(key.kid);
+      const proof = signatures.find((input) => input.params.keyid === key.kid && input.params.tag === DIRECTORY_TAG);
+      if (!proof || !proof.components.includes("@authority;req") || !proof.components.includes("content-digest") || !Number.isInteger(proof.params.created) || !Number.isInteger(proof.params.expires) || proof.params.created > now || proof.params.expires <= now || proof.params.expires <= proof.params.created)
+        denied("directory_proof");
+      verifyBytes(proof, { ...response.request, headers: response.request.headers ?? {} }, key, response);
+      expires = Math.min(expires, proof.params.expires);
+    }
+    return { keys: document.keys, expires, proof: response };
+  } catch (error) {
+    if (error instanceof WebBotAuthError) throw error;
+    return denied("directory_invalid");
+  }
+}
+class SignatureDirectoryResolver {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  options;
+  cache = /* @__PURE__ */ new Map();
+  failures = /* @__PURE__ */ new Map();
+  keyMissCooldown = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  async resolve(keyid, signerOrigin) {
+    if (!signerOrigin) return denied("origin_required");
+    const origin = receivedAgentOrigin(signerOrigin);
+    const now = (this.options.now ?? (() => Date.now() / 1e3))();
+    const cached = this.cache.get(origin);
+    if (cached && cached.freshUntil > now && cached.directory.expires > now) {
+      const key = cached.directory.keys.find((k) => k.kid === keyid);
+      if (key || (this.keyMissCooldown.get(origin) ?? 0) > now) return key ?? null;
+      this.keyMissCooldown.set(origin, now + 60);
+    }
+    if ((this.failures.get(origin) ?? 0) > now) {
+      if (cached && cached.directory.expires > now) return cached.directory.keys.find((k) => k.kid === keyid) ?? null;
+      return denied("directory_unavailable");
+    }
+    let pending = this.pending.get(origin);
+    if (!pending) {
+      if ([...this.pending.keys()].filter((pendingOrigin) => (0, import_etld.eTldPlusOne)(pendingOrigin) === (0, import_etld.eTldPlusOne)(origin)).length >= 2 || this.pending.size >= (this.options.maxConcurrentFetches ?? 16)) {
+        if (cached && cached.directory.expires > now) return cached.directory.keys.find((k) => k.kid === keyid) ?? null;
+        throw new WebBotAuthError(429, "directory_fetch_limit");
+      }
+      pending = this.fetch(origin, now);
+      this.pending.set(origin, pending);
+    }
+    try {
+      return (await pending).keys.find((k) => k.kid === keyid) ?? null;
+    } catch (error) {
+      if (cached && cached.directory.expires > now) return cached.directory.keys.find((k) => k.kid === keyid) ?? null;
+      throw error;
+    } finally {
+      if (this.pending.get(origin) === pending) this.pending.delete(origin);
+    }
+  }
+  async fetch(origin, now) {
+    try {
+      const url = origin + SIGNATURE_DIRECTORY_PATH;
+      const result = await (0, import_net.ssrfSafeFetch)(url, {
+        ...this.options.fetchOptions,
+        headers: { accept: SIGNATURE_DIRECTORY_MEDIA_TYPE },
+        timeoutMs: 1e4,
+        maxBodyBytes: 256 * 1024
+      });
+      const body = new TextDecoder("utf-8", { fatal: true }).decode(result.body);
+      const directory = verifySignatureDirectory(
+        { status: result.status, headers: result.headers, body, request: { method: "GET", url } },
+        now,
+        this.options.allowTestKeys
+      );
+      const cacheControl = result.headers["cache-control"] ?? "";
+      const maxAge = /(?:^|,)\s*(?:no-cache|no-store)(?:,|$)/i.test(cacheControl) ? 0 : Number(cacheControl.match(/(?:^|,)\s*max-age=(\d+)/i)?.[1] ?? 300);
+      const age = Number(result.headers.age ?? 0);
+      if (!Number.isFinite(age) || age < 0) denied("directory_invalid");
+      if (this.cache.size >= (this.options.maxOrigins ?? 1e3) && !this.cache.has(origin)) {
+        const oldest = this.cache.keys().next().value;
+        this.cache.delete(oldest);
+        this.keyMissCooldown.delete(oldest);
+      }
+      this.cache.set(origin, {
+        directory,
+        freshUntil: Math.min(directory.expires, now + Math.max(0, Math.min(maxAge - age, 300)))
+      });
+      this.failures.delete(origin);
+      return directory;
+    } catch (error) {
+      if (this.failures.size >= (this.options.maxOrigins ?? 1e3))
+        this.failures.delete(this.failures.keys().next().value);
+      this.failures.set(origin, now + 60);
+      throw error instanceof WebBotAuthError ? error : new WebBotAuthError(403, "directory_unavailable");
+    }
+  }
+  get allowsTestKeys() {
+    return this.options.allowTestKeys === true && ["test", "development"].includes(process.env.NODE_ENV ?? "");
+  }
+  getAuditProof(origin) {
+    return this.cache.get(receivedAgentOrigin(origin))?.directory.proof;
+  }
+}
+async function signBase(base, key) {
+  const jwk = "privateKey" in key ? key.privateKey : key.publicKey;
+  const alg = algorithm(jwk);
+  if (!["test", "development"].includes(process.env.NODE_ENV ?? "") && TEST_KIDS.has(jwkThumbprint(jwk)))
+    throw new TypeError("Published Web Bot Auth test keys cannot sign in production");
+  if ("provider" in key) {
+    if (key.provider.keyid !== jwkThumbprint(jwk) || key.provider.algorithm !== alg)
+      throw new TypeError("Web Bot Auth provider identity does not match its public key");
+    return key.provider.sign(Buffer.from(base));
+  }
+  const privateKey = (0, import_crypto.createPrivateKey)({ key: jwk, format: "jwk" });
+  return alg === "ed25519" ? (0, import_crypto.sign)(null, Buffer.from(base), privateKey) : (0, import_crypto.sign)("sha256", Buffer.from(base), { key: privateKey, dsaEncoding: "ieee-p1363" });
+}
+async function signWebBotAuth(request, key, options) {
+  const origin = (0, import_canonicalize.canonicalAgentOrigin)(options.origin);
+  const label = options.label ?? "sig1";
+  if (!/^[a-z][a-z0-9_.*-]*$/.test(label)) throw new TypeError("Invalid signature label");
+  const jwk = "privateKey" in key ? key.privateKey : key.publicKey;
+  const now = Math.floor((options.now ?? (() => Date.now() / 1e3))());
+  const window = options.windowSeconds ?? 300;
+  const nonce = options.nonce ?? (0, import_crypto.randomBytes)(32).toString("base64url");
+  if (!Number.isInteger(window) || window < 1 || window > 300 || !/^[A-Za-z0-9_+\/-]{22,256}={0,2}$/.test(nonce))
+    throw new TypeError("Invalid Web Bot Auth lifetime or nonce");
+  const headers = {};
+  for (const [name, value] of Object.entries(request.headers))
+    if (value !== void 0 && !["signature", "signature-input", "signature-agent", "content-digest"].includes(name.toLowerCase()))
+      headers[name.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
+  const components = ['"@method"', '"@target-uri"', '"@authority"'];
+  if (request.body !== void 0 && request.body !== "") {
+    if (!(0, import_canonicalize2.getHeaderValue)(headers, "content-type"))
+      throw new TypeError("Body-bearing Web Bot Auth requests need Content-Type");
+    headers["content-digest"] = (0, import_content_digest.computeContentDigest)(request.body, "rfc8941-base64");
+    components.push('"content-type"', '"content-digest"');
+  }
+  const earlier = options.relay ? inputs(request.headers) : [];
+  if (earlier.some((input2) => input2.label === label || input2.params.tag !== WEB_BOT_AUTH_PROFILE))
+    throw new TypeError("Relay requires existing Web Bot Auth signatures and a fresh label");
+  const priorAgent = options.relay ? (0, import_canonicalize2.getHeaderValue)(request.headers, "signature-agent") : void 0;
+  if (priorAgent) dictionary(priorAgent, "Signature-Agent");
+  headers["signature-agent"] = `${priorAgent ? priorAgent + ", " : ""}${label}="${origin}"`;
+  components.push(`"signature-agent";key="${label}"`);
+  for (const inner of earlier) {
+    for (const component of inner.components) {
+      const bare = component.split(";", 1)[0];
+      const encoded = `"${bare}"${component.slice(bare.length)}`;
+      if (!components.includes(encoded)) components.push(encoded);
+    }
+    components.push(`"signature-input";key="${inner.label}"`, `"signature";key="${inner.label}"`);
+  }
+  const priorInput = options.relay ? (0, import_canonicalize2.getHeaderValue)(request.headers, "signature-input") : void 0;
+  const priorSignature = options.relay ? (0, import_canonicalize2.getHeaderValue)(request.headers, "signature") : void 0;
+  if (options.relay && (!priorInput || !priorSignature || !priorAgent))
+    throw new TypeError("Relay requires the existing signature fields");
+  headers["signature-input"] = `${priorInput ? priorInput + ", " : ""}${label}=(${components.join(" ")});created=${now};expires=${now + window};nonce="${nonce}";keyid="${jwkThumbprint(jwk)}";alg="${algorithm(jwk)}";tag="web-bot-auth"`;
+  const input = (0, import_parser.parseSignatureInput)(headers["signature-input"], label);
+  if (priorSignature) headers.signature = priorSignature;
+  const bytes = await signBase(buildWebBotAuthSignatureBase(input, { ...request, headers }), key);
+  headers.signature = `${priorSignature ? priorSignature + ", " : ""}${label}=:${Buffer.from(bytes).toString("base64")}:`;
+  return headers;
+}
+async function createSignedSignatureDirectory(originUrl, signingKeys, options = {}) {
+  const origin = (0, import_canonicalize.canonicalAgentOrigin)(originUrl);
+  const now = Math.floor((options.now ?? (() => Date.now() / 1e3))());
+  const lifetime = options.lifetimeSeconds ?? 86400;
+  if (!Number.isFinite(now) || !Number.isSafeInteger(lifetime) || lifetime < 1 || !Number.isSafeInteger(now + lifetime))
+    throw new TypeError("Invalid directory proof clock or lifetime");
+  if (!signingKeys.length || signingKeys.length > 64 || !Number.isInteger(lifetime) || lifetime < 1)
+    throw new TypeError("Invalid directory keys or lifetime");
+  const keys = signingKeys.map((key) => {
+    const jwk = "privateKey" in key ? key.privateKey : key.publicKey;
+    return {
+      kty: jwk.kty,
+      crv: jwk.crv,
+      x: jwk.x,
+      ...jwk.y ? { y: jwk.y } : {},
+      kid: jwkThumbprint(jwk),
+      use: "sig"
+    };
+  });
+  if (new Set(keys.map((k) => k.kid)).size !== keys.length) throw new TypeError("Duplicate directory key");
+  const body = JSON.stringify({ keys });
+  const response = {
+    status: 200,
+    body,
+    request: { method: "GET", url: origin + SIGNATURE_DIRECTORY_PATH },
+    headers: {
+      "content-type": SIGNATURE_DIRECTORY_MEDIA_TYPE,
+      "content-digest": (0, import_content_digest.computeContentDigest)(body, "rfc8941-base64"),
+      "cache-control": `max-age=${Math.min(lifetime, 300)}`
+    }
+  };
+  const signatureInputs = [], signatures = [];
+  for (let i = 0; i < keys.length; i++) {
+    const label = `key${i + 1}`;
+    const value = `${label}=("@authority";req "content-digest");created=${now};expires=${now + lifetime};keyid="${keys[i].kid}";alg="${algorithm(keys[i])}";tag="${DIRECTORY_TAG}"`;
+    const input = (0, import_parser.parseSignatureInput)(value, label);
+    const bytes = await signBase(
+      buildWebBotAuthSignatureBase(input, { method: "GET", url: response.request.url, headers: {} }, response),
+      signingKeys[i]
+    );
+    signatureInputs.push(value);
+    signatures.push(`${label}=:${Buffer.from(bytes).toString("base64")}:`);
+  }
+  response.headers["signature-input"] = signatureInputs.join(", ");
+  response.headers.signature = signatures.join(", ");
+  return response;
+}
+function createWebBotAuthFetch(upstream, key, options) {
+  return async (input, init) => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    if (options.shouldSign && !options.shouldSign(url, init)) return upstream(input, init);
+    if (input instanceof Request)
+      throw new TypeError("Pass a URL and init to Web Bot Auth fetch so the exact body can be signed");
+    const parsed = new URL(url);
+    if (parsed.protocol !== "https:" || parsed.username || parsed.password || parsed.hash)
+      throw new TypeError("Signed targets must be HTTPS without credentials or fragments");
+    let body;
+    if (init?.body != null) {
+      if (typeof init.body === "string") body = init.body;
+      else if (init.body instanceof Uint8Array || init.body instanceof ArrayBuffer)
+        body = new TextDecoder("utf-8", { fatal: true }).decode(init.body);
+      else throw new TypeError("Web Bot Auth fetch requires a UTF-8 string or byte body");
+    }
+    const headers = {};
+    new Headers(init?.headers).forEach((value, name) => {
+      headers[name] = value;
+    });
+    if (body !== void 0 && !headers["content-type"]) headers["content-type"] = "application/json";
+    const method = init?.method ?? "GET";
+    const signed = await signWebBotAuth({ method, url, headers, body }, key, options);
+    return upstream(url, { ...init, method, body, headers: signed, redirect: "manual" });
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SIGNATURE_DIRECTORY_MEDIA_TYPE,
+  SIGNATURE_DIRECTORY_PATH,
+  SignatureDirectoryResolver,
+  WEB_BOT_AUTH_DRAFT_REVISION,
+  WEB_BOT_AUTH_PROFILE,
+  WebBotAuthError,
+  buildWebBotAuthSignatureBase,
+  createSignedSignatureDirectory,
+  createWebBotAuthAuthorizationFailure,
+  createWebBotAuthFetch,
+  getWebBotAuthAuthorizationFailure,
+  getWebBotAuthLegacyOriginGate,
+  isVerifiedWebBotSigner,
+  jwkThumbprint,
+  receivedAgentOrigin,
+  registerWebBotAuthLegacyOriginGate,
+  selectSignatureProfile,
+  signWebBotAuth,
+  verifySignatureDirectory,
+  verifyWebBotAuth,
+  webBotAuthToolFailure
+});