castrum 0.7.0 → 0.9.0

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,34 @@
+// src/shared/runtime.ts — runtime detection helpers.
+//
+// castrum is Bun-first but must also run under Node.js. This module is the
+// single place that detects the host runtime, so the rest of the codebase can
+// branch on `isBun()` / `isNode()` without sprinkling `typeof Bun` checks
+// everywhere. Importing this module has zero side effects.
+
+export type RuntimeName = 'bun' | 'node' | 'unknown'
+
+/** Whether the current runtime is Bun (the primary target). */
+export function isBun(): boolean {
+  // Bun defines the global `Bun` object; Node does not.
+  return typeof (globalThis as { Bun?: unknown }).Bun !== 'undefined'
+}
+
+/** Whether the current runtime is Node.js. */
+export function isNode(): boolean {
+  return !isBun() && typeof process !== 'undefined' && process.versions?.node != null
+}
+
+/** Best-effort name of the current runtime. */
+export function runtimeName(): RuntimeName {
+  if (isBun()) return 'bun'
+  if (isNode()) return 'node'
+  return 'unknown'
+}
+
+/** The Node.js major version when running under Node, otherwise `null`. */
+export function nodeMajorVersion(): number | null {
+  if (!isNode()) return null
+  const v = process.versions.node
+  const major = Number(v?.split('.')[0])
+  return Number.isFinite(major) ? major : null
+}

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,31 @@
+// src/shared/uuid.ts — UUIDv7 generation.
+//
+// Deliberately does NOT implement UUIDv7 in Rust: the decision matrix
+// (docs/bun-builtins-decision-matrix.md) measured Bun.randomUUIDv7 ~2x faster
+// than the FFI-crossing rust random-token path, so this delegates to the Bun
+// built-in and falls back to crypto.randomUUID (RFC 4122 v4) under Node.
+
+/** Generate a UUIDv7 (time-ordered) string, preferring Bun's native built-in. */
+export function uuidv7(): string {
+  const bun = (globalThis as { Bun?: { randomUUIDv7?: () => string } }).Bun
+  if (typeof bun?.randomUUIDv7 === 'function') {
+    return bun.randomUUIDv7()
+  }
+  // Node / non-Bun fallback: crypto.randomUUID (v4 — order not guaranteed).
+  return globalThis.crypto?.randomUUID?.() ?? fallbackRandomUuid()
+}
+
+/** Last-resort synchronous UUIDv4 (only if crypto.randomUUID is unavailable). */
+function fallbackRandomUuid(): string {
+  const bytes = new Uint8Array(16)
+  const c = globalThis.crypto
+  if (c?.getRandomValues) {
+    c.getRandomValues(bytes)
+  } else {
+    for (let i = 0; i < 16; i++) bytes[i] = Math.floor(Math.random() * 256)
+  }
+  bytes[6] = ((bytes[6] ?? 0) & 0x0f) | 0x40 // version 4
+  bytes[8] = ((bytes[8] ?? 0) & 0x3f) | 0x80 // variant 10xx
+  const hex = [...bytes].map((b) => b.toString(16).padStart(2, '0')).join('')
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`
+}

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();

package/rust/batch.rs

@@ -1,195 +0,0 @@
-// rust/batch.rs — v2: DIRECT WRITE, NO INTERMEDIATE Vec<Vec<u8>>
-use napi::bindgen_prelude::*;
-use napi_derive::napi;
-
-use crate::json_ops::{json_sum_ids_bytes, json_valid_bytes};
-use crate::util::{
-    count_batch, should_parallelize, sum_batch_i64, total_bytes, unpack,
-};
-use crate::validation::{
-    validate_email_bytes, validate_ipv4_bytes, validate_ipv6_bytes, validate_uuid_bytes,
-};
-
-// ── Internal helpers (direct-write variants) ──
-
-/// Direct-write JSON sum batch — eliminates intermediate Vec<i64>.
-#[inline]
-fn json_sum_batch_direct(items: &[&[u8]], out: &mut Vec<u8>) {
-    let n = items.len();
-    out.reserve(4 + n * 8);
-    out.extend_from_slice(&(n as u32).to_le_bytes());
-    let start = out.len();
-    out.resize(start + n * 8, 0);
-
-    // Slice the output buffer to write directly into it.
-    let out_slice = &mut out[start..];
-    
-    if should_parallelize(items.len(), total_bytes(items)) {
-        use rayon::prelude::*;
-        let chunk_size = 256;
-        
-        // Use par_chunks_mut to get mutable disjoint slices of the output buffer.
-        out_slice.par_chunks_mut(chunk_size * 8).enumerate().for_each(|(ci, out_chunk)| {
-            let num_items = out_chunk.len() / 8;
-            let item_start = ci * chunk_size;
-            let item_end = (item_start + num_items).min(items.len());
-            
-            for (i, item) in items[item_start..item_end].iter().enumerate() {
-                let sum = json_sum_ids_bytes(item).unwrap_or(0);
-                out_chunk[i * 8..(i + 1) * 8].copy_from_slice(&sum.to_le_bytes());
-            }
-        });
-    } else {
-        for (i, item) in items.iter().enumerate() {
-            let sum = json_sum_ids_bytes(item).unwrap_or(0);
-            out_slice[i * 8..(i + 1) * 8].copy_from_slice(&sum.to_le_bytes());
-        }
-    }
-}
-
-/// Direct-write parse batch — eliminates intermediate Vec<Vec<u8>>.
-#[inline]
-fn parse_batch_direct<F>(items: &[&[u8]], out: &mut Vec<u8>, f: F)
-where
-    F: Fn(&[u8]) -> Result<Vec<u8>> + Sync,
-{
-    let n = items.len();
-    out.reserve(4 + n * 32);
-    out.extend_from_slice(&(n as u32).to_le_bytes());
-    for item in items {
-        let r = f(item).unwrap_or_default();
-        out.extend_from_slice(&(r.len() as u32).to_le_bytes());
-        out.extend_from_slice(&r);
-    }
-}
-
-#[inline]
-fn query_parse_packed_vec(input: &[u8]) -> Result<Vec<u8>> {
-    crate::query_parser::query_parse_packed_vec(input)
-}
-
-#[inline]
-fn cookie_parse_packed_vec(input: &[u8]) -> Vec<u8> {
-    crate::cookie_parser::cookie_parse_packed_vec(input)
-}
-
-#[inline]
-fn http_parse_request_packed_vec(input: &[u8]) -> Result<Vec<u8>> {
-    crate::http_parser::http_parse_request_packed_vec(input)
-}
-
-#[inline]
-fn count_batch_data(data: &[u8], f: impl Fn(&[u8]) -> bool + Sync, chunk_items: usize) -> Result<u32> {
-    let items = unpack(data)?;
-    Ok(count_batch(&items, f, chunk_items) as u32)
-}
-
-#[inline]
-fn sum_ids_batch_data(data: &[u8], chunk_items: usize) -> Result<i64> {
-    let items = unpack(data)?;
-    Ok(sum_batch_i64(&items, |item| json_sum_ids_bytes(item).unwrap_or(0), chunk_items))
-}
-
-#[inline]
-fn total_len_batch_data(data: &[u8], f: impl Fn(&[u8]) -> Result<Vec<u8>> + Sync, chunk_items: usize) -> Result<u32> {
-    let items = unpack(data)?;
-    let chunk_items = chunk_items.max(64);
-    let total: usize = if should_parallelize(items.len(), total_bytes(&items)) {
-        use rayon::prelude::*;
-        items.par_chunks(chunk_items)
-            .map(|chunk| chunk.iter().map(|item| f(item).map(|v| v.len()).unwrap_or(0)).sum::<usize>())
-            .sum()
-    } else {
-        items.iter().map(|item| f(item).map(|v| v.len()).unwrap_or(0)).sum()
-    };
-    Ok(total as u32)
-}
-
-// ── Packed input → packed output ──
-
-#[inline]
-fn json_valid_batch_bytes(data: &[u8]) -> Result<Vec<u8>> {
-    let items = unpack(data)?;
-    Ok(crate::util::validation_bitset_chunked(&items, json_valid_bytes, 512))
-}
-
-#[inline]
-fn validate_email_batch_bytes(data: &[u8]) -> Result<Vec<u8>> {
-    let items = unpack(data)?;
-    Ok(crate::util::validation_bitset_chunked(&items, validate_email_bytes, 4096))
-}
-
-#[inline]
-fn validate_uuid_batch_bytes(data: &[u8]) -> Result<Vec<u8>> {
-    let items = unpack(data)?;
-    Ok(crate::util::validation_bitset_chunked(&items, validate_uuid_bytes, 4096))
-}
-
-#[inline]
-fn validate_ipv4_batch_bytes(data: &[u8]) -> Result<Vec<u8>> {
-    let items = unpack(data)?;
-    Ok(crate::util::validation_bitset_chunked(&items, validate_ipv4_bytes, 4096))
-}
-
-#[inline]
-fn validate_ipv6_batch_bytes(data: &[u8]) -> Result<Vec<u8>> {
-    let items = unpack(data)?;
-    Ok(crate::util::validation_bitset_chunked(&items, validate_ipv6_bytes, 4096))
-}
-
-#[inline]
-fn json_sum_batch_bytes(data: &[u8]) -> Result<Vec<u8>> {
-    let items = unpack(data)?;
-    let mut out = Vec::with_capacity(4 + items.len() * 8);
-    json_sum_batch_direct(&items, &mut out);
-    Ok(out)
-}
-
-#[inline]
-fn query_parse_batch_bytes(data: &[u8]) -> Result<Vec<u8>> {
-    let items = unpack(data)?;
-    let mut out = Vec::with_capacity(items.len() * 32);
-    parse_batch_direct(&items, &mut out, query_parse_packed_vec);
-    Ok(out)
-}
-
-#[inline]
-fn cookie_parse_batch_bytes(data: &[u8]) -> Result<Vec<u8>> {
-    let items = unpack(data)?;
-    let mut out = Vec::with_capacity(items.len() * 32);
-    parse_batch_direct(&items, &mut out, |i| Ok(cookie_parse_packed_vec(i)));
-    Ok(out)
-}
-
-#[inline]
-fn http_parse_request_batch_bytes(data: &[u8]) -> Result<Vec<u8>> {
-    let items = unpack(data)?;
-    let mut out = Vec::with_capacity(items.len() * 64);
-    parse_batch_direct(&items, &mut out, http_parse_request_packed_vec);
-    Ok(out)
-}
-
-// ── Sync packed batch APIs ──
-
-#[napi] pub fn json_valid_batch_packed(input: Uint8Array) -> Result<Buffer> { Ok(Buffer::from(json_valid_batch_bytes(input.as_ref())?)) }
-#[napi] pub fn validate_email_batch_packed(input: Uint8Array) -> Result<Buffer> { Ok(Buffer::from(validate_email_batch_bytes(input.as_ref())?)) }
-#[napi] pub fn validate_uuid_batch_packed(input: Uint8Array) -> Result<Buffer> { Ok(Buffer::from(validate_uuid_batch_bytes(input.as_ref())?)) }
-#[napi] pub fn validate_ipv4_batch_packed(input: Uint8Array) -> Result<Buffer> { Ok(Buffer::from(validate_ipv4_batch_bytes(input.as_ref())?)) }
-#[napi] pub fn validate_ipv6_batch_packed(input: Uint8Array) -> Result<Buffer> { Ok(Buffer::from(validate_ipv6_batch_bytes(input.as_ref())?)) }
-#[napi] pub fn json_sum_batch_packed(input: Uint8Array) -> Result<Buffer> { Ok(Buffer::from(json_sum_batch_bytes(input.as_ref())?)) }
-#[napi] pub fn query_parse_batch_packed(input: Uint8Array) -> Result<Buffer> { Ok(Buffer::from(query_parse_batch_bytes(input.as_ref())?)) }
-#[napi] pub fn cookie_parse_batch_packed(input: Uint8Array) -> Result<Buffer> { Ok(Buffer::from(cookie_parse_batch_bytes(input.as_ref())?)) }
-#[napi] pub fn http_parse_request_batch_packed(input: Uint8Array) -> Result<Buffer> { Ok(Buffer::from(http_parse_request_batch_bytes(input.as_ref())?)) }
-
-// ── Aggregate sync packed batch APIs ──
-
-#[napi] pub fn json_valid_batch_count_packed(input: Uint8Array) -> Result<u32> { count_batch_data(input.as_ref(), json_valid_bytes, 512) }
-#[napi] pub fn validate_email_batch_count_packed(input: Uint8Array) -> Result<u32> { count_batch_data(input.as_ref(), validate_email_bytes, 4096) }
-#[napi] pub fn validate_uuid_batch_count_packed(input: Uint8Array) -> Result<u32> { count_batch_data(input.as_ref(), validate_uuid_bytes, 4096) }
-#[napi] pub fn validate_ipv4_batch_count_packed(input: Uint8Array) -> Result<u32> { count_batch_data(input.as_ref(), validate_ipv4_bytes, 4096) }
-#[napi] pub fn validate_ipv6_batch_count_packed(input: Uint8Array) -> Result<u32> { count_batch_data(input.as_ref(), validate_ipv6_bytes, 4096) }
-#[napi] pub fn json_sum_batch_total_packed(input: Uint8Array) -> Result<i64> { sum_ids_batch_data(input.as_ref(), 512) }
-#[napi] pub fn query_parse_batch_total_len_packed(input: Uint8Array) -> Result<u32> { total_len_batch_data(input.as_ref(), query_parse_packed_vec, 256) }
-#[napi] pub fn cookie_parse_batch_total_len_packed(input: Uint8Array) -> Result<u32> { total_len_batch_data(input.as_ref(), |i| Ok(cookie_parse_packed_vec(i)), 256) }
-#[napi] pub fn http_parse_request_batch_total_len_packed(input: Uint8Array) -> Result<u32> { total_len_batch_data(input.as_ref(), http_parse_request_packed_vec, 256) }
-

package/rust/cookie_parser.rs

@@ -1,70 +0,0 @@
-// rust/cookie_parser.rs — Unified zero-alloc cookie parser
-// Eliminated the _vec variant; all callers use the single _into_slice path.
-// Upper-bound pre-allocation for callers that need a Vec.
-
-use crate::util::{trim_ascii_whitespace, write_bytes, write_u32_le};
-use napi::bindgen_prelude::*;
-use napi_derive::napi;
-
-/// Parse cookies into a caller-provided slice (zero-alloc).
-/// Output format: [u32 count] repeated { [u32 name_len] [name] [u32 value_len] [value] }
-#[inline]
-pub fn cookie_parse_packed_into_slice(input: &[u8], out: &mut [u8]) -> Result<usize> {
-    let mut pos = 0usize;
-    write_u32_le(out, &mut pos, 0)?;
-
-    let mut count = 0u32;
-
-    for pair in input.split(|&b| b == b';') {
-        let pair = trim_ascii_whitespace(pair);
-        if pair.is_empty() { continue; }
-
-        let (name, value) = match pair.iter().position(|&b| b == b'=') {
-            Some(eq) => (&pair[..eq], &pair[eq + 1..]),
-            None => (pair, &[][..]),
-        };
-
-        let name = trim_ascii_whitespace(name);
-        let value = trim_ascii_whitespace(value);
-
-        if name.is_empty() { continue; }
-
-        write_u32_le(out, &mut pos, name.len() as u32)?;
-        write_bytes(out, &mut pos, name)?;
-
-        write_u32_le(out, &mut pos, value.len() as u32)?;
-        write_bytes(out, &mut pos, value)?;
-
-        count += 1;
-    }
-
-    out[0..4].copy_from_slice(&count.to_le_bytes());
-    Ok(pos)
-}
-
-/// Allocate and parse cookies. Uses conservative upper bound to avoid a pre-scan.
-#[inline]
-pub fn cookie_parse_packed_vec(input: &[u8]) -> Vec<u8> {
-    let upper_bound = input.len().saturating_mul(9).saturating_add(16);
-    let mut out = vec![0u8; upper_bound];
-    match cookie_parse_packed_into_slice(input, &mut out) {
-        Ok(written) => {
-            out.truncate(written);
-            out
-        }
-        Err(_) => {
-            // Fall back to VecWriter if slice is too small (rare).
-            vec![0u8; 4] // empty result
-        }
-    }
-}
-
-#[napi]
-pub fn cookie_parse_packed(input: Uint8Array) -> Result<Buffer> {
-    Ok(Buffer::from(cookie_parse_packed_vec(input.as_ref())))
-}
-
-#[napi]
-pub fn cookie_parse_packed_into(input: Uint8Array, mut output: Uint8Array) -> Result<u32> {
-    crate::util::run_packed_into(&input, &mut output, cookie_parse_packed_into_slice)
-}