castrum 0.7.0 → 0.9.1

package/src/shared/proven.ts

@@ -0,0 +1,289 @@
+// src/shared/proven.ts — baked "proven selection" registry (PURE DATA, no addon).
+//
+// The proven selection answers: "for op X, which implementation is the
+// benchmark-proven winner, and is that what we wire as the default?"
+//
+//   - 'native' → the rust addon wins (bun:ffi on Bun / napi on Node)
+//   - 'js'     → the pure-TS implementation wins
+//   - 'bun'    → a Bun built-in wins UNDER BUN and is delegated there
+//                (see src/runtime/builtins.ts)
+//
+// This is BAKED (committed), benchmark-derived data — the winners were
+// measured by `scripts/select-native.ts` (the `nativeRatio` in
+// `src/selection.json`) and the Bun built-in decision matrix
+// (`docs/bun-builtins-decision-matrix.md`). It is PURE DATA: no addon import,
+// no dlopen, no live benchmark audit. That live audit was the friction of the
+// old `check:proven`/`check:annotate` machinery (flaky on noisy hosts) — it
+// is intentionally NOT re-added. Instead `test/unit/shared/proven.test.ts`
+// verifies every entry is wired to the impl it claims (`opImpl`, the Bun
+// built-in registry, and the addon's embedded selection.json), so drift is
+// caught deterministically instead of by re-running benchmarks.
+//
+// `typicalRatio` is the addon-vs-pure-TS-baseline ratio (rust faster = >1) for
+// native/js entries, and the Bun-built-in-vs-addon ratio for 'bun' entries
+// (higher = the built-in wins by more).
+
+/** The benchmark-proven default implementation for an op. */
+export type ProvenImpl = 'native' | 'js' | 'bun'
+
+/** How decisive the baked winner is. */
+export type ProvenStatus = 'proven' | 'parity' | 'unmeasured'
+
+/** One entry in the baked proven-selection registry. */
+export interface ProvenEntry {
+  /** Selection op name (matches `opImpl(op)` / `src/selection.json` keys). */
+  name: string
+  /** The baked default implementation: the benchmark-proven winner. */
+  impl: ProvenImpl
+  /** `proven` = decisive win, `parity` = borderline, `unmeasured` = pinned by policy. */
+  status: ProvenStatus
+  /** Measured ratio behind the decision (see module doc for the axis). */
+  typicalRatio?: number
+  /** Why this classification. */
+  note?: string
+}
+
+/**
+ * Baked proven-winner registry. Covering the FULL selection surface
+ * (`src/selection.json` ops + every Bun built-in delegation) so nothing can be
+ * silently dropped. Classifications are based on release/perf-build results;
+ * `test/unit/shared/proven.test.ts` re-checks them against the LIVE wiring.
+ */
+export const PROVEN_SELECTION: readonly ProvenEntry[] = [
+  // ── Bun built-in delegation — 'bun' (wins under Bun; consumer binding = 'js') ──
+  {
+    name: 'crc32',
+    impl: 'bun',
+    status: 'proven',
+    typicalRatio: 4,
+    note: 'Bun.hash.crc32 wins 2.8–8.4×; selection.json records js (0.659)',
+  },
+  {
+    name: 'xxh3',
+    impl: 'bun',
+    status: 'proven',
+    typicalRatio: 4.15,
+    note: 'Bun.hash.xxHash3 ~4.15×; addon kept as the Node / non-Bun path',
+  },
+  {
+    name: 'hmacSha256',
+    impl: 'bun',
+    status: 'parity',
+    typicalRatio: 1.2,
+    note: 'Bun.CryptoHasher mild 1.1–1.4×; the addon still beats the pure-JS baseline (1.212)',
+  },
+  {
+    name: 'randomToken',
+    impl: 'bun',
+    status: 'proven',
+    typicalRatio: 1.62,
+    note: 'Bun.randomUUIDv7 / crypto.getRandomValues for token-sized output',
+  },
+  {
+    name: 'gzipCompress',
+    impl: 'bun',
+    status: 'proven',
+    typicalRatio: 2.02,
+    note: 'Bun.gzipSync ~2×; gzipDecompress deliberately NOT delegated (64 MiB bomb cap)',
+  },
+  {
+    name: 'urlEncode',
+    impl: 'bun',
+    status: 'proven',
+    typicalRatio: 11.5,
+    note: 'encodeURIComponent ~11.5×, zero alloc',
+  },
+  {
+    name: 'urlDecode',
+    impl: 'bun',
+    status: 'proven',
+    typicalRatio: 6,
+    note: 'decodeURIComponent ~4–8×',
+  },
+  {
+    name: 'base64Encode',
+    impl: 'bun',
+    status: 'proven',
+    typicalRatio: 2,
+    note: 'Buffer.toString("base64") ~2×; url-safe / unpadded fall through to native',
+  },
+  {
+    name: 'base64UrlEncode',
+    impl: 'bun',
+    status: 'proven',
+    typicalRatio: 2,
+    note: 'Buffer.toString("base64url")',
+  },
+  {
+    name: 'hexEncode',
+    impl: 'bun',
+    status: 'proven',
+    typicalRatio: 1.35,
+    note: 'Buffer.toString("hex")',
+  },
+  {
+    name: 'httpDate',
+    impl: 'bun',
+    status: 'proven',
+    typicalRatio: 3.7,
+    note: 'Date.toUTCString() ~3.7×',
+  },
+
+  // ── Native winners — 'native' (addon beats the pure-TS baseline) ──
+  { name: 'fnv1a64', impl: 'native', status: 'proven', typicalRatio: 12.603 },
+  { name: 'hmacSha256Verify', impl: 'native', status: 'proven', typicalRatio: 9.028 },
+  { name: 'signCookie', impl: 'native', status: 'proven', typicalRatio: 3.64 },
+  { name: 'verifyCookie', impl: 'native', status: 'proven', typicalRatio: 1.772 },
+  { name: 'csrfToken', impl: 'native', status: 'proven', typicalRatio: 12.671 },
+  { name: 'csrfVerify', impl: 'native', status: 'proven', typicalRatio: 12.458 },
+  {
+    name: 'passwordHash',
+    impl: 'native',
+    status: 'proven',
+    typicalRatio: 1.657,
+    note: 'argon2id — rust ~1.83× vs Bun.password at equal cost; never delegate',
+  },
+  {
+    name: 'passwordVerify',
+    impl: 'native',
+    status: 'proven',
+    typicalRatio: 1.88,
+    note: 'argon2id verify — rust wins; no representative pure-TS baseline (pinned)',
+  },
+  { name: 'aeadEncrypt', impl: 'native', status: 'proven', typicalRatio: 1.288 },
+  {
+    name: 'aeadDecrypt',
+    impl: 'native',
+    status: 'parity',
+    typicalRatio: 1.108,
+    note: 'borderline — kept native',
+  },
+  { name: 'createAcceptNegotiator', impl: 'native', status: 'proven', typicalRatio: 2.01 },
+  {
+    name: 'gzipDecompress',
+    impl: 'native',
+    status: 'proven',
+    typicalRatio: 61.039,
+    note: 'deliberately NOT delegated — Bun.gunzipSync has no bomb cap; native 64 MiB cap kept',
+  },
+  {
+    name: 'brotliCompress',
+    impl: 'native',
+    status: 'proven',
+    typicalRatio: 9.983,
+    note: 'no synchronous Bun API',
+  },
+  {
+    name: 'brotliDecompress',
+    impl: 'native',
+    status: 'proven',
+    typicalRatio: 33.327,
+    note: 'no synchronous Bun API',
+  },
+  {
+    name: 'jwtSign',
+    impl: 'native',
+    status: 'unmeasured',
+    note: 'pinned native — constant-time canonical (not pure-perf)',
+  },
+  {
+    name: 'jwtVerify',
+    impl: 'native',
+    status: 'unmeasured',
+    note: 'pinned native — constant-time canonical',
+  },
+  {
+    name: 'createTemplate',
+    impl: 'native',
+    status: 'unmeasured',
+    note: 'pinned native — compiled-once instance',
+  },
+  {
+    name: 'createSchemaValidator',
+    impl: 'native',
+    status: 'unmeasured',
+    note: 'pinned native — compiled-once instance',
+  },
+
+  // ── JS winners — 'js' (pure-TS beats the addon) ──
+  { name: 'queryPairs', impl: 'js', status: 'proven', typicalRatio: 0.279 },
+  { name: 'cookiePairs', impl: 'js', status: 'proven', typicalRatio: 0.105 },
+  { name: 'formPairs', impl: 'js', status: 'proven', typicalRatio: 0.328 },
+  { name: 'etag', impl: 'js', status: 'proven', typicalRatio: 0.187 },
+  { name: 'parseMediaType', impl: 'js', status: 'proven', typicalRatio: 0.378 },
+  { name: 'parseAcceptEncoding', impl: 'js', status: 'proven', typicalRatio: 0.367 },
+  { name: 'createConditionalRequest', impl: 'js', status: 'proven', typicalRatio: 0.275 },
+  {
+    name: 'multipartParse',
+    impl: 'js',
+    status: 'unmeasured',
+    note: 'no ratio recorded — JS baseline kept',
+  },
+  {
+    name: 'jsonValid',
+    impl: 'js',
+    status: 'parity',
+    typicalRatio: 0.749,
+    note: 'borderline — JSON.parse wins',
+  },
+  {
+    name: 'jsonPatch',
+    impl: 'js',
+    status: 'proven',
+    typicalRatio: 0.014,
+    note: 'custom JSON.patch beats the addon at small sizes',
+  },
+  { name: 'sseEncode', impl: 'js', status: 'proven', typicalRatio: 0.586 },
+  { name: 'wsFrameEncode', impl: 'js', status: 'proven', typicalRatio: 0.152 },
+  {
+    name: 'wsFrameDecode',
+    impl: 'js',
+    status: 'parity',
+    typicalRatio: 0.988,
+    note: 'parity boundary — JS baseline kept',
+  },
+  { name: 'wsAcceptKey', impl: 'js', status: 'parity', typicalRatio: 0.939 },
+  { name: 'validateEmail', impl: 'js', status: 'proven', typicalRatio: 0.007 },
+  { name: 'validateUuid', impl: 'js', status: 'proven', typicalRatio: 0.008 },
+  { name: 'validateIpv4', impl: 'js', status: 'proven', typicalRatio: 0.012 },
+  { name: 'validateIpv6', impl: 'js', status: 'proven', typicalRatio: 0.078 },
+  { name: 'createRateLimiter', impl: 'js', status: 'proven', typicalRatio: 0.061 },
+  { name: 'renderTemplate', impl: 'js', status: 'proven', typicalRatio: 0.141 },
+] as const satisfies readonly ProvenEntry[]
+
+const INDEX = new Map<string, ProvenEntry>(PROVEN_SELECTION.map((e) => [e.name, e]))
+
+/**
+ * The baked {@link ProvenEntry} for `op`, or `undefined` for unknown ops.
+ * Pure data — never dlopens the addon.
+ */
+export function provenEntry(op: string): ProvenEntry | undefined {
+  return INDEX.get(op)
+}
+
+/** The baked default implementation for `op` (`native` / `js` / `bun`), or `null`. */
+export function provenImpl(op: string): ProvenImpl | null {
+  return INDEX.get(op)?.impl ?? null
+}
+
+/** The baked status for `op`, or `null` for unknown ops. */
+export function provenStatus(op: string): ProvenStatus | null {
+  return INDEX.get(op)?.status ?? null
+}
+
+/** Whether the op's baked winner is a decisive (`proven`) win. */
+export function isProven(op: string): boolean {
+  return INDEX.get(op)?.status === 'proven'
+}
+
+/** The full baked registry (same array as {@link PROVEN_SELECTION}). */
+export function provenSurface(): readonly ProvenEntry[] {
+  return PROVEN_SELECTION
+}
+
+/** A one-line summary of the baked selection (counts per implementation). */
+export function provenSummary(): string {
+  const byImpl = { native: 0, js: 0, bun: 0 }
+  for (const e of PROVEN_SELECTION) byImpl[e.impl] += 1
+  return `proven selection: ${byImpl.native} native, ${byImpl.js} js, ${byImpl.bun} bun built-in (${PROVEN_SELECTION.length} ops)`
+}

package/src/shared/request-id.ts

@@ -0,0 +1,67 @@
+// src/shared/request-id.ts — fast counter-based request ID generator.
+//
+// Used by both the fast and pre-baked ingress paths. Produces a 16-byte hex
+// string (as bytes) from a per-process counter seeded with boot randomness and
+// an optional worker ID — no crypto, no allocation per call (reuses buffers).
+//
+// SIDE-EFFECT NOTE (deliberate, kept for zero-alloc hot-path perf): the module
+// holds mutable shared state — a counter and reusable BINARY/HEX scratch
+// buffers. `generateRequestId()` returns a SINGLE shared HEX buffer that is
+// overwritten on the next call. Callers must decode or copy the returned bytes
+// before the next call; the alias is confined to this module so the hazard is
+// local and documented here.
+
+const HEX_LOOKUP = new Uint8Array(256 * 2)
+for (let i = 0; i < 256; i++) {
+  HEX_LOOKUP[i * 2] = '0123456789abcdef'.charCodeAt(i >> 4)
+  HEX_LOOKUP[i * 2 + 1] = '0123456789abcdef'.charCodeAt(i & 0x0f)
+}
+
+const BINARY = new Uint8Array(8)
+const HEX = new Uint8Array(16)
+
+const WORKER_ID = Number(process.env.INGRESS_WORKER_ID || 0) & 0xffff
+// Boot randomness: one webcrypto draw, falling back to Math.random for hosts
+// (older Node) without a `crypto` global. `[0]` is `number | undefined` under
+// noUncheckedIndexedAccess — the `??` supplies the fallback for that too.
+const BOOT_RANDOM =
+  typeof crypto !== 'undefined'
+    ? (crypto.getRandomValues(new Uint32Array(1))[0] ?? (Math.random() * 0xffffffff) >>> 0)
+    : (Math.random() * 0xffffffff) >>> 0
+
+const COUNTER = {
+  hi: (BOOT_RANDOM ^ (WORKER_ID << 16)) >>> 0,
+  lo: 0,
+}
+
+/**
+ * Generate the next request ID as 16 lowercase hex bytes (zero-alloc).
+ *
+ * @returns A shared buffer aliased across calls — decode/copy before the next
+ *   `generateRequestId()` invocation.
+ */
+export function generateRequestId(): Uint8Array {
+  if (COUNTER.lo === 0xffffffff) {
+    COUNTER.lo = 0
+    COUNTER.hi = (COUNTER.hi + 1) >>> 0
+  } else {
+    COUNTER.lo++
+  }
+
+  BINARY[0] = (COUNTER.hi >>> 24) & 0xff
+  BINARY[1] = (COUNTER.hi >>> 16) & 0xff
+  BINARY[2] = (COUNTER.hi >>> 8) & 0xff
+  BINARY[3] = COUNTER.hi & 0xff
+  BINARY[4] = (COUNTER.lo >>> 24) & 0xff
+  BINARY[5] = (COUNTER.lo >>> 16) & 0xff
+  BINARY[6] = (COUNTER.lo >>> 8) & 0xff
+  BINARY[7] = COUNTER.lo & 0xff
+
+  for (let i = 0; i < 8; i++) {
+    const b = BINARY[i] ?? 0
+    HEX[i * 2] = HEX_LOOKUP[b * 2] ?? 0
+    HEX[i * 2 + 1] = HEX_LOOKUP[b * 2 + 1] ?? 0
+  }
+
+  return HEX
+}

package/src/shared/response.ts

@@ -0,0 +1,104 @@
+// src/shared/response.ts — Response helpers for pooled (reusable) output buffers.
+//
+// When a response body is backed by a pooled buffer, the pool handle must not
+// be released until the body has actually been consumed, otherwise a later
+// request could overwrite bytes the in-flight response still references.
+// `pooledBodyResponse` wraps the slice in a streaming body that returns the
+// handle to its pool once the body is read (or the request is aborted).
+
+import type { PooledBuffer } from './buffer-pool'
+
+/**
+ * Build a `Response` whose body is backed by a pooled byte slice, returning the
+ * pool handle once the body has been fully consumed (stream closed) or the
+ * request has been cancelled.
+ *
+ * The pooled buffer stays **in flight** (not reusable) until the response
+ * stream is closed/cancelled — this is what makes zero-copy pooling safe: a
+ * buffer is never handed to a second request while a previous response may
+ * still alias it.
+ *
+ * @param handle - The pooled-buffer handle to release on consumption.
+ * @param bytes - The (possibly shared) byte slice to serve as the body.
+ * @param init - Standard `ResponseInit` (status, headers, ...).
+ * @param timeoutMs - Optional abandonment guard (ms, default 0 = disabled):
+ *   if the body is neither pulled nor cancelled within this window the pooled
+ *   buffer is released and the stream closed. Opt-in — lets zero-copy
+ *   responses bound memory under abandoned (unread) responses.
+ * @returns A `Response` that releases `handle` once its body is consumed.
+ *
+ * @remarks
+ * **Zero-copy caveat**: the body slice is served without copying — it aliases
+ * the pooled buffer. Consumers that hold a response open for a long time keep
+ * that buffer out of circulation. This helper is only intended for callers that
+ * explicitly opt into zero-copy (e.g. `INGRESS_UNSAFE_ZERO_COPY`); the default
+ * safe path copies the slice and releases the handle eagerly.
+ *
+ * @example
+ * ```ts
+ * const handle = pool.acquire(size);
+ * const used = handle.buffer.subarray(0, written);
+ * return pooledBodyResponse(handle, used, { status: 200, headers });
+ * ```
+ */
+export function pooledBodyResponse(
+  handle: PooledBuffer,
+  bytes: Uint8Array,
+  init: ResponseInit = {},
+  timeoutMs = 0,
+): Response {
+  if (bytes.byteLength === 0) {
+    // Nothing to serve: release immediately.
+    handle.release()
+    return new Response(null, init)
+  }
+
+  let released = false
+  let timer: ReturnType<typeof setTimeout> | undefined
+  const release = (): void => {
+    if (released) {
+      return
+    }
+    released = true
+    if (timer !== undefined) {
+      clearTimeout(timer)
+    }
+    handle.release()
+  }
+
+  const body = new ReadableStream<Uint8Array>({
+    start(controller) {
+      // Abandonment guard (opt-in): if the body is neither pulled nor
+      // cancelled within `timeoutMs`, release the pooled buffer so it can be
+      // reused and close the stream. Without this, an abandoned Response would
+      // hold the pooled buffer in flight forever (bounded only by maxInFlight).
+      // `pull()` re-checks `released` so a late read never serves the reused
+      // (potentially overwritten) bytes.
+      if (timeoutMs > 0) {
+        timer = setTimeout(() => {
+          if (released) {
+            return
+          }
+          release()
+          controller.close()
+        }, timeoutMs)
+      }
+    },
+    pull(controller) {
+      if (released) {
+        // Released by the abandonment guard (or a racing cancel): the pooled
+        // bytes may already be reused — never serve them. End-of-stream.
+        controller.close()
+        return
+      }
+      controller.enqueue(bytes)
+      controller.close()
+      release()
+    },
+    cancel() {
+      release()
+    },
+  })
+
+  return new Response(body, init)
+}

package/src/shared/runtime.ts

@@ -0,0 +1,29 @@
+// src/shared/runtime.ts — runtime detection helpers (facade).
+//
+// Facade over the cached detection in `src/runtime/detect.ts` (the ONLY place
+// `typeof Bun` is checked — resolved ONCE at module load by the runtime
+// adapter). Kept so existing `isBun()` / `isNode()` / `runtimeName()` /
+// `nodeMajorVersion()` call sites work unchanged.
+
+import {
+  detectedRuntime,
+  isBunRuntime,
+  isNodeRuntime,
+  nodeMajorVersion as nodeMajorVersionDetected,
+} from '../runtime/detect'
+import type { RuntimeName as RuntimeNameType } from '../runtime/types'
+
+/** Host runtime identifier. */
+export type RuntimeName = RuntimeNameType
+
+/** Whether the current runtime is Bun (the primary target). Cached once at load. */
+export const isBun: () => boolean = isBunRuntime
+
+/** Whether the current runtime is Node.js. */
+export const isNode: () => boolean = isNodeRuntime
+
+/** Best-effort name of the current runtime. */
+export const runtimeName: () => RuntimeName = () => detectedRuntime
+
+/** The Node.js major version when running under Node, otherwise `null`. */
+export const nodeMajorVersion: () => number | null = nodeMajorVersionDetected

package/src/shared/trace.ts

@@ -0,0 +1,81 @@
+// src/shared/trace.ts — W3C Trace Context helpers (zero-dep).
+//
+// Parses the `traceparent` request header and generates span ids so ingress
+// logs/hooks can correlate requests across services. This is the "tracing"
+// primitive — wire `parseTraceContext(req)` in an `onRequest` hook and pass the
+// traceId/spanId into your structured logger (pino/otel), or use it directly.
+//
+// Format: `version-traceid-spanid-flags` (e.g. `00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01`).
+
+/** A parsed W3C trace context (valid per the spec's length/hex rules). */
+export interface TraceContext {
+  /** Version, always `"00"` for accepted headers. */
+  version: string
+  /** 32 hex chars — the trace id (shared across the whole trace). */
+  traceId: string
+  /** 16 hex chars — the current span id. */
+  spanId: string
+  /** The flags byte (bit 0 = sampled). */
+  flags: number
+  /** True when the `sampled` (bit 0) flag is set. */
+  sampled: boolean
+}
+
+const HEX = /^[0-9a-fA-F]+$/
+
+/**
+ * Parse a `traceparent` header value into a {@link TraceContext}, or `null`
+ * when malformed (wrong version / length / non-hex). Invalid contexts are
+ * ignored per the spec — callers should generate a fresh trace then.
+ */
+export function parseTraceParent(header: string | null | undefined): TraceContext | null {
+  if (!header) return null
+  const parts = header.trim().split('-')
+  if (parts.length !== 4) return null
+  const [version, traceId, spanId, flagsStr] = parts
+  // Only version 00 is currently defined.
+  if (version !== '00') return null
+  if (traceId === undefined || traceId.length !== 32 || !HEX.test(traceId)) return null
+  if (spanId === undefined || spanId.length !== 16 || !HEX.test(spanId)) return null
+  if (flagsStr === undefined || flagsStr.length !== 2 || !HEX.test(flagsStr)) return null
+  const flags = Number.parseInt(flagsStr, 16)
+  return {
+    version,
+    traceId: traceId.toLowerCase(),
+    spanId: spanId.toLowerCase(),
+    flags,
+    sampled: (flags & 0x01) === 0x01,
+  }
+}
+
+/** Random 32-hex trace id (crypto-backed where available). */
+export function createTraceId(): string {
+  return randomHex(16)
+}
+
+/** Random 16-hex span id. */
+export function createSpanId(): string {
+  return randomHex(8)
+}
+
+/** Generate `n` random bytes as lowercase hex. */
+function randomHex(bytes: number): string {
+  const buf = new Uint8Array(bytes)
+  const c = globalThis.crypto
+  if (c?.getRandomValues) {
+    c.getRandomValues(buf)
+  } else {
+    for (let i = 0; i < bytes; i++) buf[i] = Math.floor(Math.random() * 256)
+  }
+  let out = ''
+  for (let i = 0; i < bytes; i++) {
+    out += (buf[i] ?? 0).toString(16).padStart(2, '0')
+  }
+  return out
+}
+
+/** Serialize a trace context back to a `traceparent` header value. */
+export function serializeTraceParent(ctx: TraceContext): string {
+  const flags = ctx.flags.toString(16).padStart(2, '0')
+  return `${ctx.version}-${ctx.traceId}-${ctx.spanId}-${flags}`
+}

package/src/shared/uuid.ts

@@ -0,0 +1,15 @@
+// src/shared/uuid.ts — UUIDv7 generation (facade).
+//
+// UUIDv7 delegates to the runtime adapter's uuid (`src/runtime/uuid.ts`):
+// `Bun.randomUUIDv7` on Bun (measured ~2x faster than the FFI-crossing rust
+// path) and `crypto.randomUUID` (RFC 4122 v4) under Node.
+
+import { runtimeUuid } from '../runtime/uuid'
+
+/**
+ * Generate a UUIDv7 (time-ordered) string, preferring Bun's native built-in.
+ * Under Node this falls back to `crypto.randomUUID` (v4).
+ *
+ * @returns A UUID string.
+ */
+export const uuidv7: () => string = runtimeUuid.uuidv7

package/Cargo.toml

@@ -1,73 +0,0 @@
-[package]
-name = "castrum"
-# Keep in sync with package.json "version" (single source of truth: the npm package).
-version = "0.7.0"
-edition = "2021"
-
-[lib]
-name = "castrum"
-crate-type = ["cdylib"]
-path = "rust/lib.rs"
-
-[dependencies]
-napi = { version = "3", features = ["napi10"] }
-napi-derive = "3"
-
-serde = { version = "1", features = ["derive"] }
-serde_json = "1"
-sonic-rs = "0.5"
-
-# default-features=false: drop resolve-http + tls-aws-lc-rs which pull in
-# reqwest -> hyper/h2/tokio/rustls (large binary, attack surface). Format
-# validators (email etc.) are built-in and NOT feature-gated in 0.48.
-jsonschema = { version = "0.48", default-features = false, features = ["resolve-file"] }
-json-patch = "4"
-aws-lc-rs = "1"
-base64 = "0.23"
-crc32fast = "1"
-httparse = "1"
-mime_guess = "2"
-phf = { version = "0.14", features = ["macros"] }
-getrandom = "0.4"
-memchr = "2"
-simdutf8 = "0.1"
-email_address = "0.2"
-fast_chemail = { version = "0.9", optional = true }
-rayon = "1"
-# mimalloc is set as the Rust #[global_allocator] (see rust/lib.rs). We DELIBERATELY
-# do NOT enable the "override" feature: it interposes libc malloc/free at the
-# process level, which is an embedding hazard when this cdylib is dlopen'd into
-# Bun (which itself embeds mimalloc -> symbol clashes). The Rust-level global
-# allocator keeps most of the allocation win without replacing the host malloc.
-mimalloc = { version = "0.1", features = ["local_dynamic_tls"] }
-core_affinity = "0.8"
-
-parking_lot = "0.12"
-xxhash-rust = { version = "0.8", features = ["xxh3"] }
-ipnet = "2"
-lru = "0.12"
-
-[build-dependencies]
-napi-build = "2"
-
-[features]
-default = ["fast-email"]
-fast-email = ["dep:fast_chemail"]
-
-[profile.release]
-opt-level = 3
-lto = "fat"
-codegen-units = 1
-strip = "symbols"
-debug = 0
-incremental = false
-# Safety: this is an embedded cdylib loaded into the Bun process. panic = "unwind"
-# (the default) lets napi's catch_unwind convert Rust panics into JS exceptions
-# instead of aborting the host process. overflow-checks = true catches integer
-# overflow in release; the cost is negligible relative to the safety gain.
-overflow-checks = true
-debug-assertions = false
-
-[profile.release.package."*"]
-opt-level = 3
-codegen-units = 1

package/bench.ts

@@ -1,3 +0,0 @@
-import { runBenchmark } from "./src/bench";
-
-runBenchmark();