castrum 0.7.0

package/src/bench/checks.ts

@@ -0,0 +1,227 @@
+import * as native from "../baseline";
+import { rust, rustBatch } from "../rust-ffi";
+import { decoder } from "../shared/bytes";
+import { pairsToObject, readHttpPacked, readPairsPacked } from "../shared/packed";
+import { assertDeepEqual, assertEqual, parseJsonBytes } from "./assert";
+import type { BenchFixtures, ComplexFixtures } from "./fixtures";
+
+export function runCorrectnessChecks(f: BenchFixtures): void {
+
+    assertDeepEqual(
+    readHttpPacked(native.nativeHttpParseRequestPacked(f.httpRaw)),
+    readHttpPacked(rust.httpParseRequestPacked(f.httpRaw)),
+    "http parse packed native writer",
+  );
+
+  assertDeepEqual(
+    pairsToObject(readPairsPacked(native.nativeQueryParsePacked(f.queryStr))),
+    pairsToObject(readPairsPacked(rust.queryParsePacked(f.queryStr))),
+    "query parse packed native writer",
+  );
+
+  assertDeepEqual(
+    pairsToObject(readPairsPacked(native.nativeCookieParsePacked(f.cookieStr))),
+    pairsToObject(readPairsPacked(rust.cookieParsePacked(f.cookieStr))),
+    "cookie parse packed native writer",
+  );
+
+  assertEqual(
+    native.nativeJsonSum(f.jsonPayload),
+    rust.jsonSumIds(f.jsonPayload),
+    "json sum",
+  );
+
+
+  assertEqual(
+    decoder.decode(native.nativeWsAcceptKey(f.wsKey)),
+    decoder.decode(rust.wsAcceptKey(f.wsKeyBytes)),
+    "ws accept key",
+  );
+
+  assertDeepEqual(
+    parseJsonBytes(native.nativeJsonPatch(f.jsonDoc, f.jsonPatch)),
+    parseJsonBytes(rust.jsonPatch(f.jsonDoc, f.jsonPatch)),
+    "json patch",
+  );
+
+  assertEqual(
+    decoder.decode(f.hmacSig),
+    decoder.decode(rust.hmacSha256(f.hmacKey, f.hmacData)),
+    "hmac sha256",
+  );
+
+  assertEqual(
+    native.nativeHmacSha256Verify(f.hmacKey, f.hmacData, f.hmacSig),
+    rust.hmacSha256Verify(f.hmacKey, f.hmacData, f.hmacSig),
+    "hmac verify",
+  );
+
+  assertEqual(
+    native.nativeValidateEmail(f.emailOk),
+    rust.validateEmail(f.emailOk),
+    "email valid",
+  );
+
+  assertEqual(
+    native.nativeValidateUuid(f.uuidOk),
+    rust.validateUuid(f.uuidOk),
+    "uuid valid",
+  );
+
+  assertEqual(
+    native.nativeValidateIpv4(f.ipv4Ok),
+    rust.validateIpv4(f.ipv4Ok),
+    "ipv4 valid",
+  );
+
+  assertEqual(
+    native.nativeValidateIpv6(f.ipv6Ok),
+    rust.validateIpv6(f.ipv6Ok),
+    "ipv6 valid",
+  );
+
+  assertEqual(
+    native.nativeCrc32(f.crcInput),
+    rust.crc32(f.crcInput),
+    "crc32",
+  );
+
+  assertEqual(
+    native.nativeFnv1a64(f.crcInput),
+    rust.fnv1a64(f.crcInput),
+    "fnv1a64",
+  );
+
+   assertEqual(
+    native.nativeJsonValid(f.jsonPayload),
+    rust.jsonValid(f.jsonPayload),
+    "json valid",
+  );
+
+
+  assertEqual(
+    native.nativeMimeFromExtension("json"),
+    decoder.decode(rust.mimeFromExtension(f.mimeExt)),
+    "mime",
+  );
+
+  assertEqual(
+    native.nativeUrlEncode("hello world & foo=bar"),
+    decoder.decode(rust.urlEncode(f.urlEncodeInput)),
+    "url encode",
+  );
+
+  assertEqual(
+    native.nativeUrlDecode("hello%20world%20%26%20foo%3Dbar"),
+    decoder.decode(rust.urlDecode(f.urlDecodeInput)),
+    "url decode",
+  );
+
+  console.log("Practical correctness checks passed. ✓");
+}
+
+export function runComplexCorrectnessChecks(
+  _f: BenchFixtures,
+  c: ComplexFixtures,
+): void {
+  // Batch JSON validation
+  const nativeBatch = c.batchJsonDocs.reduce(
+    (acc, doc) => acc + (native.nativeJsonValid(doc) ? 1 : 0),
+    0,
+  );
+  const rustBatchTest = c.batchJsonDocs.reduce(
+    (acc, doc) => acc + rust.jsonValid(doc),
+    0,
+  );
+  assertEqual(nativeBatch, rustBatchTest, "batch json valid");
+
+  // Batch email validation
+  const nativeEmails = c.batchEmails.reduce(
+    (acc, e) => acc + (native.nativeValidateEmail(e) ? 1 : 0),
+    0,
+  );
+  const rustEmails = c.batchEmails.reduce(
+    (acc, e) => acc + rust.validateEmail(e),
+    0,
+  );
+  assertEqual(nativeEmails, rustEmails, "batch email valid");
+
+  // Batch UUID validation
+  const nativeUuids = c.batchUuids.reduce(
+    (acc, u) => acc + (native.nativeValidateUuid(u) ? 1 : 0),
+    0,
+  );
+  const rustUuids = c.batchUuids.reduce(
+    (acc, u) => acc + rust.validateUuid(u),
+    0,
+  );
+  assertEqual(nativeUuids, rustUuids, "batch uuid valid");
+
+  // Batch IPv4 validation
+  const nativeIps = c.batchIpv4s.reduce(
+    (acc, ip) => acc + (native.nativeValidateIpv4(ip) ? 1 : 0),
+    0,
+  );
+  const rustIps = c.batchIpv4s.reduce(
+    (acc, ip) => acc + rust.validateIpv4(ip),
+    0,
+  );
+  assertEqual(nativeIps, rustIps, "batch ipv4 valid");
+
+
+
+  // Large JSON validation
+  assertEqual(
+    native.nativeJsonValid(c.jsonLarge),
+    rust.jsonValid(c.jsonLarge),
+    "large json valid",
+  );
+
+  // Huge JSON validation
+  assertEqual(
+    native.nativeJsonValid(c.jsonHuge),
+    rust.jsonValid(c.jsonHuge),
+    "huge json valid",
+  );
+
+  // Deep nested JSON validation
+  assertEqual(
+    native.nativeJsonValid(c.jsonNestedDeep),
+    rust.jsonValid(c.jsonNestedDeep),
+    "deep json valid",
+  );
+
+
+    const rustBatchJson = rustBatch
+    .jsonValid(c.batchJsonDocs)
+    .reduce((acc, b) => acc + b, 0);
+  assertEqual(nativeBatch, rustBatchJson, "batch json valid packed");
+
+  const rustBatchEmails = rustBatch
+    .validateEmail(c.batchEmails)
+    .reduce((acc, b) => acc + b, 0);
+  assertEqual(nativeEmails, rustBatchEmails, "batch email valid packed");
+
+  const rustBatchUuids = rustBatch
+    .validateUuid(c.batchUuids)
+    .reduce((acc, b) => acc + b, 0);
+  assertEqual(nativeUuids, rustBatchUuids, "batch uuid valid packed");
+
+  const rustBatchIpv4s = rustBatch
+    .validateIpv4(c.batchIpv4s)
+    .reduce((acc, b) => acc + b, 0);
+  assertEqual(nativeIps, rustBatchIpv4s, "batch ipv4 valid packed");
+
+  const nativeQueryCount = c.batchQueries.reduce(
+    (acc, q) => acc + readPairsPacked(native.nativeQueryParsePacked(q)).length,
+    0,
+  );
+
+  const rustQueryCount = rustBatch
+    .queryParse(c.batchQueries)
+    .reduce((acc, bytes) => acc + readPairsPacked(bytes).length, 0);
+
+  assertEqual(nativeQueryCount, rustQueryCount, "batch query packed count");
+
+  console.log("Complex correctness checks passed. ✓");
+}

package/src/bench/checksum.ts

@@ -0,0 +1,27 @@
+export function checksumValue(value: unknown): bigint {
+  if (typeof value === "bigint") {
+    return value;
+  }
+
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? BigInt(Math.trunc(value)) : 0n;
+  }
+
+  if (typeof value === "boolean") {
+    return value ? 1n : 0n;
+  }
+
+  if (typeof value === "string") {
+    return BigInt(value.length);
+  }
+
+  if (value instanceof Uint8Array) {
+    return BigInt(value.byteLength) + BigInt(value[0] ?? 0);
+  }
+
+  if (value != null) {
+    return 1n;
+  }
+
+  return 0n;
+}

package/src/bench/comparisons.ts

@@ -0,0 +1,70 @@
+import type { ComparisonReport } from "./types";
+
+export const comparisonReports: ComparisonReport[] = [
+  // ── Original sequential benchmarks ──
+  { label: "JSON valid", nativeName: "native:json_valid", rustName: "rust:json_valid" },
+  { label: "JSON sum", nativeName: "native:json_sum", rustName: "rust:json_sum" },
+  { label: "HTTP parse", nativeName: "native:http_parse", rustName: "rust:http_parse" },
+  { label: "Query parse", nativeName: "native:query_parse", rustName: "rust:query_parse" },
+  { label: "Cookie parse", nativeName: "native:cookie_parse", rustName: "rust:cookie_parse" },
+  { label: "Random token", nativeName: "native:random_token", rustName: "rust:random_token" },
+  { label: "WebSocket accept", nativeName: "native:ws_accept_key", rustName: "rust:ws_accept_key" },
+  { label: "JSON Patch", nativeName: "native:json_patch", rustName: "rust:json_patch" },
+  { label: "HMAC sign", nativeName: "native:hmac_sha256", rustName: "rust:hmac_sha256" },
+  { label: "HMAC verify", nativeName: "native:hmac_verify", rustName: "rust:hmac_verify" },
+  { label: "Email validation", nativeName: "native:validate_email", rustName: "rust:validate_email" },
+  { label: "UUID validation", nativeName: "native:validate_uuid", rustName: "rust:validate_uuid" },
+  { label: "IPv4 validation", nativeName: "native:validate_ipv4", rustName: "rust:validate_ipv4" },
+  { label: "IPv6 validation", nativeName: "native:validate_ipv6", rustName: "rust:validate_ipv6" },
+  { label: "CRC32", nativeName: "native:crc32", rustName: "rust:crc32" },
+  { label: "FNV-1a 64", nativeName: "native:fnv1a64", rustName: "rust:fnv1a64" },
+  { label: "MIME lookup", nativeName: "native:mime", rustName: "rust:mime" },
+  { label: "URL encode", nativeName: "native:url_encode", rustName: "rust:url_encode" },
+  { label: "URL decode", nativeName: "native:url_decode", rustName: "rust:url_decode" },
+
+  // ── Complex payload benchmarks ──
+  { label: "JSON valid (50k rows)", nativeName: "native:json_valid_large", rustName: "rust:json_valid_large" },
+  { label: "JSON valid (100k rows)", nativeName: "native:json_valid_huge", rustName: "rust:json_valid_huge" },
+  { label: "JSON valid (deep nested)", nativeName: "native:json_valid_deep", rustName: "rust:json_valid_deep" },
+  { label: "JSON sum (50k rows)", nativeName: "native:json_sum_large", rustName: "rust:json_sum_large" },
+  { label: "HTTP parse (complex)", nativeName: "native:http_parse_complex", rustName: "rust:http_parse_complex" },
+  { label: "HTTP parse (huge)", nativeName: "native:http_parse_huge", rustName: "rust:http_parse_huge" },
+  { label: "Cookie parse (large)", nativeName: "native:cookie_parse_large", rustName: "rust:cookie_parse_large" },
+  { label: "Query parse (complex)", nativeName: "native:query_parse_complex", rustName: "rust:query_parse_complex" },
+  { label: "URL encode (large)", nativeName: "native:url_encode_large", rustName: "rust:url_encode_large" },
+  { label: "URL decode (large)", nativeName: "native:url_decode_large", rustName: "rust:url_decode_large" },
+  { label: "JSON valid (batch 100)", nativeName: "native:json_valid_batch", rustName: "rust:json_valid_batch" },
+  { label: "Email validate (batch 100)", nativeName: "native:validate_email_batch", rustName: "rust:validate_email_batch" },
+  { label: "UUID validate (batch 100)", nativeName: "native:validate_uuid_batch", rustName: "rust:validate_uuid_batch" },
+  { label: "IPv4 validate (batch 100)", nativeName: "native:validate_ipv4_batch", rustName: "rust:validate_ipv4_batch" },
+  { label: "Query parse (batch 100)", nativeName: "native:query_parse_batch", rustName: "rust:query_parse_batch" },
+
+  // ── Concurrent burst benchmarks ──
+  { label: "JSON valid concurrent (10x50)", nativeName: "native:json_valid_concurrent_10", rustName: "rust:json_valid_concurrent_10" },
+  { label: "JSON valid concurrent (50x20)", nativeName: "native:json_valid_concurrent_50", rustName: "rust:json_valid_concurrent_50" },
+  { label: "HTTP parse concurrent (20x50)", nativeName: "native:http_parse_concurrent_20", rustName: "rust:http_parse_concurrent_20" },
+  { label: "HMAC concurrent (20x30)", nativeName: "native:hmac_sha256_concurrent_20", rustName: "rust:hmac_sha256_concurrent_20" },
+  { label: "Email validate concurrent (50x40)", nativeName: "native:validate_email_concurrent_50", rustName: "rust:validate_email_concurrent_50" },
+  { label: "UUID validate concurrent (50x40)", nativeName: "native:validate_uuid_concurrent_50", rustName: "rust:validate_uuid_concurrent_50" },
+  { label: "Query parse concurrent (20x50)", nativeName: "native:query_parse_concurrent_20", rustName: "rust:query_parse_concurrent_20" },
+  { label: "Cookie parse concurrent (20x50)", nativeName: "native:cookie_parse_concurrent_20", rustName: "rust:cookie_parse_concurrent_20" },
+  { label: "CRC32 concurrent (20x100)", nativeName: "native:crc32_concurrent_20", rustName: "rust:crc32_concurrent_20" },
+  { label: "JSON sum concurrent (20x20)", nativeName: "native:json_sum_concurrent_20", rustName: "rust:json_sum_concurrent_20" },
+
+  // ── Stress benchmarks (2s) ──
+  { label: "JSON valid stress (2s)", nativeName: "native:json_valid_stress", rustName: "rust:json_valid_stress" },
+  { label: "HTTP parse stress (2s)", nativeName: "native:http_parse_stress", rustName: "rust:http_parse_stress" },
+  { label: "HMAC stress (2s)", nativeName: "native:hmac_sha256_stress", rustName: "rust:hmac_sha256_stress" },
+  { label: "CRC32 stress (2s)", nativeName: "native:crc32_stress", rustName: "rust:crc32_stress" },
+  { label: "Query parse stress (2s)", nativeName: "native:query_parse_stress", rustName: "rust:query_parse_stress" },
+  { label: "JSON sum stress (2s)", nativeName: "native:json_sum_stress", rustName: "rust:json_sum_stress" },
+  { label: "Email validate stress (2s)", nativeName: "native:validate_email_stress", rustName: "rust:validate_email_stress" },
+  { label: "Cookie parse stress (2s)", nativeName: "native:cookie_parse_stress", rustName: "rust:cookie_parse_stress" },
+  { label: "UUID validate stress (2s)", nativeName: "native:validate_uuid_stress", rustName: "rust:validate_uuid_stress" },
+  { label: "WebSocket accept stress (2s)", nativeName: "native:ws_accept_key_stress", rustName: "rust:ws_accept_key_stress" },
+
+
+    { label: "HTTP parse pipeline", nativeName: "native:http_parse_pipeline", rustName: "rust:http_parse_pipeline" },
+  { label: "Query parse pipeline", nativeName: "native:query_parse_pipeline", rustName: "rust:query_parse_pipeline" },
+  { label: "Cookie parse pipeline", nativeName: "native:cookie_parse_pipeline", rustName: "rust:cookie_parse_pipeline" },
+];

package/src/bench/concurrent-worker.ts

@@ -0,0 +1,135 @@
+import * as native from "../baseline";
+import { rust, rustBatch } from "../rust-ffi";
+import { checksumValue } from "./checksum";
+
+type HmacPayload = {
+  key: Uint8Array;
+  data: Uint8Array;
+};
+
+let currentOp = "";
+let currentPayload: unknown;
+
+function runOnce(op: string, payload: unknown): unknown {
+  switch (op) {
+    case "native:json_valid":
+      return native.nativeJsonValid(payload as Uint8Array) ? 1 : 0;
+    case "rust:json_valid":
+      return rust.jsonValid(payload as Uint8Array);
+
+    case "native:http_parse":
+      return native.nativeHttpParseRequestPacked(payload as Uint8Array).byteLength;
+    case "rust:http_parse":
+      return rust.httpParseRequestPacked(payload as Uint8Array).byteLength;
+
+    case "native:hmac_sha256": {
+      const p = payload as HmacPayload;
+      return native.nativeHmacSha256(p.key, p.data).byteLength;
+    }
+    case "rust:hmac_sha256": {
+      const p = payload as HmacPayload;
+      return rust.hmacSha256(p.key, p.data).byteLength;
+    }
+
+    case "native:validate_email":
+      return native.nativeValidateEmail(payload as Uint8Array) ? 1 : 0;
+    case "rust:validate_email":
+      return rust.validateEmail(payload as Uint8Array);
+
+    case "native:validate_uuid":
+      return native.nativeValidateUuid(payload as Uint8Array) ? 1 : 0;
+    case "rust:validate_uuid":
+      return rust.validateUuid(payload as Uint8Array);
+
+    case "native:validate_ipv4":
+      return native.nativeValidateIpv4(payload as Uint8Array) ? 1 : 0;
+    case "rust:validate_ipv4":
+      return rust.validateIpv4(payload as Uint8Array);
+
+    case "native:validate_ipv6":
+      return native.nativeValidateIpv6(payload as Uint8Array) ? 1 : 0;
+    case "rust:validate_ipv6":
+      return rust.validateIpv6(payload as Uint8Array);
+
+    case "native:query_parse":
+      return native.nativeQueryParsePacked(payload as Uint8Array).byteLength;
+    case "rust:query_parse":
+      return rust.queryParsePacked(payload as Uint8Array).byteLength;
+
+    case "native:cookie_parse":
+      return native.nativeCookieParsePacked(payload as Uint8Array).byteLength;
+    case "rust:cookie_parse":
+      return rust.cookieParsePacked(payload as Uint8Array).byteLength;
+
+    case "native:crc32":
+      return native.nativeCrc32(payload as Uint8Array);
+    case "rust:crc32":
+      return rust.crc32(payload as Uint8Array);
+
+    case "native:json_sum":
+      return native.nativeJsonSum(payload as Uint8Array);
+    case "rust:json_sum":
+      return rust.jsonSumIds(payload as Uint8Array);
+
+    case "native:json_valid_batch": {
+      const items = payload as Uint8Array[];
+      let count = 0;
+      for (const item of items) {
+        if (native.nativeJsonValid(item)) count += 1;
+      }
+      return count;
+    }
+
+    case "rust:json_valid_batch_packed": {
+      const items = payload as Uint8Array[];
+      const bits = rustBatch.jsonValid(items);
+      let count = 0;
+      for (const bit of bits) count += bit;
+      return count;
+    }
+
+    default:
+      throw new Error(`Unknown concurrent op: ${op}`);
+  }
+}
+
+const ctx = globalThis as any;
+
+ctx.onmessage = (event: any) => {
+  const msg = event.data;
+
+  try {
+    if (msg?.type === "init") {
+      currentOp = msg.op as string;
+      currentPayload = msg.payload;
+
+      const warmup = Math.max(0, Number(msg.warmup ?? 0));
+      for (let i = 0; i < warmup; i++) {
+        checksumValue(runOnce(currentOp, currentPayload));
+      }
+
+      ctx.postMessage({ type: "ready" });
+      return;
+    }
+
+    if (msg?.type === "run") {
+      const iterations = Math.max(1, Number(msg.iterations ?? 1));
+      let checksum = 0n;
+
+      for (let i = 0; i < iterations; i++) {
+        checksum += checksumValue(runOnce(currentOp, currentPayload));
+      }
+
+      ctx.postMessage({
+        type: "result",
+        checksum: checksum.toString(),
+      });
+      return;
+    }
+  } catch (err) {
+    ctx.postMessage({
+      type: "error",
+      message: err instanceof Error ? err.message : String(err),
+    });
+  }
+};

package/src/bench/fixtures.ts

@@ -0,0 +1,233 @@
+import { nativeHmacSha256 } from "../baseline/tasks/hmac";
+import { jsonRowsBytes } from "../data/json-rows";
+import { encoder } from "../shared/bytes";
+
+export interface BenchFixtures {
+  jsonPayload: Uint8Array;
+  httpRaw: Uint8Array;
+  queryStr: Uint8Array;
+  cookieStr: Uint8Array;
+  hmacKey: Uint8Array;
+  hmacData: Uint8Array;
+  hmacSig: Uint8Array;
+  wsKey: string;
+  wsKeyBytes: Uint8Array;
+  jsonDoc: Uint8Array;
+  jsonPatch: Uint8Array;
+  emailOk: Uint8Array;
+  uuidOk: Uint8Array;
+  ipv4Ok: Uint8Array;
+  ipv6Ok: Uint8Array;
+  crcInput: Uint8Array;
+  mimeExt: Uint8Array;
+  urlEncodeInput: Uint8Array;
+  urlDecodeInput: Uint8Array;
+}
+
+export interface ComplexFixtures {
+  jsonLarge: Uint8Array;
+  jsonHuge: Uint8Array;
+  jsonNestedDeep: Uint8Array;
+  httpComplex: Uint8Array;
+  httpHuge: Uint8Array;
+  cookieLarge: Uint8Array;
+  queryComplex: Uint8Array;
+  urlLarge: Uint8Array;
+  batchJsonDocs: Uint8Array[];
+  batchEmails: Uint8Array[];
+  batchUuids: Uint8Array[];
+  batchIpv4s: Uint8Array[];
+  batchQueries: Uint8Array[];
+}
+
+export function createFixtures(): BenchFixtures {
+  const jsonPayload = jsonRowsBytes(5_000);
+
+  const httpRaw = encoder.encode(
+    "GET /api/users?page=1&limit=20 HTTP/1.1\r\n" +
+      "Host: example.com\r\n" +
+      "Accept: application/json\r\n" +
+      "Authorization: Bearer token\r\n" +
+      "Cookie: sid=abc; theme=dark\r\n" +
+      "\r\n",
+  );
+
+  const queryStr = encoder.encode(
+    "name=John+Doe&age=30&tags[]=a&tags[]=b&empty=&enc=%20hi%20",
+  );
+
+  const cookieStr = encoder.encode("session=abc123; theme=dark; lang=en-US");
+
+  const hmacKey = encoder.encode("super-secret-key-2026");
+  const hmacData = encoder.encode("message to sign with HMAC-SHA256");
+  const hmacSig = nativeHmacSha256(hmacKey, hmacData);
+
+  const wsKey = "dGhlIHNhbXBsZSBub25jZQ==";
+  const wsKeyBytes = encoder.encode(wsKey);
+
+  const jsonDoc = encoder.encode(JSON.stringify({ a: 1, b: { c: 2 } }));
+  const jsonPatch = encoder.encode(
+    JSON.stringify([{ op: "replace", path: "/a", value: 42 }]),
+  );
+
+  const emailOk = encoder.encode("user@example.com");
+  const uuidOk = encoder.encode("550e8400-e29b-41d4-a716-446655440000");
+  const ipv4Ok = encoder.encode("192.168.1.100");
+  const ipv6Ok = encoder.encode("2001:db8::1");
+
+  const crcInput = encoder.encode(
+    "Hello, practical CRC32 checksum test data!",
+  );
+
+  const mimeExt = encoder.encode("json");
+
+  const urlEncodeInput = encoder.encode("hello world & foo=bar");
+  const urlDecodeInput = encoder.encode(
+    "hello%20world%20%26%20foo%3Dbar",
+  );
+
+  return {
+    jsonPayload,
+    httpRaw,
+    queryStr,
+    cookieStr,
+    hmacKey,
+    hmacData,
+    hmacSig,
+    wsKey,
+    wsKeyBytes,
+    jsonDoc,
+    jsonPatch,
+    emailOk,
+    uuidOk,
+    ipv4Ok,
+    ipv6Ok,
+    crcInput,
+    mimeExt,
+    urlEncodeInput,
+    urlDecodeInput,
+  };
+}
+
+export function createComplexFixtures(): ComplexFixtures {
+  const jsonLarge = jsonRowsBytes(50_000);
+  const jsonHuge = jsonRowsBytes(100_000);
+
+  const jsonNestedDeep = encoder.encode(
+    JSON.stringify({
+      level1: {
+        level2: {
+          level3: {
+            level4: {
+              level5: {
+                data: Array.from({ length: 1000 }, (_, i) => ({
+                  id: i,
+                  value: `item_${i}`,
+                  tags: ["alpha", "beta", "gamma"],
+                })),
+                meta: { created: "2026-01-01", updated: "2026-07-24", version: 42 },
+              },
+            },
+          },
+        },
+      },
+    }),
+  );
+
+  const httpComplex = encoder.encode(
+    "POST /api/v1/users/123/orders?include=items,payments&expand=shipping HTTP/1.1\r\n" +
+      "Host: api.example.com\r\n" +
+      "Content-Type: application/json\r\n" +
+      "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c\r\n" +
+      "X-Request-ID: 550e8400-e29b-41d4-a716-446655440000\r\n" +
+      "X-Trace-ID: abcdef1234567890\r\n" +
+      "X-Client-Version: 2.5.1\r\n" +
+      "Accept: application/json, text/plain, */*\r\n" +
+      "Accept-Language: en-US,en;q=0.9\r\n" +
+      "Accept-Encoding: gzip, deflate, br\r\n" +
+      "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36\r\n" +
+      "Cookie: session=abc123; theme=dark; lang=en-US; prefs=compact; tracking=0\r\n" +
+      "Content-Length: 256\r\n" +
+      "Connection: keep-alive\r\n" +
+      "Cache-Control: no-cache\r\n" +
+      "Pragma: no-cache\r\n" +
+      "\r\n",
+  );
+
+  const httpHuge = encoder.encode(
+    "GET /api/search?q=" +
+      "a".repeat(4000) +
+      " HTTP/1.1\r\n" +
+      "Host: example.com\r\n" +
+      Array.from(
+        { length: 50 },
+        (_, i) => `X-Custom-Header-${i}: value-${i}\r\n`,
+      ).join("") +
+      "\r\n",
+  );
+
+  const cookieLarge = encoder.encode(
+    Array.from(
+      { length: 50 },
+      (_, i) => `cookie_${i}=value_${i}_with_some_extra_data_${i}`,
+    ).join("; "),
+  );
+
+  const queryComplex = encoder.encode(
+    Array.from(
+      { length: 100 },
+      (_, i) => `param${i}=value${i}&arr[]=${i}a&arr[]=${i}b`,
+    ).join("&"),
+  );
+
+  const urlLarge = encoder.encode(
+    "https://example.com/path/to/resource?search=" +
+      encodeURIComponent("hello world & foo=bar " + "x".repeat(2000)),
+  );
+
+  const batchJsonDocs = Array.from({ length: 100 }, (_, i) =>
+    encoder.encode(
+      JSON.stringify({
+        id: i,
+        action: "update",
+        payload: { count: i * 2, name: `item_${i}` },
+      }),
+    ),
+  );
+
+  const batchEmails = Array.from({ length: 100 }, (_, i) =>
+    encoder.encode(`user${i}@subdomain${i}.example.com`),
+  );
+
+  const batchUuids = Array.from({ length: 100 }, (_, i) =>
+    encoder.encode(
+      `550e8400-e29b-41d4-a716-${String(i).padStart(12, "0")}`,
+    ),
+  );
+
+  const batchIpv4s = Array.from({ length: 100 }, (_, i) =>
+    encoder.encode(`192.168.${Math.floor(i / 256)}.${i % 256}`),
+  );
+
+  const batchQueries = Array.from({ length: 100 }, (_, i) =>
+    encoder.encode(
+      `id=${i}&name=user${i}&active=${i % 2 === 0}&tags[]=${i}a&tags[]=${i}b`,
+    ),
+  );
+
+  return {
+    jsonLarge,
+    jsonHuge,
+    jsonNestedDeep,
+    httpComplex,
+    httpHuge,
+    cookieLarge,
+    queryComplex,
+    urlLarge,
+    batchJsonDocs,
+    batchEmails,
+    batchUuids,
+    batchIpv4s,
+    batchQueries,
+  };
+}

package/src/bench/index.ts

@@ -0,0 +1,2 @@
+export { runBenchmark } from "./run";
+export * from "./types";