castrum 0.9.9 → 0.9.10

package/Cargo.lock

@@ -233,7 +233,7 @@ checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04"
 
 [[package]]
 name = "castrum"
-version = "0.9.9"
+version = "0.9.10"
 dependencies = [
  "argon2",
  "aws-lc-rs",
@@ -245,6 +245,7 @@ dependencies = [
  "email_address",
  "fancy-regex",
  "fast_chemail",
+ "faster-hex",
  "flate2",
  "fraction",
  "getrandom 0.4.3",
@@ -477,6 +478,15 @@ dependencies = [
  "ascii_utils",
 ]
 
+[[package]]
+name = "faster-hex"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2a2b11eda1d40935b26cf18f6833c526845ae8c41e58d09af6adeb6f0269183"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "fastrand"
 version = "2.5.0"

package/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "castrum"
 # Keep in sync with package.json "version" (single source of truth: the npm package).
-version = "0.9.9"
+version = "0.9.10"
 edition = "2021"
 # Keep in sync with package.json "license" (cargo-deny rejects a crate with no
 # license expression).
@@ -45,8 +45,11 @@ sonic-rs = { version = "0.5", features = ["sort_keys"] }
 # validators (email etc.) are built-in and NOT feature-gated in 0.48.
 jsonschema = { version = "0.49", default-features = false, features = ["resolve-file"] }
 aws-lc-rs = "1"
-# NOTE: base64 0.23 enables SIMD (SSE/AVX) by default via the `simd-unsafe`
-# feature (part of `default`); no explicit feature is needed.
+# NOTE: base64 0.23 compiles its SIMD `engine::simd::Simd` (AVX2/NEON, Muła
+# kernels) by default via the `simd-unsafe` feature (part of `default`). Our
+# `rust/crypto/base64.rs` selects that engine for the hot cores on x86_64 /
+# aarch64, with the scalar `GeneralPurpose` fallback elsewhere; the wire
+# contract (PAD/NO_PAD configs, byte-identical output) is unchanged.
 base64 = "0.23"
 crc32fast = "1"
 httparse = "1"
@@ -72,7 +75,18 @@ mimalloc = { version = "0.1", features = ["local_dynamic_tls"] }
 core_affinity = "0.8"
 
 parking_lot = "0.12"
+# xxhash-rust: seeded streaming Xxh3 (ingress ip_trust rate_key, tiny 1-17
+# byte IPs) AND the public one-shot xxh3_64. Measured: the scalar core
+# sustains a FLAT ~30GB/s from 64B to 1MB (no size pathology); the ~2x gap to
+# Bun.hash.xxHash3 at >= 1KB is Bun's AVX2 width, not a scaling issue, and
+# ignex already delegates the public hash to Bun under Bun — see
+# docs/bun-builtins-decision-matrix.md.
 xxhash-rust = { version = "0.8", features = ["xxh3"] }
+# faster-hex: SIMD (runtime-dispatched SSE -> AVX2) lowercase hex encode/decode
+# with byte-exact semantics parity vs our HEX_VAL_LUT (case-insensitive decode,
+# reject [^0-9a-fA-F], odd-length error) — verified exhaustively (65,536 pairs).
+# Replaces the per-byte table loops that lost ~3-6x to Buffer.toString("hex").
+faster-hex = "0.9"
 ipnet = "2"
 # 0.18.2+ carries the RUSTSEC-2026-0253 fix (0.16.x is affected); keep this
 # requirement at or above the fixed release so `cargo deny` / OSV stay green.

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

@@ -31,7 +31,7 @@
 |---|---|---|---|---|
 | `rust.fnv1a64` | `Bun.hash` (wyhash) | 42 B | Bun (parity) | 1.06× |
 | `rust.crc32` | `Bun.hash.crc32` | 42 B | **Bun** | 2.8–8.4× |
-| `rust.xxh3` (new) | `Bun.hash.xxHash3` | 42 B | **Bun** | 4.15× |
+| `rust.xxh3` (new) | `Bun.hash.xxHash3` | 42 B–1 MB | **Bun** (≥1 KB) | 0.97× (≤64 B); ~2.0× (≥1 KB) |
 | `rust.hmacSha256` | `Bun.CryptoHasher("sha256", key)` | 32 B | Bun (mild) | 1.1–1.4× |
 | `rust.passwordHash` (argon2id) | `Bun.password.hashSync` (argon2id) | 12 B | **rust** | 0.55× (rust 1.83×) |
 | `rust.passwordVerify` | `Bun.password.verifySync` | 12 B | **rust** | 0.53× (rust 1.88×) |
@@ -62,6 +62,14 @@
 These rust ops lose to Bun's native implementation on the SAME workload — the
 FFI crossing cannot beat Bun's in-process C++:
 
+> Re-swept 2026-09-19 (64 B → 1 MB, interleaved medians + per-call input
+> rotation): the hex and url rows in this table no longer lose — rust hex
+> encode/decode is now 4.7–18.9× / 1.4–6.7× over Buffer, the url codec
+> ~2–3× over `encodeURIComponent`, and base64 decode wins 1.4–6.0×. Only the
+> rows still marked "Prefer Bun" below remain genuinely faster in Bun. See
+> the rows themselves and `src/runtime/builtins.ts` for what the adapter
+> currently delegates.
+
 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
@@ -70,13 +78,13 @@ 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. The runtime adapter delegates the public `rust.xxh3` to Bun under Bun. |
+| `xxh3` | Prefer `Bun.hash.xxHash3` (~2× at ≥1 KB via AVX2; parity ≤64 B). The rust core is FLAT ~30 GB/s at every size (re-swept 2026-09-19 — the gap is Bun's AVX2 width, not a size pathology); keep it as the Node/non-Bun fast path. The 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). |
-| `urlEncode` / `urlDecode` | Prefer `encodeURIComponent` / `decodeURIComponent` (JSC string builtins — ~11.5×, zero alloc). |
-| `base64Encode` / `base64UrlEncode` | Prefer `Buffer.toString('base64'|'base64url')`. |
-| `hexEncode` | Prefer `Buffer.toString('hex')`. |
+| `urlEncode` / `urlDecode` | Fan-out. Re-swept 2026-09-19 on escape-heavy input the rust LUT+run-copy codec is ~2.8–3.2× (encode) / ~2× (decode) FASTER than `encodeURIComponent` / `decodeURIComponent` — the earlier ~11.5× reading was input/profile-dependent. The current adapter still delegates via `BUILTIN_OPS`. |
+| `base64Encode` / `base64UrlEncode` | rust wins ≤1 KB (encode 1.8–2.3×); parity ≥16 KiB (0.88–1.07× — both AVX2 and memory-bound). Base64 **decode** is the strong rust play (1.4–6.0×). Fine to prefer rust for both; the adapter currently delegates encode to Buffer per `BUILTIN_OPS`. |
+| `hexEncode` / `hexDecode` | Prefer rust: encode 4.7–18.9×, decode 1.4–6.7× over Buffer (faster-hex SIMD + single-pass AVX2 decode kernel; re-swept 2026-09-19 — previously Buffer won). The adapter still delegates to Buffer per `BUILTIN_OPS`. |
 | `httpDate` | Prefer `Date.toUTCString()`. |
 
 **Delegation rule of thumb**: rust stays the default only where it beats its
@@ -96,7 +104,7 @@ genuinely wins or Bun has no equivalent.
 ### → Implemented primitives (gaps closed)
 | Primitive | Outcome |
 |---|---|
-| `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.xxh3` (XXH3-64) | Exposed; re-swept 2026-09-19: parity ≤64 B, Bun ~2× at ≥1 KB (its AVX2 width; rust is flat 30 GB/s) → the adapter still delegates under Bun (Node keeps the addon path). |
 | `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. |
@@ -108,7 +116,9 @@ random tokens, and gzip, Bun 1.4's built-ins are already faster than any
 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).
+sync equivalent), **brotli** (no Bun sync API), and — since the 2026-09-19
+re-sweep — the **hex and URL byte codecs and base64 decode** (1.4–18.9× over
+the corresponding Buffer / URI built-ins at every size).
 
 ## Re-run
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "castrum",
-  "version": "0.9.9",
+  "version": "0.9.10",
   "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",

package/rust/crypto/base64.rs

@@ -1,25 +1,66 @@
 // rust/crypto/base64.rs — base64 (standard/url-safe) + hex encode/decode.
 //
-// Uses the `base64` crate engines (Cargo dep already present). The
-// `Base64Codec` higher-order instance precompiles the alphabet/decoding
-// configuration once in its constructor and reuses it across calls.
+// Uses the `base64` crate engines (Cargo dep already present). On the shipped
+// targets (x86_64 / aarch64) the hot cores dispatch to the crate's
+// runtime-detected SIMD engine (`engine::simd::Simd` — AVX2 / NEON kernels):
+// payloads ≥ 64 B (decode) / ≥ 128 B (encode) go through the wide kernels,
+// anything smaller falls back to the scalar engine internally, so both length
+// regimes stay efficient and output stays byte-identical to the scalar path.
+// Other targets keep the scalar `GeneralPurpose` engine (not a shipped
+// castrum target — local dev / test builds only). The `Base64Codec`
+// higher-order instance precompiles the alphabet/decoding configuration once
+// in its constructor and reuses it across calls.
 
 use napi::bindgen_prelude::*;
 use napi_derive::napi;
 
-use crate::util::bytes::{hex_val, HEX_LOWER};
 use base64::Engine as _;
 
-fn engine(url_safe: bool, padding: bool) -> base64::engine::general_purpose::GeneralPurpose {
+/// Engine selection for a base64 call.
+///
+/// SIMD branch (x86_64 / aarch64 — every shipped castrum target): the
+/// `engine::simd::Simd` engine detects AVX2 / NEON once at construction and
+/// falls back to the scalar `GeneralPurpose` when the CPU (or a payload below
+/// the 64 B decode / 128 B encode thresholds) doesn't benefit, so small
+/// payloads keep the same fixed costs while large ones get wide kernels. The
+/// `PAD` / `NO_PAD` `GeneralPurposeConfig` consts are the exact configs the
+/// preconfigured scalar engines use, so the wire contract is unchanged.
+#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
+mod engine_sel {
+    use base64::engine::general_purpose::{NO_PAD, PAD};
+    use base64::engine::simd::Simd;
+
+    pub(super) type Engine = Simd;
+
+    pub(super) fn engine(url_safe: bool, padding: bool) -> Simd {
+        match (url_safe, padding) {
+            (false, true) => Simd::standard(PAD),
+            (false, false) => Simd::standard(NO_PAD),
+            (true, true) => Simd::url_safe(PAD),
+            (true, false) => Simd::url_safe(NO_PAD),
+        }
+    }
+}
+
+/// Scalar fallback (non-x86_64 / non-aarch64 targets only).
+#[cfg(not(any(target_arch = "x86_64", target_arch = "aarch64")))]
+mod engine_sel {
     use base64::engine::general_purpose::*;
-    match (url_safe, padding) {
-        (false, true) => STANDARD,
-        (false, false) => STANDARD_NO_PAD,
-        (true, true) => URL_SAFE,
-        (true, false) => URL_SAFE_NO_PAD,
+
+    pub(super) type Engine = GeneralPurpose;
+
+    pub(super) fn engine(url_safe: bool, padding: bool) -> GeneralPurpose {
+        match (url_safe, padding) {
+            (false, true) => STANDARD,
+            (false, false) => STANDARD_NO_PAD,
+            (true, true) => URL_SAFE,
+            (true, false) => URL_SAFE_NO_PAD,
+        }
     }
 }
 
+use engine_sel::engine;
+
 #[napi]
 pub fn base64_encode(input: Uint8Array, url_safe: Option<bool>, padding: Option<bool>) -> Buffer {
     let out = engine(url_safe.unwrap_or(false), padding.unwrap_or(true)).encode(input.as_ref());
@@ -40,16 +81,12 @@ pub fn base64_decode(
 
 #[napi]
 pub fn base64url_encode(input: Uint8Array) -> Buffer {
-    Buffer::from(
-        base64::engine::general_purpose::URL_SAFE_NO_PAD
-            .encode(input.as_ref())
-            .into_bytes(),
-    )
+    Buffer::from(engine(true, false).encode(input.as_ref()).into_bytes())
 }
 
 #[napi]
 pub fn base64url_decode(input: Uint8Array) -> Result<Buffer> {
-    base64::engine::general_purpose::URL_SAFE_NO_PAD
+    engine(true, false)
         .decode(input.as_ref())
         .map(Buffer::from)
         .map_err(|e| Error::from_reason(e.to_string()))
@@ -76,9 +113,7 @@ pub fn base64_decode_bytes(input: &[u8], url_safe: bool, padding: bool) -> Resul
 /// one place.
 #[inline]
 pub fn base64url_encode_bytes(data: &[u8]) -> Vec<u8> {
-    base64::engine::general_purpose::URL_SAFE_NO_PAD
-        .encode(data)
-        .into_bytes()
+    engine(true, false).encode(data).into_bytes()
 }
 
 /// Base64url (RFC 7515 §2 — URL-safe alphabet, NO padding) decode from raw
@@ -86,15 +121,26 @@ pub fn base64url_encode_bytes(data: &[u8]) -> Vec<u8> {
 #[inline]
 pub fn base64url_decode_bytes(data: &[u8]) -> Option<Vec<u8>> {
     let text = std::str::from_utf8(data).ok()?;
-    base64::engine::general_purpose::URL_SAFE_NO_PAD
-        .decode(text)
-        .ok()
+    engine(true, false).decode(text).ok()
 }
 
 // ── hex ──────────────────────────────────────────────────────────
-
-/// Encode bytes as lowercase hex (uses the shared `HEX_LOWER` table — direct
-/// byte writes, no per-nibble `char` push).
+//
+// Lowercase hex encode + case-insensitive decode. Encode goes through the
+// `faster-hex` SIMD engine (runtime-dispatched SSE→AVX2; measured 4.3-18.9x
+// faster than Buffer.toString("hex") at every size 64B→1MB, replacing the
+// per-byte table loop that lost 0.30x; the 1KB outlier ~19x is Bun-side). Decode has TWO tiers:
+//   - x86_64 + AVX2: our single-pass `hex_fast` kernel (validity mask + value
+//     map in one vector pass, 64 chars/iteration, scalar fallback on any
+//     invalid chunk). faster-hex decode does a separate validation scan +
+//     decode pass (~5GB/s cap vs Buffer.from(s,"hex") ~10.5GB/s); the
+//     single-pass kernel targets that class directly.
+//   - everywhere else: faster-hex decode (SSE/scalar, validated).
+// Both tiers are byte-identical to the HEX_VAL_LUT semantics — verified by
+// exhaustive tests (all 256 bytes × encode, all 65,536 byte-pairs × decode,
+// plus a length sweep across the 64-char chunk boundary).
+
+/// Lowercase-hex encode (SIMD via `faster-hex`).
 ///
 /// # Safety
 ///
@@ -102,26 +148,31 @@ pub fn base64url_decode_bytes(data: &[u8]) -> Option<Vec<u8>> {
 /// the built `Vec<u8>` is valid UTF-8 by construction; `from_utf8_unchecked`
 /// skips a redundant validation pass on the allocating hot path.
 pub fn hex_encode_bytes(input: &[u8]) -> String {
-    let mut out = Vec::with_capacity(input.len() * 2);
-    for &b in input {
-        out.push(HEX_LOWER[(b >> 4) as usize]);
-        out.push(HEX_LOWER[(b & 0x0f) as usize]);
-    }
-    // SAFETY: every byte pushed is an ASCII hex digit from `HEX_LOWER`.
+    let mut out = vec![0u8; input.len() * 2];
+    // faster-hex encode cannot fail on an exactly-sized buffer.
+    faster_hex::hex_encode(input, &mut out).expect("hex encode: exact-size output buffer");
+    // SAFETY: every byte written is an ASCII hex digit from `HEX_LOWER`.
     unsafe { String::from_utf8_unchecked(out) }
 }
 
-/// Decode lowercase/uppercase hex to bytes.
+/// Decode lowercase/uppercase hex to bytes. On x86_64 + AVX2 this uses the
+/// single-pass `hex_fast` kernel; elsewhere the validated `faster-hex` engine
+/// — both reject `[^0-9a-fA-F]` exactly like `hex_val`.
 pub fn hex_decode_bytes(input: &[u8]) -> std::result::Result<Vec<u8>, &'static str> {
     if !input.len().is_multiple_of(2) {
         return Err("odd hex length");
     }
-    let mut out = Vec::with_capacity(input.len() / 2);
-    for i in (0..input.len()).step_by(2) {
-        let hi = hex_val(input[i]).ok_or("invalid hex digit")?;
-        let lo = hex_val(input[i + 1]).ok_or("invalid hex digit")?;
-        out.push((hi << 4) | lo);
+    let mut out = vec![0u8; input.len() / 2];
+    #[cfg(target_arch = "x86_64")]
+    {
+        if std::arch::is_x86_feature_detected!("avx2") {
+            // SAFETY: AVX2 runtime-detected; `input` even, `out` exactly
+            // `input.len() / 2` (both established above).
+            unsafe { hex_fast::decode(input, &mut out) }?;
+            return Ok(out);
+        }
     }
+    faster_hex::hex_decode(input, &mut out).map_err(|_| "invalid hex digit")?;
     Ok(out)
 }
 
@@ -144,8 +195,8 @@ pub fn hex_decode(input: Uint8Array) -> Result<Buffer> {
 // a fresh Vec + napi Buffer per call. They error on a buffer that is too small;
 // input/output overlap is handled by `crate::util::run_packed_into`.
 
-/// Lowercase-hex encode directly into `out`. Returns bytes written
-/// (`input.len() * 2`). Errors if `out` is too small.
+/// Lowercase-hex encode directly into `out` (SIMD via `faster-hex`). Returns
+/// bytes written (`input.len() * 2`). Errors if `out` is too small.
 #[inline]
 pub fn hex_encode_into_slice(input: &[u8], out: &mut [u8]) -> Result<usize> {
     let needed = input
@@ -155,13 +206,12 @@ pub fn hex_encode_into_slice(input: &[u8], out: &mut [u8]) -> Result<usize> {
     if out.len() < needed {
         return Err(Error::from_reason("hex encode: output buffer too small"));
     }
-    let mut pos = 0usize;
-    for &b in input {
-        out[pos] = HEX_LOWER[(b >> 4) as usize];
-        out[pos + 1] = HEX_LOWER[(b & 0x0f) as usize];
-        pos += 2;
-    }
-    Ok(pos)
+    // Slice to the exact size so the pipeline never sees a ragged tail: the
+    // caller-sized-buffer contract is preserved (error above), and the engine
+    // fills `needed` bytes exactly.
+    let exact = &mut out[..needed];
+    faster_hex::hex_encode(input, exact).expect("hex encode: exact-size output buffer");
+    Ok(needed)
 }
 
 #[napi]
@@ -169,8 +219,12 @@ pub fn hex_encode_into(input: Uint8Array, mut output: Uint8Array) -> Result<u32>
     crate::util::run_packed_into(&input, &mut output, hex_encode_into_slice)
 }
 
-/// Hex-decode directly into `out`. Returns bytes written (`input.len() / 2`).
-/// Errors on odd length, invalid digits, or an output buffer that is too small.
+/// Hex-decode directly into `out` — case-insensitive, rejects
+/// `[^0-9a-fA-F]` exactly like `hex_val`. Returns bytes written
+/// (`input.len() / 2`). Errors on odd length, invalid digits, or an output
+/// buffer that is too small. On x86_64 with AVX2 this dispatches to the
+/// single-pass `hex_fast` kernel; everywhere else it uses the validated
+/// `faster-hex` engine — both byte-identical to the scalar LUT semantics.
 #[inline]
 pub fn hex_decode_into_slice(input: &[u8], out: &mut [u8]) -> Result<usize> {
     if !input.len().is_multiple_of(2) {
@@ -180,14 +234,27 @@ pub fn hex_decode_into_slice(input: &[u8], out: &mut [u8]) -> Result<usize> {
     if out.len() < needed {
         return Err(Error::from_reason("hex decode: output buffer too small"));
     }
-    let mut pos = 0usize;
-    for i in (0..input.len()).step_by(2) {
-        let hi = hex_val(input[i]).ok_or_else(|| Error::from_reason("invalid hex digit"))?;
-        let lo = hex_val(input[i + 1]).ok_or_else(|| Error::from_reason("invalid hex digit"))?;
-        out[pos] = (hi << 4) | lo;
-        pos += 1;
+    hex_decode_into_slice_impl(input, &mut out[..needed])
+}
+
+#[cfg(target_arch = "x86_64")]
+#[inline]
+fn hex_decode_into_slice_impl(input: &[u8], out: &mut [u8]) -> Result<usize> {
+    if std::arch::is_x86_feature_detected!("avx2") {
+        // SAFETY: AVX2 runtime-detected; `input` even and `out` exactly
+        // `input.len() / 2` (checked above).
+        unsafe { hex_fast::decode(input, out) }.map_err(Error::from_reason)
+    } else {
+        faster_hex::hex_decode(input, out).map_err(|_| Error::from_reason("invalid hex digit"))?;
+        Ok(out.len())
     }
-    Ok(pos)
+}
+
+#[cfg(not(target_arch = "x86_64"))]
+#[inline]
+fn hex_decode_into_slice_impl(input: &[u8], out: &mut [u8]) -> Result<usize> {
+    faster_hex::hex_decode(input, out).map_err(|_| Error::from_reason("invalid hex digit"))?;
+    Ok(out.len())
 }
 
 #[napi]
@@ -195,6 +262,113 @@ pub fn hex_decode_into(input: Uint8Array, mut output: Uint8Array) -> Result<u32>
     crate::util::run_packed_into(&input, &mut output, hex_decode_into_slice)
 }
 
+/// Single-pass AVX2 hex decode — the accelerated decode tier on x86_64 (see
+/// the hex section header). Decodes 64 hex chars (32 output bytes) per
+/// iteration, computing the validity mask and the hex-digit values in ONE
+/// vector pass. Any chunk containing a non-hex byte rejects the whole input
+/// (byte-identical to the HEX_VAL_LUT scalar reject-everywhere semantics —
+/// no partial writes). The remainder (< 64 chars) is decoded by the validated
+/// `faster-hex` engine, so error behavior and output are identical everywhere.
+///
+/// faster-hex decode does a separate validation scan + decode pass (~5GB/s
+/// cap measured vs Buffer.from(hex) ~10.5GB/s); this kernel is single-pass
+/// and targets that gap.
+#[cfg(target_arch = "x86_64")]
+pub mod hex_fast {
+    use std::arch::x86_64::*;
+
+    /// Decode `chars[0..64]` → `out[0..32]`. Returns false when any of the 64
+    /// chars is not `[0-9a-fA-F]`; on false, `out` is left untouched so
+    /// callers can error without partial writes.
+    #[target_feature(enable = "avx2")]
+    unsafe fn decode_chunk(chars: *const u8, out: *mut u8) -> bool {
+        let lo = _mm256_loadu_si256(chars as *const __m256i); // chars 0..31
+        let hi = _mm256_loadu_si256(chars.add(32) as *const __m256i); // chars 32..63
+
+        // Lowercase for the letter test ('A'-'F' | 0x20 == 'a'-'f').
+        let loo = _mm256_or_si256(lo, _mm256_set1_epi8(0x20));
+        let hio = _mm256_or_si256(hi, _mm256_set1_epi8(0x20));
+
+        // Validity per byte (signed compares; all bounds are < 0x80 so signed
+        // and unsigned agree for the printable range, and bytes >= 0x80 fail
+        // both bounds): (b in '0'..='9') | (b|0x20 in 'a'..='f').
+        let lo_digit = _mm256_and_si256(
+            _mm256_cmpgt_epi8(loo, _mm256_set1_epi8((b'0' - 1) as i8)),
+            _mm256_cmpgt_epi8(_mm256_set1_epi8((b'9' + 1) as i8), loo),
+        );
+        let lo_letter = _mm256_and_si256(
+            _mm256_cmpgt_epi8(loo, _mm256_set1_epi8((b'a' - 1) as i8)),
+            _mm256_cmpgt_epi8(_mm256_set1_epi8((b'f' + 1) as i8), loo),
+        );
+        let hi_digit = _mm256_and_si256(
+            _mm256_cmpgt_epi8(hio, _mm256_set1_epi8((b'0' - 1) as i8)),
+            _mm256_cmpgt_epi8(_mm256_set1_epi8((b'9' + 1) as i8), hio),
+        );
+        let hi_letter = _mm256_and_si256(
+            _mm256_cmpgt_epi8(hio, _mm256_set1_epi8((b'a' - 1) as i8)),
+            _mm256_cmpgt_epi8(_mm256_set1_epi8((b'f' + 1) as i8), hio),
+        );
+        let lo_valid = _mm256_or_si256(lo_digit, lo_letter);
+        let hi_valid = _mm256_or_si256(hi_digit, hi_letter);
+        if _mm256_movemask_epi8(lo_valid) != -1 || _mm256_movemask_epi8(hi_valid) != -1 {
+            return false;
+        }
+
+        // Value: (b|0x20) - '0' gives 0-9 for digits and 49-54 for a-f;
+        // subtract 39 where it is a letter so a-f map to 10-15.
+        let lo_letter_sel = _mm256_cmpgt_epi8(loo, _mm256_set1_epi8((b'a' - 1) as i8));
+        let hi_letter_sel = _mm256_cmpgt_epi8(hio, _mm256_set1_epi8((b'a' - 1) as i8));
+        let v_lo = _mm256_sub_epi8(
+            _mm256_sub_epi8(loo, _mm256_set1_epi8(b'0' as i8)),
+            _mm256_and_si256(lo_letter_sel, _mm256_set1_epi8(39)),
+        );
+        let v_hi = _mm256_sub_epi8(
+            _mm256_sub_epi8(hio, _mm256_set1_epi8(b'0' as i8)),
+            _mm256_and_si256(hi_letter_sel, _mm256_set1_epi8(39)),
+        );
+
+        // Pack adjacent pairs (v0, v1) -> (v0 << 4) | v1 with pmaddubsw
+        // (unsigned v * signed pattern [16, 1] per pair, summed into u16).
+        let pat = _mm256_set1_epi16(0x0110); // little-endian bytes: 0x10=16, 0x01=1
+        let p_lo = _mm256_maddubs_epi16(v_lo, pat); // u16 lanes: out[0..8] (half0), out[8..16] (half1)
+        let p_hi = _mm256_maddubs_epi16(v_hi, pat); // u16 lanes: out[16..24] (half0), out[24..32] (half1)
+
+        // packus_epi16 lays halves side by side per 128-bit lane:
+        //   lane0 = out[0..8]  + out[16..24]   lane1 = out[8..16] + out[24..32]
+        // so a 64-bit lane permute [0, 2, 1, 3] restores the byte order.
+        let packed = _mm256_packus_epi16(p_lo, p_hi);
+        let ordered = _mm256_permute4x64_epi64(packed, 0b11_01_10_00);
+        _mm256_storeu_si256(out as *mut __m256i, ordered);
+        true
+    }
+
+    /// Single-pass decode of `input` into `out`. Preconditions (checked by the
+    /// callers): `input.len()` is even and `out.len() == input.len()/2`.
+    /// Returns `Ok(limit / 2)` or `Err("invalid hex digit")`.
+    ///
+    /// # Safety
+    /// The caller must have runtime-detected AVX2
+    /// (`is_x86_feature_detected!("avx2")`) and must uphold the length
+    /// preconditions above.
+    #[target_feature(enable = "avx2")]
+    pub unsafe fn decode(input: &[u8], out: &mut [u8]) -> std::result::Result<usize, &'static str> {
+        let limit = input.len();
+        let mut i = 0usize;
+        while i + 64 <= limit {
+            if !decode_chunk(input.as_ptr().add(i), out.as_mut_ptr().add(i / 2)) {
+                return Err("invalid hex digit");
+            }
+            i += 64;
+        }
+        if i < limit {
+            // Tail (a multiple-of-2 remainder < 64 chars): validated engine.
+            faster_hex::hex_decode(&input[i..], &mut out[i / 2..limit / 2])
+                .map_err(|_| "invalid hex digit")?;
+        }
+        Ok(limit / 2)
+    }
+}
+
 /// Pure core: base64-encode `input` into `out` (zero-alloc `encode_slice`).
 /// Returns bytes written; errors if `out` is too small. Shared by the `_into`
 /// napi path and the pure-core unit tests.
@@ -255,10 +429,11 @@ pub fn base64_decode_into(
 
 /// Higher-order instance: the alphabet/padding engine is selected ONCE at
 /// construction and stored concretely, so `encode`/`decode` never re-run the
-/// 4-way engine match on the per-call path.
+/// 4-way engine match on the per-call path. On x86_64/aarch64 this holds the
+/// SIMD runtime-dispatched engine, so large payloads also get AVX2/NEON.
 #[napi]
 pub struct Base64Codec {
-    engine: base64::engine::general_purpose::GeneralPurpose,
+    engine: engine_sel::Engine,
 }
 
 #[napi]
@@ -335,6 +510,81 @@ mod tests {
         assert_eq!(enc.as_ref(), b"-w");
     }
 
+    // ── SIMD engine (x86_64 / aarch64: AVX2 / NEON kernels) ──
+    //
+    // The SIMD engine must be a drop-in for the scalar one: byte-identical
+    // output, identical validity/padding errors, on payloads both above the
+    // SIMD thresholds (decode ≥ 64 B, encode ≥ 128 B) and below them.
+
+    fn deterministic(n: usize) -> Vec<u8> {
+        (0..n)
+            .map(|i| (i.wrapping_mul(31) ^ (i >> 3)) as u8)
+            .collect()
+    }
+
+    #[test]
+    fn simd_large_payload_roundtrip_into_slice() {
+        // 16 KiB: well above both SIMD thresholds — exercises the wide kernels
+        // end-to-end and must round-trip byte-identically.
+        let data = deterministic(16 * 1024);
+        let mut enc = vec![0u8; data.len().div_ceil(3) * 4];
+        let w = base64_encode_into_slice(&data, &mut enc, false, true).unwrap();
+        assert_eq!(w, enc.len());
+        let mut dec = vec![0u8; data.len()];
+        let m = base64_decode_into_slice(&enc, &mut dec, false, true).unwrap();
+        assert_eq!(&dec[..m], &data[..]);
+    }
+
+    #[test]
+    fn simd_output_byte_identical_to_scalar() {
+        // Large payload: SIMD encode/decode must match the scalar engines
+        // exactly (alphabet + padding wire contract unchanged).
+        let data = deterministic(2048);
+        // standard w/ padding
+        let mut enc = vec![0u8; data.len().div_ceil(3) * 4];
+        let w = base64_encode_into_slice(&data, &mut enc, false, true).unwrap();
+        let scalar_exp = base64::engine::general_purpose::STANDARD.encode(&data);
+        assert_eq!(&enc[..w], scalar_exp.as_bytes());
+        // url-safe, no padding
+        let mut encu = vec![0u8; data.len().div_ceil(3) * 4];
+        let wu = base64_encode_into_slice(&data, &mut encu, true, false).unwrap();
+        let scalar_expu = base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(&data);
+        assert_eq!(&encu[..wu], scalar_expu.as_bytes());
+        // decode path parity
+        let mut dec = vec![0u8; data.len()];
+        let m = base64_decode_into_slice(scalar_exp.as_bytes(), &mut dec, false, true).unwrap();
+        assert_eq!(&dec[..m], &data[..]);
+        let mut decu = vec![0u8; data.len()];
+        let mu = base64_decode_into_slice(scalar_expu.as_bytes(), &mut decu, true, false).unwrap();
+        assert_eq!(&decu[..mu], &data[..]);
+    }
+
+    #[test]
+    fn simd_large_decode_rejects_invalid() {
+        // Invalid base64 symbol mid-buffer above the SIMD threshold: the wide
+        // kernel breaks out and the scalar decoder reports the error — parity
+        // with the scalar engine's rejection.
+        let mut bad = vec![b'A'; 4096];
+        bad[2048] = b'!';
+        let mut out = vec![0u8; 4096];
+        assert!(base64_decode_into_slice(&bad, &mut out, false, true).is_err());
+        let scalar = base64::engine::general_purpose::STANDARD.decode(bad.as_slice());
+        assert!(scalar.is_err());
+    }
+
+    #[test]
+    fn simd_small_payload_matches_scalar() {
+        // Below the SIMD thresholds the engine is scalar internally; output
+        // and errors must match the preconfigured engines.
+        let data = b"hello world!";
+        let mut enc = [0u8; 32];
+        let w = base64_encode_into_slice(data, &mut enc, false, true).unwrap();
+        assert_eq!(&enc[..w], b"aGVsbG8gd29ybGQh");
+        let mut dec = [0u8; 16];
+        let m = base64_decode_into_slice(b"aGVsbG8gd29ybGQh", &mut dec, false, true).unwrap();
+        assert_eq!(&dec[..m], data);
+    }
+
     // ── reusable-output (_into) variants ──
 
     #[test]
@@ -384,6 +634,171 @@ mod tests {
         assert!(hex_decode_into_slice(b"0001020304", &mut out).is_err());
     }
 
+    // ── hex SIMD engine (faster-hex: runtime-dispatched SSE→AVX2) ──
+    //
+    // faster-hex must be a drop-in for the previous HEX_VAL_LUT scalar loops:
+    // byte-identical encode output, identical accept/reject + values on
+    // decode, at lengths both below and above the SIMD chunk boundaries
+    // (pshufb processes 16 bytes/iteration, so 15/16/17, 31/32/33, … are the
+    // straddle cases that would expose a broken fast path).
+
+    /// Reference lowercase-hex encode (the previous per-byte LUT loop).
+    fn ref_hex_encode(input: &[u8]) -> Vec<u8> {
+        let hex = b"0123456789abcdef";
+        let mut out = Vec::with_capacity(input.len() * 2);
+        for &b in input {
+            out.push(hex[(b >> 4) as usize]);
+            out.push(hex[(b & 0x0f) as usize]);
+        }
+        out
+    }
+
+    /// Reference hex-digit value (the previous HEX_VAL_LUT semantics).
+    fn ref_hex_val(b: u8) -> Option<u8> {
+        match b {
+            b'0'..=b'9' => Some(b - b'0'),
+            b'a'..=b'f' => Some(b - b'a' + 10),
+            b'A'..=b'F' => Some(b - b'A' + 10),
+            _ => None,
+        }
+    }
+
+    #[test]
+    fn hex_simd_encode_parity_all_lengths_and_sizes() {
+        // Every length 0..=96 (covers every pshufb chunk boundary twice) plus
+        // larger payloads that exercise the wide kernels end-to-end.
+        let mut lens: Vec<usize> = (0..=96).collect();
+        lens.extend([128, 255, 256, 511, 512, 1024, 16 * 1024, 256 * 1024]);
+        for n in lens {
+            let data = deterministic(n);
+            let expect = ref_hex_encode(&data);
+            // allocating path
+            assert_eq!(hex_encode_bytes(&data).as_bytes(), &expect[..], "len {n}");
+            // into-slice path (exact-size buffer, like the C-ABI caller)
+            let mut out = vec![0u8; n * 2];
+            let w = hex_encode_into_slice(&data, &mut out).unwrap();
+            assert_eq!(w, n * 2);
+            assert_eq!(&out[..w], &expect[..], "len {n}");
+        }
+    }
+
+    #[test]
+    fn hex_simd_decode_exhaustive_pair_matrix() {
+        // All 65,536 two-char combos: accept/reject and decoded value must be
+        // identical to the reference LUT semantics (case-insensitive digits,
+        // everything else rejected). A SIMD engine with a divergent validity
+        // mask fails here.
+        for hi in 0u16..=255 {
+            for lo in 0u16..=255 {
+                let pair = [hi as u8, lo as u8];
+                let want = match (ref_hex_val(pair[0]), ref_hex_val(pair[1])) {
+                    (Some(h), Some(l)) => Some((h << 4) | l),
+                    _ => None,
+                };
+                let mut out = [0u8; 1];
+                let got = hex_decode_into_slice(&pair, &mut out);
+                match want {
+                    Some(v) => {
+                        assert!(got.is_ok(), "{pair:02x?}: expected OK");
+                        assert_eq!(out[0], v, "{pair:02x?}: value");
+                    }
+                    None => assert!(got.is_err(), "{pair:02x?}: expected reject"),
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn hex_simd_large_roundtrip() {
+        // 2 MiB deterministic payload: SIMD encode → SIMD decode must be the
+        // identity, and the decoded bytes must match the source exactly.
+        let data = deterministic(2 * 1024 * 1024);
+        let mut enc = vec![0u8; data.len() * 2];
+        let w = hex_encode_into_slice(&data, &mut enc).unwrap();
+        assert_eq!(w, data.len() * 2);
+        let mut dec = vec![0u8; data.len()];
+        let m = hex_decode_into_slice(&enc, &mut dec).unwrap();
+        assert_eq!(m, data.len());
+        assert_eq!(&dec[..], &data[..]);
+        // uppercase decodes to the same bytes (case-insensitive)
+        for b in enc.iter_mut() {
+            if b.is_ascii_lowercase() {
+                *b = b.to_ascii_uppercase();
+            }
+        }
+        let mut dec2 = vec![0u8; data.len()];
+        let m2 = hex_decode_into_slice(&enc, &mut dec2).unwrap();
+        assert_eq!(&dec2[..m2], &data[..]);
+    }
+
+    #[test]
+    fn hex_simd_large_decode_rejects_invalid_tail() {
+        // An invalid char at the very END of a 256 KiB string: the SIMD tail
+        // handler must still reject (parity with the scalar loop's rejection
+        // at any position).
+        let mut hex = Vec::with_capacity(256 * 1024);
+        for _ in 0..(128 * 1024) {
+            hex.extend_from_slice(b"ab");
+        }
+        hex.push(b'g'); // 'g' is not a hex digit → odd+invalid
+        let mut out = vec![0u8; 128 * 1024];
+        assert!(hex_decode_into_slice(&hex, &mut out).is_err());
+
+        // Even-length with a bad char one past the SIMD chunk boundary.
+        let mut hex2 = hex[..hex.len() - 1].to_vec(); // even, all "ab..."
+        hex2[200_001] = b'z';
+        assert!(hex_decode_into_slice(&hex2, &mut out).is_err());
+    }
+
+    #[test]
+    fn hex_simd_decode_chunk_boundary_sweep() {
+        // Every length 0..=160 crosses the AVX2 kernel's 64-char chunk
+        // boundary several times: valid inputs must decode to the reference
+        // bytes, and an invalid char must be rejected no matter which bucket
+        // it lands in (chunk body, chunk boundary, or the < 64-char tail).
+        // This is the direct guard on the single-pass kernel's chunk loop +
+        // tail handoff (the exhaustive pair matrix above covers 2-char inputs,
+        // which only ever exercise the tail path).
+        let mut lens: Vec<usize> = (0..=160).collect();
+        lens.extend([192, 200, 512, 4096]);
+        for n in lens {
+            let even = n - n % 2; // even number of HEX CHARS in the input
+            let expect: Vec<u8> = (0..even / 2)
+                .map(|i| (i.wrapping_mul(13) + 7) as u8)
+                .collect();
+            let hex: String = expect.iter().map(|b| format!("{b:02x}")).collect();
+            assert_eq!(hex.len(), even);
+            let mut out = vec![0u8; even / 2];
+            let w = hex_decode_into_slice(hex.as_bytes(), &mut out).unwrap();
+            assert_eq!(&out[..w], &expect[..], "len {even}");
+            // Reject an invalid char at one position per bucket.
+            for &pos in &[
+                0usize,
+                1,
+                14,
+                30,
+                31,
+                32,
+                62,
+                63,
+                64,
+                65,
+                even.saturating_sub(2),
+                even.saturating_sub(1),
+            ] {
+                if pos < even {
+                    let mut bad = hex.clone().into_bytes();
+                    bad[pos] = b'g'; // 'g' is never a hex digit
+                    let mut o = vec![0u8; even / 2];
+                    assert!(
+                        hex_decode_into_slice(&bad, &mut o).is_err(),
+                        "len {even} pos {pos}"
+                    );
+                }
+            }
+        }
+    }
+
     #[test]
     fn base64_encode_into_reports_length() {
         let data = b"hello world!";

package/rust/crypto/hashing.rs

@@ -137,4 +137,72 @@ mod tests {
             xxh3(Uint8Array::new(input.to_vec()))
         );
     }
+
+    /// Known-value xxh3-64 vectors that LOCK the spec output across both the
+    /// short-input (< 240 B) and long-input (>= 240 B) regimes of the engine.
+    /// Generated with `Bun.hash.xxHash3` (independent spec-compliant
+    /// implementation). The 240/241 pair guards the engine's internal
+    /// threshold: an implementation or length-handling regression that
+    /// diverges only above it fails here even though small-input tests pass.
+    /// (Perf note: the scalar core is FLAT ~30GB/s 64B→1MB — measured, no
+    /// size pathology; see docs/bun-builtins-decision-matrix.md for why Bun
+    /// still wins the consumer under Bun.)
+    #[test]
+    fn xxh3_vectors_lock_spec_across_simd_threshold() {
+        // input: (i * 31 + 5) % 256 for i in 0..n (deterministic)
+        const V: &[(usize, u64)] = &[
+            (0, 0x2d06_8005_38d3_94c2),
+            (1, 0x929e_358d_27ae_3ee2),
+            (2, 0xf8a9_b018_ddb0_dc1a),
+            (3, 0xea4f_94f7_8c69_f54e),
+            (4, 0xc674_aba0_6059_22b7),
+            (5, 0x988e_18b6_a130_77ac),
+            (6, 0x19e7_8a37_d9eb_8365),
+            (7, 0x4d32_b9b4_d45d_9319),
+            (8, 0xad43_7729_e900_e521),
+            (9, 0x2f54_64ee_70cc_cff9),
+            (10, 0x97a1_114c_1cbf_45ae),
+            (11, 0x2933_959d_e03b_8ce8),
+            (12, 0x5cba_0687_e71c_0f12),
+            (13, 0x5a27_1d93_20eb_cb8a),
+            (14, 0xeb81_cf37_8320_b598),
+            (15, 0xec7b_ee5b_893b_d5d5),
+            (16, 0x0903_f58f_8225_3d8c),
+            (17, 0x48a3_8615_d4ee_fb8b),
+            (18, 0xb871_d958_cc11_dfa4),
+            (19, 0xc6ed_7037_b89b_d206),
+            (23, 0xd410_62e4_0171_ac46),
+            (31, 0x4334_b263_9627_f197),
+            (32, 0xebeb_3ba5_7ab1_edca),
+            (33, 0x7ff1_7572_bd9e_70a9),
+            (63, 0x504d_3e53_12aa_2db1),
+            (64, 0xd8cc_034e_d06e_92f3),
+            (65, 0x73c9_73e2_4eda_1cdc),
+            (95, 0x45f6_3f33_cade_8c19),
+            (96, 0x4c46_e758_08f2_74e9),
+            (127, 0x1ed1_3eff_d01b_9402),
+            (128, 0x05a1_567d_530f_961c),
+            (191, 0xba5e_7dfd_d63d_7785),
+            (192, 0x999d_b9f2_4d8c_ffcf),
+            (238, 0xda80_d2d5_c7b9_397e),
+            (239, 0xb0ca_9389_9a38_51d5),
+            (240, 0xc502_31c4_c4c8_6a63),
+            (241, 0xa7dc_042e_5a9f_6aa6),
+            (255, 0x62c8_1de1_9704_658e),
+            (256, 0x84f8_cedc_d725_6d1a),
+            (512, 0xd4d7_d053_e788_d9ef),
+            (1024, 0xdb4a_2f32_c2a5_bc38),
+            (16384, 0xf04a_c437_8b21_4439),
+            (262144, 0x6c36_c9dc_9aaf_20f0),
+        ];
+        let input =
+            |n: usize| -> Vec<u8> { (0..n).map(|i| (i.wrapping_mul(31) + 5) as u8).collect() };
+        for (n, want) in V {
+            assert_eq!(
+                fast_hash_bytes(&input(*n)),
+                *want,
+                "xxh3({n} bytes) — engine regime mismatch",
+            );
+        }
+    }
 }

package/rust/payload/sse.rs

@@ -40,10 +40,14 @@ pub fn encode_event_size(
     if let Some(retry) = retry {
         need += 8 + u64_digits(retry); // "retry: " + digits + "\n"
     }
-    // One `data: ` (6) + `\n` (1) per input line, the line bytes themselves,
-    // then the terminating blank `\n`.
-    let line_count = data.iter().filter(|&&b| b == b'\n').count() + 1;
-    need + line_count * 7 + data.len() + 1
+    // One `data: ` (6) + `\n` (1) per input line, the line bytes themselves
+    // (SEGMENTS EXCLUDE the `\n` separators — sum of segment lengths =
+    // `data.len() - (line_count - 1)`), then the terminating blank `\n`.
+    // Line boundaries found via SIMD memchr — a scalar `filter().count()`
+    // pass over the full payload was ~1 cycle/byte (~650ns/KB steady state),
+    // collapsing large encodes to 0.10× of JS.
+    let line_count = memchr::memchr_iter(b'\n', data).count() + 1;
+    need + line_count * 7 + data.len() - (line_count - 1) + 1
 }
 
 /// Encode one SSE event into `out`, returning bytes written. Zero-alloc (no
@@ -98,7 +102,23 @@ pub fn encode_event_into_slice(
         out[w] = b'\n';
         w += 1;
     }
-    for line in data.split(|&b| b == b'\n') {
+    // One `data: ` line per input line: SIMD memchr finds the `\n` boundaries
+    // (no scalar split() re-scan of the whole payload), copying each run.
+    // `data.split('\n')` semantics are preserved exactly: the tail after the
+    // last `\n` is emitted even when empty.
+    let mut line_start = 0usize;
+    for sep in memchr::memchr_iter(b'\n', data) {
+        let line = &data[line_start..sep];
+        out[w..w + 6].copy_from_slice(b"data: ");
+        w += 6;
+        out[w..w + line.len()].copy_from_slice(line);
+        w += line.len();
+        out[w] = b'\n';
+        w += 1;
+        line_start = sep + 1;
+    }
+    {
+        let line = &data[line_start..];
         out[w..w + 6].copy_from_slice(b"data: ");
         w += 6;
         out[w..w + line.len()].copy_from_slice(line);
@@ -211,4 +231,57 @@ mod tests {
         let mut out = [0u8; 3];
         assert!(encode_event_into_slice(Some("update"), b"payload", None, None, &mut out).is_err());
     }
+
+    #[test]
+    fn large_multiline_matches_allocating() {
+        // 4k lines x 96-byte data — spans well past any SIMD threshold.
+        let mut data = Vec::with_capacity(4 * 1024 * 96);
+        for i in 0..4 * 1024 {
+            data.extend_from_slice(format!("line-{i} ").as_bytes());
+            data.extend_from_slice(b"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"); // 55
+            data.push(b'\n');
+        }
+        let expected = encode_event(None, &data, None, None);
+        assert!(
+            expected.len() > 256 * 1024,
+            "test payload unexpectedly small: {}",
+            expected.len()
+        );
+        let mut out = vec![0u8; encode_event_size(None, &data, None, None)];
+        let w = encode_event_into_slice(None, &data, None, None, &mut out).unwrap();
+        assert_eq!(w, expected.len());
+        assert_eq!(&out[..w], &expected[..]);
+    }
+
+    #[test]
+    fn single_large_line_scales_too() {
+        // One 1MB line — the old scalar split() path cost ~300us here.
+        let mut data = vec![b'a'; 1 << 20];
+        data.push(b'\n');
+        let expected = encode_event(None, &data, None, None);
+        let mut out = vec![0u8; encode_event_size(None, &data, None, None)];
+        let w = encode_event_into_slice(None, &data, None, None, &mut out).unwrap();
+        assert_eq!(w, expected.len());
+        assert_eq!(&out[..w], &expected[..]);
+    }
+
+    #[test]
+    fn trailing_newline_emits_empty_tail_line() {
+        // split() semantics: "a\n" -> ["a", ""] -> one empty data: line.
+        assert_eq!(
+            encode_event(None, b"hello\n", None, None),
+            b"data: hello\ndata: \n\n"
+        );
+        assert_eq!(encode_event(None, b"\n", None, None), b"data: \ndata: \n\n");
+        assert_eq!(encode_event(None, b"", None, None), b"data: \n\n");
+    }
+
+    #[test]
+    fn embedded_crlf_kept_in_line() {
+        // Only \n splits lines; \r stays in the line bytes.
+        assert_eq!(
+            encode_event(None, b"a\r\nb", None, None),
+            b"data: a\r\ndata: b\n\n"
+        );
+    }
 }

package/rust/util/text.rs

@@ -14,23 +14,50 @@ use napi_derive::napi;
 /// [`regex_escape_write`].
 const REGEX_META: &[u8; 14] = b"\\.*+?^${}()|[]";
 
+/// 256-entry membership lookup for [`REGEX_META`] — one table load per byte.
+/// The previous per-byte `REGEX_META.contains(&c)` did a linear 14-element
+/// scan PER byte (O(n·14)); a 16KB payload took ~100µs (~160MB/s) and the
+/// win margin vs JS regex-replace collapsed with size. The LUT makes the hot
+/// loop branch-predictable (~1 load/byte), and safe runs are copied in bulk
+/// (memcpy) instead of one push per byte.
+const REGEX_META_LUT: [u8; 256] = {
+    let mut t = [0u8; 256];
+    let mut i = 0usize;
+    while i < REGEX_META.len() {
+        t[REGEX_META[i] as usize] = 1;
+        i += 1;
+    }
+    t
+};
+
+#[inline(always)]
+fn is_meta(b: u8) -> bool {
+    REGEX_META_LUT[b as usize] != 0
+}
+
 /// Append the RegExp-escaped form of `input` to `out`. ASCII-only transform
 /// (backslash before metachar bytes) — multi-byte UTF-8 sequences pass
 /// through byte-exact because no UTF-8 continuation byte is a metachar.
+/// Safe runs are bulk-copied (memcpy) between metachars, so throughput scales
+/// with memory bandwidth, not the metachar-set size.
 pub fn regex_escape_into(input: &[u8], out: &mut Vec<u8>) {
-    for &c in input {
-        if REGEX_META.contains(&c) {
+    let mut run_start = 0usize;
+    for (i, &c) in input.iter().enumerate() {
+        if is_meta(c) {
+            out.extend_from_slice(&input[run_start..i]);
             out.push(b'\\');
+            out.push(c);
+            run_start = i + 1;
         }
-        out.push(c);
     }
+    out.extend_from_slice(&input[run_start..]);
 }
 
 /// Exact escaped length (metachar count + input length) — lets callers size
 /// output buffers without running the escape twice.
 #[inline]
 pub fn regex_escape_len(input: &[u8]) -> usize {
-    input.len() + input.iter().filter(|b| REGEX_META.contains(b)).count()
+    input.len() + input.iter().filter(|&&b| is_meta(b)).count()
 }
 
 /// Write the escaped form of `input` into `out` (which must be at least
@@ -38,15 +65,21 @@ pub fn regex_escape_len(input: &[u8]) -> usize {
 /// written.
 pub fn regex_escape_write(input: &[u8], out: &mut [u8]) -> usize {
     let mut pos = 0usize;
-    for &c in input {
-        if REGEX_META.contains(&c) {
+    let mut run_start = 0usize;
+    for (i, &c) in input.iter().enumerate() {
+        if is_meta(c) {
+            let run = &input[run_start..i];
+            out[pos..pos + run.len()].copy_from_slice(run);
+            pos += run.len();
             out[pos] = b'\\';
-            pos += 1;
+            out[pos + 1] = c;
+            pos += 2;
+            run_start = i + 1;
         }
-        out[pos] = c;
-        pos += 1;
     }
-    pos
+    let tail = &input[run_start..];
+    out[pos..pos + tail.len()].copy_from_slice(tail);
+    pos + tail.len()
 }
 
 /// Escape JS RegExp metacharacters in a string → a pattern that matches the
@@ -127,4 +160,73 @@ mod tests {
         let escaped = String::from_utf8(out).expect("utf8");
         assert_eq!(escaped, r"a\.c");
     }
+
+    /// Reference escape (the previous per-byte `REGEX_META.contains` loop).
+    fn ref_escape(input: &[u8]) -> Vec<u8> {
+        const META: &[u8] = b"\\.*+?^${}()|[]";
+        let mut out = Vec::new();
+        for &c in input {
+            if META.contains(&c) {
+                out.push(b'\\');
+            }
+            out.push(c);
+        }
+        out
+    }
+
+    #[test]
+    fn regex_escape_matches_reference_for_all_lengths() {
+        // Every length 0..=96 plus larger payloads: the LUT + run-copy core
+        // (bulk memcpy between metachars) must be byte-identical to the naive
+        // per-byte reference. Lengths 15/16/17… straddle no SIMD chunk here
+        // (the transform is scalar), but the sweep locks positional behavior:
+        // a run-copy off-by-one (dropping or duplicating a safe byte) surfaces.
+        let mut lens: Vec<usize> = (0..=96).collect();
+        lens.extend([128, 512, 16 * 1024, 256 * 1024]);
+        for n in lens {
+            let input: Vec<u8> = (0..n).map(|i| (i.wrapping_mul(31) + 5) as u8).collect();
+            let expect = ref_escape(&input);
+            // allocating path
+            let mut out = Vec::new();
+            regex_escape_into(&input, &mut out);
+            assert_eq!(out, expect, "len {n}");
+            // len formula
+            assert_eq!(regex_escape_len(&input), expect.len(), "len {n}");
+            // write path (exact-size buffer, like the C-ABI caller)
+            let mut buf = vec![0u8; expect.len()];
+            let written = regex_escape_write(&input, &mut buf);
+            assert_eq!(written, expect.len(), "len {n}");
+            assert_eq!(&buf[..written], &expect[..], "len {n}");
+        }
+    }
+
+    #[test]
+    fn regex_escape_large_payload_edges() {
+        // Three 256 KiB extremes: every byte a metachar (no bulk runs — the
+        // worst case for the run-copy core), no metachars at all (pure bulk
+        // copy), and a dense alternating pattern. All must match the reference
+        // and the exact-length contract.
+        let all_meta: Vec<u8> = (0..256 * 1024)
+            .map(|i| b"\\.*+?^${}()|[]"[i % 14])
+            .collect();
+        let none: Vec<u8> = (0..256 * 1024).map(|i| b"abcXYZ0123_-/"[i % 13]).collect();
+        let dense: Vec<u8> = (0..256 * 1024)
+            .map(|i| if i % 2 == 0 { b'.' } else { b'a' })
+            .collect();
+        for input in [all_meta, none, dense] {
+            let expect = ref_escape(&input);
+            let mut out = Vec::new();
+            regex_escape_into(&input, &mut out);
+            assert_eq!(out, expect);
+            assert_eq!(regex_escape_len(&input), expect.len());
+            let mut buf = vec![0u8; expect.len()];
+            let written = regex_escape_write(&input, &mut buf);
+            assert_eq!(written, expect.len());
+            assert_eq!(&buf[..written], &expect[..]);
+        }
+        // All-metachar bound: escaped length is exactly 2x (every byte gets a
+        // backslash); all-safe bound: escaped length equals input length.
+        assert_eq!(regex_escape_len(&vec![b'.'; 1024]), 2048);
+        assert_eq!(regex_escape_len(&vec![b'a'; 1024]), 1024);
+    }
 }

package/rust/util/validation.rs

@@ -317,6 +317,40 @@ mod tests {
         assert!(!validate_uuid_bytes(b"550e8400e29b41d4a716446655440000")); // no dashes
     }
 
+    /// Byte-for-byte pins the accept set: replacing ANY single hex position
+    /// (0..7, 9..12, 15..17, 20..22, 24..35) with a non-hex digit must reject,
+    /// and every one of the 32 hex positions must accept uppercase + lowercase
+    /// digits. Guards against a future rewrite (e.g. SIMD/run-split) silently
+    /// dropping or mis-scoping a position — measured perf-neutral, kept as a
+    /// spec-lock regression net.
+    #[test]
+    fn validate_uuid_hex_run_coverage() {
+        let dash = |i: usize| matches!(i, 8 | 13 | 18 | 23);
+        for pos in 0..36 {
+            let valid = b"550e8400-e29b-41d4-a716-446655440000";
+            if dash(pos) {
+                continue; // dash positions are pinned by their own check
+            }
+            // every non-dash position is a hex position (version/variant cols
+            // included — 14 must stay '4', 19 must stay in 8/9/a/b set)
+            if valid[pos].is_ascii_hexdigit() {
+                let mut upper = *valid;
+                upper[pos] = valid[pos].to_ascii_uppercase();
+                assert!(validate_uuid_bytes(&upper), "uppercase at {pos}");
+            }
+            let mut bad = *valid;
+            bad[pos] = b'g'; // 'g' is not a hex digit
+            assert!(!validate_uuid_bytes(&bad), "g at {pos}");
+        }
+        // and the version / variant columns still reject wrong values
+        let mut v = *b"550e8400-e29b-41d4-a716-446655440000";
+        v[14] = b'5';
+        assert!(!validate_uuid_bytes(&v));
+        v = *b"550e8400-e29b-41d4-a716-446655440000";
+        v[19] = b'c';
+        assert!(!validate_uuid_bytes(&v));
+    }
+
     #[test]
     fn validate_ipv4_cases() {
         assert!(validate_ipv4_bytes(b"192.168.0.1"));