@stacksjs/zig-dtsx 0.9.13 → 0.9.14

package/src/emitter.zig

@@ -12,29 +12,40 @@ inline fn isIdentChar(c: u8) bool {
     return (c >= 'A' and c <= 'Z') or (c >= 'a' and c <= 'z') or (c >= '0' and c <= '9') or c == '_' or c == '$' or c > 127;
 }
 
-/// Check if `name` appears as a whole word in `text` (fast indexOf + boundary check)
-pub fn isWordInText(name: []const u8, text: []const u8) bool {
-    if (name.len == 0) return false;
-    var search_from: usize = 0;
-    while (search_from < text.len) {
-        const idx = ch.indexOf(text, name, search_from) orelse return false;
-        const before: u8 = if (idx > 0) text[idx - 1] else ' ';
-        const after: u8 = if (idx + name.len < text.len) text[idx + name.len] else ' ';
-        if (!isIdentChar(before) and !isIdentChar(after)) return true;
-        search_from = idx + 1;
-    }
-    return false;
-}
+/// Check if `name` appears as a whole word in `text` — delegated to scanner.zig (single source of truth)
+pub const isWordInText = @import("scanner.zig").isWordInText;
 
-/// Extract all identifier words from text into an existing HashMap (single pass, O(n))
+/// Extract all identifier words from text into an existing HashMap (single pass, O(n)).
+/// Uses SIMD to skip 16 non-identifier bytes at a time.
 fn extractWords(words: *std.StringHashMap(void), text: []const u8) void {
     var i: usize = 0;
     while (i < text.len) {
+        // SIMD fast-skip: tighten the "interesting byte" predicate to actual
+        // identifier-start chars. Previously the `>= 'A'` check accepted brace
+        // and bracket characters too (all in 91..96, 123..126), causing
+        // unnecessary scalar fall-throughs for type-heavy declarations.
+        while (i + 16 <= text.len) {
+            const chunk: @Vector(16, u8) = text[i..][0..16].*;
+            const upper = (chunk >= @as(@Vector(16, u8), @splat('A'))) & (chunk <= @as(@Vector(16, u8), @splat('Z')));
+            const lower = (chunk >= @as(@Vector(16, u8), @splat('a'))) & (chunk <= @as(@Vector(16, u8), @splat('z')));
+            const is_dollar = chunk == @as(@Vector(16, u8), @splat('$'));
+            const is_under = chunk == @as(@Vector(16, u8), @splat('_'));
+            const is_high = chunk > @as(@Vector(16, u8), @splat(127));
+            const interesting = upper | lower | is_dollar | is_under | is_high;
+            if (@reduce(.Or, interesting)) {
+                const bits: u16 = @bitCast(interesting);
+                i += @ctz(bits);
+                break;
+            }
+            i += 16;
+        }
+        if (i >= text.len) break;
+
         const c = text[i];
-        if ((c >= 'A' and c <= 'Z') or (c >= 'a' and c <= 'z') or c == '_' or c == '$' or c > 127) {
+        if (ch.isIdentStart(c)) {
             const start = i;
             i += 1;
-            while (i < text.len and isIdentChar(text[i])) i += 1;
+            while (i < text.len and ch.isIdentChar(text[i])) i += 1;
             words.put(text[start..i], {}) catch {};
         } else {
             i += 1;
@@ -45,6 +56,8 @@ fn extractWords(words: *std.StringHashMap(void), text: []const u8) void {
 /// Extract triple-slash directives from source start
 fn extractTripleSlashDirectives(alloc: std.mem.Allocator, source: []const u8) ![][]const u8 {
     var directives = std.array_list.Managed([]const u8).init(alloc);
+    // Pre-allocate small capacity — typical files have 0-3 directives.
+    try directives.ensureTotalCapacity(2);
     var line_start: usize = 0;
 
     var i: usize = 0;
@@ -59,8 +72,14 @@ fn extractTripleSlashDirectives(alloc: std.mem.Allocator, source: []const u8) ![
             line_start = i + 1;
 
             if (trimmed.len >= 3 and trimmed[0] == '/' and trimmed[1] == '/' and trimmed[2] == '/') {
-                // Check for /// <reference .../>
-                if (ch.contains(trimmed, "<reference ") or ch.contains(trimmed, "<amd-module ") or ch.contains(trimmed, "<amd-dependency ")) {
+                // Inline char-by-char check: avoids three full ch.contains scans.
+                // Look for "<reference ", "<amd-module ", "<amd-dependency ".
+                const lt = ch.indexOfChar(trimmed, '<', 3) orelse continue;
+                const tail = trimmed[lt..];
+                if ((tail.len > 11 and std.mem.eql(u8, tail[0..11], "<reference ")) or
+                    (tail.len > 12 and std.mem.eql(u8, tail[0..12], "<amd-module ")) or
+                    (tail.len > 16 and std.mem.eql(u8, tail[0..16], "<amd-dependency ")))
+                {
                     try directives.append(trimmed);
                 }
             } else if (trimmed.len == 0 or (trimmed.len >= 2 and trimmed[0] == '/' and trimmed[1] == '/')) {
@@ -74,7 +93,7 @@ fn extractTripleSlashDirectives(alloc: std.mem.Allocator, source: []const u8) ![
     return directives.toOwnedSlice();
 }
 
-/// Format leading comments — direct alloc, output ≤ total comment length + newlines
+/// Format leading comments — avoids allocation for the most common case (single comment).
 fn formatComments(alloc: std.mem.Allocator, comments: ?[]const []const u8, keep_comments: bool) ![]const u8 {
     if (!keep_comments) return "";
     const cmts = comments orelse return "";
@@ -82,28 +101,49 @@ fn formatComments(alloc: std.mem.Allocator, comments: ?[]const []const u8, keep_
 
     // Fast path: single comment (very common)
     if (cmts.len == 1) {
-        const t = ch.sliceTrimmed(cmts[0], 0, cmts[0].len);
+        const raw = cmts[0];
+        const t = ch.sliceTrimmed(raw, 0, raw.len);
+        // Zero-alloc fast path: if the trimmed comment is the full slice AND
+        // there's a '\n' right after it in memory, return a slice that includes
+        // the newline. This works because comments point into the source buffer.
+        if (t.len == raw.len and t.len > 0) {
+            // Check if the byte after the comment in the source buffer is '\n'
+            const end_ptr = t.ptr + t.len;
+            if (@intFromPtr(end_ptr) > 0 and end_ptr[0] == '\n') {
+                return t.ptr[0 .. t.len + 1];
+            }
+        }
         const buf = try alloc.alloc(u8, t.len + 1);
         @memcpy(buf[0..t.len], t);
         buf[t.len] = '\n';
         return buf;
     }
 
-    // Pre-compute exact size
+    // Two-pass approach: cache trimmed slices in a small stack-allocated array
+    // when the count is reasonable, or a heap-allocated array otherwise. This
+    // avoids running sliceTrimmed twice for each comment.
+    var inline_buf: [8][]const u8 = undefined;
+    const trimmed_slices = if (cmts.len <= inline_buf.len)
+        inline_buf[0..cmts.len]
+    else
+        try alloc.alloc([]const u8, cmts.len);
+    defer if (cmts.len > inline_buf.len) alloc.free(trimmed_slices);
+
     var total_len: usize = cmts.len; // newlines between + trailing
-    for (cmts) |c| {
+    for (cmts, 0..) |c, i| {
         const t = ch.sliceTrimmed(c, 0, c.len);
+        trimmed_slices[i] = t;
         total_len += t.len;
     }
 
     const buf = try alloc.alloc(u8, total_len);
-    var pos: usize = 0;
-    for (cmts, 0..) |c, idx| {
-        if (idx > 0) {
-            buf[pos] = '\n';
-            pos += 1;
-        }
-        const t = ch.sliceTrimmed(c, 0, c.len);
+    // First slice — write without leading newline.
+    @memcpy(buf[0..trimmed_slices[0].len], trimmed_slices[0]);
+    var pos: usize = trimmed_slices[0].len;
+    // Subsequent slices — newline-separated.
+    for (trimmed_slices[1..]) |t| {
+        buf[pos] = '\n';
+        pos += 1;
         @memcpy(buf[pos..][0..t.len], t);
         pos += t.len;
     }
@@ -156,10 +196,13 @@ fn processVariableDeclaration(alloc: std.mem.Allocator, decl: Declaration, keep_
     // The scanner already built the correct DTS text using the type annotation,
     // so we can return it directly without type inference or value processing.
     if (decl.type_annotation.len > 0 and decl.value.len > 0) {
-        const trimmed_val = std.mem.trim(u8, decl.value, " \t\n\r");
-        if (!ch.endsWith(trimmed_val, "as const") and
-            !ch.contains(decl.value, " satisfies "))
-        {
+        // Cheaper "ends with as const" check that skips the trim allocation.
+        // We just need to ignore trailing whitespace.
+        var ve: usize = decl.value.len;
+        while (ve > 0 and (decl.value[ve - 1] == ' ' or decl.value[ve - 1] == '\t' or
+            decl.value[ve - 1] == '\n' or decl.value[ve - 1] == '\r')) : (ve -= 1) {}
+        const ends_as_const = ve >= 8 and std.mem.eql(u8, decl.value[ve - 8 .. ve], "as const");
+        if (!ends_as_const and !ch.contains(decl.value, " satisfies ")) {
             const kind: []const u8 = if (decl.modifiers) |mods| (if (mods.len > 0) mods[0] else "const") else "const";
             if (!std.mem.eql(u8, kind, "const") or !type_inf.isGenericType(decl.type_annotation)) {
                 if (comments.len == 0) return decl.text;
@@ -200,18 +243,24 @@ fn processVariableDeclaration(alloc: std.mem.Allocator, decl: Declaration, keep_
     if (type_annotation.len == 0) type_annotation = "unknown";
 
     // Add @defaultValue JSDoc for widened declarations
-    // Skip when value uses 'as const' — types are already narrow/self-documenting
+    // Skip when value uses 'as const' — types are already narrow/self-documenting.
+    // Cache the trimmed value so we don't trim a second time below.
     const val_trimmed_for_check = std.mem.trim(u8, decl.value, " \t\n\r");
     const has_as_const = ch.endsWith(val_trimmed_for_check, "as const");
     if (decl.value.len > 0 and decl.type_annotation.len == 0 and !has_as_const) {
         var default_val: ?[]const u8 = null;
         var is_container = false;
-        const trimmed_val = std.mem.trim(u8, decl.value, " \t\n\r");
+        const trimmed_val = val_trimmed_for_check;
 
         if (!std.mem.eql(u8, kind, "const")) {
-            const is_widened = std.mem.eql(u8, type_annotation, "string") or
-                std.mem.eql(u8, type_annotation, "number") or
-                std.mem.eql(u8, type_annotation, "boolean");
+            // Length-first dispatch — three primitive types have distinct lengths
+            // (string=6, number=6, boolean=7) so we can short-circuit before
+            // running std.mem.eql on a non-matching annotation.
+            const is_widened = switch (type_annotation.len) {
+                6 => std.mem.eql(u8, type_annotation, "string") or std.mem.eql(u8, type_annotation, "number"),
+                7 => std.mem.eql(u8, type_annotation, "boolean"),
+                else => false,
+            };
             if (is_widened and trimmed_val.len > 0) {
                 default_val = trimmed_val;
             }
@@ -231,7 +280,7 @@ fn processVariableDeclaration(alloc: std.mem.Allocator, decl: Declaration, keep_
             const tag_mem = try alloc.alloc(u8, tag_max);
             var tp: usize = 0;
 
-            if (std.mem.indexOf(u8, dv, "\n")) |_| {
+            if (std.mem.indexOfScalar(u8, dv, '\n')) |_| {
                 const hdr = "@defaultValue\n * ```ts\n";
                 @memcpy(tag_mem[tp..][0..hdr.len], hdr); tp += hdr.len;
                 var line_iter = std.mem.splitScalar(u8, dv, '\n');
@@ -265,7 +314,7 @@ fn processVariableDeclaration(alloc: std.mem.Allocator, decl: Declaration, keep_
                 var end = before_raw.len;
                 while (end > 0 and (before_raw[end - 1] == ' ' or before_raw[end - 1] == '\t' or before_raw[end - 1] == '\n' or before_raw[end - 1] == '\r')) : (end -= 1) {}
                 const before = before_raw[0..end];
-                if (before.len > 4 and ch.startsWith(before, "/** ") and std.mem.indexOf(u8, before, "\n") == null) {
+                if (before.len > 4 and ch.startsWith(before, "/** ") and std.mem.indexOfScalar(u8, before, '\n') == null) {
                     @memcpy(rbuf[rp..][0..7], "/**\n * "); rp += 7;
                     @memcpy(rbuf[rp..][0..before.len - 4], before[4..]); rp += before.len - 4;
                 } else {
@@ -288,7 +337,7 @@ fn processVariableDeclaration(alloc: std.mem.Allocator, decl: Declaration, keep_
                 @memcpy(rbuf[rp..][0..default_tag.len], default_tag); rp += default_tag.len;
                 @memcpy(rbuf[rp..][0..5], "\n */\n"); rp += 5;
             } else {
-                if (std.mem.indexOf(u8, default_tag, "\n") != null) {
+                if (std.mem.indexOfScalar(u8, default_tag, '\n') != null) {
                     @memcpy(rbuf[rp..][0..7], "/**\n * "); rp += 7;
                     @memcpy(rbuf[rp..][0..default_tag.len], default_tag); rp += default_tag.len;
                     @memcpy(rbuf[rp..][0..5], "\n */\n"); rp += 5;
@@ -496,29 +545,22 @@ fn processModuleDeclaration(alloc: std.mem.Allocator, decl: Declaration, keep_co
         (decl.name.len > 0 and (decl.name[0] == '"' or decl.name[0] == '\'' or decl.name[0] == '`'));
 
     if (is_ambient) {
-        var result = std.array_list.Managed(u8).init(alloc);
-        try result.ensureTotalCapacity(comments.len + decl.text.len + 32);
-        try result.appendSlice(comments);
-        try result.appendSlice("declare module ");
-        try result.appendSlice(decl.name);
-
-        if (ch.indexOfChar(decl.text, '{', 0)) |brace_idx| {
-            try result.append(' ');
-            try result.appendSlice(decl.text[brace_idx..]);
-        } else {
-            try result.appendSlice(" {}");
-        }
-        return result.toOwnedSlice();
+        // Direct alloc (no ArrayList overhead)
+        const dm = "declare module ";
+        const body_ambient = if (ch.indexOfChar(decl.text, '{', 0)) |brace_idx| decl.text[brace_idx..] else "{}";
+        const total_ambient = comments.len + dm.len + decl.name.len + 1 + body_ambient.len;
+        const buf_ambient = try alloc.alloc(u8, total_ambient);
+        var ap: usize = 0;
+        if (comments.len > 0) { @memcpy(buf_ambient[ap..][0..comments.len], comments); ap += comments.len; }
+        @memcpy(buf_ambient[ap..][0..dm.len], dm); ap += dm.len;
+        @memcpy(buf_ambient[ap..][0..decl.name.len], decl.name); ap += decl.name.len;
+        buf_ambient[ap] = ' '; ap += 1;
+        @memcpy(buf_ambient[ap..][0..body_ambient.len], body_ambient); ap += body_ambient.len;
+        return buf_ambient[0..ap];
     }
 
-    // Regular namespace
-    var result = std.array_list.Managed(u8).init(alloc);
-    try result.ensureTotalCapacity(comments.len + decl.text.len + 32);
-    try result.appendSlice(comments);
-
-    if (decl.is_exported) try result.appendSlice("export ");
-
-    // Check if declare is already in modifiers
+    // Regular namespace — direct alloc (no ArrayList overhead)
+    const export_prefix: []const u8 = if (decl.is_exported) "export " else "";
     var has_declare = false;
     if (decl.modifiers) |mods| {
         for (mods) |m| {
@@ -528,19 +570,20 @@ fn processModuleDeclaration(alloc: std.mem.Allocator, decl: Declaration, keep_co
             }
         }
     }
-    if (!has_declare) try result.appendSlice("declare ");
-
-    try result.appendSlice("namespace ");
-    try result.appendSlice(decl.name);
-
-    if (ch.indexOfChar(decl.text, '{', 0)) |brace_idx| {
-        try result.append(' ');
-        try result.appendSlice(decl.text[brace_idx..]);
-    } else {
-        try result.appendSlice(" {}");
-    }
-
-    return result.toOwnedSlice();
+    const declare_kw: []const u8 = if (!has_declare) "declare " else "";
+    const body = if (ch.indexOfChar(decl.text, '{', 0)) |brace_idx| decl.text[brace_idx..] else "{}";
+    const ns = "namespace ";
+    const total = comments.len + export_prefix.len + declare_kw.len + ns.len + decl.name.len + 1 + body.len;
+    const buf = try alloc.alloc(u8, total);
+    var pos: usize = 0;
+    if (comments.len > 0) { @memcpy(buf[pos..][0..comments.len], comments); pos += comments.len; }
+    @memcpy(buf[pos..][0..export_prefix.len], export_prefix); pos += export_prefix.len;
+    @memcpy(buf[pos..][0..declare_kw.len], declare_kw); pos += declare_kw.len;
+    @memcpy(buf[pos..][0..ns.len], ns); pos += ns.len;
+    @memcpy(buf[pos..][0..decl.name.len], decl.name); pos += decl.name.len;
+    buf[pos] = ' '; pos += 1;
+    @memcpy(buf[pos..][0..body.len], body); pos += body.len;
+    return buf[0..pos];
 }
 
 /// Main entry point: process declarations array into final .d.ts output.
@@ -555,7 +598,9 @@ pub fn processDeclarations(
     import_order: []const []const u8,
 ) ![]const u8 {
     var result = std.array_list.Managed(u8).init(result_alloc);
-    try result.ensureTotalCapacity(source_code.len);
+    // DTS output is typically 30-60% of source size (bodies stripped, types added).
+    // Bias toward 60% + 256 byte slack to avoid the final 1-2 reallocs on average files.
+    try result.ensureTotalCapacity((source_code.len * 6) / 10 + 256);
 
     // Extract triple-slash directives
     // Fast check: skip whitespace
@@ -569,58 +614,94 @@ pub fn processDeclarations(
         }
     }
 
-    // Group declarations by type (pre-size to avoid incremental reallocation)
-    const group_cap: usize = @max(declarations.len / 4, 4);
-    var imports = std.array_list.Managed(Declaration).init(alloc);
-    try imports.ensureTotalCapacity(group_cap);
-    var functions = std.array_list.Managed(Declaration).init(alloc);
-    try functions.ensureTotalCapacity(group_cap);
-    var variables = std.array_list.Managed(Declaration).init(alloc);
-    try variables.ensureTotalCapacity(group_cap);
-    var interfaces = std.array_list.Managed(Declaration).init(alloc);
-    try interfaces.ensureTotalCapacity(group_cap);
-    var type_decls = std.array_list.Managed(Declaration).init(alloc);
-    try type_decls.ensureTotalCapacity(group_cap);
-    var classes = std.array_list.Managed(Declaration).init(alloc);
-    try classes.ensureTotalCapacity(group_cap);
-    var enums = std.array_list.Managed(Declaration).init(alloc);
-    try enums.ensureTotalCapacity(group_cap);
-    var modules = std.array_list.Managed(Declaration).init(alloc);
-    try modules.ensureTotalCapacity(group_cap);
-    var exports = std.array_list.Managed(Declaration).init(alloc);
-    try exports.ensureTotalCapacity(group_cap);
+    // Index-based grouping: store indices into the declarations array instead of
+    // copying Declaration structs. A single allocation for the index array replaces
+    // 9 separate ArrayList allocations, dramatically reducing overhead for small files.
+    const GROUP_COUNT = 9;
+    // Group order: imports(0), functions(1), variables(2), interfaces(3), types(4),
+    //              classes(5), enums(6), modules(7), exports(8)
+    var group_counts = [_]u32{0} ** GROUP_COUNT;
 
+    // First pass: count declarations per group
     for (declarations) |d| {
-        switch (d.kind) {
-            .import_decl => try imports.append(d),
-            .function_decl => try functions.append(d),
-            .variable_decl => try variables.append(d),
-            .interface_decl => try interfaces.append(d),
-            .type_decl => try type_decls.append(d),
-            .class_decl => try classes.append(d),
-            .enum_decl => try enums.append(d),
-            .module_decl, .namespace_decl => try modules.append(d),
-            .export_decl => try exports.append(d),
-            .unknown_decl => {},
-        }
+        const g: usize = switch (d.kind) {
+            .import_decl => 0,
+            .function_decl => 1,
+            .variable_decl => 2,
+            .interface_decl => 3,
+            .type_decl => 4,
+            .class_decl => 5,
+            .enum_decl => 6,
+            .module_decl, .namespace_decl => 7,
+            .export_decl => 8,
+            .unknown_decl => continue,
+        };
+        group_counts[g] += 1;
+    }
+
+    // Compute offsets for each group in the flat index array. Reuse the
+    // cumulative running total as the final size — saves one O(GROUP_COUNT)
+    // pass over the counts.
+    var group_offsets = [_]u32{0} ** GROUP_COUNT;
+    var total_indexed: u32 = 0;
+    for (0..GROUP_COUNT) |g| {
+        group_offsets[g] = total_indexed;
+        total_indexed += group_counts[g];
     }
 
+    // Single allocation for all group indices
+    const group_indices = try alloc.alloc(u32, total_indexed);
+    var write_pos = [_]u32{0} ** GROUP_COUNT;
+    @memcpy(&write_pos, &group_offsets);
+
+    // Second pass: fill indices
+    for (declarations, 0..) |d, di| {
+        const g: usize = switch (d.kind) {
+            .import_decl => 0,
+            .function_decl => 1,
+            .variable_decl => 2,
+            .interface_decl => 3,
+            .type_decl => 4,
+            .class_decl => 5,
+            .enum_decl => 6,
+            .module_decl, .namespace_decl => 7,
+            .export_decl => 8,
+            .unknown_decl => continue,
+        };
+        group_indices[write_pos[g]] = @intCast(di);
+        write_pos[g] += 1;
+    }
+
+    // Helper to get a group's slice of declaration indices
+    const imports_idx = group_indices[group_offsets[0]..write_pos[0]];
+    const functions_idx = group_indices[group_offsets[1]..write_pos[1]];
+    const variables_idx = group_indices[group_offsets[2]..write_pos[2]];
+    const interfaces_idx = group_indices[group_offsets[3]..write_pos[3]];
+    const type_decls_idx = group_indices[group_offsets[4]..write_pos[4]];
+    const classes_idx = group_indices[group_offsets[5]..write_pos[5]];
+    const enums_idx = group_indices[group_offsets[6]..write_pos[6]];
+    const modules_idx = group_indices[group_offsets[7]..write_pos[7]];
+    const exports_idx = group_indices[group_offsets[8]..write_pos[8]];
+
     // Parse exports to track exported items
+    const exports_len = exports_idx.len;
     var exported_items = std.StringHashMap(void).init(alloc);
-    try exported_items.ensureTotalCapacity(@intCast(@max(exports.items.len * 4, 8)));
+    try exported_items.ensureTotalCapacity(@intCast(@max(exports_len * 4, 8)));
     var type_export_stmts = std.array_list.Managed([]const u8).init(alloc);
-    try type_export_stmts.ensureTotalCapacity(@max(exports.items.len / 2, 2));
+    try type_export_stmts.ensureTotalCapacity(@max(exports_len / 2, 2));
     var value_export_stmts = std.array_list.Managed([]const u8).init(alloc);
-    try value_export_stmts.ensureTotalCapacity(@max(exports.items.len / 2, 2));
+    try value_export_stmts.ensureTotalCapacity(@max(exports_len / 2, 2));
     var default_exports = std.array_list.Managed([]const u8).init(alloc);
-    var seen_exports = std.StringHashMap(void).init(alloc);
-    try seen_exports.ensureTotalCapacity(@intCast(@max(exports.items.len, 4)));
+    // Use linear array for small export counts (faster than HashMap for <32 entries)
+    var seen_exports_arr = std.array_list.Managed([]const u8).init(alloc);
+    try seen_exports_arr.ensureTotalCapacity(@max(exports_len, 4));
 
     // Reusable buffer for building export statements (avoids per-iteration alloc)
     var stmt_buf = std.array_list.Managed(u8).init(alloc);
     try stmt_buf.ensureTotalCapacity(256);
 
-    for (exports.items) |decl| {
+    for (exports_idx) |eidx| {
+        const decl = declarations[eidx];
         const comments = try formatComments(alloc, decl.leading_comments, keep_comments);
 
         if (ch.startsWith(decl.text, "export default")) {
@@ -644,7 +725,8 @@ pub fn processDeclarations(
             if (ch.indexOfChar(export_text, '{', 0)) |brace_s| {
                 if (ch.indexOfChar(export_text, '}', brace_s)) |brace_e| {
                     const items_str = export_text[brace_s + 1 .. brace_e];
-                    var iter = std.mem.splitSequence(u8, items_str, ",");
+                    // splitScalar is faster than splitSequence for a 1-byte separator.
+                    var iter = std.mem.splitScalar(u8, items_str, ',');
                     while (iter.next()) |item| {
                         const trimmed_item = ch.sliceTrimmed(item, 0, item.len);
                         if (trimmed_item.len > 0) {
@@ -654,14 +736,30 @@ pub fn processDeclarations(
                 }
             }
 
+            // Determine type-only-ness BEFORE concatenation. Checking
+            // ch.contains on the full (comments + export_text) text scanned
+            // arbitrarily long comment text on every export.
+            const is_type_export = ch.startsWith(export_text, "export type");
+
             stmt_buf.clearRetainingCapacity();
             try stmt_buf.appendSlice(comments);
             try stmt_buf.appendSlice(export_text);
             const full_text = try stmt_buf.toOwnedSlice();
 
-            const gop = try seen_exports.getOrPut(full_text);
-            if (!gop.found_existing) {
-                if (ch.contains(full_text, "export type")) {
+            // Linear dedup: faster than HashMap for typical export counts (<32).
+            // Length pre-check rejects most non-matches without invoking
+            // std.mem.eql, which compares byte-by-byte even on length mismatch.
+            var is_dup = false;
+            const ft_len = full_text.len;
+            for (seen_exports_arr.items) |seen| {
+                if (seen.len == ft_len and std.mem.eql(u8, seen, full_text)) {
+                    is_dup = true;
+                    break;
+                }
+            }
+            if (!is_dup) {
+                try seen_exports_arr.append(full_text);
+                if (is_type_export) {
                     try type_export_stmts.append(full_text);
                 } else {
                     try value_export_stmts.append(full_text);
@@ -673,15 +771,18 @@ pub fn processDeclarations(
     // Short-circuit: skip combined_words building and import map when there are no imports.
     // For import-free code (e.g. synthetic benchmarks), this avoids O(n) word
     // extraction across all declarations — a significant saving on large inputs.
+    // Lazy-init: only allocate when there are interfaces to check
     var interface_references = std.StringHashMap(void).init(alloc);
+    _ = &interface_references; // prevent unused warning in no-imports path
     var processed_imports = std.array_list.Managed([]const u8).init(alloc);
 
-    if (imports.items.len > 0) {
+    if (imports_idx.len > 0) {
         // Build import-item-to-declaration map (only when imports exist)
         const ImportDeclMap = std.StringHashMap(Declaration);
         var all_imported_items_map = ImportDeclMap.init(alloc);
-        try all_imported_items_map.ensureTotalCapacity(@intCast(@max(imports.items.len * 4, 8)));
-        for (imports.items) |imp| {
+        try all_imported_items_map.ensureTotalCapacity(@intCast(@max(imports_idx.len * 4, 8)));
+        for (imports_idx) |iidx| {
+            const imp = declarations[iidx];
             const items = extractAllImportedItems(imp);
             for (items) |item| {
                 try all_imported_items_map.put(item, imp);
@@ -711,9 +812,10 @@ pub fn processDeclarations(
         }
 
         // Interface reference detection
-        try interface_references.ensureTotalCapacity(@intCast(@max(interfaces.items.len, 4)));
-        if (interfaces.items.len > 0 and combined_words.count() > 0) {
-            for (interfaces.items) |iface| {
+        try interface_references.ensureTotalCapacity(@intCast(@max(interfaces_idx.len, 4)));
+        if (interfaces_idx.len > 0 and combined_words.count() > 0) {
+            for (interfaces_idx) |iidx| {
+                const iface = declarations[iidx];
                 if (combined_words.contains(iface.name)) {
                     try interface_references.put(iface.name, {});
                 }
@@ -721,13 +823,14 @@ pub fn processDeclarations(
         }
 
         // Add interface text to combined_words (after ref detection, before import filtering)
-        for (interfaces.items) |iface| {
+        for (interfaces_idx) |iidx| {
+            const iface = declarations[iidx];
             if (iface.is_exported or interface_references.contains(iface.name)) {
                 extractWords(&combined_words, iface.text);
             }
         }
         var used_import_items = std.StringHashMap(void).init(alloc);
-        try used_import_items.ensureTotalCapacity(@intCast(@max(imports.items.len * 4, 8)));
+        try used_import_items.ensureTotalCapacity(@intCast(@max(imports_idx.len * 4, 8)));
 
         if (combined_words.count() > 0) {
             var map_iter = all_imported_items_map.keyIterator();
@@ -747,14 +850,15 @@ pub fn processDeclarations(
         }
 
         // Filter and rebuild imports
-        try processed_imports.ensureTotalCapacity(imports.items.len);
+        try processed_imports.ensureTotalCapacity(imports_idx.len);
         // Reusable buffer for building import statements
         var import_buf = std.array_list.Managed(u8).init(alloc);
         try import_buf.ensureTotalCapacity(256);
         var used_named = std.array_list.Managed([]const u8).init(alloc);
         try used_named.ensureTotalCapacity(16);
 
-        for (imports.items) |imp| {
+        for (imports_idx) |iidx| {
+            const imp = declarations[iidx];
             // Preserve side-effect imports
             if (imp.is_side_effect) {
                 const trimmed_imp = ch.sliceTrimmed(imp.text, 0, imp.text.len);
@@ -795,16 +899,20 @@ pub fn processDeclarations(
                     if (parsed.default_name) |dn| try import_buf.appendSlice(dn);
                     if (used_named.items.len > 0) {
                         try import_buf.appendSlice(", { ");
-                        for (used_named.items, 0..) |ni, idx| {
-                            if (idx > 0) try import_buf.appendSlice(", ");
+                        // Emit first item, then comma-prefixed subsequent items —
+                        // skips the per-iteration `if (idx > 0)` branch.
+                        try import_buf.appendSlice(used_named.items[0]);
+                        for (used_named.items[1..]) |ni| {
+                            try import_buf.appendSlice(", ");
                             try import_buf.appendSlice(ni);
                         }
                         try import_buf.appendSlice(" }");
                     }
                 } else if (used_named.items.len > 0) {
                     try import_buf.appendSlice("{ ");
-                    for (used_named.items, 0..) |ni, idx| {
-                        if (idx > 0) try import_buf.appendSlice(", ");
+                    try import_buf.appendSlice(used_named.items[0]);
+                    for (used_named.items[1..]) |ni| {
+                        try import_buf.appendSlice(", ");
                         try import_buf.appendSlice(ni);
                     }
                     try import_buf.appendSlice(" }");
@@ -818,61 +926,70 @@ pub fn processDeclarations(
             }
         }
 
-        // Sort imports by priority then locale-aware alphabetical
+        // Sort imports by priority then locale-aware alphabetical.
+        // Pre-compute priorities once (avoids re-scanning during O(n log n) sort).
         if (processed_imports.items.len > 1) {
-            const SortCtx = struct {
-                import_order_items: []const []const u8,
-                default_priority: usize,
-
-                pub fn priority(self: @This(), imp: []const u8) usize {
-                    for (self.import_order_items, 0..) |p, idx| {
-                        var found = false;
-                        if (ch.indexOf(imp, "from '", 0)) |fi| {
-                            if (ch.indexOf(imp, p, fi + 6) != null) found = true;
-                        }
-                        if (!found) {
-                            if (ch.indexOf(imp, "from \"", 0)) |fi| {
-                                if (ch.indexOf(imp, p, fi + 6) != null) found = true;
-                            }
-                        }
-                        if (found) return idx;
+            const default_priority = import_order.len;
+            const priorities = try alloc.alloc(usize, processed_imports.items.len);
+            for (processed_imports.items, 0..) |imp, pi| {
+                // Locate the source-string slice. Single scan via indexOf for
+                // the " from " marker, then dispatch on the quote byte we find
+                // there — avoids two separate searches for the 7-byte needle.
+                var src_start: usize = 0;
+                var src_end: usize = imp.len;
+                if (ch.indexOf(imp, " from ", 0)) |fi| {
+                    var qi = fi + 6;
+                    while (qi < imp.len and (imp[qi] == ' ' or imp[qi] == '\t')) qi += 1;
+                    if (qi < imp.len and (imp[qi] == '\'' or imp[qi] == '"')) {
+                        const quote = imp[qi];
+                        src_start = qi + 1;
+                        if (ch.indexOfChar(imp, quote, src_start)) |qe| src_end = qe;
                     }
-                    return self.default_priority;
                 }
+                const src = if (src_start < src_end) imp[src_start..src_end] else imp;
+                var prio = default_priority;
+                for (import_order, 0..) |p, idx| {
+                    if (ch.indexOf(src, p, 0) != null) { prio = idx; break; }
+                }
+                priorities[pi] = prio;
+            }
+
+            // Sort import indices by (priority, locale-order)
+            const indices = try alloc.alloc(usize, processed_imports.items.len);
+            for (0..indices.len) |ii| indices[ii] = ii;
+
+            const SortCtx2 = struct {
+                prios: []const usize,
+                items: []const []const u8,
 
-                /// Locale-aware char sort key: symbols < digits < letters
-                /// Matches JavaScript's localeCompare behavior
                 fn charSortKey(c_val: u8) u32 {
                     if (c_val >= 'a' and c_val <= 'z') return @as(u32, c_val - 'a') * 4 + 1000;
                     if (c_val >= 'A' and c_val <= 'Z') return @as(u32, c_val - 'A') * 4 + 1001;
                     if (c_val >= '0' and c_val <= '9') return @as(u32, c_val - '0') + 500;
                     return @as(u32, c_val);
                 }
+            };
 
-                pub fn localeCompare(_: @This(), a: []const u8, b: []const u8) bool {
+            const sort_ctx = SortCtx2{ .prios = priorities, .items = processed_imports.items };
+            std.mem.sort(usize, indices, sort_ctx, struct {
+                fn lessThan(ctx: SortCtx2, ai: usize, bi: usize) bool {
+                    if (ctx.prios[ai] != ctx.prios[bi]) return ctx.prios[ai] < ctx.prios[bi];
+                    const a = ctx.items[ai];
+                    const b = ctx.items[bi];
                     const min_len = @min(a.len, b.len);
                     for (0..min_len) |i| {
-                        const ak = charSortKey(a[i]);
-                        const bk = charSortKey(b[i]);
+                        const ak = SortCtx2.charSortKey(a[i]);
+                        const bk = SortCtx2.charSortKey(b[i]);
                         if (ak != bk) return ak < bk;
                     }
                     return a.len < b.len;
                 }
-            };
-
-            const ctx = SortCtx{
-                .import_order_items = import_order,
-                .default_priority = import_order.len,
-            };
-
-            std.mem.sort([]const u8, processed_imports.items, ctx, struct {
-                fn lessThan(c_ctx: SortCtx, a: []const u8, b: []const u8) bool {
-                    const ap = c_ctx.priority(a);
-                    const bp = c_ctx.priority(b);
-                    if (ap != bp) return ap < bp;
-                    return c_ctx.localeCompare(a, b);
-                }
             }.lessThan);
+
+            // Reorder in-place using sorted indices
+            const sorted = try alloc.alloc([]const u8, processed_imports.items.len);
+            for (indices, 0..) |idx_val, di| sorted[di] = processed_imports.items[idx_val];
+            @memcpy(processed_imports.items, sorted);
         }
     }
 
@@ -889,18 +1006,19 @@ pub fn processDeclarations(
     }
 
     // Emit declaration groups: functions, variables, interfaces, types, classes, enums, modules
-    const decl_groups = [_]struct { items: []const Declaration, kind_tag: u8 }{
-        .{ .items = functions.items, .kind_tag = 'f' },
-        .{ .items = variables.items, .kind_tag = 'v' },
-        .{ .items = interfaces.items, .kind_tag = 'i' },
-        .{ .items = type_decls.items, .kind_tag = 't' },
-        .{ .items = classes.items, .kind_tag = 'c' },
-        .{ .items = enums.items, .kind_tag = 'e' },
-        .{ .items = modules.items, .kind_tag = 'm' },
+    const decl_group_indices = [_][]const u32{
+        functions_idx,
+        variables_idx,
+        interfaces_idx,
+        type_decls_idx,
+        classes_idx,
+        enums_idx,
+        modules_idx,
     };
 
-    for (decl_groups) |group| {
-        for (group.items) |decl| {
+    for (decl_group_indices) |group_idx| {
+        for (group_idx) |didx| {
+            const decl = declarations[didx];
             switch (decl.kind) {
                 .function_decl, .class_decl => {
                     // Direct emit: write comments + text straight to result buffer
@@ -1043,3 +1161,30 @@ test "extractTripleSlashDirectives" {
         try std.testing.expectEqualStrings("/// <reference types=\"node\" />", directives[0]);
     }
 }
+
+test "extractTripleSlashDirectives recognizes amd-module and amd-dependency" {
+    const alloc = std.testing.allocator;
+    const src = "/// <amd-module name=\"m\" />\n/// <amd-dependency path=\"./d\" />\nexport {};";
+    const directives = try extractTripleSlashDirectives(alloc, src);
+    defer alloc.free(directives);
+    try std.testing.expectEqual(@as(usize, 2), directives.len);
+    try std.testing.expect(std.mem.indexOf(u8, directives[0], "amd-module") != null);
+    try std.testing.expect(std.mem.indexOf(u8, directives[1], "amd-dependency") != null);
+}
+
+test "extractTripleSlashDirectives skips triple-slash comments without `<` (fast pre-filter)" {
+    const alloc = std.testing.allocator;
+    const src = "/// just a comment, no angle bracket\nexport {};";
+    const directives = try extractTripleSlashDirectives(alloc, src);
+    defer alloc.free(directives);
+    try std.testing.expectEqual(@as(usize, 0), directives.len);
+}
+
+test "extractTripleSlashDirectives stops at first non-comment statement" {
+    const alloc = std.testing.allocator;
+    const src = "/// <reference types=\"node\" />\nexport const x = 1;\n/// <reference types=\"bun\" />";
+    const directives = try extractTripleSlashDirectives(alloc, src);
+    defer alloc.free(directives);
+    try std.testing.expectEqual(@as(usize, 1), directives.len);
+    try std.testing.expect(std.mem.indexOf(u8, directives[0], "node") != null);
+}