castrum 0.9.0 → 0.9.1

package/docs/REPO_MAP.md

@@ -19,7 +19,7 @@ agent editing this repo, [`AGENTS.md`](../AGENTS.md) is the agent-facing map.
   Under Bun, `bun:ffi` is the PRIMARY transport; NAPI is the fallback
   (Node, `CASTRUM_FFI_MODE=napi`, or a failed ffi self-test).
 - **TypeScript** (`src/`) provides the ergonomic public API: the flat `rust.*`
-  FFI client, the `proven` performance surface, and the ingress layer.
+  FFI client and the ingress layer.
 - It ships benchmarks: a **CPU benchmark** (`bench.ts` → `src/bench`) and an
   **HTTP benchmark** (`bench/run-bench.ts` + `bench/servers/*`).
 
@@ -43,8 +43,6 @@ Bun is the primary runtime; Node.js ≥20.3 is supported via a compiled ESM entr
 | Installed-tarball e2e | `bun run verify:install` | pack → install → import from `node_modules` |
 | Typecheck | `bun run typecheck` | `bunx tsc --noEmit` (only `index.ts`, `bench.ts`, `src/`) |
 | CPU benchmark + correctness | `bun run check` | == `bun bench.ts`; writes `bench/results/cpu/` |
-| Proven-surface audit | `bun run check:proven[:fail]` | `:fail` gates CI on regressions |
-| Performance JSDoc | `bun run check:annotate` | rewrites perf JSDoc from CPU report; `--dry-run` previews |
 | HTTP bench (all servers) | `bun run bench:http` | |
 | HTTP smoke (fast sanity) | `bun run bench:http:smoke` | **the wire-format guard** (CI-gated) |
 | Startup bench | `bun run bench:startup` | import + first-call timing |
@@ -62,7 +60,7 @@ Bun is the primary runtime; Node.js ≥20.3 is supported via a compiled ESM entr
 ### Source (what you edit)
 
 ```
-index.ts                  Package entry (Bun). Re-exports src/rust-ffi, proven, shared helpers, src/ingress.
+index.ts                  Package entry (Bun). Re-exports src/rust-ffi, shared helpers, src/ingress.
 bench.ts                  CPU benchmark entry point → src/bench/run.ts.
 
 examples/                 Runnable sample app (basic-server.ts + README) — see also README Quick Start.
@@ -70,28 +68,46 @@ examples/                 Runnable sample app (basic-server.ts + README) — see
 
 src/
   native/                 The native transport layer: bun:ffi (primary on Bun) + NAPI fallback.
-    types.ts              NativeAddon interface + every instance type (mirrors index.d.ts).
+    types.ts              NativeAddon module-surface interface (mirrors index.d.ts).
+    types/instances.ts    Per-class INSTANCE types (Ingress, SchemaValidator, JwtSigner, ...) + result types.
     loader.ts             Addon path resolution (multi-root) + getAddon()/lazyAddon().
     ffi.ts                bun:ffi C-ABI bindings (Bun-only): lazy bind + bind-time self-test,
                           CASTRUM_FFI_MODE gating, castrum_ingress_layout blob for constants.ts.
+    ffi/                  ffi/types.ts (BunFFI interface) + constants.ts + selftest.ts (bind-time self-test).
     index.ts              Barrel.
+  runtime/                THE RUNTIME ADAPTER seam (Bun/Node) — selected once at load.
+    detect.ts             Cached runtime detection — the ONLY place `typeof Bun` is checked.
+    types.ts              RuntimeAdapter contract (codec/uuid/env/builtins/transport/server/websocket).
+    codec.ts              Runtime-native UTF-8 codec (Bun transfer vs TextEncoder/Decoder).
+    uuid.ts               uuidv7 (Bun.randomUUIDv7 vs crypto.randomUUID).
+    builtins.ts           BUN_WINS delegation registry (single source; `has(op)`).
+    transport.ts          bun:ffi-first `resolve(op)` + ffi/napi surfaces (lazy bind).
+    native.ts             FFI-facing seam (codec/uuid/env/builtins/transport) — imported by rust-ffi.
+    server.ts             createIngressServer: Bun.serve on Bun, node:http on Node.
+    websocket.ts          101 upgrade on Bun; clear Bun-only error on Node.
+    index.ts              FULL adapter `runtime` (native + server + websocket) — for the public API.
   rust-ffi/               The flat `rust.*` FFI client (TS wrappers over the addon).
     client.ts             createRust() factory + the default `rust` instance + configure().
-    scalar/ / text.ts / batch.ts / packed.ts   namespaces (buildScalar, buildText, ...).
-    context.ts            Per-instance state (caches, rayon-pool bookkeeping).
+    scalar/ / text.ts / packed.ts   namespaces (buildScalar, buildText, ...).
+    batch/                Array-of-bytes batch namespace: types.ts (RustBatch interface) + build.ts (impl) + index.ts.
+    context.ts            Per-instance state (caches, rayon-pool bookkeeping, runtime seam).
     options.ts            RustOptions + rayon-thread resolution + coercion helpers.
     addon.ts              The single shared lazy addon proxy.
-    proven.ts             `proven` client — the FULL rust.* surface, annotated (same object as `rust`).
     index.ts              Barrel (exports rust, createRust, types).
   shared/                 Cross-cutting helpers.
-    runtime.ts            THE ONLY place `typeof Bun` is checked (isBun/isNode).
-    bytes.ts              Shared TextEncoder/Decoder singletons + toPlainBuffer.
-    packed.ts             Packed-wire unpackers (unpackU32Array, packBatch, readPairsPacked, ...).
+    runtime.ts            Facade over src/runtime/detect.ts (isBun/isNode — cached).
+    codec.ts              Facade over src/runtime/codec.ts.
+    uuid.ts               Facade over src/runtime/uuid.ts.
+    bytes.ts              encoder/decoder (Uint8Array|string union normalization) + toPlainBuffer.
+    packed/               Packed wire-format helpers (split from the old packed.ts monolith).
+      wire.ts             PURE byte encode/decode (u32/bitset/i64/byte-results/multipart, pairs, pack-scratch) — no addon.
+      schema.ts           SchemaValidator alias + schemaValidateBatch/Count.
+      parsers.ts          lazy-addon string parsers (parseQueryString/parseCookieHeader/parseFormBody).
+      index.ts            Barrel (existing `../shared/packed` imports unchanged).
     request-id.ts         Zero-alloc request-id generator (both ingress paths).
     buffer-pool.ts        Generic reusable byte-buffer pool (pooled ingress output).
     response.ts           pooledBodyResponse (releases the pool on body consume).
     log.ts                createStructuredLogger (CASTRUM_LOG_LEVEL-gated JSON lines).
-    proven.ts             PROVEN_SURFACE registry (PURE DATA — no addon imports).
   ingress/                The HTTP ingress pipeline (two paths — see §4.2).
     fast.ts               PATH 1: createIngressFast (packed-input via handleRequestPacked).
     handlers.ts           PATH 2: createIngressHandler (JS-packs the frame via IngressInputPacker
@@ -130,7 +146,9 @@ rust/                     ONE cdylib crate (Cargo [lib] → lib.rs).
   ingress/                THE ingress pipeline: mod.rs (napi boundary), pipeline.rs (core 8-stage),
                           options/time/packed, cors, proxy, ip_trust, rate_limit, terminal,
                           output.rs (single numeric layout source), ingress_constants.rs (napi projection).
-  ffi.rs                  #[no_mangle] extern "C" exports (45 castrum_* symbols) for Bun's bun:ffi
+  ffi.rs                  #[no_mangle] extern "C" exports (79 castrum_* symbols — 71 direct + 4
+                          validator_c_abi! + 4 compress_to_out!; parity guarded by
+                          test/unit/features/ffi-symbol-parity.test.ts) for Bun's bun:ffi
                           primary transport, incl. castrum_ingress_layout (the layout blob).
   unit_tests.rs / test_support.rs   Cross-module Rust test suites.
 ```
@@ -185,22 +203,22 @@ this reason. **Shared between both paths**: `generateRequestId`
 - `src/native/loader.ts` resolves the `.node` from multiple roots so it works
   from both the source layout (`src/…`) and the bundled layout (`dist/…`).
   Honors `CASTRUM_NATIVE_LIBRARY_PATH` / `NAPI_RS_NATIVE_LIBRARY_PATH`.
-- Runtime detection lives **only** in `src/shared/runtime.ts`
-  (`isBun`/`isNode`). `createIngressServer` is Bun-only; Node users use
-  `createIngressServerNode` (same route handlers via `buildRouteHandlers`).
+- Runtime detection lives **only** in `src/runtime/detect.ts` (resolved once at
+  load; `src/shared/runtime.ts` is a thin facade). The public
+  `createIngressServer` (via the adapter's `server`) picks `Bun.serve` on Bun
+  and the `node:http` backend on Node; `createIngressServerNode` stays for
+  pinned Node users (same route handlers via `buildRouteHandlers`).
 - ⚠️ `src/ingress/constants.ts` is the **one module that dlopens the addon at
   import time** (its constants are needed as soon as ingress is imported).
   Everything else is lazy.
 
-### 4.4 The `proven` performance surface
-`src/shared/proven.ts` (`PROVEN_SURFACE`) is the single source of truth for the
-per-function performance classifications. It is **pure data** (no addon
-imports) so `scripts/check-proven.ts` can audit it without dlopening.
-`src/rust-ffi/proven.ts` exposes the FULL `rust.*` surface (nothing is
-filtered); each function's JSDoc carries its measured performance vs the JS
-baseline, written by `scripts/annotate-performance.ts` (`bun run check:annotate`)
-and marked `@deprecated` when slower. `bun run check:proven:fail` (CI) audits
-the registry against the CPU benchmark report on a **release** build.
+### 4.4 The runtime adapter
+`src/runtime/` is the single seam for every Bun-vs-Node and transport decision
+(detection, codec, uuid, env, the BUN_WINS built-in delegation, the bun:ffi-vs-
+napi transport, the ingress server backend, websocket) — selected ONCE at
+module load. The FFI layer imports the seam (`src/runtime/native.ts`); the
+public API imports the full `runtime` (`src/runtime/index.ts`). No
+`isBun()` / `getBunFFI()` branches in builders.
 
 ### 4.5 Pooled output buffers (path 2)
 `createIngressHandler` owns a `BufferPool` (`src/shared/buffer-pool.ts`) sized
@@ -251,9 +269,11 @@ consumed.
 | Doc | Purpose |
 |-----|---------|
 | [`GETTING_STARTED.md`](./GETTING_STARTED.md) | Beginner tutorial (intern-friendly) |
+| [`API.md`](./API.md) | The complete public API reference |
+| [`CASE_STUDY.md`](./CASE_STUDY.md) | Data-driven case study: how castrum was built and measured |
 | [`ARCHITECTURE.md`](./ARCHITECTURE.md) | Deep-dive: modules, data flow, output layout, memory, concurrency |
 | [`INGRESS.md`](./INGRESS.md) | The pre-baked ingress API + route factories + servers |
 | [`BENCHMARKS.md`](./BENCHMARKS.md) | Benchmark scenarios, report format, how to run |
 | [`ENVIRONMENT.md`](./ENVIRONMENT.md) | All `CASTRUM_*` env vars (+ legacy aliases) |
 | [`AGENTS.md`](../AGENTS.md) | AI-agent editing guidance (commands, constraints, gotchas) |
-| `README.md` | Public-facing quick start + API reference |
+| `README.md` | Public-facing overview + quick start |

package/docs/adr/0003-bun-builtins-delegation.md

@@ -17,7 +17,7 @@ Every overlapping op is **benchmarked against its Bun built-in** before it is
 built, kept, or delegated. Results live in
 `docs/bun-builtins-decision-matrix.md`. Rules:
 
-1. **Delegate to Bun** at the `@flux/native` wrapper layer where Bun wins
+1. **Delegate to Bun** at the selection/delegation layer where Bun wins
    clearly: non-crypto hashing (`Bun.hash.crc32` ~3x, `xxHash3` ~4x),
    gzip (`Bun.gzipSync`/`gunzipSync`), `Bun.randomUUIDv7` (~2x), HMAC
    (`Bun.CryptoHasher` ~1.2x).
@@ -31,10 +31,11 @@ built, kept, or delegated. Results live in
 
 - New `rust.*` primitives ship with a Bun-built-in baseline + decision-matrix
   entry (`xxh3`, `passwordHashBcrypt`/`verifyBcrypt`, `pbkdf2Sha256`).
-- `PROVEN_SURFACE` classifications reflect the Bun/JS baseline honestly
-  (e.g. `xxh3` is `not-competitive` vs `Bun.hash.xxHash3`).
-- Diagnostic benchmark tasks use `diag:` names so they never perturb the
-  `check:proven` audit.
+- The Bun/JS baselines are recorded honestly in the decision matrix
+  (e.g. `xxh3` is measured `Bun.hash.xxHash3` ~4x faster — the public
+  `rust.xxh3` delegates to it under Bun via the runtime adapter's `builtins`).
+- Diagnostic benchmark tasks use `diag:` names so they are never mistaken for
+  shipped-op `native:`/`rust:` comparisons.
 
 ## See also
 

package/docs/bun-builtins-decision-matrix.md

@@ -2,7 +2,7 @@
 
 > **Question this answers**: for the same workload, does a Bun native built-in
 > beat the castrum Rust op? Where it does, castrum should stop reinventing the
-> wheel and `@flux/native` should delegate to Bun; where castrum wins (or Bun
+> wheel and delegate to Bun; where castrum wins (or Bun
 > has no sync equivalent), the Rust op stands.
 
 ## Methodology
@@ -12,9 +12,8 @@
   shipped profile).
 - **Driver**: `bun run check` (CPU benchmark → `bench/results/cpu/latest.json`).
   Each pair runs on the SAME input (fixture payloads, see table).
-- **Naming**: diagnostic comparisons use `diag:` task names so
-  `scripts/check-proven.ts` never aggregates them into a `PROVEN_SURFACE`
-  entry (see `src/bench/comparisons.ts`).
+- **Naming**: diagnostic comparisons use `diag:` task names so they are kept out
+  of the shipped-op `native:`/`rust:` comparisons (see `src/bench/comparisons.ts`).
 - **Honesty guard**: every Bun API is verified to actually execute real work at
   runtime before a result is trusted. This is important — the first run
   produced false "wins" (brotli 156×, validators 3–5×) because this Bun
@@ -56,22 +55,30 @@
 
 ## Decisions
 
-### → Delegate to Bun at the `@flux/native` wrapper layer (Bun wins)
+### → Delegate to Bun at the selection layer (Bun wins)
 These rust ops lose to Bun's native implementation on the SAME workload — the
 FFI crossing cannot beat Bun's in-process C++:
 
+This table mirrors `BUILTIN_OPS` in `src/runtime/builtins.ts` (the 11 ops that
+delegate to Bun built-ins under Bun; `src/selection.ts` derives from it). `fnv1a64` is parity/either but is NOT delegated
+(`Bun.hash` is wyhash — a different algorithm — and rust `fnv1a64` stays the
+benchmarked impl).
+
 | Op | Recommendation |
 |---|---|
 | `crc32` | Prefer `Bun.hash.crc32`; keep rust as fallback (pure-TS path already exists). |
-| `xxh3` | Prefer `Bun.hash.xxHash3` (~4×); keep the rust export as the Node/non-Bun fast path. Classified `not-competitive` in `PROVEN_SURFACE`. |
-| `gzipCompress` / `gzipDecompress` | Prefer `Bun.gzipSync` / `Bun.gunzipSync`. |
+| `xxh3` | Prefer `Bun.hash.xxHash3` (~4×); keep the rust export as the Node/non-Bun fast path. The runtime adapter delegates the public `rust.xxh3` to Bun under Bun. |
+| `gzipCompress` | Prefer `Bun.gzipSync` (~2×). **`gzipDecompress` is deliberately NOT delegated** — `Bun.gunzipSync` has no decompression-bomb cap; the rust surface keeps its native 64 MiB-capped path under Bun. |
 | `randomToken` | Prefer `Bun.randomUUIDv7()` (or `crypto.getRandomValues`) for token-sized output; keep rust for byte-precise control. |
 | `hmacSha256` | Prefer `Bun.CryptoHasher("sha256", key)` (1.17× — mild; keep rust batch path, which wins on larger inputs). |
-| `fnv1a64` | Parity — either is fine; `Bun.hash` (wyhash) is a stronger algorithm, prefer it for NEW non-crypto hashing needs. |
+| `urlEncode` / `urlDecode` | Prefer `encodeURIComponent` / `decodeURIComponent` (JSC string builtins — ~11.5×, zero alloc). |
+| `base64Encode` / `base64UrlEncode` | Prefer `Buffer.toString('base64'|'base64url')`. |
+| `hexEncode` | Prefer `Buffer.toString('hex')`. |
+| `httpDate` | Prefer `Date.toUTCString()`. |
 
-**Delegation rule of thumb**: rust stays the default only where it is
-`proven` against its **Bun** baseline (not just its JS baseline). These are the
-ops where rust genuinely wins or Bun has no equivalent.
+**Delegation rule of thumb**: rust stays the default only where it beats its
+**Bun** baseline (not just its JS baseline). These are the ops where rust
+genuinely wins or Bun has no equivalent.
 
 ### → Keep rust (rust wins or Bun has no equivalent)
 | Op | Rationale |
@@ -83,19 +90,19 @@ ops where rust genuinely wins or Bun has no equivalent.
 | `validateEmail` / `validateUuid` / `validateIpv4` / `validateIpv6` | `Bun.validators` absent in 1.4; keep rust. Re-check when Bun adds it. |
 | `jsonValid` / `jsonSumIds` / packed parsers / ingress | No Bun sync equivalent for the zero-DOM / zero-copy semantics; keep rust. |
 
-### → Add primitives that close gaps (Phase 2)
-| Gap | Plan |
+### → Implemented primitives (gaps closed)
+| Primitive | Outcome |
 |---|---|
-| Public XXH3-64 (`rust.xxh3`) | **Done** — exposed; measured Bun.hash.xxHash3 4.15× faster → classify `not-competitive`, prefer Bun under Bun. |
-| bcrypt | **Done** — `rust.passwordHashBcrypt`/`passwordVerifyBcrypt`; hash parity, verify rust 1.49×. |
-| PBKDF2 | **Done** — `rust.pbkdf2Sha256`; parity with node:crypto, only sync option in Bun. |
-| UUIDv7 | `Bun.randomUUIDv7` already wins — **do not** build a rust UUIDv7; use Bun. |
+| `rust.xxh3` (XXH3-64) | Exposed; measured `Bun.hash.xxHash3` 4.15× faster → the runtime adapter delegates the public `rust.xxh3` to Bun under Bun (Node keeps the addon). |
+| `rust.passwordHashBcrypt` / `rust.passwordVerifyBcrypt` | bcrypt `$2b$` PHC; hash parity, verify rust 1.49×. |
+| `rust.pbkdf2Sha256` | PBKDF2-HMAC-SHA256; parity with `node:crypto`, the only sync option in Bun. |
+| UUIDv7 (`uuidv7()`) | `Bun.randomUUIDv7` already wins — delegated to Bun (`crypto.randomUUID` on Node), not built in Rust. |
 
 ## Summary
 
 **The "don't reinvent the wheel" takeaway:** for non-cryptographic hashing,
 random tokens, and gzip, Bun 1.4's built-ins are already faster than any
-FFI-crossing Rust op — `@flux/native` should prefer them. Rust retains a clear,
+FFI-crossing Rust op — the selection layer should prefer them. Rust retains a clear,
 defensible moat exactly where it matters: **argon2id password hashing
 (≈1.9× vs Bun)**, the **zero-DOM / zero-copy parsers and JSON paths** (no Bun
 sync equivalent), and **brotli** (no Bun sync API).

package/index.ts

@@ -1,9 +1,15 @@
 // index.ts — castrum package entry (barrel).
 //
 // Re-exports the full public API: the flat `rust.*` FFI surface
-// (src/rust-ffi), the runtime selection hints (src/selection), the
-// performance-proven registry (src/shared/proven), and the higher-order
-// loader (src/loader). See AGENTS.md for the layout map.
+// (src/rust-ffi), the runtime selection hints (src/selection), and the
+// higher-order loader (src/loader). See AGENTS.md for the layout map.
+//
+// EAGER-DLOPEN CONTRACT: this barrel unconditionally re-exports `src/ingress`
+// → `src/ingress/constants.ts`, which is the ONE module that touches native at
+// import time (it reads the Rust binary layout and runs the bind-time
+// self-test). This is intentional — even `import { rust }` pays the eager
+// load. Do NOT add more eager-native modules; keep everything else lazy (see
+// test/unit/features/import-contract.test.ts).
 
 export * from './src/rust-ffi'
 
@@ -15,19 +21,6 @@ export * from './src/rust-ffi'
 export { opImpl, isNativeOp, opDecision } from './src/selection'
 export type { OpImpl, OpDecision } from './src/selection'
 
-// Performance-proven surface: only `rust.*` functions that beat their JS
-// baseline in benchmarks. See src/shared/proven.ts for the registry.
-export {
-  proven,
-  PROVEN_SURFACE,
-  provenStatus,
-  isProven,
-  provenSurface,
-  provenSummary,
-} from './src/rust-ffi/proven'
-export type { ProvenClient, ProvenKey } from './src/rust-ffi/proven'
-export type { PerformanceStatus, ProvenEntry } from './src/shared/proven'
-
 export { encoder, decoder } from './src/shared/bytes'
 // Bounded EWMA adaptive-estimate utility (drives BufferPool adaptive sizing
 // and reusable runtime self-optimization decisions).

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "castrum",
-    "version": "0.9.0",
+    "version": "0.9.1",
     "private": false,
     "description": "Enterprise-grade Bun + Rust runtime: Rust-accelerated FFI primitives, a production-grade HTTP ingress pipeline, validation, hashing, and JSON processing with benchmark-grade performance.",
     "type": "module",
@@ -25,6 +25,10 @@
         "type": "git",
         "url": "git+https://github.com/Axylabs/flux-rs.git"
     },
+    "homepage": "https://github.com/Axylabs/flux-rs#readme",
+    "bugs": {
+        "url": "https://github.com/Axylabs/flux-rs/issues"
+    },
     "publishConfig": {
         "access": "public"
     },
@@ -45,18 +49,21 @@
         "README.md",
         "*.node",
         "!src/bench",
-        "!src/baseline"
+        "!src/baseline",
+        "!src/data"
     ],
     "scripts": {
         "build": "napi build --release --platform",
         "build:perf": "bash scripts/build-perf.sh",
+        "build:v3": "bash scripts/build-v3.sh",
+        "build:all": "bun run build && bun run build:v3",
         "build:js": "bun run build:js:bundle && bun run build:js:types",
         "build:js:bundle": "bun build ./index.ts --target=node --format=esm --outdir=dist",
         "build:js:types": "dts-bundle-generator -o dist/index.d.ts index.ts",
         "bench": "bun run build && bun bench.ts",
         "check": "bun bench.ts",
         "test": "bun test",
-        "test:all": "bun test && bun run typecheck && bun run typecheck:test && bun run lint:ci && cargo test --lib",
+        "test:all": "bun test && bun run typecheck && bun run typecheck:test && bun run lint:ci && bun run check:clean && cargo test --lib",
         "test:coverage": "node scripts/check-coverage.mjs",
         "setup": "bun install && bun run build",
         "test:node": "node --test test/integration/node-smoke.test.mjs test/integration/node-enterprise.test.mjs",
@@ -72,38 +79,42 @@
         "deny": "cargo deny check",
         "check:version": "bun scripts/check-version.mjs",
         "check:jsdoc": "bun scripts/check-jsdoc.ts",
+        "check:selection": "bun scripts/select-native.ts --check",
+        "check:clean": "bun scripts/check-clean.ts",
         "audit": "bun audit",
         "publish:manual": "node scripts/publish-manual.mjs",
         "publish:manual:dry": "node scripts/publish-manual.mjs --dry-run",
         "prepublishOnly": "bun run build:js && node scripts/prepublish.mjs",
-        "check:proven": "bun scripts/check-proven.ts",
-        "check:proven:fail": "bun scripts/check-proven.ts --fail",
-        "check:annotate": "bun scripts/annotate-performance.ts",
-        "check:annotate:dry": "bun scripts/annotate-performance.ts --dry-run",
-        "check:docs": "bun run check && bun run check:annotate && bun run check:proven",
-        "bench:http": "bun run bench/run-bench.ts",
-        "bench:http:smoke": "bun run bench/run-bench.ts smoke",
-        "bench:http:stress": "bun run bench/run-bench.ts stress",
-        "bench:http:heavy": "bun run bench/run-bench.ts heavy-json",
-        "bench:http:crud": "bun run bench/run-bench.ts crud",
-        "bench:http:spike": "bun run bench/run-bench.ts spike",
-        "bench:http:soak": "bun run bench/run-bench.ts soak",
-        "bench:http:storm": "bun run bench/run-bench.ts storm",
-        "bench:http:boundary": "bun run bench/run-bench.ts boundary",
-        "bench:http:elysia": "bun run bench/run-bench.ts '' elysia",
-        "bench:http:ingress": "bun run bench/run-bench.ts '' ingress",
-        "bench:http:bun-only": "bun run bench/run-bench.ts '' bun",
-        "bench:http:all-heavy": "bun run bench/run-bench.ts 1",
+        "bench:http": "BUN_CONFIG_MAX_HTTP_REQUESTS=65536 bun run bench/run-bench.ts",
+        "bench:http:smoke": "BUN_CONFIG_MAX_HTTP_REQUESTS=65536 bun run bench/run-bench.ts smoke",
+        "bench:http:stress": "BUN_CONFIG_MAX_HTTP_REQUESTS=65536 bun run bench/run-bench.ts stress",
+        "bench:http:heavy": "BUN_CONFIG_MAX_HTTP_REQUESTS=65536 bun run bench/run-bench.ts heavy-json",
+        "bench:http:crud": "BUN_CONFIG_MAX_HTTP_REQUESTS=65536 bun run bench/run-bench.ts crud",
+        "bench:http:spike": "BUN_CONFIG_MAX_HTTP_REQUESTS=65536 bun run bench/run-bench.ts spike",
+        "bench:http:soak": "BUN_CONFIG_MAX_HTTP_REQUESTS=65536 bun run bench/run-bench.ts soak",
+        "bench:http:storm": "BUN_CONFIG_MAX_HTTP_REQUESTS=65536 bun run bench/run-bench.ts storm",
+        "bench:http:boundary": "BUN_CONFIG_MAX_HTTP_REQUESTS=65536 bun run bench/run-bench.ts boundary",
+        "bench:http:elysia": "BUN_CONFIG_MAX_HTTP_REQUESTS=65536 bun run bench/run-bench.ts '' elysia",
+        "bench:http:ingress": "BUN_CONFIG_MAX_HTTP_REQUESTS=65536 bun run bench/run-bench.ts '' ingress",
+        "bench:http:bun-only": "BUN_CONFIG_MAX_HTTP_REQUESTS=65536 bun run bench/run-bench.ts '' bun",
+        "bench:http:all-heavy": "BUN_CONFIG_MAX_HTTP_REQUESTS=65536 bun run bench/run-bench.ts 1",
+        "bench:http:ac": "bun bench/autocannon-stress.mjs",
+        "bench:http:stress:ac": "SCENARIO=03-stress bun bench/autocannon-stress.mjs",
         "bench:startup": "bun run bench/startup.ts",
+        "bench:load": "bun run bench/load-phase.ts",
         "bench:ffi": "bun run bench/ffi-all.ts",
         "bench:ffi:load": "bun run bench/ffi-load.ts",
         "bench:ffi:public": "bun run bench/ffi-public.ts",
         "bench:ffi:workers": "bun run bench/ffi-workers.ts",
+        "bench:margin": "bun run bench/ffi-margin.ts",
+        "bench:router": "bun run bench/router-cost.ts",
+        "bench:ingress-cost": "bun run bench/ingress-cost.ts",
+        "bench:ingress-cost:post": "bun run bench/ingress-cost-post.ts",
         "verify:native:batch": "bun run scripts/verify-native-batch.ts"
     },
     "dependencies": {},
     "peerDependencies": {
-        "@types/node": ">=20"
+        "@types/node": "^26.1.2"
     },
     "peerDependenciesMeta": {
         "@types/node": {
@@ -112,14 +123,15 @@
     },
     "devDependencies": {
         "@elysia/cors": "^1.4.2",
-        "@napi-rs/cli": "^3.7.4",
+        "@napi-rs/cli": "^3.8.6",
         "@types/bun": "^1.3.14",
         "@types/mime-types": "^3.0.1",
+        "autocannon": "^8.0.0",
         "@types/validator": "^13.15.10",
         "ajv": "^8.20.0",
         "crc-32": "^1.2.2",
         "dts-bundle-generator": "^9.5.1",
-        "elysia": "^1.4.0",
+        "elysia": "^1.4.29",
         "fast-json-patch": "^3.1.1",
         "mime-types": "^3.0.2",
         "typescript": "5.9.3",