@stacksjs/zig-dtsx 0.9.13 → 0.9.14

package/README.md

@@ -52,6 +52,34 @@ The Zig binary communicates with the Node/Bun runtime via FFI, allowing seamless
 
 ## Benchmarks
 
+Benchmarked on Apple M3 Pro, macOS _(bun 1.3.11, arm64-darwin)_.
+
+### In-Process API — No Cache
+
+| Tool | Small (~50 lines) | Medium (~100 lines) | Large (~330 lines) | XLarge (~1050 lines) |
+|------|-------------------|---------------------|--------------------|--------------------|
+| **zig-dtsx**|**3.37 µs**|**7.05 µs**|**21.89 µs**|**144.89 µs** |
+| oxc-transform | 7.36 µs _(2.2x)_ | 21.91 µs _(3.1x)_ | 89.66 µs _(4.1x)_ | 560.86 µs _(3.9x)_ |
+| tsc | 169.69 µs _(50.4x)_ | 410.31 µs _(58.2x)_ | 1.03 ms _(47.1x)_ | 4.02 ms _(27.7x)_ |
+
+### CLI — Single File
+
+| Tool | Small (~50 lines) | Medium (~100 lines) | Large (~330 lines) | XLarge (~1050 lines) |
+|------|-------------------|---------------------|--------------------|--------------------|
+| **zig-dtsx**|**2.69 ms**|**2.35 ms**|**2.28 ms**|**3.14 ms** |
+| oxc | 17.08 ms _(6.3x)_ | 17.12 ms _(7.3x)_ | 17.95 ms _(7.9x)_ | 17.69 ms _(5.6x)_ |
+| tsgo | 40.53 ms _(15.1x)_ | 44.10 ms _(18.8x)_ | 44.39 ms _(19.5x)_ | 57.77 ms _(18.4x)_ |
+| tsc | 384.25 ms _(142.8x)_ | 407.51 ms _(173.4x)_ | 418.81 ms _(183.7x)_ | 454.74 ms _(144.8x)_ |
+
+### Multi-File Project
+
+| Tool | 50 files | 100 files | 500 files |
+|------|----------|-----------|-----------|
+| **zig-dtsx**|**18.10 ms**|**31.46 ms**|**~140 ms** |
+| oxc | 48.27 ms _(2.7x)_ | 79.00 ms _(2.5x)_ | ~365 ms _(2.6x)_ |
+| tsgo | 244.68 ms _(13.5x)_ | 419.65 ms _(13.3x)_ | - |
+| tsc | 871.48 ms _(48.1x)_ | - | - |
+
 ```bash
 bun run benchmark
 ```

package/build.zig

@@ -15,7 +15,7 @@ pub fn build(b: *std.Build) void {
             .link_libc = true,
         }),
     });
-    // Enable LTO on Linux release builds (LLD required; macOS Mach-O doesn't support LLD)
+    // Enable LTO on Linux release builds (requires LLD; macOS Mach-O doesn't support LLD yet)
     if (target.result.os.tag == .linux and optimize != .Debug) {
         lib.use_lld = true;
         lib.lto = .full;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/zig-dtsx",
   "type": "module",
-  "version": "0.9.13",
+  "version": "0.9.14",
   "description": "High-performance DTS emitter written in Zig",
   "exports": {
     ".": {
@@ -18,6 +18,6 @@
     "benchmark": "bun run test/benchmark.ts"
   },
   "dependencies": {
-    "@stacksjs/dtsx": "0.9.13"
+    "@stacksjs/dtsx": "0.9.14"
   }
 }

package/src/char_utils.zig

@@ -61,30 +61,79 @@ pub inline fn isDigit(ch: u8) bool {
     return ch >= '0' and ch <= '9';
 }
 
-/// Find needle in haystack starting from start position
+/// Find needle in haystack starting from start position.
+/// For single-byte needles, uses SIMD. For multi-byte, uses SIMD first-byte scan + verify.
 pub inline fn indexOf(haystack: []const u8, needle: []const u8, start: usize) ?usize {
     if (needle.len == 0) return start;
     if (start + needle.len > haystack.len) return null;
-    return std.mem.indexOfPos(u8, haystack, start, needle);
+    if (needle.len == 1) return indexOfChar(haystack, needle[0], start);
+    // SIMD first-byte scan: find positions where needle[0] matches, then verify rest
+    const first = needle[0];
+    const search = haystack[start..];
+    var i: usize = 0;
+    while (i + needle.len <= search.len) {
+        // SIMD: scan for first byte of needle
+        while (i + 16 <= search.len) {
+            const chunk: @Vector(16, u8) = search[i..][0..16].*;
+            const match_mask = chunk == @as(@Vector(16, u8), @splat(first));
+            if (@reduce(.Or, match_mask)) {
+                const bits: u16 = @bitCast(match_mask);
+                const offset = @ctz(bits);
+                i += offset;
+                break;
+            }
+            i += 16;
+        }
+        if (i + needle.len > search.len) return null;
+        // Verify full needle match
+        if (search[i] == first and std.mem.eql(u8, search[i..][0..needle.len], needle)) {
+            return start + i;
+        }
+        i += 1;
+    }
+    return null;
 }
 
-/// Find a single byte in haystack starting from start position
+/// Find a single byte in haystack starting from start position.
+/// Uses SIMD to scan 16 bytes at a time for the target character.
 pub inline fn indexOfChar(haystack: []const u8, needle: u8, start: usize) ?usize {
     if (start >= haystack.len) return null;
-    return std.mem.indexOfScalarPos(u8, haystack, start, needle);
+    const search = haystack[start..];
+    // SIMD fast path: scan 16 bytes at a time
+    var i: usize = 0;
+    while (i + 16 <= search.len) {
+        const chunk: @Vector(16, u8) = search[i..][0..16].*;
+        const match_mask = chunk == @as(@Vector(16, u8), @splat(needle));
+        if (@reduce(.Or, match_mask)) {
+            const bits: u16 = @bitCast(match_mask);
+            return start + i + @ctz(bits);
+        }
+        i += 16;
+    }
+    // Scalar fallback for remaining bytes
+    while (i < search.len) : (i += 1) {
+        if (search[i] == needle) return start + i;
+    }
+    return null;
 }
 
 /// Slice source[start..end) with leading/trailing whitespace trimmed
-pub fn sliceTrimmed(source: []const u8, start_pos: usize, end_pos: usize) []const u8 {
-    var s = start_pos;
-    var e = end_pos;
-    if (s >= e) return "";
-
-    // Fast path: if endpoints are already non-whitespace, skip trim loops
-    if (!isWhitespace(source[s]) and !isWhitespace(source[e - 1])) {
-        return source[s..e];
+pub inline fn sliceTrimmed(source: []const u8, start_pos: usize, end_pos: usize) []const u8 {
+    if (start_pos >= end_pos) return "";
+
+    // Fast path: if endpoints are already non-whitespace, skip trim loops.
+    // Most slices in TS source already have clean boundaries — this branch
+    // dominates and is worth keeping out of any function call.
+    const first = source[start_pos];
+    const last = source[end_pos - 1];
+    if (first != CH_SPACE and first != CH_TAB and first != CH_LF and first != CH_CR and
+        last != CH_SPACE and last != CH_TAB and last != CH_LF and last != CH_CR)
+    {
+        return source[start_pos..end_pos];
     }
 
+    var s = start_pos;
+    var e = end_pos;
     while (s < e and isWhitespace(source[s])) s += 1;
     while (e > s and isWhitespace(source[e - 1])) e -= 1;
     return source[s..e];
@@ -143,6 +192,23 @@ test "sliceTrimmed" {
     try std.testing.expectEqualStrings("hello", sliceTrimmed(src, 2, 7));
 }
 
+test "sliceTrimmed fast path: clean endpoints return zero-copy slice" {
+    // After the inline + manual-whitespace-check rewrite the fast path must
+    // still bypass the trim loops when the endpoints are non-whitespace.
+    const src = "abc def";
+    const out = sliceTrimmed(src, 0, src.len);
+    try std.testing.expectEqualStrings("abc def", out);
+    // Returned slice points into the same buffer (no copy).
+    try std.testing.expect(out.ptr == src.ptr);
+}
+
+test "sliceTrimmed handles tabs, newlines, and CR" {
+    try std.testing.expectEqualStrings("x", sliceTrimmed("\tx\n", 0, 3));
+    try std.testing.expectEqualStrings("x", sliceTrimmed("\rx\r", 0, 3));
+    try std.testing.expectEqualStrings("", sliceTrimmed("   ", 0, 3));
+    try std.testing.expectEqualStrings("", sliceTrimmed("abc", 1, 1));
+}
+
 test "indexOf" {
     const s = "hello world";
     try std.testing.expectEqual(@as(?usize, 6), indexOf(s, "world", 0));