castrum 0.9.9 → 0.9.11

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