@zeldrisho/pi-web-fetch 0.15.0 → 0.16.0

package/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.16.0] - 2026-10-28
+
+### Added
+
+- Automatically resolve supported AWS WAF challenges when fetching pages.
+
 ## [0.15.0] - 2026-10-28
 
 ### Added
@@ -289,7 +295,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Add bounded public page fetching ([b979496](https://github.com/zeldrisho/pi-packages/commit/b979496b32de1cead172ba570307e4a4a7b3421d))
 
-[Unreleased]: https://github.com/zeldrisho/pi-packages/compare/pi-web-fetch-v0.15.0...HEAD
+[Unreleased]: https://github.com/zeldrisho/pi-packages/compare/pi-web-fetch-v0.16.0...HEAD
+[0.16.0]: https://github.com/zeldrisho/pi-packages/compare/pi-web-fetch-v0.15.0...pi-web-fetch-v0.16.0
 [0.15.0]: https://github.com/zeldrisho/pi-packages/compare/pi-web-fetch-v0.14.1...pi-web-fetch-v0.15.0
 [0.14.1]: https://github.com/zeldrisho/pi-packages/compare/pi-web-fetch-v0.14.0...pi-web-fetch-v0.14.1
 [0.14.0]: https://github.com/zeldrisho/pi-packages/compare/pi-web-fetch-v0.13.0...pi-web-fetch-v0.14.0

package/README.md

@@ -23,15 +23,13 @@ The `web_fetch` tool accepts public HTTP and HTTPS URLs and supports HTML, Markd
 | `query`   | Optional; selects matching sections from a long page. Sections remain in source order.                    |
 | `offset`  | Optional character offset for continuing through extracted content; takes precedence over a URL fragment. |
 
-Output is bounded to 6,000 characters by default. For long pages, use the returned `nextOffset` to continue. A query selects a focused view of the fetched page; omit it to read the complete document. Large fenced source files can be focused in line-aligned excerpts; excerpts are not necessarily valid standalone source. OpenAPI and Swagger JSON or YAML documents and JavaScript bundles containing literal specs can be reported as `openapi-spec`; detection is best-effort and limited to source bodies up to 512 KiB. Pi's preview renders Markdown with the active theme and is collapsed by default (`Ctrl+O` expands it). The call preview shows the URL; the focus query and character offset are not repeated there.
+Output is bounded to 6,000 characters by default. For long pages, use the returned `nextOffset` to continue. Use `query` to focus on matching sections, or omit it to read the complete document. Pi's preview is collapsed by default; press `Ctrl+O` to expand it.
 
 For example, a URL such as `https://github.com/shadcn-ui/lint#get-started` starts at the matching heading. GitHub `blob` links and bare gists are converted to raw source URLs; repository roots use their README. GitHub directory listings are not supported.
 
 ### Page alternatives and bot challenges
 
-The tool can discover advertised Markdown versions and `/llms.txt` indexes. When an index is discovered, its URL is shown in the result so you can follow it if the fetched page is insufficient; when the index replaces the requested page, the result explains that fallback. Markdown files served with a generic binary content type are read as text. Anubis proof-of-work challenges are supported, and a page withheld by an AWS WAF or Cloudflare bot challenge falls back to the site's documentation index when one exists. Other unsupported challenges and JavaScript CAPTCHAs return a blocked result. There is no browser fallback. Challenge cookies are not reused between fetches.
-
-Pages with HTML nested beyond 512 elements are rejected.
+The tool can discover advertised Markdown versions and `/llms.txt` indexes. An index URL appears in the result when found; follow it if the page is insufficient. The tool can solve Anubis and supported AWS WAF proof-of-work challenges. If an AWS WAF or Cloudflare challenge remains blocked, it may fall back to the site's documentation index. Unsupported challenges and JavaScript CAPTCHAs return a blocked result; there is no browser fallback.
 
 ### Caching
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeldrisho/pi-web-fetch",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "Pi extension for secure, bounded public web page fetching and Markdown extraction",
   "keywords": [
     "pi",

package/src/acquisition/fetch.ts

@@ -14,6 +14,13 @@ import {
   parseAnubisChallenge,
   solveAnubisChallenge,
 } from "../challenges/anubis.ts";
+import {
+  AWS_WAF_TOKEN_COOKIE,
+  isAwsWafChallengeResponse,
+  type AwsWafResolver,
+  type AwsWafSolution,
+} from "../challenges/aws-waf.ts";
+import { nativeAwsWafResolver } from "../challenges/aws-waf-resolver.ts";
 import {
   sliceCompleteDocument,
   type CompleteDocument,
@@ -89,6 +96,10 @@ export interface FetchRemoteDependencies extends RedirectDependencies {
   timeoutMs?: number;
   /** When false, an Anubis interstitial is reported as blocked instead of solved. Defaults to true. */
   solveAnubisChallenges?: boolean;
+  /** When false, an AWS WAF challenge is reported as blocked instead of solved. Defaults to true. */
+  solveAwsWafChallenges?: boolean;
+  /** Resolver used for AWS WAF challenges; defaults to the in-process resolver. */
+  awsWafResolver?: AwsWafResolver;
 }
 
 /**
@@ -190,7 +201,7 @@ export class ChallengeBlockedError extends Error {
 function assertSuccessfulResponse(response: IncomingMessage): void {
   const status = response.statusCode ?? 0;
 
-  if (responseHeader(response, "x-amzn-waf-action")?.trim().toLowerCase() === "challenge") {
+  if (isAwsWafChallengeResponse(response)) {
     response.resume();
     throw new ChallengeBlockedError(
       `web_fetch was blocked by an AWS WAF anti-bot challenge (HTTP ${status}).`,
@@ -493,6 +504,37 @@ function assertAbsoluteHttpUrlForFetch(value: string): URL {
   return url;
 }
 
+/**
+ * Attempts one WAF token resolution while preserving caller cancellation.
+ * Solver failures are intentionally converted into the normal blocked path.
+ */
+async function resolveAwsWafToken(
+  resolver: AwsWafResolver,
+  target: ValidatedTarget,
+  signal: AbortSignal,
+  network: RedirectDependencies,
+  budgetMs: number,
+): Promise<AwsWafSolution | undefined> {
+  if (budgetMs <= 0) return undefined;
+
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), budgetMs);
+  const resolverSignal = AbortSignal.any([signal, controller.signal]);
+
+  try {
+    return await awaitWithAbort(
+      resolver.resolve({ url: target.url, signal: resolverSignal, network }),
+      resolverSignal,
+    );
+  } catch (error) {
+    if (signal.aborted) throw error;
+
+    return undefined;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
 /**
  * Fetches a URL and returns the complete document with extracted content.
  *
@@ -513,6 +555,7 @@ async function fetchDocument(
   assertAbsoluteHttpUrlForFetch(normalizeGitHubRawUrl(rawUrl));
   const controller = new AbortController();
   const timeoutMs = dependencies.timeoutMs ?? REQUEST_TIMEOUT_MS;
+  const deadline = Date.now() + timeoutMs;
   const extractHtml = dependencies.extractHtml ?? extractHtmlToMarkdown;
   let timedOut = false;
 
@@ -579,6 +622,48 @@ async function fetchDocument(
       }
     }
 
+    if (
+      isAwsWafChallengeResponse(response) &&
+      requestDependencies.solveAwsWafChallenges !== false
+    ) {
+      const resolver = requestDependencies.awsWafResolver ?? nativeAwsWafResolver;
+
+      if (resolver) {
+        response.resume();
+
+        const solution = await resolveAwsWafToken(
+          resolver,
+          target,
+          controller.signal,
+          requestDependencies,
+          Math.floor(Math.max(0, deadline - Date.now()) / 2),
+        );
+
+        if (solution) {
+          const stored = requestDependencies.cookies?.set(
+            AWS_WAF_TOKEN_COOKIE,
+            solution.token,
+            target.url,
+          );
+
+          if (stored) {
+            // Retry once inside the same validated redirect and cookie boundary.
+            // Keep the browser identity that earned the token, and report a
+            // second challenge as blocked instead of looping.
+            const retryDependencies = solution.userAgent
+              ? { ...requestDependencies, userAgent: solution.userAgent }
+              : requestDependencies;
+
+            ({ target, response } = await requestFollowingRedirects(
+              target.url,
+              controller.signal,
+              retryDependencies,
+            ));
+          }
+        }
+      }
+    }
+
     if (response.statusCode === 304 && cached) {
       response.resume();
       const etag = responseHeader(response, "etag") ?? cached.validators?.etag;

package/src/acquisition/llms.ts

@@ -191,7 +191,7 @@ async function probeUsableRawText(
         const document = await fetchCompleteDocument(
           candidate.toString(),
           sharedSignal,
-          { ...dependencies, solveAnubisChallenges: false },
+          { ...dependencies, solveAnubisChallenges: false, solveAwsWafChallenges: false },
           // An index probe never accepts an empty body.
           false,
           // A probe wants exactly this representation; retrying as HTML only burns

package/src/challenges/aws-waf-resolver.ts

@@ -0,0 +1,806 @@
+import { createCipheriv, randomBytes, randomInt, randomUUID } from "node:crypto";
+import { Worker } from "node:worker_threads";
+import type { AwsWafWork } from "./aws-waf-solver.ts";
+import type { IncomingMessage } from "node:http";
+import { crc32 } from "node:zlib";
+import type { AwsWafResolveContext, AwsWafResolver, AwsWafSolution } from "./aws-waf.ts";
+import { CookieJar } from "../network/cookies.ts";
+import {
+  requestFollowingRedirects,
+  type RedirectDependencies,
+} from "../network/network-redirects.ts";
+import { validateRemoteUrl } from "../network/network-policy.ts";
+import {
+  FETCH_MAX_BYTES,
+  decodeResponse,
+  decompressResponse,
+  readResponseBytes,
+  requestPinned,
+  responseHeader,
+} from "../network/network-transport.ts";
+
+/** AWS WAF browser-challenge signal encryption key used by the current challenge family. */
+const SIGNAL_KEY = Buffer.from(
+  "6f71a512b1e035eaab53d8be73120d3fb68a0ca346b9560aab3e5cdf753d5e98",
+  "hex",
+);
+
+/** Browser identity used for the challenge handshake and the retry. */
+const BROWSER_USER_AGENT =
+  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36";
+
+const BROWSER_VERSION = "144";
+
+const SCREEN = "1920-1080-1080-24-*-*-*";
+
+const PLUGINS = [
+  { name: "PDF Viewer", str: "PDF Viewer " },
+  { name: "Chrome PDF Viewer", str: "Chrome PDF Viewer " },
+  { name: "Chromium PDF Viewer", str: "Chromium PDF Viewer " },
+  { name: "Microsoft Edge PDF Viewer", str: "Microsoft Edge PDF Viewer " },
+  { name: "WebKit built-in PDF", str: "WebKit built-in PDF " },
+];
+
+const PLUGIN_STRING = PLUGINS.map((plugin) => plugin.str).join("");
+
+const MATH_VALUES = {
+  tan: "-1.4214488238747245",
+  sin: "0.8178819121159085",
+  cos: "-0.5753861119575491",
+};
+
+const GPU_EXTENSIONS = [
+  "ANGLE_instanced_arrays",
+  "EXT_blend_minmax",
+  "EXT_clip_control",
+  "EXT_color_buffer_half_float",
+  "EXT_depth_clamp",
+  "EXT_disjoint_timer_query",
+  "EXT_float_blend",
+  "EXT_frag_depth",
+  "EXT_polygon_offset_clamp",
+  "EXT_shader_texture_lod",
+  "EXT_texture_compression_bptc",
+  "EXT_texture_compression_rgtc",
+  "EXT_texture_filter_anisotropic",
+  "EXT_texture_mirror_clamp_to_edge",
+  "EXT_sRGB",
+  "KHR_parallel_shader_compile",
+  "OES_element_index_uint",
+  "OES_fbo_render_mipmap",
+  "OES_standard_derivatives",
+  "OES_texture_float",
+  "OES_texture_float_linear",
+  "OES_texture_half_float",
+  "OES_texture_half_float_linear",
+  "OES_vertex_array_object",
+  "WEBGL_blend_func_extended",
+  "WEBGL_color_buffer_float",
+  "WEBGL_compressed_texture_astc",
+  "WEBGL_compressed_texture_etc",
+  "WEBGL_compressed_texture_etc1",
+  "WEBGL_compressed_texture_s3tc",
+  "WEBGL_compressed_texture_s3tc_srgb",
+  "WEBGL_debug_renderer_info",
+  "WEBGL_debug_shaders",
+  "WEBGL_depth_texture",
+  "WEBGL_lose_context",
+  "WEBGL_multi_draw",
+  "WEBGL_polygon_mode",
+];
+
+/** Maps challenge type hashes to their proof-of-work family. */
+function normalizeChallengeType(value: string): string {
+  if (value.startsWith("ha9faaffd")) return "NetworkBandwidth";
+
+  if (value.startsWith("h72f957df")) return "HashcashScrypt";
+
+  if (value.startsWith("h7b0c470f")) return "SHA256";
+
+  return value;
+}
+
+/** Returns the submission endpoint for a challenge type. */
+function challengeEndpoint(challengeType: string): string {
+  return challengeType === "NetworkBandwidth" ? "mp_verify" : "verify";
+}
+
+const CHALLENGE_SAME_ORIGIN = /(\/__challenge_[A-Za-z0-9]+\/[a-f0-9]+\/[a-f0-9]+)/;
+
+const CHALLENGE_EXTERNAL =
+  /(https:\/\/[a-z0-9]+\.[a-z0-9]+\.[a-z0-9-]+\.token\.awswaf\.com\/[^/\s"]+\/[^/\s"]+\/[^/\s"]+)/;
+
+const CHALLENGE_SDK =
+  /(https:\/\/[a-z0-9]+\.edge\.sdk\.awswaf\.com\/[a-z0-9]+\/[a-z0-9]+)\/challenge\.js/;
+
+const GOKU_PROPS = /window\.gokuProps\s*=\s*(\{[^}]+\})/;
+
+type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue };
+
+type JsonObject = { [key: string]: JsonValue };
+
+interface TextResponse {
+  url: URL;
+  status: number;
+  text: string;
+}
+
+interface FingerprintMetrics {
+  fp2: number;
+  browser: number;
+  capabilities: number;
+  gpu: number;
+  dnt: number;
+  math: number;
+  screen: number;
+  navigator: number;
+  auto: number;
+  stealth: number;
+  subtle: number;
+  canvas: number;
+  formdetector: number;
+  be: number;
+}
+
+interface Collector {
+  name: keyof FingerprintMetrics;
+  metric: string;
+  low: number;
+  high: number;
+}
+
+const COLLECTORS: readonly Collector[] = [
+  { name: "fp2", metric: "100", low: 0.5, high: 3 },
+  { name: "browser", metric: "101", low: 0, high: 1 },
+  { name: "capabilities", metric: "102", low: 2, high: 8 },
+  { name: "gpu", metric: "103", low: 3, high: 12 },
+  { name: "dnt", metric: "104", low: 0, high: 1 },
+  { name: "math", metric: "105", low: 0, high: 1 },
+  { name: "screen", metric: "106", low: 0, high: 1 },
+  { name: "navigator", metric: "107", low: 0, high: 1 },
+  { name: "auto", metric: "108", low: 0, high: 1 },
+  { name: "stealth", metric: "undefined", low: 1, high: 4 },
+  { name: "subtle", metric: "110", low: 0, high: 1 },
+  { name: "canvas", metric: "111", low: 80, high: 200 },
+  { name: "formdetector", metric: "112", low: 0, high: 3 },
+  { name: "be", metric: "undefined", low: 0, high: 1 },
+];
+
+interface ChallengeData {
+  input: string;
+  hmac?: string;
+  region?: string;
+}
+
+interface ChallengeInputs {
+  challenge: ChallengeData;
+  challengeType: string;
+  difficulty: number;
+  memory: number;
+}
+
+interface BuiltMetrics {
+  metrics: JsonValue[];
+  fingerprint: FingerprintMetrics;
+}
+
+/** Returns whether a value is a plain JSON object. */
+// oxlint-disable-next-line anti-slop/no-unknown-parameters -- parses untrusted challenge JSON at the I/O boundary
+function isJsonObject(value: unknown): value is JsonObject {
+  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validates untrusted challenge JSON before use
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** Parses untrusted JSON text into a plain object. */
+function parseJsonObject(text: string): JsonObject | undefined {
+  try {
+    const parsed: unknown = JSON.parse(text);
+
+    return isJsonObject(parsed) ? parsed : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Reads a string field, returning undefined for missing or non-string values. */
+function stringField(value: JsonObject, key: string): string | undefined {
+  const field = value[key];
+
+  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validates an untrusted JSON field
+  return typeof field === "string" ? field : undefined;
+}
+
+/** Reads a numeric field, returning undefined for missing or non-numeric values. */
+function numberField(value: JsonObject, key: string): number | undefined {
+  const field = value[key];
+
+  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validates an untrusted JSON field
+  return typeof field === "number" && Number.isFinite(field) ? field : undefined;
+}
+
+/** Returns a random floating-point metric in the supplied range. */
+function randomMetric(low: number, high: number): number {
+  return Math.round((low + Math.random() * (high - low)) * 10) / 10;
+}
+
+/** Builds realistic-looking WAF metrics and the matching fingerprint metric map. */
+function buildMetrics(hasToken: boolean): BuiltMetrics {
+  const fingerprint: FingerprintMetrics = {
+    fp2: 0,
+    browser: 0,
+    capabilities: 0,
+    gpu: 0,
+    dnt: 0,
+    math: 0,
+    screen: 0,
+    navigator: 0,
+    auto: 0,
+    stealth: 0,
+    subtle: 0,
+    canvas: 0,
+    formdetector: 0,
+    be: 0,
+  };
+
+  const metrics: JsonValue[] = [];
+
+  for (const collector of COLLECTORS) {
+    const value = randomMetric(collector.low, collector.high);
+
+    fingerprint[collector.name] = Math.trunc(value);
+    metrics.push({ name: collector.metric, value, unit: "2" });
+  }
+
+  const encoding = randomMetric(0.5, 3);
+  const encryption = randomMetric(2, 8);
+
+  const acquisition =
+    COLLECTORS.reduce((total, collector) => total + fingerprint[collector.name], 0) +
+    encoding +
+    encryption +
+    randomMetric(2, 6);
+
+  const challenge = randomMetric(2, 8);
+  const cookie = randomMetric(0.1, 1);
+  const total = acquisition + challenge + cookie;
+
+  metrics.push(
+    { name: "2", value: encoding, unit: "2" },
+    { name: "3", value: encryption, unit: "2" },
+    { name: "7", value: hasToken ? 1 : 0, unit: "4" },
+    { name: "1", value: acquisition, unit: "2" },
+    { name: "4", value: challenge, unit: "2" },
+    { name: "5", value: cookie, unit: "2" },
+    { name: "6", value: total, unit: "2" },
+    { name: "8", value: 1, unit: "4" },
+  );
+
+  return { metrics, fingerprint };
+}
+
+/** Builds a browser fingerprint object accepted by the WAF signal decoder. */
+function buildSignal(site: string, fingerprint: FingerprintMetrics) {
+  const now = Date.now();
+  const canvasHash = randomInt(100_000_000, 1_000_000_000);
+  const histogram = Array.from({ length: 256 }, () => randomInt(1, 50));
+
+  return {
+    metrics: { ...fingerprint },
+    start: now,
+    flashVersion: null,
+    plugins: PLUGINS.map((plugin) => ({ name: plugin.name, str: plugin.str })),
+    dupedPlugins: `${PLUGIN_STRING}||${SCREEN}`,
+    screenInfo: SCREEN,
+    referrer: "",
+    userAgent: BROWSER_USER_AGENT,
+    location: `${site}/`,
+    webDriver: false,
+    capabilities: {
+      css: {
+        textShadow: 1,
+        WebkitTextStroke: 1,
+        boxShadow: 1,
+        borderRadius: 1,
+        borderImage: 1,
+        opacity: 1,
+        transform: 1,
+        transition: 1,
+      },
+      js: {
+        audio: true,
+        geolocation: true,
+        localStorage: "supported",
+        touch: false,
+        video: true,
+        webWorker: true,
+      },
+      elapsed: fingerprint.capabilities,
+    },
+    gpu: {
+      vendor: "Google Inc. (NVIDIA Corporation)",
+      model: "ANGLE (NVIDIA Corporation, NVIDIA GeForce RTX 5070/PCIe/SSE2, OpenGL ES 3.2)",
+      extensions: GPU_EXTENSIONS,
+    },
+    dnt: null,
+    math: MATH_VALUES,
+    automation: {
+      wd: { properties: { document: [], window: [], navigator: [] } },
+      phantom: { properties: { window: [] } },
+    },
+    stealth: { t1: 0, t2: 0, i: 1, mte: 0, mtd: false },
+    crypto: {
+      crypto: 1,
+      subtle: 1,
+      encrypt: true,
+      decrypt: true,
+      wrapKey: true,
+      unwrapKey: true,
+      sign: true,
+      verify: true,
+      digest: true,
+      deriveBits: true,
+      deriveKey: true,
+      getRandomValues: true,
+      randomUUID: true,
+    },
+    canvas: { hash: canvasHash, emailHash: null, histogramBins: histogram },
+    formDetected: false,
+    numForms: 0,
+    numFormElements: 0,
+    be: { si: false },
+    end: now + 1,
+    errors: [],
+    version: "2.4.0",
+    id: randomUUID(),
+  };
+}
+
+/** Builds and encrypts the browser signal payload. */
+function encodeSignal(site: string, hasToken: boolean) {
+  const built = buildMetrics(hasToken);
+  const signal = buildSignal(site, built.fingerprint);
+  const plaintextJson = JSON.stringify(signal);
+  const checksum = crc32(plaintextJson).toString(16).toUpperCase().padStart(8, "0");
+  const iv = randomBytes(12);
+  const cipher = createCipheriv("aes-256-gcm", SIGNAL_KEY, iv);
+
+  const ciphertext = Buffer.concat([
+    cipher.update(`${checksum}#${plaintextJson}`, "utf8"),
+    cipher.final(),
+  ]);
+
+  const tag = cipher.getAuthTag();
+
+  return {
+    encrypted: `${iv.toString("base64")}::${tag.toString("hex")}::${ciphertext.toString("hex")}`,
+    checksum,
+    metrics: built.metrics,
+    signal,
+  };
+}
+
+/** Builds the signal entry used in challenge submissions. */
+function signalEntry(encrypted: string): JsonValue[] {
+  return [{ name: "Zoey", value: { Present: encrypted } }];
+}
+
+/** Run CPU-intensive work off the main thread and terminate it on cancellation. */
+function solveAwsWafChallenge(
+  inputs: ChallengeInputs,
+  checksum: string,
+  signal: AbortSignal,
+): Promise<string | undefined> {
+  signal.throwIfAborted();
+
+  const work: AwsWafWork = {
+    type: inputs.challengeType,
+    input: inputs.challenge.input,
+    checksum,
+    difficulty: inputs.difficulty,
+    memory: inputs.memory,
+  };
+
+  const worker = new Worker(new URL("../../workers/aws-waf-worker.js", import.meta.url), {
+    workerData: work,
+    resourceLimits: { maxOldGenerationSizeMb: 64, maxYoungGenerationSizeMb: 16 },
+  });
+
+  return new Promise((resolve, reject) => {
+    let settled = false;
+
+    const timer = setTimeout(
+      () => finish(() => reject(new Error("AWS WAF worker timed out."))),
+      60_000,
+    );
+
+    function finish(callback: () => void): void {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      signal.removeEventListener("abort", onAbort);
+      void worker.terminate();
+      callback();
+    }
+
+    function onAbort(): void {
+      finish(() => reject(signal.reason));
+    }
+
+    worker.on(
+      "message",
+      (message: { kind: "solved"; solution?: string } | { kind: "error"; message: string }) => {
+        if (message.kind === "solved") finish(() => resolve(message.solution));
+        else finish(() => reject(new Error(message.message)));
+      },
+    );
+    worker.on("error", (error) => finish(() => reject(error)));
+    worker.on("exit", (code) =>
+      finish(() => reject(new Error(`AWS WAF worker exited with code ${code}.`))),
+    );
+
+    if (signal.aborted) onAbort();
+    else signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+/** Parses the base64 challenge input into challenge metadata. */
+function decodeChallengeInput(input: string): JsonObject | undefined {
+  try {
+    return parseJsonObject(Buffer.from(input, "base64").toString("utf8"));
+  } catch {
+    return undefined;
+  }
+}
+
+/** Reads challenge inputs from the `/inputs` response. */
+function parseChallengeInputs(value: JsonObject): ChallengeInputs | undefined {
+  const challenge = value["challenge"];
+
+  if (!isJsonObject(challenge)) return undefined;
+
+  const input = stringField(challenge, "input");
+
+  if (!input) return undefined;
+
+  const decoded = decodeChallengeInput(input);
+
+  const challengeType =
+    (decoded ? stringField(decoded, "challenge_type") : undefined) ??
+    stringField(value, "challenge_type");
+
+  if (!challengeType) return undefined;
+
+  const difficulty =
+    (decoded ? numberField(decoded, "difficulty") : undefined) ??
+    numberField(value, "difficulty") ??
+    1;
+
+  const memory =
+    (decoded ? numberField(decoded, "memory") : undefined) ?? numberField(value, "memory") ?? 128;
+
+  return {
+    challenge: {
+      input,
+      hmac: stringField(challenge, "hmac"),
+      region: stringField(challenge, "region"),
+    },
+    challengeType: normalizeChallengeType(challengeType),
+    difficulty,
+    memory,
+  };
+}
+
+/** Extracts the challenge URL and goku properties from a WAF page. */
+export function extractAwsWafChallenge(
+  html: string,
+  site: URL,
+): { challengeUrl: string; gokuProps?: JsonObject } | undefined {
+  const sameOrigin = CHALLENGE_SAME_ORIGIN.exec(html);
+  const external = CHALLENGE_EXTERNAL.exec(html);
+  const sdk = CHALLENGE_SDK.exec(html);
+  const match = sameOrigin ?? external ?? sdk;
+
+  if (!match) return undefined;
+
+  const challengeUrl = sameOrigin ? new URL(match[1], site).href : external ? match[1] : match[1];
+  const gokuMatch = GOKU_PROPS.exec(html);
+  const gokuProps = gokuMatch ? parseJsonObject(gokuMatch[1]) : undefined;
+
+  return { challengeUrl, gokuProps };
+}
+
+/** Builds the browser headers used to request the protected page. */
+function browserHeaders() {
+  return {
+    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",
+    "accept-language": "en-US,en;q=0.9",
+    "sec-ch-ua": `"Not:A-Brand";v="8", "Chromium";v="${BROWSER_VERSION}", "Google Chrome";v="${BROWSER_VERSION}"`,
+    "sec-ch-ua-mobile": "?0",
+    "sec-ch-ua-platform": '"Windows"',
+    "sec-fetch-dest": "document",
+    "sec-fetch-mode": "navigate",
+    "sec-fetch-site": "none",
+    "sec-fetch-user": "?1",
+    "upgrade-insecure-requests": "1",
+  };
+}
+
+/** Builds the headers used for challenge API calls. */
+function apiHeaders(site: string) {
+  return {
+    accept: "*/*",
+    "accept-language": "en-US,en;q=0.9",
+    "cache-control": "no-cache",
+    origin: site,
+    pragma: "no-cache",
+    priority: "u=1, i",
+    referer: `${site}/`,
+    "sec-ch-ua": `"Not:A-Brand";v="8", "Chromium";v="${BROWSER_VERSION}", "Google Chrome";v="${BROWSER_VERSION}"`,
+    "sec-ch-ua-mobile": "?0",
+    "sec-ch-ua-platform": '"Windows"',
+    "sec-fetch-dest": "empty",
+    "sec-fetch-mode": "cors",
+    "sec-fetch-site": "cross-site",
+  };
+}
+
+/** Reads and decodes a bounded response body. */
+async function readText(response: IncomingMessage, signal: AbortSignal): Promise<string> {
+  const bytes = await readResponseBytes(response, FETCH_MAX_BYTES, signal);
+  const decompressed = decompressResponse(bytes, responseHeader(response, "content-encoding"));
+
+  return decodeResponse(decompressed, responseHeader(response, "content-type") ?? "text/plain");
+}
+
+/** Performs a GET through the validated redirect and cookie boundary. */
+async function getText(
+  url: string,
+  network: RedirectDependencies,
+  signal: AbortSignal,
+  headers: Readonly<Record<string, string>>,
+): Promise<TextResponse> {
+  const { target, response } = await requestFollowingRedirects(url, signal, network, headers);
+  const text = await readText(response, signal);
+
+  return { url: target.url, status: response.statusCode ?? 0, text };
+}
+
+/** Performs a POST to a validated target without following redirects. */
+async function postText(
+  url: string,
+  network: RedirectDependencies,
+  signal: AbortSignal,
+  headers: Readonly<Record<string, string>>,
+  body: string,
+): Promise<TextResponse> {
+  const validateUrl = network.validateUrl ?? validateRemoteUrl;
+  const target = await validateUrl(url);
+  const cookieHeader = network.cookies?.headerFor(target.url);
+
+  const requestHeaders = { ...headers };
+
+  if (network.userAgent) requestHeaders["User-Agent"] = network.userAgent;
+
+  if (cookieHeader) requestHeaders.Cookie = cookieHeader;
+
+  const request =
+    network.request ??
+    ((value, requestSignal, requestHeadersInit, options) =>
+      requestPinned(value, requestSignal, {
+        headers: requestHeadersInit,
+        method: options?.method,
+        body: options?.body,
+      }));
+
+  const response = await request(target, signal, requestHeaders, { method: "POST", body });
+  const text = await readText(response, signal);
+
+  return { url: target.url, status: response.statusCode ?? 0, text };
+}
+
+/** Builds the multipart body used by bandwidth challenges. */
+function buildMultipart(
+  domain: string,
+  challenge: ChallengeData,
+  solution: string,
+  checksum: string,
+  encrypted: string,
+  metrics: JsonValue[],
+  gokuProps: JsonObject | undefined,
+) {
+  const boundary = `----WebKitFormBoundary${randomBytes(16).toString("hex")}`;
+
+  const metadata = {
+    challenge: {
+      input: challenge.input,
+      hmac: challenge.hmac ?? null,
+      region: challenge.region ?? null,
+    },
+    solution: null,
+    signals: signalEntry(encrypted),
+    checksum,
+    existing_token: null,
+    client: "Browser",
+    domain,
+    metrics,
+    goku_props: gokuProps ?? null,
+  };
+
+  const body = [
+    `--${boundary}`,
+    'Content-Disposition: form-data; name="solution_data"',
+    "",
+    solution,
+    `--${boundary}`,
+    'Content-Disposition: form-data; name="solution_metadata"',
+    "",
+    JSON.stringify(metadata),
+    `--${boundary}--`,
+    "",
+  ].join("\r\n");
+
+  return { body, contentType: `multipart/form-data; boundary=${boundary}` };
+}
+
+/** Builds the JSON body used by verify challenges. */
+function buildVerificationPayload(
+  domain: string,
+  challenge: ChallengeData,
+  solution: string,
+  checksum: string,
+  encrypted: string,
+  metrics: JsonValue[],
+  existingToken: string | undefined,
+  gokuProps: JsonObject | undefined,
+) {
+  return {
+    challenge: {
+      input: challenge.input,
+      hmac: challenge.hmac ?? null,
+      region: challenge.region ?? null,
+    },
+    solution,
+    signals: signalEntry(encrypted),
+    checksum,
+    existing_token: existingToken ?? null,
+    client: "Browser",
+    domain,
+    metrics,
+    goku_props: gokuProps ?? null,
+  };
+}
+
+/** Reads a token from a challenge response, including nested response objects. */
+function parseToken(value: JsonObject): string | undefined {
+  const direct = stringField(value, "token");
+
+  if (direct) return direct;
+
+  const nested = value["response"];
+
+  return isJsonObject(nested) ? stringField(nested, "token") : undefined;
+}
+
+/** Reads replacement challenge inputs from a challenge response. */
+function parseReplacementInputs(value: JsonObject): ChallengeInputs | undefined {
+  const nested = value["response"];
+
+  if (isJsonObject(nested)) {
+    const inputs = nested["inputs"];
+
+    if (isJsonObject(inputs)) return parseChallengeInputs(inputs);
+  }
+
+  const inputs = value["inputs"];
+
+  return isJsonObject(inputs) ? parseChallengeInputs(inputs) : undefined;
+}
+
+/** Runs the native AWS WAF challenge flow and returns a token. */
+async function resolveAwsWafNative(
+  context: AwsWafResolveContext,
+): Promise<AwsWafSolution | undefined> {
+  const network: RedirectDependencies = {
+    ...context.network,
+    userAgent: BROWSER_USER_AGENT,
+    persistentHeaders: browserHeaders(),
+    cookies: context.network?.cookies ?? new CookieJar(),
+  };
+
+  const site = context.url.origin;
+  const domain = context.url.hostname;
+
+  const page = await getText(context.url.href, network, context.signal, browserHeaders());
+
+  if (page.status !== 200 && page.status !== 202) return undefined;
+
+  const discovery = extractAwsWafChallenge(page.text, context.url);
+
+  if (!discovery) return undefined;
+
+  const inputsResponse = await getText(
+    `${discovery.challengeUrl}/inputs?client=browser`,
+    network,
+    context.signal,
+    apiHeaders(site),
+  );
+
+  if (inputsResponse.status !== 200) return undefined;
+
+  let inputs = parseChallengeInputs(parseJsonObject(inputsResponse.text) ?? {});
+
+  if (!inputs) return undefined;
+
+  let token: string | undefined;
+
+  for (let round = 0; round < 2; round += 1) {
+    const signal = encodeSignal(site, token !== undefined);
+    const solution = await solveAwsWafChallenge(inputs, signal.checksum, context.signal);
+
+    if (!solution) return undefined;
+
+    const endpoint = challengeEndpoint(inputs.challengeType);
+    let body: string;
+    let contentType = "text/plain;charset=UTF-8";
+
+    if (endpoint === "mp_verify") {
+      const multipart = buildMultipart(
+        domain,
+        inputs.challenge,
+        solution,
+        signal.checksum,
+        signal.encrypted,
+        signal.metrics,
+        discovery.gokuProps,
+      );
+
+      body = multipart.body;
+      contentType = multipart.contentType;
+    } else {
+      body = JSON.stringify(
+        buildVerificationPayload(
+          domain,
+          inputs.challenge,
+          solution,
+          signal.checksum,
+          signal.encrypted,
+          signal.metrics,
+          token,
+          discovery.gokuProps,
+        ),
+      );
+    }
+
+    const headers = { ...apiHeaders(site), "content-type": contentType };
+
+    const response = await postText(
+      `${discovery.challengeUrl}/${endpoint}`,
+      network,
+      context.signal,
+      headers,
+      body,
+    );
+
+    if (response.status !== 200) return undefined;
+
+    const parsed = parseJsonObject(response.text);
+
+    if (!parsed) return undefined;
+
+    token = parseToken(parsed) ?? token;
+
+    if (token) break;
+
+    const replacement = parseReplacementInputs(parsed);
+
+    if (replacement) inputs = replacement;
+  }
+
+  return token ? { token, userAgent: BROWSER_USER_AGENT } : undefined;
+}
+
+/** Native in-process AWS WAF resolver. */
+export const nativeAwsWafResolver: AwsWafResolver = {
+  resolve: resolveAwsWafNative,
+};

package/src/challenges/aws-waf-solver.ts

@@ -0,0 +1,65 @@
+import { createHash, scryptSync } from "node:crypto";
+
+/** Bounded proof-of-work request sent to the AWS WAF worker. */
+export interface AwsWafWork {
+  type: string;
+  input: string;
+  checksum: string;
+  difficulty: number;
+  memory: number;
+}
+
+/** Returns whether the first `difficulty` bits of a hash are zero. */
+export function hasLeadingZeroBits(hash: Uint8Array, difficulty: number): boolean {
+  for (let bit = 0; bit < difficulty; bit += 1) {
+    const byte = hash[Math.floor(bit / 8)];
+
+    if (byte === undefined || (byte & (1 << (7 - (bit % 8)))) !== 0) return false;
+  }
+
+  return true;
+}
+
+/** Solves the bandwidth challenge using a bounded zero-filled buffer. */
+export function solveAwsWafBandwidth(difficulty: number): string {
+  const sizes = [1_024, 1_024, 10_240, 102_400, 1_048_576, 10_485_760];
+
+  return Buffer.alloc(sizes[Math.min(5, Math.max(0, difficulty))] ?? 1_024).toString("base64");
+}
+
+/** Computes bounded proof-of-work inside a disposable worker. */
+export function solveAwsWafWork(work: AwsWafWork): string | undefined {
+  if (!Number.isInteger(work.difficulty) || work.difficulty < 1 || work.difficulty > 32)
+    return undefined;
+
+  if (work.type === "NetworkBandwidth") return solveAwsWafBandwidth(work.difficulty);
+
+  if (work.type === "SHA256") {
+    for (let nonce = 0; nonce < 2_000_000; nonce += 1) {
+      const digest = createHash("sha256").update(`${work.input}${work.checksum}${nonce}`).digest();
+
+      if (hasLeadingZeroBits(digest, work.difficulty)) return String(nonce);
+    }
+  }
+
+  if (work.type === "HashcashScrypt") {
+    const cost = work.memory > 0 ? work.memory : 128;
+
+    // Reject large or invalid costs before invoking OpenSSL.
+    if (!Number.isInteger(cost) || cost < 2 || cost > 16_384 || (cost & (cost - 1)) !== 0)
+      return undefined;
+
+    for (let nonce = 0; nonce < 100_000; nonce += 1) {
+      const digest = scryptSync(`${work.input}${work.checksum}${nonce}`, work.checksum, 32, {
+        N: cost,
+        r: 8,
+        p: 1,
+        maxmem: 64 * 1_024 * 1_024,
+      });
+
+      if (hasLeadingZeroBits(digest, work.difficulty)) return String(nonce);
+    }
+  }
+
+  return undefined;
+}

package/src/challenges/aws-waf-worker.ts

@@ -0,0 +1,14 @@
+/* v8 ignore file -- exercised through worker integration tests. */
+import { parentPort, workerData } from "node:worker_threads";
+import { solveAwsWafWork, type AwsWafWork } from "./aws-waf-solver.ts";
+
+const work: AwsWafWork = workerData;
+
+try {
+  parentPort?.postMessage({ kind: "solved", solution: solveAwsWafWork(work) });
+} catch (error) {
+  parentPort?.postMessage({
+    kind: "error",
+    message: error instanceof Error ? error.message : "AWS WAF worker failed.",
+  });
+}

package/src/challenges/aws-waf.ts

@@ -0,0 +1,34 @@
+import type { IncomingMessage } from "node:http";
+import type { RedirectDependencies } from "../network/network-redirects.ts";
+
+/** Cookie that carries an AWS WAF challenge token. */
+export const AWS_WAF_TOKEN_COOKIE = "aws-waf-token";
+
+/** A resolved AWS WAF token and the browser identity it was issued for. */
+export interface AwsWafSolution {
+  token: string;
+  userAgent?: string;
+}
+
+/** A request to resolve one AWS WAF challenge. */
+export interface AwsWafResolveContext {
+  /** The page URL withheld by the challenge. */
+  url: URL;
+  /** Cancels the solver request. */
+  signal: AbortSignal;
+  /** Network dependencies used by the resolver. */
+  network?: RedirectDependencies;
+}
+
+/** Resolves an AWS WAF challenge to a token accepted by the target origin. */
+export interface AwsWafResolver {
+  resolve(context: AwsWafResolveContext): Promise<AwsWafSolution | undefined>;
+}
+
+/** Returns whether a response carries an AWS WAF challenge. */
+export function isAwsWafChallengeResponse(response: Pick<IncomingMessage, "headers">): boolean {
+  const value = response.headers["x-amzn-waf-action"];
+  const action = Array.isArray(value) ? value[0] : value;
+
+  return action?.trim().toLowerCase() === "challenge";
+}

package/src/index.ts

@@ -20,6 +20,13 @@ export {
   type AnubisSolveContext,
 } from "./challenges/anubis.ts";
 
+export {
+  AWS_WAF_TOKEN_COOKIE,
+  isAwsWafChallengeResponse,
+  type AwsWafResolveContext,
+  type AwsWafResolver,
+} from "./challenges/aws-waf.ts";
+
 export { CookieJar } from "./network/cookies.ts";
 
 export type { FetchResult } from "./document/content.ts";

package/src/network/cookies.ts

@@ -211,6 +211,47 @@ export class CookieJar {
     this.#evict();
   }
 
+  /**
+   * Stores a challenge token returned by a resolver.
+   *
+   * The token is untrusted input. It is accepted only for the target origin,
+   * scoped to the whole origin, and held in memory for the current acquisition.
+   *
+   * @param name - Cookie name
+   * @param value - Cookie value
+   * @param url - The page URL the cookie belongs to
+   * @returns Whether the cookie was accepted
+   */
+  set(name: string, value: string, url: URL): boolean {
+    const token = value.trim();
+
+    if (
+      name.length === 0 ||
+      name.length > MAX_COOKIE_NAME_CHARACTERS ||
+      !COOKIE_NAME.test(name) ||
+      token.length === 0 ||
+      token.length > MAX_COOKIE_VALUE_CHARACTERS ||
+      hasInvalidCookieCharacter(token) ||
+      /[\s";,\\]/u.test(token)
+    ) {
+      return false;
+    }
+
+    const key = `${url.origin}\0${name}\0/`;
+    this.#cookies.delete(key);
+    this.#cookies.set(key, {
+      name,
+      value: token,
+      origin: url.origin,
+      path: "/",
+      secure: url.protocol === "https:",
+      createdAt: Date.now(),
+    });
+    this.#evict();
+
+    return true;
+  }
+
   /**
    * Returns a Cookie header value for a URL, excluding expired, insecure, and
    * cross-origin cookies.

package/src/network/network-redirects.ts

@@ -29,11 +29,16 @@ export interface RedirectDependencies {
     target: ValidatedTarget,
     signal: AbortSignal,
     headers?: Readonly<Record<string, string>>,
+    options?: { method?: string; body?: string | Uint8Array },
   ) => Promise<IncomingMessage>;
   random?: () => number;
   sleep?: (milliseconds: number, signal: AbortSignal) => Promise<void>;
   /** Origin-scoped cookies for the current acquisition, including challenge handshakes. */
   cookies?: CookieJar;
+  /** User-Agent override that persists across redirects. */
+  userAgent?: string;
+  /** Headers that survive a redirect, used by challenge handshakes that need browser identity. */
+  persistentHeaders?: Readonly<Record<string, string>>;
 }
 
 /** Creates the consistent abort error used by redirect and retry coordination. */
@@ -144,7 +149,14 @@ async function coordinatedRequest(
     const release = await acquireOrigin(target.url.origin, signal);
     let response: IncomingMessage;
     const cookieHeader = dependencies.cookies?.headerFor(target.url);
-    const requestHeaders = cookieHeader ? { Cookie: cookieHeader, ...headers } : headers;
+
+    const headersWithUserAgent = dependencies.userAgent
+      ? { "User-Agent": dependencies.userAgent, ...headers }
+      : headers;
+
+    const requestHeaders = cookieHeader
+      ? { Cookie: cookieHeader, ...headersWithUserAgent }
+      : headersWithUserAgent;
 
     try {
       response = await request(target, signal, requestHeaders);
@@ -197,7 +209,8 @@ export async function requestFollowingRedirects(
     response.resume();
     target = await awaitWithAbort(validateUrl(new URL(location, target.url)), signal);
     // Validators describe the originally cached resource and must not leak to a redirect target.
-    requestHeaders = {};
+    // Challenge handshakes opt into a fixed browser identity instead.
+    requestHeaders = dependencies.persistentHeaders ?? {};
   }
 
   throw new Error("web_fetch followed too many redirects.");

package/src/network/network-transport.ts

@@ -8,6 +8,9 @@ import type { ValidatedTarget } from "./network-policy.ts";
 /** Maximum size in bytes for raw HTTP response bodies. */
 export const FETCH_MAX_BYTES = 5 * 1_024 * 1_024;
 
+/** Fixed User-Agent used for page requests and challenge solvers. */
+export const WEB_FETCH_USER_AGENT = "Mozilla/5.0 (compatible; PiWebFetch/1.0; +https://pi.dev)";
+
 /**
  * Per-address connect deadline. A hanging address is abandoned after this
  * budget so the next validated address can be tried inside the overall
@@ -67,6 +70,8 @@ async function requestOnce(
   signal: AbortSignal,
   attemptTimeoutMs: number,
   headers: Readonly<Record<string, string>>,
+  method = "GET",
+  body?: string | Uint8Array,
 ): Promise<IncomingMessage> {
   const family = isIP(address);
 
@@ -114,11 +119,12 @@ async function requestOnce(
       target.url,
       {
         lookup,
+        method,
         signal: controller.signal,
         headers: {
           Accept:
             "text/markdown;q=1.0, text/x-markdown;q=0.9, text/plain;q=0.8, text/html;q=0.7, application/xhtml+xml;q=0.7, application/json;q=0.7, application/xml;q=0.7, */*;q=0.1",
-          "User-Agent": "Mozilla/5.0 (compatible; PiWebFetch/1.0; +https://pi.dev)",
+          "User-Agent": WEB_FETCH_USER_AGENT,
           ...headers,
         },
       },
@@ -139,7 +145,7 @@ async function requestOnce(
       if (attemptExpired) finish(() => reject(unreachableError()));
       else finish(() => reject(error));
     });
-    outgoing.end();
+    outgoing.end(body);
   });
 }
 
@@ -148,6 +154,10 @@ export interface RequestPinnedOptions {
   attemptTimeoutMs?: number;
   /** Additional fixed request headers, used for conditional cache revalidation. */
   headers?: Readonly<Record<string, string>>;
+  /** HTTP method; defaults to GET. */
+  method?: string;
+  /** Request body for non-GET requests. */
+  body?: string | Uint8Array;
 }
 
 /**
@@ -169,7 +179,15 @@ export async function requestPinned(
 
   for (const address of addresses) {
     try {
-      return await requestOnce(target, address, signal, attemptTimeoutMs, options.headers ?? {});
+      return await requestOnce(
+        target,
+        address,
+        signal,
+        attemptTimeoutMs,
+        options.headers ?? {},
+        options.method,
+        options.body,
+      );
     } catch (error) {
       lastError = error;
 

package/workers/aws-waf-solver.js

@@ -0,0 +1,56 @@
+import { createHash, scryptSync } from "node:crypto";
+
+/** Returns whether the first `difficulty` bits of a hash are zero. */
+export function hasLeadingZeroBits(hash, difficulty) {
+  for (let bit = 0; bit < difficulty; bit += 1) {
+    const byte = hash[Math.floor(bit / 8)];
+
+    if (byte === undefined || (byte & (1 << (7 - (bit % 8)))) !== 0) return false;
+  }
+
+  return true;
+}
+
+/** Solves the bandwidth challenge using a bounded zero-filled buffer. */
+export function solveAwsWafBandwidth(difficulty) {
+  const sizes = [1_024, 1_024, 10_240, 102_400, 1_048_576, 10_485_760];
+
+  return Buffer.alloc(sizes[Math.min(5, Math.max(0, difficulty))] ?? 1_024).toString("base64");
+}
+
+/** Computes bounded proof-of-work inside a disposable worker. */
+export function solveAwsWafWork(work) {
+  if (!Number.isInteger(work.difficulty) || work.difficulty < 1 || work.difficulty > 32)
+    return undefined;
+
+  if (work.type === "NetworkBandwidth") return solveAwsWafBandwidth(work.difficulty);
+
+  if (work.type === "SHA256") {
+    for (let nonce = 0; nonce < 2_000_000; nonce += 1) {
+      const digest = createHash("sha256").update(`${work.input}${work.checksum}${nonce}`).digest();
+
+      if (hasLeadingZeroBits(digest, work.difficulty)) return String(nonce);
+    }
+  }
+
+  if (work.type === "HashcashScrypt") {
+    const cost = work.memory > 0 ? work.memory : 128;
+
+    // Reject large or invalid costs before invoking OpenSSL.
+    if (!Number.isInteger(cost) || cost < 2 || cost > 16_384 || (cost & (cost - 1)) !== 0)
+      return undefined;
+
+    for (let nonce = 0; nonce < 100_000; nonce += 1) {
+      const digest = scryptSync(`${work.input}${work.checksum}${nonce}`, work.checksum, 32, {
+        N: cost,
+        r: 8,
+        p: 1,
+        maxmem: 64 * 1_024 * 1_024,
+      });
+
+      if (hasLeadingZeroBits(digest, work.difficulty)) return String(nonce);
+    }
+  }
+
+  return undefined;
+}

package/workers/aws-waf-worker.js

@@ -0,0 +1,14 @@
+/* v8 ignore file -- exercised through worker integration tests. */
+import { parentPort, workerData } from "node:worker_threads";
+import { solveAwsWafWork } from "./aws-waf-solver.js";
+
+const work = workerData;
+
+try {
+  parentPort?.postMessage({ kind: "solved", solution: solveAwsWafWork(work) });
+} catch (error) {
+  parentPort?.postMessage({
+    kind: "error",
+    message: error instanceof Error ? error.message : "AWS WAF worker failed.",
+  });
+}