sourcemap: bit-packed InternalSourceMap (~2.4 B/mapping, no decode)

bench/sourcemap/.gitignore

@@ -0,0 +1 @@
+big-module.generated.ts

bench/sourcemap/internal-sourcemap-bench.ts

@@ -0,0 +1,52 @@
+// Microbench for the InternalSourceMap stack-trace remapping path. Compare
+// against a baseline build by running:
+//
+//   bun run build:release bench/sourcemap/internal-sourcemap-bench.ts
+//
+// On first run this generates a ~150k-line .ts module next to this file so the
+// stack frames being remapped live inside a large SavedSourceMap entry.
+
+import fs from "node:fs";
+import path from "node:path";
+
+const ITER = 10_000;
+const BIG_LINES = 150_000;
+
+const flag = process.argv[2] ?? "bench";
+const mb = (n: number) => (n / 1048576).toFixed(2) + " MB";
+
+const bigPath = path.join(import.meta.dir, "big-module.generated.ts");
+if (!fs.existsSync(bigPath)) {
+  let src = "let v: number = 0;\n";
+  for (let i = 0; i < BIG_LINES; i++) src += `v = (v + ${i % 97}) | 0;\n`;
+  src += "export function go(): string { return new Error('e').stack!; }\n";
+  fs.writeFileSync(bigPath, src);
+}
+
+const rssBefore = process.memoryUsage().rss;
+const tLoad0 = performance.now();
+const { go } = require(bigPath) as { go: () => string };
+const tLoad1 = performance.now();
+const rssAfterLoad = process.memoryUsage().rss;
+
+// First .stack: triggers full VLQ decode in the old path.
+const tFirst0 = performance.now();
+let s = go();
+const tFirst1 = performance.now();
+const rssAfterFirst = process.memoryUsage().rss;
+
+const t0 = performance.now();
+for (let i = 0; i < ITER; i++) s = go();
+const t1 = performance.now();
+const rssAfterLoop = process.memoryUsage().rss;
+
+console.log(`[${flag}] load big module:          ${(tLoad1 - tLoad0).toFixed(2)} ms`);
+console.log(`[${flag}] first new Error().stack:  ${(tFirst1 - tFirst0).toFixed(3)} ms`);
+console.log(
+  `[${flag}] ${ITER}x new Error().stack: ${(t1 - t0).toFixed(2)} ms (${(((t1 - t0) * 1000) / ITER).toFixed(2)} µs/op)`,
+);
+console.log(
+  `[${flag}] rss before/afterLoad/afterFirst/afterLoop: ${mb(rssBefore)} / ${mb(rssAfterLoad)} / ${mb(rssAfterFirst)} / ${mb(rssAfterLoop)}`,
+);
+console.log(`[${flag}] rss delta load→firstStack: ${mb(rssAfterFirst - rssAfterLoad)}`);
+void s;

src/StandaloneModuleGraph.zig

@@ -264,25 +264,22 @@
             defer init_lock.unlock();
 
             return switch (this.*) {
                 .none => null,
                 .parsed => |map| map,
                 .serialized => |serialized| {
-                    var stored = switch (SourceMap.Mapping.parse(
-                        bun.default_allocator,
-                        serialized.mappingVLQ(),
-                        null,
-                        std.math.maxInt(i32),
-                        std.math.maxInt(i32),
-                        .{},
-                    )) {
-                        .success => |x| x,
-                        .fail => {
-                            this.* = .none;
-                            return null;
-                        },
+                    const blob = serialized.mappingBlob();
+                    if (blob.len < SourceMap.InternalSourceMap.header_size) {
+                        this.* = .none;
+                        return null;
+                    }
+                    const ism = SourceMap.InternalSourceMap{ .data = blob.ptr };
+                    var stored: SourceMap.ParsedSourceMap = .{
+                        .ref_count = .init(),
+                        .internal = ism,
+                        .input_line_count = ism.inputLineCount(),
                     };
 
                     const source_files = serialized.sourceFileNames();
                     const slices = bun.handleOom(bun.default_allocator.alloc(?[]u8, source_files.len * 2));
 
                     const file_names: [][]const u8 = @ptrCast(slices[0..source_files.len]);
@@ -1358,14 +1355,15 @@
 
     /// Source map serialization in the bundler is specially designed to be
     /// loaded in memory as is. Source contents are compressed with ZSTD to
-    /// reduce the file size, and mappings are stored as uncompressed VLQ.
+    /// reduce the file size, and mappings are stored as an InternalSourceMap
+    /// blob (varint deltas + sync points) so lookups need no decode pass.
     pub const SerializedSourceMap = struct {
         bytes: []const u8,
 
         /// Following the header bytes:
         /// - source_files_count number of StringPointer, file names
         /// - source_files_count number of StringPointer, zstd compressed contents
-        /// - the mapping data, `map_vlq_length` bytes
+        /// - the InternalSourceMap blob, `map_bytes_length` bytes
         /// - all the StringPointer contents
         pub const Header = extern struct {
             source_files_count: u32,
@@ -1376,7 +1374,7 @@
             return @ptrCast(map.bytes.ptr);
         }
 
-        pub fn mappingVLQ(map: SerializedSourceMap) []const u8 {
+        pub fn mappingBlob(map: SerializedSourceMap) []const u8 {
             const head = map.header();
             const start = @sizeOf(Header) + head.source_files_count * @sizeOf(StringPointer) * 2;
             return map.bytes[start..][0..head.map_bytes_length];
@@ -1466,14 +1464,16 @@
         }
 
         const map_vlq: []const u8 = mappings_str.data.e_string.slice(arena);
+        const map_blob = SourceMap.InternalSourceMap.fromVLQ(arena, map_vlq, 0) catch
+            return error.InvalidSourceMap;
 
         try out.writeInt(u32, sources_paths.items.len, .little);
-        try out.writeInt(u32, @intCast(map_vlq.len), .little);
+        try out.writeInt(u32, @intCast(map_blob.len), .little);
 
         const string_payload_start_location = @sizeOf(u32) +
             @sizeOf(u32) +
             @sizeOf(bun.StringPointer) * sources_content.items.len * 2 + // path + source
-            map_vlq.len;
+            map_blob.len;
 
         for (sources_paths.items.slice()) |item| {
             if (item.data != .e_string)
@@ -1519,7 +1519,7 @@
             try out.writeInt(u32, slice.length, .little);
         }
 
-        try out.writeAll(map_vlq);
+        try out.writeAll(map_blob);
 
         bun.assert(header_list.items.len == string_payload_start_location);
     }

src/bun.js/RuntimeTranspilerCache.zig

@@ -15,7 +15,8 @@
 /// Version 16: Added typeof undefined minification optimization.
 /// Version 17: Removed transpiler import rewrite for bun:test. Not bumping it causes test/js/bun/http/req-url-leak.test.ts to fail with SyntaxError: Export named 'expect' not found in module 'bun:test'.
 /// Version 18: Include ESM record (module info) with an ES Module, see #15758
-const expected_version = 18;
+/// Version 19: Sourcemap blob is InternalSourceMap (varint stream + sync points), not VLQ.
+const expected_version = 19;
 
 const debug = Output.scoped(.cache, .visible);
 const MINIMUM_CACHE_SIZE = 50 * 1024;