@stacksjs/zig-dtsx 0.9.12 → 0.9.14

package/src/lib.zig

@@ -10,8 +10,14 @@ const ProcessResult = struct {
 };
 
 fn emptyResult() ProcessResult {
-    const empty = std.heap.c_allocator.alloc(u8, 1) catch @panic("OOM");
-    empty[0] = 0;
+    // Allocate 16 zero bytes so the SIMD result_length scan can read a full
+    // 16-byte vector without touching memory past the allocation. The caller
+    // sees `len == 0` and `ptr[0] == 0`, but free_result will receive `len + 1
+    // = 1` so the freed range matches the slice length the allocator tracks.
+    // Pre-fix this allocated 1 byte and the SIMD loop in result_length would
+    // read 15 bytes of unrelated heap state.
+    const empty = std.heap.c_allocator.alloc(u8, 16) catch @panic("OOM");
+    @memset(empty, 0);
     return .{ .ptr = empty.ptr, .len = 0 };
 }
 
@@ -98,11 +104,21 @@ fn processSourceInternal(
     return .{ .ptr = dts_output.ptr, .len = dts_output.len };
 }
 
-/// Get the length of a result string (without null terminator)
+/// Get the length of a result string (without null terminator).
+/// SIMD-scan 16 bytes at a time for the null terminator — faster on long
+/// results than the byte-by-byte loop the compiler will generate from the
+/// scalar form.
 export fn result_length(ptr: [*]const u8) usize {
     var i: usize = 0;
-    while (ptr[i] != 0) i += 1;
-    return i;
+    while (true) {
+        const chunk: @Vector(16, u8) = ptr[i..][0..16].*;
+        const zero_mask = chunk == @as(@Vector(16, u8), @splat(0));
+        if (@reduce(.Or, zero_mask)) {
+            const bits: u16 = @bitCast(zero_mask);
+            return i + @ctz(bits);
+        }
+        i += 16;
+    }
 }
 
 /// Free a result string previously returned by process_source
@@ -204,7 +220,12 @@ export fn process_batch(
         @intCast(thread_count)
     else
         @intCast(std.Thread.getCpuCount() catch 4);
-    const num_threads = @min(max_threads, n);
+    // Cap the thread count so each thread gets at least ~4 files. Spawn+join
+    // overhead (~100µs per thread) dominates if a thread has only 1-2 small
+    // files to process. Mirrors the heuristic in main.zig:processProject.
+    const min_files_per_thread = 4;
+    const desired_threads = @max(n / min_files_per_thread, 1);
+    const num_threads = @min(@min(max_threads, desired_threads), n);
 
     if (num_threads <= 1) {
         // Single-threaded: process all sequentially
@@ -220,9 +241,15 @@ export fn process_batch(
     };
     defer std.heap.c_allocator.free(threads);
 
-    const chunk_size = (n + num_threads - 1) / num_threads;
-    var thread_spawned: [64]bool = .{false} ** 64; // max 64 threads
+    // Heap-allocate thread-spawned flags so we don't overflow when num_threads > 64.
+    const thread_spawned = std.heap.c_allocator.alloc(bool, num_threads) catch {
+        batchWorker(tasks);
+        return;
+    };
+    defer std.heap.c_allocator.free(thread_spawned);
+    @memset(thread_spawned, false);
 
+    const chunk_size = (n + num_threads - 1) / num_threads;
     for (0..num_threads) |t| {
         const start = t * chunk_size;
         if (start >= n) break;

package/src/main.zig

@@ -7,8 +7,17 @@ const Scanner = @import("scanner.zig").Scanner;
 const emitter = @import("emitter.zig");
 
 // Platform-aware C stdio bindings.
-// On Windows, @cImport fails because stdin/stdout are runtime function calls
-// that Zig can't evaluate at comptime. We declare the extern functions manually.
+//
+// Zig 0.17 removed `@cImport` as a language builtin, so we declare every C
+// symbol we need manually here instead of pulling them in from system
+// headers. This also keeps cross-compilation working on CI runners where
+// `addTranslateC` blows up with `CacheCheckFailed` for cross targets.
+//
+// On Windows we use UCRT's `_findfirst`/`__acrt_iob_func` family. On POSIX
+// (Linux + the BSD-derived Apple platforms) we use stdio + dirent + open(2)
+// directly. Stdio FILE* globals have different external symbol names
+// across libcs (`stdin`/`stdout`/`stderr` on glibc/musl, `__stdinp` etc.
+// on Apple), so we expose them as functions that resolve via `@extern`.
 const c = if (builtin.os.tag == .windows) struct {
     pub const FILE = opaque {};
     pub extern "c" fn __acrt_iob_func(index: c_int) *FILE;
@@ -34,14 +43,59 @@ const c = if (builtin.os.tag == .windows) struct {
     pub extern "c" fn _findnext(handle: isize, fileinfo: *_finddata_t) c_int;
     pub extern "c" fn _findclose(handle: isize) c_int;
     pub extern "c" fn _mkdir(path: [*:0]const u8) c_int;
-} else @cImport({
-    @cInclude("stdio.h");
-    @cInclude("stdlib.h");
-    @cInclude("dirent.h");
-    @cInclude("sys/stat.h");
-    @cInclude("fcntl.h");
-    @cInclude("unistd.h");
-});
+} else struct {
+    pub const FILE = opaque {};
+
+    /// True when targeting a BSD-derived libc (Darwin, FreeBSD, DragonFly).
+    /// These share the `__stdinp` / `__stdoutp` / `__stderrp` stdio symbol
+    /// naming and the BSD-style hex `O_CREAT`/`O_TRUNC` flag values, both
+    /// of which differ from glibc/musl Linux.
+    const bsd_libc = builtin.os.tag.isDarwin() or
+        builtin.os.tag == .freebsd or
+        builtin.os.tag == .dragonfly;
+
+    pub extern "c" fn fopen(path: [*:0]const u8, mode: [*:0]const u8) ?*FILE;
+    pub extern "c" fn fclose(stream: *FILE) c_int;
+    pub extern "c" fn fread(ptr: [*]u8, size: usize, nmemb: usize, stream: *FILE) usize;
+    pub extern "c" fn fwrite(ptr: [*]const u8, size: usize, nmemb: usize, stream: *FILE) usize;
+    pub extern "c" fn fseek(stream: *FILE, offset: c_long, whence: c_int) c_int;
+    pub extern "c" fn ftell(stream: *FILE) c_long;
+    pub const SEEK_SET: c_int = 0;
+    pub const SEEK_END: c_int = 2;
+
+    pub extern "c" fn open(path: [*:0]const u8, flags: c_int, ...) c_int;
+    pub extern "c" fn openat(dirfd: c_int, path: [*:0]const u8, flags: c_int, ...) c_int;
+    pub extern "c" fn close(fd: c_int) c_int;
+    pub extern "c" fn read(fd: c_int, buf: [*]u8, count: usize) isize;
+    pub extern "c" fn write(fd: c_int, buf: [*]const u8, count: usize) isize;
+    pub extern "c" fn lseek(fd: c_int, offset: c_long, whence: c_int) c_long;
+    pub extern "c" fn mkdir(path: [*:0]const u8, mode: c_uint) c_int;
+
+    // fcntl.h flag values. BSD-derived libcs (Darwin/FreeBSD/DragonFly) use
+    // hex bits; glibc/musl Linux use octal — these specific constants are
+    // mutually inconsistent so we have to pick per OS.
+    pub const O_RDONLY: c_int = 0;
+    pub const O_WRONLY: c_int = 1;
+    pub const O_CREAT: c_int = if (bsd_libc) 0x0200 else 0o100;
+    pub const O_TRUNC: c_int = if (bsd_libc) 0x0400 else 0o1000;
+
+    // Stdio FILE* globals. The on-disk symbol names differ between BSD
+    // libcs (`__stdinp` etc.) and glibc/musl (`stdin` etc.), so resolve
+    // them via @extern. Exposed as functions so getStdioPtr's
+    // "function-like" branch picks them up correctly.
+    pub fn stdin() *FILE {
+        const ptr = @extern(**FILE, .{ .name = if (bsd_libc) "__stdinp" else "stdin" });
+        return ptr.*;
+    }
+    pub fn stdout() *FILE {
+        const ptr = @extern(**FILE, .{ .name = if (bsd_libc) "__stdoutp" else "stdout" });
+        return ptr.*;
+    }
+    pub fn stderr() *FILE {
+        const ptr = @extern(**FILE, .{ .name = if (bsd_libc) "__stderrp" else "stderr" });
+        return ptr.*;
+    }
+};
 
 fn getStdout() *c.FILE {
     if (builtin.os.tag == .windows) return c.__acrt_iob_func(1);
@@ -150,15 +204,19 @@ fn collectTsFiles(alloc: std.mem.Allocator, dir_path: []const u8) ![][]const u8
             if (c._findnext(handle, &fdata) != 0) break;
         }
     } else {
-        // POSIX: use opendir/readdir
+        // POSIX: use std.c's per-platform `dirent` layout + `opendir` /
+        // `readdir` / `closedir`. Zig's std already encodes the right
+        // struct shape for glibc/musl, Darwin, FreeBSD, DragonFly, etc.,
+        // so we don't have to (and `readdir` is dispatched to the right
+        // symbol on macOS x86_64 — `readdir$INODE64` — automatically).
         const dir_z = try alloc.dupeZ(u8, dir_path);
         defer alloc.free(dir_z);
 
-        const dir = c.opendir(dir_z.ptr) orelse return files.toOwnedSlice();
-        defer _ = c.closedir(dir);
+        const dir = std.c.opendir(dir_z.ptr) orelse return files.toOwnedSlice();
+        defer _ = std.c.closedir(dir);
 
-        while (c.readdir(dir)) |entry| {
-            const name_ptr: [*:0]const u8 = @ptrCast(&entry.*.d_name);
+        while (std.c.readdir(dir)) |entry| {
+            const name_ptr: [*:0]const u8 = @ptrCast(&entry.*.name);
             const name = std.mem.span(name_ptr);
             if (std.mem.endsWith(u8, name, ".ts") and !std.mem.endsWith(u8, name, ".d.ts")) {
                 try files.append(try alloc.dupe(u8, name));
@@ -185,77 +243,50 @@ const WorkerCtx = struct {
 
 /// Worker: read + process + write each file using thread-local arena.
 /// Uses POSIX openat for directory-relative I/O (no path resolution overhead).
+/// Arena is reset every N files to batch allocations and reduce overhead.
 fn workerFn(ctx: WorkerCtx) void {
     var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     defer arena.deinit();
     const default_import_order = [_][]const u8{"bun"};
+    var files_since_reset: usize = 0;
 
     for (ctx.tasks) |task| {
         const alloc = arena.allocator();
 
         if (builtin.os.tag == .windows) {
-            // Windows: C stdio with full paths
-            const fp = c.fopen(task.input_name_z, "rb") orelse {
-                _ = arena.reset(.retain_capacity);
-                continue;
-            };
+            const fp = c.fopen(task.input_name_z, "rb") orelse continue;
             _ = c.fseek(fp, 0, c.SEEK_END);
             const tell_result = c.ftell(fp);
-            if (tell_result < 0) {
-                _ = c.fclose(fp);
-                _ = arena.reset(.retain_capacity);
-                continue;
-            }
+            if (tell_result < 0) { _ = c.fclose(fp); continue; }
             const size: usize = @intCast(tell_result);
             _ = c.fseek(fp, 0, c.SEEK_SET);
-            const buf = alloc.alloc(u8, size) catch {
-                _ = c.fclose(fp);
-                _ = arena.reset(.retain_capacity);
-                continue;
-            };
+            const buf = alloc.alloc(u8, size) catch { _ = c.fclose(fp); continue; };
             const nread = c.fread(buf.ptr, 1, size, fp);
             _ = c.fclose(fp);
 
             var scanner = Scanner.init(alloc, buf[0..nread], task.keep_comments, false);
-            _ = scanner.scan() catch {
-                _ = arena.reset(.retain_capacity);
-                continue;
-            };
+            _ = scanner.scan() catch continue;
             const output = emitter.processDeclarations(
                 alloc, alloc, scanner.declarations.items, buf[0..nread],
                 task.keep_comments, &default_import_order,
-            ) catch {
-                _ = arena.reset(.retain_capacity);
-                continue;
-            };
+            ) catch continue;
 
-            const out_fp = c.fopen(task.output_name_z, "wb") orelse {
-                _ = arena.reset(.retain_capacity);
-                continue;
-            };
+            const out_fp = c.fopen(task.output_name_z, "wb") orelse continue;
             _ = c.fwrite(output.ptr, 1, output.len, out_fp);
             _ = c.fwrite("\n", 1, 1, out_fp);
             _ = c.fclose(out_fp);
         } else {
-            // POSIX: openat + read/write (no path resolution overhead)
+            // POSIX: openat + fstat + read (fewer syscalls than lseek+lseek+read)
             const fd = c.openat(ctx.input_dir_fd, task.input_name_z, c.O_RDONLY);
-            if (fd < 0) {
-                _ = arena.reset(.retain_capacity);
-                continue;
-            }
+            if (fd < 0) continue;
+
+            // Use lseek to get file size (avoids opaque cimport struct_stat)
             const end_off = c.lseek(fd, 0, 2); // SEEK_END
-            if (end_off < 0) {
-                _ = c.close(fd);
-                _ = arena.reset(.retain_capacity);
-                continue;
-            }
+            if (end_off < 0) { _ = c.close(fd); continue; }
             _ = c.lseek(fd, 0, 0); // SEEK_SET
             const size: usize = @intCast(end_off);
-            const buf = alloc.alloc(u8, size) catch {
-                _ = c.close(fd);
-                _ = arena.reset(.retain_capacity);
-                continue;
-            };
+
+            const buf = alloc.alloc(u8, size) catch { _ = c.close(fd); continue; };
             var total: usize = 0;
             while (total < size) {
                 const n = c.read(fd, @ptrCast(buf.ptr + total), size - total);
@@ -266,35 +297,32 @@ fn workerFn(ctx: WorkerCtx) void {
             const source = buf[0..total];
 
             var scanner = Scanner.init(alloc, source, task.keep_comments, false);
-            _ = scanner.scan() catch {
-                _ = arena.reset(.retain_capacity);
-                continue;
-            };
+            _ = scanner.scan() catch continue;
             const output = emitter.processDeclarations(
                 alloc, alloc, scanner.declarations.items, source,
                 task.keep_comments, &default_import_order,
-            ) catch {
-                _ = arena.reset(.retain_capacity);
-                continue;
-            };
+            ) catch continue;
 
-            // Combined write: data + "\n" in single syscall
-            const combined = alloc.alloc(u8, output.len + 1) catch {
-                _ = arena.reset(.retain_capacity);
-                continue;
-            };
-            @memcpy(combined[0..output.len], output);
-            combined[output.len] = '\n';
+            // Single-syscall write: overwrite the null terminator with '\n'.
+            // The emitter appends '\0' after content, so output.ptr[output.len] == 0.
+            // Since output is arena-allocated, the byte is writable.
+            @as([*]u8, @constCast(output.ptr))[output.len] = '\n';
 
             const out_fd = c.openat(ctx.output_dir_fd, task.output_name_z,
                 c.O_WRONLY | c.O_CREAT | c.O_TRUNC, @as(c_uint, 0o644));
             if (out_fd >= 0) {
-                _ = c.write(out_fd, @ptrCast(combined.ptr), combined.len);
+                _ = c.write(out_fd, @ptrCast(output.ptr), output.len + 1);
                 _ = c.close(out_fd);
             }
         }
 
-        _ = arena.reset(.retain_capacity);
+        files_since_reset += 1;
+        // Batch arena reset: every 4 files to amortize reset overhead.
+        // Typical file processing uses ~50-200KB; 4 files fits comfortably.
+        if (files_since_reset >= 4) {
+            _ = arena.reset(.retain_capacity);
+            files_since_reset = 0;
+        }
     }
 }
 
@@ -366,9 +394,10 @@ fn processProject(alloc: std.mem.Allocator, project_dir: []const u8, out_dir: []
         }
     }
 
-    // Thread pool — use all CPU cores for mixed I/O + compute workload
+    // Thread pool — cap threads to avoid spawn/join overhead dominating for small projects.
+    // Each thread needs ~8 files minimum to amortize ~100µs spawn+join cost.
     const cpu_count = std.Thread.getCpuCount() catch 4;
-    const max_threads = @min(cpu_count, filenames.len);
+    const max_threads = @min(cpu_count, @max(filenames.len / 8, 1));
 
     if (max_threads <= 1) {
         workerFn(.{ .input_dir_fd = input_dir_fd, .output_dir_fd = output_dir_fd, .tasks = tasks });
@@ -379,7 +408,9 @@ fn processProject(alloc: std.mem.Allocator, project_dir: []const u8, out_dir: []
     const remainder = filenames.len % max_threads;
     const threads = try sa.alloc(std.Thread, max_threads);
 
-    var thread_spawned: [256]bool = .{false} ** 256; // max 256 threads
+    // Heap-allocate so >256-core machines don't silently truncate.
+    const thread_spawned = try sa.alloc(bool, max_threads);
+    @memset(thread_spawned, false);
     var offset: usize = 0;
     for (0..max_threads) |t| {
         const count = files_per_thread + @as(usize, if (t < remainder) 1 else 0);

package/src/scan_loop.zig

@@ -16,21 +16,38 @@ pub fn scanMainLoop(s: *Scanner) !void {
         const stmt_start = s.pos;
         const ch0 = s.source[s.pos];
 
-        if (ch0 == 'i' and s.matchWord("import")) {
-            const decl = ext.extractImport(s, stmt_start);
-            try s.declarations.append(decl);
-        } else if (ch0 == 'e' and s.matchWord("export")) {
-            try handleExport(s, stmt_start);
+        if (ch0 == 'i') {
+            // Combined dispatch for both 'i'-keywords ("import" / "interface") —
+            // saves an extra first-char check vs the previous separate branches.
+            if (s.matchWord("import")) {
+                const decl = ext.extractImport(s, stmt_start);
+                try s.declarations.append(decl);
+            } else if (s.matchWord("interface")) {
+                const decl = ext.extractInterface(s, stmt_start, false);
+                s.putNonExportedType(decl.name, decl);
+            } else {
+                s.pos += 1;
+                s.skipToStatementEnd();
+            }
+        } else if (ch0 == 'e') {
+            // Combined dispatch for "export" / "enum".
+            if (s.matchWord("export")) {
+                try handleExport(s, stmt_start);
+            } else if (s.matchWord("enum")) {
+                const decl = ext.extractEnum(s, stmt_start, false, false);
+                s.putNonExportedType(decl.name, decl);
+                try s.declarations.append(decl);
+            } else {
+                s.pos += 1;
+                s.skipToStatementEnd();
+            }
         } else if (ch0 == 'd' and s.matchWord("declare")) {
             s.pos += 7;
             s.skipWhitespaceAndComments();
             ext.handleDeclare(s, stmt_start, false);
-        } else if (ch0 == 'i' and s.matchWord("interface")) {
-            const decl = ext.extractInterface(s, stmt_start, false);
-            s.non_exported_types.put(decl.name, decl) catch {};
         } else if (ch0 == 't' and s.matchWord("type")) {
             const decl = ext.extractTypeAlias(s, stmt_start, false);
-            s.non_exported_types.put(decl.name, decl) catch {};
+            s.putNonExportedType(decl.name, decl);
             try s.declarations.append(decl);
         } else if (ch0 == 'f' and s.matchWord("function")) {
             s.skipToStatementEnd();
@@ -42,7 +59,7 @@ pub fn scanMainLoop(s: *Scanner) !void {
                 s.skipWhitespaceAndComments();
                 if (s.matchWord("class")) {
                     const decl = ext.extractClass(s, stmt_start, false, false);
-                    s.non_exported_types.put(decl.name, decl) catch {};
+                    s.putNonExportedType(decl.name, decl);
                     try s.declarations.append(decl);
                 } else {
                     s.skipToStatementEnd();
@@ -54,7 +71,7 @@ pub fn scanMainLoop(s: *Scanner) !void {
         } else if (ch0 == 'c') {
             if (s.matchWord("class")) {
                 const decl = ext.extractClass(s, stmt_start, false, false);
-                s.non_exported_types.put(decl.name, decl) catch {};
+                s.putNonExportedType(decl.name, decl);
                 try s.declarations.append(decl);
             } else if (s.matchWord("const")) {
                 const saved_pos = s.pos;
@@ -64,7 +81,7 @@ pub fn scanMainLoop(s: *Scanner) !void {
                     s.pos = saved_pos + 5;
                     s.skipWhitespaceAndComments();
                     const decl = ext.extractEnum(s, stmt_start, false, true);
-                    s.non_exported_types.put(decl.name, decl) catch {};
+                    s.putNonExportedType(decl.name, decl);
                     try s.declarations.append(decl);
                 } else {
                     s.pos = saved_pos;
@@ -74,19 +91,14 @@ pub fn scanMainLoop(s: *Scanner) !void {
                 s.pos += 1;
                 s.skipToStatementEnd();
             }
-        } else if (ch0 == 'e' and s.matchWord("enum")) {
-            const decl = ext.extractEnum(s, stmt_start, false, false);
-            s.non_exported_types.put(decl.name, decl) catch {};
-            try s.declarations.append(decl);
-        } else if (ch0 == 'l' and s.matchWord("let")) {
+        } else if ((ch0 == 'l' and s.matchWord("let")) or (ch0 == 'v' and s.matchWord("var"))) {
+            // Top-level let/var without `export` are skipped — same handling for both.
             s.skipToStatementEnd();
-        } else if (ch0 == 'v' and s.matchWord("var")) {
-            s.skipToStatementEnd();
-        } else if (ch0 == 'm' and s.matchWord("module")) {
-            const decl = ext.extractModule(s, stmt_start, false, "module");
-            try s.declarations.append(decl);
-        } else if (ch0 == 'n' and s.matchWord("namespace")) {
-            const decl = ext.extractModule(s, stmt_start, false, "namespace");
+        } else if ((ch0 == 'm' and s.matchWord("module")) or (ch0 == 'n' and s.matchWord("namespace"))) {
+            // Both module/namespace dispatch to the same extractor; share the
+            // append step and pick the keyword from the first byte.
+            const kw: []const u8 = if (ch0 == 'm') "module" else "namespace";
+            const decl = ext.extractModule(s, stmt_start, false, kw);
             try s.declarations.append(decl);
         } else {
             // Skip unknown top-level content
@@ -133,34 +145,51 @@ fn handleExport(s: *Scanner, stmt_start: usize) !void {
         if (dch == 'f' and s.matchWord("function")) {
             const decl = ext.extractFunction(s, stmt_start, true, false, true);
             if (decl) |d| try s.declarations.append(d);
-        } else if (dch == 'a' and s.matchWord("async")) {
-            s.pos += 5;
-            s.skipWhitespaceAndComments();
-            if (s.matchWord("function")) {
-                const decl = ext.extractFunction(s, stmt_start, true, true, true);
-                if (decl) |d| try s.declarations.append(d);
+        } else if (dch == 'c' and s.matchWord("class")) {
+            const decl = ext.extractClass(s, stmt_start, true, false);
+            try s.declarations.append(decl);
+        } else if (dch == 'a') {
+            // Combined dispatch — both async and abstract start with 'a',
+            // and only one matchWord runs per code path.
+            if (s.matchWord("async")) {
+                s.pos += 5;
+                s.skipWhitespaceAndComments();
+                if (s.matchWord("function")) {
+                    const decl = ext.extractFunction(s, stmt_start, true, true, true);
+                    if (decl) |d| try s.declarations.append(d);
+                } else {
+                    s.skipToStatementEnd();
+                    const full_text = s.sliceTrimmed(stmt_start, s.pos);
+                    try s.declarations.append(.{
+                        .kind = .export_decl,
+                        .name = "default",
+                        .text = full_text,
+                        .is_exported = true,
+                        .start = stmt_start,
+                        .end = s.pos,
+                    });
+                }
+            } else if (s.matchWord("abstract")) {
+                s.pos += 8;
+                s.skipWhitespaceAndComments();
+                if (s.matchWord("class")) {
+                    const decl = ext.extractClass(s, stmt_start, true, true);
+                    try s.declarations.append(decl);
+                }
             } else {
                 s.skipToStatementEnd();
-                const full_text = s.sliceTrimmed(stmt_start, s.pos);
+                const text = s.sliceTrimmed(stmt_start, s.pos);
+                const comments = ext.extractLeadingComments(s, stmt_start);
                 try s.declarations.append(.{
                     .kind = .export_decl,
                     .name = "default",
-                    .text = full_text,
+                    .text = text,
                     .is_exported = true,
+                    .leading_comments = comments,
                     .start = stmt_start,
                     .end = s.pos,
                 });
             }
-        } else if (dch == 'c' and s.matchWord("class")) {
-            const decl = ext.extractClass(s, stmt_start, true, false);
-            try s.declarations.append(decl);
-        } else if (dch == 'a' and s.matchWord("abstract")) {
-            s.pos += 8;
-            s.skipWhitespaceAndComments();
-            if (s.matchWord("class")) {
-                const decl = ext.extractClass(s, stmt_start, true, true);
-                try s.declarations.append(decl);
-            }
         } else {
             s.skipToStatementEnd();
             const text = s.sliceTrimmed(stmt_start, s.pos);
@@ -216,12 +245,25 @@ fn handleExport(s: *Scanner, stmt_start: usize) !void {
     } else if (ech == 'f' and s.matchWord("function")) {
         const decl = ext.extractFunction(s, stmt_start, true, false, false);
         if (decl) |d| try s.declarations.append(d);
-    } else if (ech == 'a' and s.matchWord("async")) {
-        s.pos += 5;
-        s.skipWhitespaceAndComments();
-        if (s.matchWord("function")) {
-            const decl = ext.extractFunction(s, stmt_start, true, true, false);
-            if (decl) |d| try s.declarations.append(d);
+    } else if (ech == 'a') {
+        // Combined dispatch — both async and abstract start with 'a',
+        // and only one matchWord runs in any given path.
+        if (s.matchWord("async")) {
+            s.pos += 5;
+            s.skipWhitespaceAndComments();
+            if (s.matchWord("function")) {
+                const decl = ext.extractFunction(s, stmt_start, true, true, false);
+                if (decl) |d| try s.declarations.append(d);
+            } else {
+                s.skipToStatementEnd();
+            }
+        } else if (s.matchWord("abstract")) {
+            s.pos += 8;
+            s.skipWhitespaceAndComments();
+            if (s.matchWord("class")) {
+                const decl = ext.extractClass(s, stmt_start, true, true);
+                try s.declarations.append(decl);
+            }
         } else {
             s.skipToStatementEnd();
         }
@@ -246,13 +288,6 @@ fn handleExport(s: *Scanner, stmt_start: usize) !void {
         } else {
             s.skipToStatementEnd();
         }
-    } else if (ech == 'a' and s.matchWord("abstract")) {
-        s.pos += 8;
-        s.skipWhitespaceAndComments();
-        if (s.matchWord("class")) {
-            const decl = ext.extractClass(s, stmt_start, true, true);
-            try s.declarations.append(decl);
-        }
     } else if (ech == 'l' and s.matchWord("let")) {
         const decls = ext.extractVariable(s, stmt_start, "let", true);
         for (decls) |d| try s.declarations.append(d);
@@ -266,16 +301,17 @@ fn handleExport(s: *Scanner, stmt_start: usize) !void {
         s.pos += 7;
         s.skipWhitespaceAndComments();
         ext.handleDeclare(s, stmt_start, true);
-    } else if (ech == 'n' and s.matchWord("namespace")) {
-        const decl = ext.extractModule(s, stmt_start, true, "namespace");
-        try s.declarations.append(decl);
-    } else if (ech == 'm' and s.matchWord("module")) {
-        const decl = ext.extractModule(s, stmt_start, true, "module");
+    } else if ((ech == 'n' and s.matchWord("namespace")) or (ech == 'm' and s.matchWord("module"))) {
+        // Same extractor for both — pick the keyword from the first byte.
+        const kw: []const u8 = if (ech == 'n') "namespace" else "module";
+        const decl = ext.extractModule(s, stmt_start, true, kw);
         try s.declarations.append(decl);
     } else if (ech == ch.CH_LBRACE) {
         s.skipExportBraces();
         const text = s.sliceTrimmed(stmt_start, s.pos);
-        const is_type_only = ch.contains(text, "export type");
+        // type-only exports start with "export type {…} " — use startsWith
+        // instead of scanning the entire text with ch.contains.
+        const is_type_only = ch.startsWith(text, "export type");
         const comments = ext.extractLeadingComments(s, stmt_start);
         try s.declarations.append(.{
             .kind = .export_decl,
@@ -291,16 +327,16 @@ fn handleExport(s: *Scanner, stmt_start: usize) !void {
         s.skipExportStar();
         const text = s.sliceTrimmed(stmt_start, s.pos);
         const comments = ext.extractLeadingComments(s, stmt_start);
-        // Extract source from 'from "..."'
+        // Extract source from 'from "..."'. indexOfChar is the single-byte
+        // SIMD path; the previous indexOf with a 1-char needle was strictly slower.
         var export_source: []const u8 = "";
         const from_idx = ch.indexOf(text, "from ", 0);
         if (from_idx) |fi| {
             var qi = fi + 5;
             while (qi < text.len and (text[qi] == ' ' or text[qi] == '\t')) qi += 1;
             if (qi < text.len and (text[qi] == '\'' or text[qi] == '"')) {
-                const q_str: []const u8 = if (text[qi] == '\'') "'" else "\"";
-                const q_end = ch.indexOf(text, q_str, qi + 1);
-                if (q_end) |qe| export_source = text[qi + 1 .. qe];
+                const quote = text[qi];
+                if (ch.indexOfChar(text, quote, qi + 1)) |qe| export_source = text[qi + 1 .. qe];
             }
         }
         try s.declarations.append(.{