castrum 0.7.0

package/src/bench/tasks/concurrent.ts

@@ -0,0 +1,213 @@
+import type { BenchFixtures, ComplexFixtures } from "../fixtures";
+import type { ConcurrentBenchTask } from "../types";
+
+export function concurrentTasks(
+  f: BenchFixtures,
+  c: ComplexFixtures,
+): ConcurrentBenchTask[] {
+  return [
+    // ── JSON validation: medium concurrency ──
+    {
+      name: "native:json_valid_concurrent_10",
+      op: "native:json_valid",
+      payload: f.jsonPayload,
+      concurrency: 10,
+      iterationsPerSlot: 50,
+      warmupPerSlot: 5,
+    },
+    {
+      name: "rust:json_valid_concurrent_10",
+      op: "rust:json_valid",
+      payload: f.jsonPayload,
+      concurrency: 10,
+      iterationsPerSlot: 50,
+      warmupPerSlot: 5,
+    },
+
+    // ── JSON validation: high concurrency ──
+    {
+      name: "native:json_valid_concurrent_50",
+      op: "native:json_valid",
+      payload: f.jsonPayload,
+      concurrency: 50,
+      iterationsPerSlot: 20,
+      warmupPerSlot: 2,
+    },
+    {
+      name: "rust:json_valid_concurrent_50",
+      op: "rust:json_valid",
+      payload: f.jsonPayload,
+      concurrency: 50,
+      iterationsPerSlot: 20,
+      warmupPerSlot: 2,
+    },
+
+    // ── HTTP parse burst ──
+    {
+      name: "native:http_parse_concurrent_20",
+      op: "native:http_parse",
+      payload: f.httpRaw,
+      concurrency: 20,
+      iterationsPerSlot: 50,
+      warmupPerSlot: 5,
+    },
+    {
+      name: "rust:http_parse_concurrent_20",
+      op: "rust:http_parse",
+      payload: f.httpRaw,
+      concurrency: 20,
+      iterationsPerSlot: 50,
+      warmupPerSlot: 5,
+    },
+
+    // ── HMAC burst ──
+    {
+      name: "native:hmac_sha256_concurrent_20",
+      op: "native:hmac_sha256",
+      payload: {
+        key: f.hmacKey,
+        data: f.hmacData,
+      },
+      concurrency: 20,
+      iterationsPerSlot: 30,
+      warmupPerSlot: 5,
+    },
+    {
+      name: "rust:hmac_sha256_concurrent_20",
+      op: "rust:hmac_sha256",
+      payload: {
+        key: f.hmacKey,
+        data: f.hmacData,
+      },
+      concurrency: 20,
+      iterationsPerSlot: 30,
+      warmupPerSlot: 5,
+    },
+
+    // ── Validation burst: email ──
+    {
+      name: "native:validate_email_concurrent_50",
+      op: "native:validate_email",
+      payload: f.emailOk,
+      concurrency: 50,
+      iterationsPerSlot: 40,
+      warmupPerSlot: 5,
+    },
+    {
+      name: "rust:validate_email_concurrent_50",
+      op: "rust:validate_email",
+      payload: f.emailOk,
+      concurrency: 50,
+      iterationsPerSlot: 40,
+      warmupPerSlot: 5,
+    },
+
+    // ── Validation burst: uuid ──
+    {
+      name: "native:validate_uuid_concurrent_50",
+      op: "native:validate_uuid",
+      payload: f.uuidOk,
+      concurrency: 50,
+      iterationsPerSlot: 40,
+      warmupPerSlot: 5,
+    },
+    {
+      name: "rust:validate_uuid_concurrent_50",
+      op: "rust:validate_uuid",
+      payload: f.uuidOk,
+      concurrency: 50,
+      iterationsPerSlot: 40,
+      warmupPerSlot: 5,
+    },
+
+    // ── Query parse burst ──
+    {
+      name: "native:query_parse_concurrent_20",
+      op: "native:query_parse",
+      payload: f.queryStr,
+      concurrency: 20,
+      iterationsPerSlot: 50,
+      warmupPerSlot: 5,
+    },
+    {
+      name: "rust:query_parse_concurrent_20",
+      op: "rust:query_parse",
+      payload: f.queryStr,
+      concurrency: 20,
+      iterationsPerSlot: 50,
+      warmupPerSlot: 5,
+    },
+
+    // ── Cookie parse burst ──
+    {
+      name: "native:cookie_parse_concurrent_20",
+      op: "native:cookie_parse",
+      payload: f.cookieStr,
+      concurrency: 20,
+      iterationsPerSlot: 50,
+      warmupPerSlot: 5,
+    },
+    {
+      name: "rust:cookie_parse_concurrent_20",
+      op: "rust:cookie_parse",
+      payload: f.cookieStr,
+      concurrency: 20,
+      iterationsPerSlot: 50,
+      warmupPerSlot: 5,
+    },
+
+    // ── CRC32 burst ──
+    {
+      name: "native:crc32_concurrent_20",
+      op: "native:crc32",
+      payload: f.crcInput,
+      concurrency: 20,
+      iterationsPerSlot: 100,
+      warmupPerSlot: 10,
+    },
+    {
+      name: "rust:crc32_concurrent_20",
+      op: "rust:crc32",
+      payload: f.crcInput,
+      concurrency: 20,
+      iterationsPerSlot: 100,
+      warmupPerSlot: 10,
+    },
+
+    // ── JSON sum burst ──
+    {
+      name: "native:json_sum_concurrent_20",
+      op: "native:json_sum",
+      payload: f.jsonPayload,
+      concurrency: 20,
+      iterationsPerSlot: 20,
+      warmupPerSlot: 3,
+    },
+    {
+      name: "rust:json_sum_concurrent_20",
+      op: "rust:json_sum",
+      payload: f.jsonPayload,
+      concurrency: 20,
+      iterationsPerSlot: 20,
+      warmupPerSlot: 3,
+    },
+
+    // ── Batch JSON validation burst ──
+    {
+      name: "native:json_valid_batch_concurrent_10",
+      op: "native:json_valid_batch",
+      payload: c.batchJsonDocs,
+      concurrency: 10,
+      iterationsPerSlot: 20,
+      warmupPerSlot: 3,
+    },
+    {
+      name: "rust:json_valid_batch_concurrent_10",
+      op: "rust:json_valid_batch_packed",
+      payload: c.batchJsonDocs,
+      concurrency: 10,
+      iterationsPerSlot: 20,
+      warmupPerSlot: 3,
+    },
+  ];
+}

package/src/bench/tasks/cookie.ts

@@ -0,0 +1,44 @@
+import * as native from "../../baseline";
+import { rust } from "../../rust-ffi";
+import { pairsToObject, readPairsPacked } from "../../shared/packed";
+import type { BenchFixtures } from "../fixtures";
+import type { BenchTask } from "../types";
+
+export function cookieTasks(f: BenchFixtures): BenchTask[] {
+  return [
+    {
+      name: "native:cookie_parse",
+      run: () => native.nativeCookieParsePacked(f.cookieStr).byteLength,
+      iterations: 500,
+      warmup: 50,
+    },
+    {
+      name: "rust:cookie_parse",
+      run: () => rust.cookieParsePacked(f.cookieStr).byteLength,
+      iterations: 500,
+      warmup: 50,
+    },
+    {
+      name: "native:cookie_parse_pipeline",
+      run: () => {
+        const obj = pairsToObject(
+          readPairsPacked(native.nativeCookieParsePacked(f.cookieStr)),
+        );
+        return Object.keys(obj).length;
+      },
+      iterations: 300,
+      warmup: 30,
+    },
+    {
+      name: "rust:cookie_parse_pipeline",
+      run: () => {
+        const obj = pairsToObject(
+          readPairsPacked(rust.cookieParsePacked(f.cookieStr)),
+        );
+        return Object.keys(obj).length;
+      },
+      iterations: 300,
+      warmup: 30,
+    },
+  ];
+}

package/src/bench/tasks/hashing.ts

@@ -0,0 +1,33 @@
+import * as native from "../../baseline";
+import { rust } from "../../rust-ffi";
+import type { BenchFixtures } from "../fixtures";
+import type { BenchTask } from "../types";
+
+export function hashingTasks(f: BenchFixtures): BenchTask[] {
+  return [
+    {
+      name: "native:crc32",
+      run: () => native.nativeCrc32(f.crcInput),
+      iterations: 1000,
+      warmup: 100,
+    },
+    {
+      name: "rust:crc32",
+      run: () => rust.crc32(f.crcInput),
+      iterations: 1000,
+      warmup: 100,
+    },
+    {
+      name: "native:fnv1a64",
+      run: () => native.nativeFnv1a64(f.crcInput),
+      iterations: 1000,
+      warmup: 100,
+    },
+    {
+      name: "rust:fnv1a64",
+      run: () => rust.fnv1a64(f.crcInput),
+      iterations: 1000,
+      warmup: 100,
+    },
+  ];
+}

package/src/bench/tasks/hmac.ts

@@ -0,0 +1,36 @@
+import * as native from "../../baseline";
+import { rust } from "../../rust-ffi";
+import type { BenchFixtures } from "../fixtures";
+import type { BenchTask } from "../types";
+
+export function hmacTasks(f: BenchFixtures): BenchTask[] {
+  return [
+    {
+      name: "native:hmac_sha256",
+      run: () => native.nativeHmacSha256(f.hmacKey, f.hmacData).byteLength,
+      iterations: 500,
+      warmup: 50,
+    },
+    {
+      name: "rust:hmac_sha256",
+      run: () => rust.hmacSha256(f.hmacKey, f.hmacData).byteLength,
+      iterations: 500,
+      warmup: 50,
+    },
+    {
+      name: "native:hmac_verify",
+      run: () =>
+        native.nativeHmacSha256Verify(f.hmacKey, f.hmacData, f.hmacSig)
+          ? 1
+          : 0,
+      iterations: 500,
+      warmup: 50,
+    },
+    {
+      name: "rust:hmac_verify",
+      run: () => rust.hmacSha256Verify(f.hmacKey, f.hmacData, f.hmacSig),
+      iterations: 500,
+      warmup: 50,
+    },
+  ];
+}

package/src/bench/tasks/http.ts

@@ -0,0 +1,50 @@
+import * as native from "../../baseline";
+import { rust } from "../../rust-ffi";
+import { readHttpPacked } from "../../shared/packed";
+import type { BenchFixtures } from "../fixtures";
+import type { BenchTask } from "../types";
+
+export function httpTasks(f: BenchFixtures): BenchTask[] {
+  return [
+    {
+      name: "native:http_parse",
+      run: () => native.nativeHttpParseRequestPacked(f.httpRaw).byteLength,
+      iterations: 500,
+      warmup: 50,
+    },
+    {
+      name: "rust:http_parse",
+      run: () => rust.httpParseRequestPacked(f.httpRaw).byteLength,
+      iterations: 500,
+      warmup: 50,
+    },
+    {
+      name: "native:http_parse_pipeline",
+      run: () => {
+        const parsed = readHttpPacked(
+          native.nativeHttpParseRequestPacked(f.httpRaw),
+        );
+        return (
+          parsed.method.length +
+          parsed.path.length +
+          Object.keys(parsed.headers).length
+        );
+      },
+      iterations: 300,
+      warmup: 30,
+    },
+    {
+      name: "rust:http_parse_pipeline",
+      run: () => {
+        const parsed = readHttpPacked(rust.httpParseRequestPacked(f.httpRaw));
+        return (
+          parsed.method.length +
+          parsed.path.length +
+          Object.keys(parsed.headers).length
+        );
+      },
+      iterations: 300,
+      warmup: 30,
+    },
+  ];
+}

package/src/bench/tasks/index.ts

@@ -0,0 +1,52 @@
+import type { BenchFixtures, ComplexFixtures } from "../fixtures";
+import type { BenchTask, ConcurrentBenchTask, StressBenchTask } from "../types";
+import { cookieTasks } from "./cookie";
+import { concurrentTasks } from "./concurrent";
+import { complexTasks } from "./complex";
+import { hashingTasks } from "./hashing";
+import { hmacTasks } from "./hmac";
+import { httpTasks } from "./http";
+import { jsonTasks } from "./json";
+import { jsonPatchTasks } from "./json-patch";
+import { mimeTasks } from "./mime";
+import { queryTasks } from "./query";
+import { stressTasks } from "./stress";
+import { tokenTasks } from "./token";
+import { urlTasks } from "./url";
+import { validationTasks } from "./validation";
+import { websocketTasks } from "./websocket";
+
+export function createAllTasks(fixtures: BenchFixtures): BenchTask[] {
+  return [
+    ...jsonTasks(fixtures),
+    ...httpTasks(fixtures),
+    ...queryTasks(fixtures),
+    ...cookieTasks(fixtures),
+    ...tokenTasks(),
+    ...websocketTasks(fixtures),
+    ...jsonPatchTasks(fixtures),
+    ...hmacTasks(fixtures),
+    ...validationTasks(fixtures),
+    ...hashingTasks(fixtures),
+    ...mimeTasks(fixtures),
+    ...urlTasks(fixtures),
+  ];
+}
+
+export function createComplexTasks(fixtures: ComplexFixtures): BenchTask[] {
+  return complexTasks(fixtures);
+}
+
+export function createConcurrentTasks(
+  fixtures: BenchFixtures,
+  complex: ComplexFixtures,
+): ConcurrentBenchTask[] {
+  return concurrentTasks(fixtures, complex);
+}
+
+export function createStressTasks(
+  fixtures: BenchFixtures,
+  complex: ComplexFixtures,
+): StressBenchTask[] {
+  return stressTasks(fixtures, complex);
+}

package/src/bench/tasks/json-patch.ts

@@ -0,0 +1,21 @@
+import * as native from "../../baseline";
+import { rust } from "../../rust-ffi";
+import type { BenchFixtures } from "../fixtures";
+import type { BenchTask } from "../types";
+
+export function jsonPatchTasks(f: BenchFixtures): BenchTask[] {
+  return [
+    {
+      name: "native:json_patch",
+      run: () => native.nativeJsonPatch(f.jsonDoc, f.jsonPatch).byteLength,
+      iterations: 500,
+      warmup: 50,
+    },
+    {
+      name: "rust:json_patch",
+      run: () => rust.jsonPatch(f.jsonDoc, f.jsonPatch).byteLength,
+      iterations: 500,
+      warmup: 50,
+    },
+  ];
+}

package/src/bench/tasks/json.ts

@@ -0,0 +1,33 @@
+import * as native from "../../baseline";
+import { rust } from "../../rust-ffi";
+import type { BenchFixtures } from "../fixtures";
+import type { BenchTask } from "../types";
+
+export function jsonTasks(f: BenchFixtures): BenchTask[] {
+  return [
+    {
+      name: "native:json_valid",
+      run: () => native.nativeJsonValid(f.jsonPayload),
+      iterations: 100,
+      warmup: 10,
+    },
+    {
+      name: "rust:json_valid",
+      run: () => rust.jsonValid(f.jsonPayload),
+      iterations: 100,
+      warmup: 10,
+    },
+    {
+      name: "native:json_sum",
+      run: () => native.nativeJsonSum(f.jsonPayload),
+      iterations: 100,
+      warmup: 10,
+    },
+    {
+      name: "rust:json_sum",
+      run: () => rust.jsonSumIds(f.jsonPayload),
+      iterations: 100,
+      warmup: 10,
+    },
+  ];
+}

package/src/bench/tasks/mime.ts

@@ -0,0 +1,21 @@
+import * as native from "../../baseline";
+import { rust } from "../../rust-ffi";
+import type { BenchFixtures } from "../fixtures";
+import type { BenchTask } from "../types";
+
+export function mimeTasks(f: BenchFixtures): BenchTask[] {
+  return [
+    {
+      name: "native:mime",
+      run: () => native.nativeMimeFromExtension("json").length,
+      iterations: 1000,
+      warmup: 100,
+    },
+    {
+      name: "rust:mime",
+      run: () => rust.mimeFromExtension(f.mimeExt).byteLength,
+      iterations: 1000,
+      warmup: 100,
+    },
+  ];
+}

package/src/bench/tasks/query.ts

@@ -0,0 +1,44 @@
+import * as native from "../../baseline";
+import { rust } from "../../rust-ffi";
+import { pairsToObject, readPairsPacked } from "../../shared/packed";
+import type { BenchFixtures } from "../fixtures";
+import type { BenchTask } from "../types";
+
+export function queryTasks(f: BenchFixtures): BenchTask[] {
+  return [
+    {
+      name: "native:query_parse",
+      run: () => native.nativeQueryParsePacked(f.queryStr).byteLength,
+      iterations: 500,
+      warmup: 50,
+    },
+    {
+      name: "rust:query_parse",
+      run: () => rust.queryParsePacked(f.queryStr).byteLength,
+      iterations: 500,
+      warmup: 50,
+    },
+    {
+      name: "native:query_parse_pipeline",
+      run: () => {
+        const obj = pairsToObject(
+          readPairsPacked(native.nativeQueryParsePacked(f.queryStr)),
+        );
+        return Object.keys(obj).length;
+      },
+      iterations: 300,
+      warmup: 30,
+    },
+    {
+      name: "rust:query_parse_pipeline",
+      run: () => {
+        const obj = pairsToObject(
+          readPairsPacked(rust.queryParsePacked(f.queryStr)),
+        );
+        return Object.keys(obj).length;
+      },
+      iterations: 300,
+      warmup: 30,
+    },
+  ];
+}

package/src/bench/tasks/stress.ts

@@ -0,0 +1,142 @@
+import * as native from "../../baseline";
+import { rust } from "../../rust-ffi";
+import type { BenchFixtures, ComplexFixtures } from "../fixtures";
+import type { StressBenchTask } from "../types";
+
+export function stressTasks(
+  f: BenchFixtures,
+  _c: ComplexFixtures,
+): StressBenchTask[] {
+  return [
+    // ── JSON validation stress ──
+    {
+      name: "native:json_valid_stress",
+      run: () => native.nativeJsonValid(f.jsonPayload),
+      durationMs: 2000,
+      warmupMs: 200,
+    },
+    {
+      name: "rust:json_valid_stress",
+      run: () => rust.jsonValid(f.jsonPayload),
+      durationMs: 2000,
+      warmupMs: 200,
+    },
+    // ── JSON sum stress ──
+    {
+      name: "native:json_sum_stress",
+      run: () => native.nativeJsonSum(f.jsonPayload),
+      durationMs: 2000,
+      warmupMs: 200,
+    },
+    {
+      name: "rust:json_sum_stress",
+      run: () => rust.jsonSumIds(f.jsonPayload),
+      durationMs: 2000,
+      warmupMs: 200,
+    },
+    // ── HTTP parse stress ──
+    {
+      name: "native:http_parse_stress",
+      run: () => native.nativeHttpParseRequestPacked(f.httpRaw).byteLength,
+      durationMs: 2000,
+      warmupMs: 200,
+    },
+    {
+      name: "rust:http_parse_stress",
+      run: () => rust.httpParseRequestPacked(f.httpRaw).byteLength,
+      durationMs: 2000,
+      warmupMs: 200,
+    },
+    // ── HMAC stress ──
+    {
+      name: "native:hmac_sha256_stress",
+      run: () => native.nativeHmacSha256(f.hmacKey, f.hmacData).byteLength,
+      durationMs: 2000,
+      warmupMs: 200,
+    },
+    {
+      name: "rust:hmac_sha256_stress",
+      run: () => rust.hmacSha256(f.hmacKey, f.hmacData).byteLength,
+      durationMs: 2000,
+      warmupMs: 200,
+    },
+    // ── CRC32 stress ──
+    {
+      name: "native:crc32_stress",
+      run: () => native.nativeCrc32(f.crcInput),
+      durationMs: 2000,
+      warmupMs: 200,
+    },
+    {
+      name: "rust:crc32_stress",
+      run: () => rust.crc32(f.crcInput),
+      durationMs: 2000,
+      warmupMs: 200,
+    },
+    // ── Query parse stress ──
+    {
+      name: "native:query_parse_stress",
+      run: () => native.nativeQueryParsePacked(f.queryStr).byteLength,
+      durationMs: 2000,
+      warmupMs: 200,
+    },
+    {
+      name: "rust:query_parse_stress",
+      run: () => rust.queryParsePacked(f.queryStr).byteLength,
+      durationMs: 2000,
+      warmupMs: 200,
+    },
+    // ── Email validation stress ──
+    {
+      name: "native:validate_email_stress",
+      run: () => (native.nativeValidateEmail(f.emailOk) ? 1 : 0),
+      durationMs: 2000,
+      warmupMs: 200,
+    },
+    {
+      name: "rust:validate_email_stress",
+      run: () => rust.validateEmail(f.emailOk),
+      durationMs: 2000,
+      warmupMs: 200,
+    },
+    // ── UUID validation stress ──
+    {
+      name: "native:validate_uuid_stress",
+      run: () => (native.nativeValidateUuid(f.uuidOk) ? 1 : 0),
+      durationMs: 2000,
+      warmupMs: 200,
+    },
+    {
+      name: "rust:validate_uuid_stress",
+      run: () => rust.validateUuid(f.uuidOk),
+      durationMs: 2000,
+      warmupMs: 200,
+    },
+    // ── Cookie parse stress ──
+    {
+      name: "native:cookie_parse_stress",
+      run: () => native.nativeCookieParsePacked(f.cookieStr).byteLength,
+      durationMs: 2000,
+      warmupMs: 200,
+    },
+    {
+      name: "rust:cookie_parse_stress",
+      run: () => rust.cookieParsePacked(f.cookieStr).byteLength,
+      durationMs: 2000,
+      warmupMs: 200,
+    },
+    // ── WebSocket accept stress ──
+    {
+      name: "native:ws_accept_key_stress",
+      run: () => native.nativeWsAcceptKey(f.wsKey).byteLength,
+      durationMs: 2000,
+      warmupMs: 200,
+    },
+    {
+      name: "rust:ws_accept_key_stress",
+      run: () => rust.wsAcceptKey(f.wsKeyBytes).byteLength,
+      durationMs: 2000,
+      warmupMs: 200,
+    },
+  ];
+}