Remove `cache_files` since it's not used and causes slower Bun compilation times

8 files changed, 4949 insertions, 5052 deletions

diff --git a/src/bundler.zig b/src/bundler.zig
index b34241f1b..77534e602 100644
--- a/src/bundler.zig
+++ b/src/bundler.zig
@@ -38,6 +38,9 @@ const NewBunQueue = @import("./bun_queue.zig").NewBunQueue;
 const NodeFallbackModules = @import("./node_fallbacks.zig");
 const CacheEntry = @import("./cache.zig").FsCacheEntry;
 
+const Linker = linker.Linker;
+const Resolver = _resolver.Resolver;
+
 // How it works end-to-end
 // 1. Resolve a file path from input using the resolver
 // 2. Look at the extension of that file path, and determine a loader
@@ -94,1748 +97,1409 @@ pub const ParseResult = struct {
     empty: bool = false,
 };
 
-pub fn NewBundler(cache_files: bool) type {
-    return struct {
-        pub const Linker = if (cache_files) linker.Linker else linker.ServeLinker;
-        pub const Resolver = if (cache_files) _resolver.Resolver else _resolver.ResolverUncached;
-        const ThisBundler = @This();
+const cache_files = false;
 
-        options: options.BundleOptions,
-        log: *logger.Log,
-        allocator: *std.mem.Allocator,
-        result: options.TransformResult = undefined,
-        resolver: Resolver,
-        fs: *Fs.FileSystem,
-        // thread_pool: *ThreadPool,
-        output_files: std.ArrayList(options.OutputFile),
-        resolve_results: *ResolveResults,
-        resolve_queue: ResolveQueue,
-        elapsed: i128 = 0,
-        needs_runtime: bool = false,
-        router: ?Router = null,
-
-        linker: Linker,
-        timer: Timer = Timer{},
-        env: *DotEnv.Loader,
-
-        // must be pointer array because we can't we don't want the source to point to invalid memory if the array size is reallocated
-        virtual_modules: std.ArrayList(*ClientEntryPoint),
-
-        pub const isCacheEnabled = cache_files;
-
-        pub fn clone(this: *ThisBundler, allocator: *std.mem.Allocator, to: *ThisBundler) !void {
-            to.* = this.*;
-            to.setAllocator(allocator);
-            to.log = try allocator.create(logger.Log);
-            to.log.* = logger.Log.init(allocator);
-            to.setLog(to.log);
-        }
+pub const Bundler = struct {
+    const ThisBundler = @This();
 
-        pub fn setLog(this: *ThisBundler, log: *logger.Log) void {
-            this.log = log;
-            this.linker.log = log;
-            this.resolver.log = log;
-        }
+    options: options.BundleOptions,
+    log: *logger.Log,
+    allocator: *std.mem.Allocator,
+    result: options.TransformResult = undefined,
+    resolver: Resolver,
+    fs: *Fs.FileSystem,
+    // thread_pool: *ThreadPool,
+    output_files: std.ArrayList(options.OutputFile),
+    resolve_results: *ResolveResults,
+    resolve_queue: ResolveQueue,
+    elapsed: i128 = 0,
+    needs_runtime: bool = false,
+    router: ?Router = null,
+
+    linker: Linker,
+    timer: Timer = Timer{},
+    env: *DotEnv.Loader,
+
+    // must be pointer array because we can't we don't want the source to point to invalid memory if the array size is reallocated
+    virtual_modules: std.ArrayList(*ClientEntryPoint),
+
+    pub const isCacheEnabled = cache_files;
+
+    pub fn clone(this: *ThisBundler, allocator: *std.mem.Allocator, to: *ThisBundler) !void {
+        to.* = this.*;
+        to.setAllocator(allocator);
+        to.log = try allocator.create(logger.Log);
+        to.log.* = logger.Log.init(allocator);
+        to.setLog(to.log);
+    }
 
-        pub fn setAllocator(this: *ThisBundler, allocator: *std.mem.Allocator) void {
-            this.allocator = allocator;
-            this.linker.allocator = allocator;
-            this.resolver.allocator = allocator;
-        }
+    pub fn setLog(this: *ThisBundler, log: *logger.Log) void {
+        this.log = log;
+        this.linker.log = log;
+        this.resolver.log = log;
+    }
 
-        // to_bundle:
+    pub fn setAllocator(this: *ThisBundler, allocator: *std.mem.Allocator) void {
+        this.allocator = allocator;
+        this.linker.allocator = allocator;
+        this.resolver.allocator = allocator;
+    }
 
-        // thread_pool: *ThreadPool,
+    // to_bundle:
 
-        pub fn init(
-            allocator: *std.mem.Allocator,
-            log: *logger.Log,
-            opts: Api.TransformOptions,
-            existing_bundle: ?*NodeModuleBundle,
-            env_loader_: ?*DotEnv.Loader,
-        ) !ThisBundler {
-            js_ast.Expr.Data.Store.create(allocator);
-            js_ast.Stmt.Data.Store.create(allocator);
-            var fs = try Fs.FileSystem.init1(
-                allocator,
-                opts.absolute_working_dir,
-            );
-            const bundle_options = try options.BundleOptions.fromApi(
-                allocator,
-                fs,
-                log,
-                opts,
-                existing_bundle,
-            );
+    // thread_pool: *ThreadPool,
 
-            var env_loader = env_loader_ orelse brk: {
-                var map = try allocator.create(DotEnv.Map);
-                map.* = DotEnv.Map.init(allocator);
+    pub fn init(
+        allocator: *std.mem.Allocator,
+        log: *logger.Log,
+        opts: Api.TransformOptions,
+        existing_bundle: ?*NodeModuleBundle,
+        env_loader_: ?*DotEnv.Loader,
+    ) !ThisBundler {
+        js_ast.Expr.Data.Store.create(allocator);
+        js_ast.Stmt.Data.Store.create(allocator);
+        var fs = try Fs.FileSystem.init1(
+            allocator,
+            opts.absolute_working_dir,
+        );
+        const bundle_options = try options.BundleOptions.fromApi(
+            allocator,
+            fs,
+            log,
+            opts,
+            existing_bundle,
+        );
 
-                var loader = try allocator.create(DotEnv.Loader);
-                loader.* = DotEnv.Loader.init(map, allocator);
-                break :brk loader;
-            };
-            // var pool = try allocator.create(ThreadPool);
-            // try pool.init(ThreadPool.InitConfig{
-            //     .allocator = allocator,
-            // });
-            var resolve_results = try allocator.create(ResolveResults);
-            resolve_results.* = ResolveResults.init(allocator);
-            return ThisBundler{
-                .options = bundle_options,
-                .fs = fs,
-                .allocator = allocator,
-                .resolver = Resolver.init1(allocator, log, fs, bundle_options),
-                .log = log,
-                // .thread_pool = pool,
-                .linker = undefined,
-                .result = options.TransformResult{ .outbase = bundle_options.output_dir },
-                .resolve_results = resolve_results,
-                .resolve_queue = ResolveQueue.init(allocator),
-                .output_files = std.ArrayList(options.OutputFile).init(allocator),
-                .virtual_modules = std.ArrayList(*ClientEntryPoint).init(allocator),
-                .env = env_loader,
-            };
-        }
+        var env_loader = env_loader_ orelse brk: {
+            var map = try allocator.create(DotEnv.Map);
+            map.* = DotEnv.Map.init(allocator);
 
-        pub fn configureLinker(bundler: *ThisBundler) void {
-            bundler.linker = Linker.init(
-                bundler.allocator,
-                bundler.log,
-                &bundler.resolve_queue,
-                &bundler.options,
-                &bundler.resolver,
-                bundler.resolve_results,
-                bundler.fs,
-            );
-        }
+            var loader = try allocator.create(DotEnv.Loader);
+            loader.* = DotEnv.Loader.init(map, allocator);
+            break :brk loader;
+        };
+        // var pool = try allocator.create(ThreadPool);
+        // try pool.init(ThreadPool.InitConfig{
+        //     .allocator = allocator,
+        // });
+        var resolve_results = try allocator.create(ResolveResults);
+        resolve_results.* = ResolveResults.init(allocator);
+        return ThisBundler{
+            .options = bundle_options,
+            .fs = fs,
+            .allocator = allocator,
+            .resolver = Resolver.init1(allocator, log, fs, bundle_options),
+            .log = log,
+            // .thread_pool = pool,
+            .linker = undefined,
+            .result = options.TransformResult{ .outbase = bundle_options.output_dir },
+            .resolve_results = resolve_results,
+            .resolve_queue = ResolveQueue.init(allocator),
+            .output_files = std.ArrayList(options.OutputFile).init(allocator),
+            .virtual_modules = std.ArrayList(*ClientEntryPoint).init(allocator),
+            .env = env_loader,
+        };
+    }
 
-        pub fn runEnvLoader(this: *ThisBundler) !void {
-            switch (this.options.env.behavior) {
-                .prefix, .load_all => {
-                    // Step 1. Load the project root.
-                    var dir: *Fs.FileSystem.DirEntry = ((this.resolver.readDirInfo(this.fs.top_level_dir) catch return) orelse return).getEntries() orelse return;
+    pub fn configureLinker(bundler: *ThisBundler) void {
+        bundler.linker = Linker.init(
+            bundler.allocator,
+            bundler.log,
+            &bundler.resolve_queue,
+            &bundler.options,
+            &bundler.resolver,
+            bundler.resolve_results,
+            bundler.fs,
+        );
+    }
 
-                    // Process always has highest priority.
-                    this.env.loadProcess();
-                    if (this.options.production) {
-                        try this.env.load(&this.fs.fs, dir, false);
-                    } else {
-                        try this.env.load(&this.fs.fs, dir, true);
-                    }
-                },
-                else => {},
-            }
+    pub fn runEnvLoader(this: *ThisBundler) !void {
+        switch (this.options.env.behavior) {
+            .prefix, .load_all => {
+                // Step 1. Load the project root.
+                var dir: *Fs.FileSystem.DirEntry = ((this.resolver.readDirInfo(this.fs.top_level_dir) catch return) orelse return).getEntries() orelse return;
+
+                // Process always has highest priority.
+                this.env.loadProcess();
+                if (this.options.production) {
+                    try this.env.load(&this.fs.fs, dir, false);
+                } else {
+                    try this.env.load(&this.fs.fs, dir, true);
+                }
+            },
+            else => {},
         }
+    }
 
-        // This must be run after a framework is configured, if a framework is enabled
-        pub fn configureDefines(this: *ThisBundler) !void {
-            if (this.options.defines_loaded) {
-                return;
-            }
+    // This must be run after a framework is configured, if a framework is enabled
+    pub fn configureDefines(this: *ThisBundler) !void {
+        if (this.options.defines_loaded) {
+            return;
+        }
 
-            try this.runEnvLoader();
+        try this.runEnvLoader();
 
-            js_ast.Expr.Data.Store.create(this.allocator);
-            js_ast.Stmt.Data.Store.create(this.allocator);
-            defer js_ast.Expr.Data.Store.reset();
-            defer js_ast.Stmt.Data.Store.reset();
+        js_ast.Expr.Data.Store.create(this.allocator);
+        js_ast.Stmt.Data.Store.create(this.allocator);
+        defer js_ast.Expr.Data.Store.reset();
+        defer js_ast.Stmt.Data.Store.reset();
 
-            if (this.options.framework) |framework| {
-                if (this.options.platform.isClient()) {
-                    try this.options.loadDefines(this.allocator, this.env, &framework.client.env);
-                } else {
-                    try this.options.loadDefines(this.allocator, this.env, &framework.server.env);
-                }
+        if (this.options.framework) |framework| {
+            if (this.options.platform.isClient()) {
+                try this.options.loadDefines(this.allocator, this.env, &framework.client.env);
             } else {
-                try this.options.loadDefines(this.allocator, this.env, &this.options.env);
+                try this.options.loadDefines(this.allocator, this.env, &framework.server.env);
             }
+        } else {
+            try this.options.loadDefines(this.allocator, this.env, &this.options.env);
         }
+    }
 
-        pub fn configureFramework(
-            this: *ThisBundler,
-            comptime load_defines: bool,
-        ) !void {
-            if (this.options.framework) |*framework| {
-                if (framework.needsResolveFromPackage()) {
-                    var route_config = this.options.routes;
-                    var pair = PackageJSON.FrameworkRouterPair{ .framework = framework, .router = &route_config };
+    pub fn configureFramework(
+        this: *ThisBundler,
+        comptime load_defines: bool,
+    ) !void {
+        if (this.options.framework) |*framework| {
+            if (framework.needsResolveFromPackage()) {
+                var route_config = this.options.routes;
+                var pair = PackageJSON.FrameworkRouterPair{ .framework = framework, .router = &route_config };
 
-                    if (framework.development) {
-                        try this.resolver.resolveFramework(framework.package, &pair, .development, load_defines);
-                    } else {
-                        try this.resolver.resolveFramework(framework.package, &pair, .production, load_defines);
-                    }
+                if (framework.development) {
+                    try this.resolver.resolveFramework(framework.package, &pair, .development, load_defines);
+                } else {
+                    try this.resolver.resolveFramework(framework.package, &pair, .production, load_defines);
+                }
 
-                    if (this.options.areDefinesUnset()) {
-                        if (this.options.platform.isClient()) {
-                            this.options.env = framework.client.env;
-                        } else {
-                            this.options.env = framework.server.env;
-                        }
+                if (this.options.areDefinesUnset()) {
+                    if (this.options.platform.isClient()) {
+                        this.options.env = framework.client.env;
+                    } else {
+                        this.options.env = framework.server.env;
                     }
+                }
 
-                    if (pair.loaded_routes) {
-                        this.options.routes = route_config;
-                    }
-                    framework.resolved = true;
-                    this.options.framework = framework.*;
-                } else if (!framework.resolved) {
-                    Global.panic("directly passing framework path is not implemented yet!", .{});
+                if (pair.loaded_routes) {
+                    this.options.routes = route_config;
                 }
+                framework.resolved = true;
+                this.options.framework = framework.*;
+            } else if (!framework.resolved) {
+                Global.panic("directly passing framework path is not implemented yet!", .{});
             }
         }
+    }
 
-        pub fn configureFrameworkWithResolveResult(this: *ThisBundler, comptime client: bool) !?_resolver.Result {
-            if (this.options.framework != null) {
-                try this.configureFramework(true);
-                if (comptime client) {
-                    if (this.options.framework.?.client.isEnabled()) {
-                        return try this.resolver.resolve(this.fs.top_level_dir, this.options.framework.?.client.path, .stmt);
-                    }
+    pub fn configureFrameworkWithResolveResult(this: *ThisBundler, comptime client: bool) !?_resolver.Result {
+        if (this.options.framework != null) {
+            try this.configureFramework(true);
+            if (comptime client) {
+                if (this.options.framework.?.client.isEnabled()) {
+                    return try this.resolver.resolve(this.fs.top_level_dir, this.options.framework.?.client.path, .stmt);
+                }
 
-                    if (this.options.framework.?.fallback.isEnabled()) {
-                        return try this.resolver.resolve(this.fs.top_level_dir, this.options.framework.?.fallback.path, .stmt);
-                    }
-                } else {
-                    if (this.options.framework.?.server.isEnabled()) {
-                        return try this.resolver.resolve(this.fs.top_level_dir, this.options.framework.?.server, .stmt);
-                    }
+                if (this.options.framework.?.fallback.isEnabled()) {
+                    return try this.resolver.resolve(this.fs.top_level_dir, this.options.framework.?.fallback.path, .stmt);
+                }
+            } else {
+                if (this.options.framework.?.server.isEnabled()) {
+                    return try this.resolver.resolve(this.fs.top_level_dir, this.options.framework.?.server, .stmt);
                 }
             }
-
-            return null;
         }
 
-        pub fn configureRouter(this: *ThisBundler, comptime load_defines: bool) !void {
-            try this.configureFramework(load_defines);
-            defer {
-                if (load_defines) {
-                    this.configureDefines() catch {};
-                }
+        return null;
+    }
+
+    pub fn configureRouter(this: *ThisBundler, comptime load_defines: bool) !void {
+        try this.configureFramework(load_defines);
+        defer {
+            if (load_defines) {
+                this.configureDefines() catch {};
             }
+        }
 
-            // if you pass just a directory, activate the router configured for the pages directory
-            // for now:
-            // - "." is not supported
-            // - multiple pages directories is not supported
-            if (!this.options.routes.routes_enabled and this.options.entry_points.len == 1 and !this.options.serve) {
-
-                // When inferring:
-                // - pages directory with a file extension is not supported. e.g. "pages.app/" won't work.
-                //     This is a premature optimization to avoid this magical auto-detection we do here from meaningfully increasing startup time if you're just passing a file
-                //     readDirInfo is a recursive lookup, top-down instead of bottom-up. It opens each folder handle and potentially reads the package.jsons
-                // So it is not fast! Unless it's already cached.
-                var paths = [_]string{std.mem.trimLeft(u8, this.options.entry_points[0], "./")};
-                if (std.mem.indexOfScalar(u8, paths[0], '.') == null) {
-                    var pages_dir_buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
-                    var entry = this.fs.absBuf(&paths, &pages_dir_buf);
-
-                    if (std.fs.path.extension(entry).len == 0) {
-                        allocators.constStrToU8(entry).ptr[entry.len] = '/';
-
-                        // Only throw if they actually passed in a route config and the directory failed to load
-                        var dir_info_ = this.resolver.readDirInfo(entry) catch return;
-                        var dir_info = dir_info_ orelse return;
-
-                        this.options.routes.dir = dir_info.abs_path;
-                        this.options.routes.extensions = std.mem.span(&options.RouteConfig.DefaultExtensions);
-                        this.options.routes.routes_enabled = true;
-                        this.router = try Router.init(this.fs, this.allocator, this.options.routes);
-                        try this.router.?.loadRoutes(
-                            dir_info,
-                            Resolver,
-                            &this.resolver,
-                            std.math.maxInt(u16),
-                            true,
-                        );
-                        this.router.?.routes.client_framework_enabled = this.options.isFrontendFrameworkEnabled();
-                        return;
-                    }
+        // if you pass just a directory, activate the router configured for the pages directory
+        // for now:
+        // - "." is not supported
+        // - multiple pages directories is not supported
+        if (!this.options.routes.routes_enabled and this.options.entry_points.len == 1 and !this.options.serve) {
+
+            // When inferring:
+            // - pages directory with a file extension is not supported. e.g. "pages.app/" won't work.
+            //     This is a premature optimization to avoid this magical auto-detection we do here from meaningfully increasing startup time if you're just passing a file
+            //     readDirInfo is a recursive lookup, top-down instead of bottom-up. It opens each folder handle and potentially reads the package.jsons
+            // So it is not fast! Unless it's already cached.
+            var paths = [_]string{std.mem.trimLeft(u8, this.options.entry_points[0], "./")};
+            if (std.mem.indexOfScalar(u8, paths[0], '.') == null) {
+                var pages_dir_buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
+                var entry = this.fs.absBuf(&paths, &pages_dir_buf);
+
+                if (std.fs.path.extension(entry).len == 0) {
+                    allocators.constStrToU8(entry).ptr[entry.len] = '/';
+
+                    // Only throw if they actually passed in a route config and the directory failed to load
+                    var dir_info_ = this.resolver.readDirInfo(entry) catch return;
+                    var dir_info = dir_info_ orelse return;
+
+                    this.options.routes.dir = dir_info.abs_path;
+                    this.options.routes.extensions = std.mem.span(&options.RouteConfig.DefaultExtensions);
+                    this.options.routes.routes_enabled = true;
+                    this.router = try Router.init(this.fs, this.allocator, this.options.routes);
+                    try this.router.?.loadRoutes(
+                        dir_info,
+                        Resolver,
+                        &this.resolver,
+                        std.math.maxInt(u16),
+                        true,
+                    );
+                    this.router.?.routes.client_framework_enabled = this.options.isFrontendFrameworkEnabled();
+                    return;
                 }
-            } else if (this.options.routes.routes_enabled) {
-                var dir_info_ = try this.resolver.readDirInfo(this.options.routes.dir);
-                var dir_info = dir_info_ orelse return error.MissingRoutesDir;
-
-                this.options.routes.dir = dir_info.abs_path;
-
-                this.router = try Router.init(this.fs, this.allocator, this.options.routes);
-                try this.router.?.loadRoutes(dir_info, Resolver, &this.resolver, std.math.maxInt(u16), true);
-                this.router.?.routes.client_framework_enabled = this.options.isFrontendFrameworkEnabled();
-                return;
             }
+        } else if (this.options.routes.routes_enabled) {
+            var dir_info_ = try this.resolver.readDirInfo(this.options.routes.dir);
+            var dir_info = dir_info_ orelse return error.MissingRoutesDir;
 
-            // If we get this far, it means they're trying to run the bundler without a preconfigured router
-            if (this.options.entry_points.len > 0) {
-                this.options.routes.routes_enabled = false;
-            }
+            this.options.routes.dir = dir_info.abs_path;
 
-            if (this.router) |*router| {
-                router.routes.client_framework_enabled = this.options.isFrontendFrameworkEnabled();
-            }
+            this.router = try Router.init(this.fs, this.allocator, this.options.routes);
+            try this.router.?.loadRoutes(dir_info, Resolver, &this.resolver, std.math.maxInt(u16), true);
+            this.router.?.routes.client_framework_enabled = this.options.isFrontendFrameworkEnabled();
+            return;
         }
 
-        pub fn resetStore(bundler: *ThisBundler) void {
-            js_ast.Expr.Data.Store.reset();
-            js_ast.Stmt.Data.Store.reset();
+        // If we get this far, it means they're trying to run the bundler without a preconfigured router
+        if (this.options.entry_points.len > 0) {
+            this.options.routes.routes_enabled = false;
         }
 
-        pub const GenerateNodeModuleBundle = struct {
-            const BunQueue = NewBunQueue(_resolver.Result);
-
-            pub const ThreadPool = struct {
-                // Hardcode 512 as max number of threads for now.
-                workers: [512]Worker = undefined,
-                workers_used: u32 = 0,
-                cpu_count: u32 = 0,
-                started_workers: std.atomic.Atomic(u32) = std.atomic.Atomic(u32).init(0),
-                stopped_workers: std.atomic.Atomic(u32) = std.atomic.Atomic(u32).init(0),
-                completed_count: std.atomic.Atomic(u32) = std.atomic.Atomic(u32).init(0),
-                pub fn start(this: *ThreadPool, generator: *GenerateNodeModuleBundle) !void {
-                    generator.bundler.env.loadProcess();
-
-                    this.cpu_count = @truncate(u32, @divFloor((try std.Thread.getCpuCount()) + 1, 2));
-
-                    if (generator.bundler.env.map.get("GOMAXPROCS")) |max_procs| {
-                        if (std.fmt.parseInt(u32, max_procs, 10)) |cpu_count| {
-                            this.cpu_count = std.math.min(this.cpu_count, cpu_count);
-                        } else |err| {}
-                    }
+        if (this.router) |*router| {
+            router.routes.client_framework_enabled = this.options.isFrontendFrameworkEnabled();
+        }
+    }
 
-                    if (this.cpu_count <= 1) return;
+    pub fn resetStore(bundler: *ThisBundler) void {
+        js_ast.Expr.Data.Store.reset();
+        js_ast.Stmt.Data.Store.reset();
+    }
 
-                    while (this.workers_used < this.cpu_count) : (this.workers_used += 1) {
-                        try this.workers[this.workers_used].init(generator);
-                    }
+    pub const GenerateNodeModuleBundle = struct {
+        const BunQueue = NewBunQueue(_resolver.Result);
+
+        pub const ThreadPool = struct {
+            // Hardcode 512 as max number of threads for now.
+            workers: [512]Worker = undefined,
+            workers_used: u32 = 0,
+            cpu_count: u32 = 0,
+            started_workers: std.atomic.Atomic(u32) = std.atomic.Atomic(u32).init(0),
+            stopped_workers: std.atomic.Atomic(u32) = std.atomic.Atomic(u32).init(0),
+            completed_count: std.atomic.Atomic(u32) = std.atomic.Atomic(u32).init(0),
+            pub fn start(this: *ThreadPool, generator: *GenerateNodeModuleBundle) !void {
+                generator.bundler.env.loadProcess();
+
+                this.cpu_count = @truncate(u32, @divFloor((try std.Thread.getCpuCount()) + 1, 2));
+
+                if (generator.bundler.env.map.get("GOMAXPROCS")) |max_procs| {
+                    if (std.fmt.parseInt(u32, max_procs, 10)) |cpu_count| {
+                        this.cpu_count = std.math.min(this.cpu_count, cpu_count);
+                    } else |err| {}
                 }
 
-                pub fn wait(this: *ThreadPool, generator: *GenerateNodeModuleBundle) !void {
-                    if (this.cpu_count <= 1) {
-                        var worker = generator.allocator.create(Worker) catch unreachable;
-                        worker.* = Worker{
-                            .generator = generator,
-                            .allocator = generator.allocator,
-                            .data = generator.allocator.create(Worker.WorkerData) catch unreachable,
-                            .thread_id = undefined,
-                            .thread = undefined,
-                        };
-                        worker.data.shared_buffer = try MutableString.init(generator.allocator, 0);
-                        worker.data.scan_pass_result = js_parser.ScanPassResult.init(generator.allocator);
-                        worker.data.log = generator.log;
+                if (this.cpu_count <= 1) return;
 
-                        defer {
-                            worker.data.deinit(generator.allocator);
-                        }
+                while (this.workers_used < this.cpu_count) : (this.workers_used += 1) {
+                    try this.workers[this.workers_used].init(generator);
+                }
+            }
 
-                        while (generator.queue.next()) |item| {
-                            try generator.processFile(worker, item);
-                        }
+            pub fn wait(this: *ThreadPool, generator: *GenerateNodeModuleBundle) !void {
+                if (this.cpu_count <= 1) {
+                    var worker = generator.allocator.create(Worker) catch unreachable;
+                    worker.* = Worker{
+                        .generator = generator,
+                        .allocator = generator.allocator,
+                        .data = generator.allocator.create(Worker.WorkerData) catch unreachable,
+                        .thread_id = undefined,
+                        .thread = undefined,
+                    };
+                    worker.data.shared_buffer = try MutableString.init(generator.allocator, 0);
+                    worker.data.scan_pass_result = js_parser.ScanPassResult.init(generator.allocator);
+                    worker.data.log = generator.log;
 
-                        generator.estimated_input_lines_of_code = worker.data.estimated_input_lines_of_code;
-                        return;
+                    defer {
+                        worker.data.deinit(generator.allocator);
                     }
 
-                    while (generator.queue.count.load(.SeqCst) != generator.pool.completed_count.load(.SeqCst)) {
-                        var j: usize = 0;
-                        while (j < 100) : (j += 1) {}
-                        std.atomic.spinLoopHint();
+                    while (generator.queue.next()) |item| {
+                        try generator.processFile(worker, item);
                     }
 
-                    for (this.workers[0..this.workers_used]) |*worker| {
-                        @atomicStore(bool, &worker.quit, true, .Release);
-                    }
+                    generator.estimated_input_lines_of_code = worker.data.estimated_input_lines_of_code;
+                    return;
+                }
 
-                    while (this.stopped_workers.load(.Acquire) != this.workers_used) {
-                        var j: usize = 0;
-                        while (j < 100) : (j += 1) {}
-                        std.atomic.spinLoopHint();
-                    }
+                while (generator.queue.count.load(.SeqCst) != generator.pool.completed_count.load(.SeqCst)) {
+                    var j: usize = 0;
+                    while (j < 100) : (j += 1) {}
+                    std.atomic.spinLoopHint();
+                }
 
-                    for (this.workers[0..this.workers_used]) |*worker| {
-                        worker.thread.join();
-                    }
+                for (this.workers[0..this.workers_used]) |*worker| {
+                    @atomicStore(bool, &worker.quit, true, .Release);
                 }
 
-                pub const Task = struct {
-                    result: _resolver.Result,
-                    generator: *GenerateNodeModuleBundle,
-                };
+                while (this.stopped_workers.load(.Acquire) != this.workers_used) {
+                    var j: usize = 0;
+                    while (j < 100) : (j += 1) {}
+                    std.atomic.spinLoopHint();
+                }
 
-                pub const Worker = struct {
-                    thread_id: std.Thread.Id,
-                    thread: std.Thread,
+                for (this.workers[0..this.workers_used]) |*worker| {
+                    worker.thread.join();
+                }
+            }
 
-                    allocator: *std.mem.Allocator,
-                    generator: *GenerateNodeModuleBundle,
-                    data: *WorkerData = undefined,
-                    quit: bool = false,
+            pub const Task = struct {
+                result: _resolver.Result,
+                generator: *GenerateNodeModuleBundle,
+            };
 
-                    has_notify_started: bool = false,
+            pub const Worker = struct {
+                thread_id: std.Thread.Id,
+                thread: std.Thread,
 
-                    pub const WorkerData = struct {
-                        shared_buffer: MutableString = undefined,
-                        scan_pass_result: js_parser.ScanPassResult = undefined,
-                        log: *logger.Log,
-                        estimated_input_lines_of_code: usize = 0,
+                allocator: *std.mem.Allocator,
+                generator: *GenerateNodeModuleBundle,
+                data: *WorkerData = undefined,
+                quit: bool = false,
+
+                has_notify_started: bool = false,
+
+                pub const WorkerData = struct {
+                    shared_buffer: MutableString = undefined,
+                    scan_pass_result: js_parser.ScanPassResult = undefined,
+                    log: *logger.Log,
+                    estimated_input_lines_of_code: usize = 0,
+
+                    pub fn deinit(this: *WorkerData, allocator: *std.mem.Allocator) void {
+                        this.shared_buffer.deinit();
+                        this.scan_pass_result.named_imports.deinit();
+                        this.scan_pass_result.import_records.deinit();
+                        allocator.destroy(this);
+                    }
+                };
 
-                        pub fn deinit(this: *WorkerData, allocator: *std.mem.Allocator) void {
-                            this.shared_buffer.deinit();
-                            this.scan_pass_result.named_imports.deinit();
-                            this.scan_pass_result.import_records.deinit();
-                            allocator.destroy(this);
-                        }
-                    };
+                pub fn init(worker: *Worker, generator: *GenerateNodeModuleBundle) !void {
+                    worker.generator = generator;
+                    worker.allocator = generator.allocator;
+                    worker.thread = try std.Thread.spawn(.{}, Worker.run, .{worker});
+                }
 
-                    pub fn init(worker: *Worker, generator: *GenerateNodeModuleBundle) !void {
-                        worker.generator = generator;
-                        worker.allocator = generator.allocator;
-                        worker.thread = try std.Thread.spawn(.{}, Worker.run, .{worker});
+                pub fn notifyStarted(this: *Worker) void {
+                    if (!this.has_notify_started) {
+                        this.has_notify_started = true;
+                        _ = this.generator.pool.started_workers.fetchAdd(1, .Release);
+                        std.Thread.Futex.wake(&this.generator.pool.started_workers, std.math.maxInt(u32));
                     }
+                }
 
-                    pub fn notifyStarted(this: *Worker) void {
-                        if (!this.has_notify_started) {
-                            this.has_notify_started = true;
-                            _ = this.generator.pool.started_workers.fetchAdd(1, .Release);
-                            std.Thread.Futex.wake(&this.generator.pool.started_workers, std.math.maxInt(u32));
-                        }
+                pub fn run(this: *Worker) void {
+                    Output.Source.configureThread();
+                    this.thread_id = std.Thread.getCurrentId();
+                    if (isDebug) {
+                        Output.prettyln("Thread started.\n", .{});
                     }
-
-                    pub fn run(this: *Worker) void {
-                        Output.Source.configureThread();
-                        this.thread_id = std.Thread.getCurrentId();
+                    defer {
                         if (isDebug) {
-                            Output.prettyln("Thread started.\n", .{});
+                            Output.prettyln("Thread stopped.\n", .{});
                         }
-                        defer {
-                            if (isDebug) {
-                                Output.prettyln("Thread stopped.\n", .{});
-                            }
-                            Output.flush();
-                        }
-
-                        this.loop() catch |err| {
-                            Output.prettyErrorln("<r><red>Error: {s}<r>", .{@errorName(err)});
-                        };
+                        Output.flush();
                     }
 
-                    pub fn loop(this: *Worker) anyerror!void {
-                        defer {
-                            _ = this.generator.pool.stopped_workers.fetchAdd(1, .Release);
-                            this.notifyStarted();
+                    this.loop() catch |err| {
+                        Output.prettyErrorln("<r><red>Error: {s}<r>", .{@errorName(err)});
+                    };
+                }
 
-                            std.Thread.Futex.wake(&this.generator.pool.stopped_workers, 1);
-                            // std.Thread.Futex.wake(&this.generator.queue.len, std.math.maxInt(u32));
-                        }
+                pub fn loop(this: *Worker) anyerror!void {
+                    defer {
+                        _ = this.generator.pool.stopped_workers.fetchAdd(1, .Release);
+                        this.notifyStarted();
 
-                        js_ast.Expr.Data.Store.create(this.generator.allocator);
-                        js_ast.Stmt.Data.Store.create(this.generator.allocator);
-                        this.data = this.generator.allocator.create(WorkerData) catch unreachable;
-                        this.data.* = WorkerData{
-                            .log = this.generator.allocator.create(logger.Log) catch unreachable,
-                            .estimated_input_lines_of_code = 0,
-                        };
-                        this.data.log.* = logger.Log.init(this.generator.allocator);
-                        this.data.shared_buffer = try MutableString.init(this.generator.allocator, 0);
-                        this.data.scan_pass_result = js_parser.ScanPassResult.init(this.generator.allocator);
-
-                        defer {
-                            {
-                                this.generator.log_lock.lock();
-                                this.data.log.appendTo(this.generator.log) catch {};
-                                this.generator.estimated_input_lines_of_code += this.data.estimated_input_lines_of_code;
-                                this.generator.log_lock.unlock();
-                            }
+                        std.Thread.Futex.wake(&this.generator.pool.stopped_workers, 1);
+                        // std.Thread.Futex.wake(&this.generator.queue.len, std.math.maxInt(u32));
+                    }
 
-                            this.data.deinit(this.generator.allocator);
+                    js_ast.Expr.Data.Store.create(this.generator.allocator);
+                    js_ast.Stmt.Data.Store.create(this.generator.allocator);
+                    this.data = this.generator.allocator.create(WorkerData) catch unreachable;
+                    this.data.* = WorkerData{
+                        .log = this.generator.allocator.create(logger.Log) catch unreachable,
+                        .estimated_input_lines_of_code = 0,
+                    };
+                    this.data.log.* = logger.Log.init(this.generator.allocator);
+                    this.data.shared_buffer = try MutableString.init(this.generator.allocator, 0);
+                    this.data.scan_pass_result = js_parser.ScanPassResult.init(this.generator.allocator);
+
+                    defer {
+                        {
+                            this.generator.log_lock.lock();
+                            this.data.log.appendTo(this.generator.log) catch {};
+                            this.generator.estimated_input_lines_of_code += this.data.estimated_input_lines_of_code;
+                            this.generator.log_lock.unlock();
                         }
 
-                        this.notifyStarted();
+                        this.data.deinit(this.generator.allocator);
+                    }
 
-                        while (!@atomicLoad(bool, &this.quit, .Acquire)) {
-                            while (this.generator.queue.next()) |item| {
-                                defer {
-                                    _ = this.generator.pool.completed_count.fetchAdd(1, .Release);
-                                }
+                    this.notifyStarted();
 
-                                try this.generator.processFile(this, item);
+                    while (!@atomicLoad(bool, &this.quit, .Acquire)) {
+                        while (this.generator.queue.next()) |item| {
+                            defer {
+                                _ = this.generator.pool.completed_count.fetchAdd(1, .Release);
                             }
+
+                            try this.generator.processFile(this, item);
                         }
                     }
-                };
-            };
-            write_lock: Lock,
-            log_lock: Lock = Lock.init(),
-            module_list: std.ArrayList(Api.JavascriptBundledModule),
-            package_list: std.ArrayList(Api.JavascriptBundledPackage),
-            header_string_buffer: MutableString,
-
-            // Just need to know if we've already enqueued this one
-            package_list_map: std.AutoHashMap(u64, u32),
-            queue: *BunQueue,
-            bundler: *ThisBundler,
-            allocator: *std.mem.Allocator,
-            tmpfile: std.fs.File,
-            log: *logger.Log,
-            pool: *ThreadPool,
-            tmpfile_byte_offset: u32 = 0,
-            code_end_byte_offset: u32 = 0,
-            has_jsx: bool = false,
-            estimated_input_lines_of_code: usize = 0,
-
-            work_waiter: std.atomic.Atomic(u32) = std.atomic.Atomic(u32).init(0),
-            list_lock: Lock = Lock.init(),
-
-            dynamic_import_file_size_store: U32Map,
-            dynamic_import_file_size_store_lock: Lock,
-
-            always_bundled_package_hashes: []u32 = &[_]u32{},
-            always_bundled_package_jsons: []*const PackageJSON = &.{},
-
-            const U32Map = std.AutoHashMap(u32, u32);
-            pub const current_version: u32 = 1;
-            const dist_index_js_string_pointer = Api.StringPointer{ .length = "dist/index.js".len };
-            const index_js_string_pointer = Api.StringPointer{ .length = "index.js".len, .offset = "dist/".len };
-
-            pub fn enqueueItem(this: *GenerateNodeModuleBundle, resolve: _resolver.Result) !void {
-                var result = resolve;
-                var path = result.path() orelse return;
-
-                const loader = this.bundler.options.loaders.get(path.name.ext) orelse .file;
-                if (!loader.isJavaScriptLikeOrJSON()) return;
-                path.* = try path.dupeAlloc(this.allocator);
-
-                if (BundledModuleData.get(this, &result)) |mod| {
-                    try this.queue.upsert(mod.module_id, result);
-                } else {
-                    try this.queue.upsert(result.hash(this.bundler.fs.top_level_dir, loader), result);
                 }
-            }
-
-            // The Bun Bundle Format
-            // All the node_modules your app uses in a single compact file with metadata
-            // A binary JavaScript bundle format prioritizing generation time and deserialization time
-            pub const magic_bytes = "#!/usr/bin/env bun\n\n";
-            // This makes it possible to do ./path-to-bundle on posix systems so you can see the raw JS contents
-            // https://en.wikipedia.org/wiki/Magic_number_(programming)#In_files
-            // Immediately after the magic bytes, the next character is a uint32 followed by a newline
-            // 0x00000000\n
-            // That uint32 denotes the byte offset in the file where the code for the bundle ends
-            //     - If the value is 0, that means the file did not finish writing or there are no modules
-            //     - This imposes a maximum bundle size of around 4,294,967,295 bytes. If your JS is more than 4 GB, it won't work.
-            // The raw JavaScript is encoded as a UTF-8 string starting from the current position + 1 until the above byte offset.
-            // This uint32 is useful for HTTP servers to separate:
-            // - Which part of the bundle is the JS code?
-            // - Which part is the metadata?
-            // Without needing to do a full pass through the file, or necessarily care about the metadata.
-            // The metadata is at the bottom of the file instead of the top because the metadata is written after all JS code in the bundle is written.
-            // The rationale there is:
-            // 1. We cannot prepend to a file without rewriting the entire file
-            // 2. The metadata is variable-length and that format will change often.
-            // 3. We won't have all the metadata until after all JS is finished writing
-            // If you have 32 MB of JavaScript dependencies, you really want to avoid reading the code in memory.
-            //      - This lets you seek to the specific position in the file.
-            //      - HTTP servers should use sendfile() instead of copying the file to userspace memory.
-            // So instead, we append metadata to the file after printing each node_module
-            // When there are no more modules to process, we generate the metadata
-            // To find the metadata, you look at the byte offset: initial_header[magic_bytes.len..initial_header.len - 1]
-            // Then, you add that number to initial_header.len
-            const initial_header = brk: {
-                var buf = std.mem.zeroes([magic_bytes.len + 5]u8);
-                std.mem.copy(u8, &buf, magic_bytes);
-                var remainder = buf[magic_bytes.len..];
-                // Write an invalid byte offset to be updated after we finish generating the code
-                std.mem.writeIntNative(u32, remainder[0 .. remainder.len - 1], 0);
-                buf[buf.len - 1] = '\n';
-                break :brk buf;
             };
-            const code_start_byte_offset: u32 = initial_header.len;
-            // The specifics of the metadata is not documented here. You can find it in src/api/schema.peechy.
-
-            pub fn appendHeaderString(generator: *GenerateNodeModuleBundle, str: string) !Api.StringPointer {
-                // This is so common we might as well just reuse it
-                // Plus this is one machine word so it's a quick comparison
-                if (strings.eqlComptime(str, "index.js")) {
-                    return index_js_string_pointer;
-                } else if (strings.eqlComptime(str, "dist/index.js")) {
-                    return dist_index_js_string_pointer;
-                }
+        };
+        write_lock: Lock,
+        log_lock: Lock = Lock.init(),
+        module_list: std.ArrayList(Api.JavascriptBundledModule),
+        package_list: std.ArrayList(Api.JavascriptBundledPackage),
+        header_string_buffer: MutableString,
+
+        // Just need to know if we've already enqueued this one
+        package_list_map: std.AutoHashMap(u64, u32),
+        queue: *BunQueue,
+        bundler: *ThisBundler,
+        allocator: *std.mem.Allocator,
+        tmpfile: std.fs.File,
+        log: *logger.Log,
+        pool: *ThreadPool,
+        tmpfile_byte_offset: u32 = 0,
+        code_end_byte_offset: u32 = 0,
+        has_jsx: bool = false,
+        estimated_input_lines_of_code: usize = 0,
 
-                var offset = generator.header_string_buffer.list.items.len;
-                try generator.header_string_buffer.append(str);
-                return Api.StringPointer{
-                    .offset = @truncate(u32, offset),
-                    .length = @truncate(u32, str.len),
-                };
+        work_waiter: std.atomic.Atomic(u32) = std.atomic.Atomic(u32).init(0),
+        list_lock: Lock = Lock.init(),
+
+        dynamic_import_file_size_store: U32Map,
+        dynamic_import_file_size_store_lock: Lock,
+
+        always_bundled_package_hashes: []u32 = &[_]u32{},
+        always_bundled_package_jsons: []*const PackageJSON = &.{},
+
+        const U32Map = std.AutoHashMap(u32, u32);
+        pub const current_version: u32 = 1;
+        const dist_index_js_string_pointer = Api.StringPointer{ .length = "dist/index.js".len };
+        const index_js_string_pointer = Api.StringPointer{ .length = "index.js".len, .offset = "dist/".len };
+
+        pub fn enqueueItem(this: *GenerateNodeModuleBundle, resolve: _resolver.Result) !void {
+            var result = resolve;
+            var path = result.path() orelse return;
+
+            const loader = this.bundler.options.loaders.get(path.name.ext) orelse .file;
+            if (!loader.isJavaScriptLikeOrJSON()) return;
+            path.* = try path.dupeAlloc(this.allocator);
+
+            if (BundledModuleData.get(this, &result)) |mod| {
+                try this.queue.upsert(mod.module_id, result);
+            } else {
+                try this.queue.upsert(result.hash(this.bundler.fs.top_level_dir, loader), result);
             }
+        }
 
-            pub fn generate(
-                bundler: *ThisBundler,
-                allocator: *std.mem.Allocator,
-                framework_config: ?Api.LoadedFramework,
-                route_config: ?Api.LoadedRouteConfig,
-                destination: [*:0]const u8,
-                estimated_input_lines_of_code: *usize,
-            ) !?Api.JavascriptBundleContainer {
-                var tmpdir: std.fs.Dir = try bundler.fs.fs.openTmpDir();
-                var tmpname_buf: [64]u8 = undefined;
-                bundler.resetStore();
-                try bundler.configureDefines();
-
-                const tmpname = try bundler.fs.tmpname(
-                    ".bun",
-                    std.mem.span(&tmpname_buf),
-                    std.hash.Wyhash.hash(0, std.mem.span(destination)),
-                );
+        // The Bun Bundle Format
+        // All the node_modules your app uses in a single compact file with metadata
+        // A binary JavaScript bundle format prioritizing generation time and deserialization time
+        pub const magic_bytes = "#!/usr/bin/env bun\n\n";
+        // This makes it possible to do ./path-to-bundle on posix systems so you can see the raw JS contents
+        // https://en.wikipedia.org/wiki/Magic_number_(programming)#In_files
+        // Immediately after the magic bytes, the next character is a uint32 followed by a newline
+        // 0x00000000\n
+        // That uint32 denotes the byte offset in the file where the code for the bundle ends
+        //     - If the value is 0, that means the file did not finish writing or there are no modules
+        //     - This imposes a maximum bundle size of around 4,294,967,295 bytes. If your JS is more than 4 GB, it won't work.
+        // The raw JavaScript is encoded as a UTF-8 string starting from the current position + 1 until the above byte offset.
+        // This uint32 is useful for HTTP servers to separate:
+        // - Which part of the bundle is the JS code?
+        // - Which part is the metadata?
+        // Without needing to do a full pass through the file, or necessarily care about the metadata.
+        // The metadata is at the bottom of the file instead of the top because the metadata is written after all JS code in the bundle is written.
+        // The rationale there is:
+        // 1. We cannot prepend to a file without rewriting the entire file
+        // 2. The metadata is variable-length and that format will change often.
+        // 3. We won't have all the metadata until after all JS is finished writing
+        // If you have 32 MB of JavaScript dependencies, you really want to avoid reading the code in memory.
+        //      - This lets you seek to the specific position in the file.
+        //      - HTTP servers should use sendfile() instead of copying the file to userspace memory.
+        // So instead, we append metadata to the file after printing each node_module
+        // When there are no more modules to process, we generate the metadata
+        // To find the metadata, you look at the byte offset: initial_header[magic_bytes.len..initial_header.len - 1]
+        // Then, you add that number to initial_header.len
+        const initial_header = brk: {
+            var buf = std.mem.zeroes([magic_bytes.len + 5]u8);
+            std.mem.copy(u8, &buf, magic_bytes);
+            var remainder = buf[magic_bytes.len..];
+            // Write an invalid byte offset to be updated after we finish generating the code
+            std.mem.writeIntNative(u32, remainder[0 .. remainder.len - 1], 0);
+            buf[buf.len - 1] = '\n';
+            break :brk buf;
+        };
+        const code_start_byte_offset: u32 = initial_header.len;
+        // The specifics of the metadata is not documented here. You can find it in src/api/schema.peechy.
+
+        pub fn appendHeaderString(generator: *GenerateNodeModuleBundle, str: string) !Api.StringPointer {
+            // This is so common we might as well just reuse it
+            // Plus this is one machine word so it's a quick comparison
+            if (strings.eqlComptime(str, "index.js")) {
+                return index_js_string_pointer;
+            } else if (strings.eqlComptime(str, "dist/index.js")) {
+                return dist_index_js_string_pointer;
+            }
 
-                var tmpfile = try tmpdir.createFileZ(tmpname, .{ .read = isDebug, .exclusive = true });
+            var offset = generator.header_string_buffer.list.items.len;
+            try generator.header_string_buffer.append(str);
+            return Api.StringPointer{
+                .offset = @truncate(u32, offset),
+                .length = @truncate(u32, str.len),
+            };
+        }
 
-                errdefer {
-                    tmpfile.close();
-                    tmpdir.deleteFile(std.mem.span(tmpname)) catch {};
-                }
+        pub fn generate(
+            bundler: *ThisBundler,
+            allocator: *std.mem.Allocator,
+            framework_config: ?Api.LoadedFramework,
+            route_config: ?Api.LoadedRouteConfig,
+            destination: [*:0]const u8,
+            estimated_input_lines_of_code: *usize,
+        ) !?Api.JavascriptBundleContainer {
+            var tmpdir: std.fs.Dir = try bundler.fs.fs.openTmpDir();
+            var tmpname_buf: [64]u8 = undefined;
+            bundler.resetStore();
+            try bundler.configureDefines();
 
-                var generator = try allocator.create(GenerateNodeModuleBundle);
-                var queue = try BunQueue.init(allocator);
-                defer allocator.destroy(generator);
-                generator.* = GenerateNodeModuleBundle{
-                    .module_list = std.ArrayList(Api.JavascriptBundledModule).init(allocator),
-                    .package_list = std.ArrayList(Api.JavascriptBundledPackage).init(allocator),
-                    .header_string_buffer = try MutableString.init(allocator, "dist/index.js".len),
-                    .allocator = allocator,
-                    .queue = queue,
-                    .estimated_input_lines_of_code = 0,
-                    // .resolve_queue = queue,
-                    .bundler = bundler,
-                    .tmpfile = tmpfile,
-
-                    .dynamic_import_file_size_store = U32Map.init(allocator),
-                    .dynamic_import_file_size_store_lock = Lock.init(),
-                    .log = bundler.log,
-                    .package_list_map = std.AutoHashMap(u64, u32).init(allocator),
-                    .pool = undefined,
-                    .write_lock = Lock.init(),
-                };
-                // dist/index.js appears more common than /index.js
-                // but this means we can store both "dist/index.js" and "index.js" in one.
-                try generator.header_string_buffer.append("dist/index.js");
-                try generator.package_list_map.ensureTotalCapacity(128);
-                var pool = try allocator.create(ThreadPool);
-                pool.* = ThreadPool{};
-                generator.pool = pool;
-
-                var this = generator;
-                // Always inline the runtime into the bundle
-                try generator.appendBytes(&initial_header);
-                // If we try to be smart and rely on .written, it turns out incorrect
-                const code_start_pos = try this.tmpfile.getPos();
-                if (isDebug) {
-                    try generator.appendBytes(runtime.Runtime.sourceContent());
-                    try generator.appendBytes("\n\n");
-                } else {
-                    try generator.appendBytes(comptime runtime.Runtime.sourceContent() ++ "\n\n");
-                }
+            const tmpname = try bundler.fs.tmpname(
+                ".bun",
+                std.mem.span(&tmpname_buf),
+                std.hash.Wyhash.hash(0, std.mem.span(destination)),
+            );
 
-                if (bundler.log.level == .verbose) {
-                    bundler.resolver.debug_logs = try DebugLogs.init(allocator);
-                }
+            var tmpfile = try tmpdir.createFileZ(tmpname, .{ .read = isDebug, .exclusive = true });
 
-                always_bundled: {
-                    const root_package_json_resolved: _resolver.Result = bundler.resolver.resolve(bundler.fs.top_level_dir, "./package.json", .stmt) catch |err| {
-                        generator.log.addWarning(null, logger.Loc.Empty, "Please run `bun bun` from a directory containing a package.json.") catch unreachable;
-                        break :always_bundled;
-                    };
-                    const root_package_json = root_package_json_resolved.package_json orelse brk: {
-                        const read_dir = (bundler.resolver.readDirInfo(bundler.fs.top_level_dir) catch unreachable).?;
-                        break :brk read_dir.package_json.?;
-                    };
-                    if (root_package_json.always_bundle.len > 0) {
-                        var always_bundled_package_jsons = bundler.allocator.alloc(*PackageJSON, root_package_json.always_bundle.len) catch unreachable;
-                        var always_bundled_package_hashes = bundler.allocator.alloc(u32, root_package_json.always_bundle.len) catch unreachable;
-                        var i: u16 = 0;
-
-                        inner: for (root_package_json.always_bundle) |name| {
-                            std.mem.copy(u8, &tmp_buildfile_buf, name);
-                            std.mem.copy(u8, tmp_buildfile_buf[name.len..], "/package.json");
-                            const package_json_import = tmp_buildfile_buf[0 .. name.len + "/package.json".len];
-                            const result = bundler.resolver.resolve(bundler.fs.top_level_dir, package_json_import, .stmt) catch |err| {
-                                generator.log.addErrorFmt(null, logger.Loc.Empty, bundler.allocator, "{s} resolving always bundled module \"{s}\"", .{ @errorName(err), name }) catch unreachable;
-                                continue :inner;
-                            };
+            errdefer {
+                tmpfile.close();
+                tmpdir.deleteFile(std.mem.span(tmpname)) catch {};
+            }
 
-                            var package_json: *PackageJSON = result.package_json orelse brk: {
-                                const read_dir = (bundler.resolver.readDirInfo(package_json_import) catch unreachable).?;
-                                if (read_dir.package_json == null) {
-                                    generator.log.addWarningFmt(null, logger.Loc.Empty, bundler.allocator, "{s} missing package.json. It will not be bundled", .{name}) catch unreachable;
-                                    continue :inner;
-                                }
-                                break :brk read_dir.package_json.?;
-                            };
+            var generator = try allocator.create(GenerateNodeModuleBundle);
+            var queue = try BunQueue.init(allocator);
+            defer allocator.destroy(generator);
+            generator.* = GenerateNodeModuleBundle{
+                .module_list = std.ArrayList(Api.JavascriptBundledModule).init(allocator),
+                .package_list = std.ArrayList(Api.JavascriptBundledPackage).init(allocator),
+                .header_string_buffer = try MutableString.init(allocator, "dist/index.js".len),
+                .allocator = allocator,
+                .queue = queue,
+                .estimated_input_lines_of_code = 0,
+                // .resolve_queue = queue,
+                .bundler = bundler,
+                .tmpfile = tmpfile,
+
+                .dynamic_import_file_size_store = U32Map.init(allocator),
+                .dynamic_import_file_size_store_lock = Lock.init(),
+                .log = bundler.log,
+                .package_list_map = std.AutoHashMap(u64, u32).init(allocator),
+                .pool = undefined,
+                .write_lock = Lock.init(),
+            };
+            // dist/index.js appears more common than /index.js
+            // but this means we can store both "dist/index.js" and "index.js" in one.
+            try generator.header_string_buffer.append("dist/index.js");
+            try generator.package_list_map.ensureTotalCapacity(128);
+            var pool = try allocator.create(ThreadPool);
+            pool.* = ThreadPool{};
+            generator.pool = pool;
+
+            var this = generator;
+            // Always inline the runtime into the bundle
+            try generator.appendBytes(&initial_header);
+            // If we try to be smart and rely on .written, it turns out incorrect
+            const code_start_pos = try this.tmpfile.getPos();
+            if (isDebug) {
+                try generator.appendBytes(runtime.Runtime.sourceContent());
+                try generator.appendBytes("\n\n");
+            } else {
+                try generator.appendBytes(comptime runtime.Runtime.sourceContent() ++ "\n\n");
+            }
 
-                            package_json.source.key_path = result.path_pair.primary;
-
-                            // if (!strings.contains(result.path_pair.primary.text, package_json.name)) {
-                            //     generator.log.addErrorFmt(
-                            //         null,
-                            //         logger.Loc.Empty,
-                            //         bundler.allocator,
-                            //         "Bundling \"{s}\" is not supported because the package isn.\n To fix this, move the package's code to a directory containing the name.\n Location: \"{s}\"",
-                            //         .{
-                            //             name,
-                            //             name,
-                            //             result.path_pair.primary.text,
-                            //         },
-                            //     ) catch unreachable;
-                            //     continue :inner;
-                            // }
+            if (bundler.log.level == .verbose) {
+                bundler.resolver.debug_logs = try DebugLogs.init(allocator);
+            }
 
-                            always_bundled_package_jsons[i] = package_json;
-                            always_bundled_package_hashes[i] = package_json.hash;
-                            i += 1;
-                        }
-                        generator.always_bundled_package_hashes = always_bundled_package_hashes[0..i];
-                        generator.always_bundled_package_jsons = always_bundled_package_jsons[0..i];
+            always_bundled: {
+                const root_package_json_resolved: _resolver.Result = bundler.resolver.resolve(bundler.fs.top_level_dir, "./package.json", .stmt) catch |err| {
+                    generator.log.addWarning(null, logger.Loc.Empty, "Please run `bun bun` from a directory containing a package.json.") catch unreachable;
+                    break :always_bundled;
+                };
+                const root_package_json = root_package_json_resolved.package_json orelse brk: {
+                    const read_dir = (bundler.resolver.readDirInfo(bundler.fs.top_level_dir) catch unreachable).?;
+                    break :brk read_dir.package_json.?;
+                };
+                if (root_package_json.always_bundle.len > 0) {
+                    var always_bundled_package_jsons = bundler.allocator.alloc(*PackageJSON, root_package_json.always_bundle.len) catch unreachable;
+                    var always_bundled_package_hashes = bundler.allocator.alloc(u32, root_package_json.always_bundle.len) catch unreachable;
+                    var i: u16 = 0;
+
+                    inner: for (root_package_json.always_bundle) |name| {
+                        std.mem.copy(u8, &tmp_buildfile_buf, name);
+                        std.mem.copy(u8, tmp_buildfile_buf[name.len..], "/package.json");
+                        const package_json_import = tmp_buildfile_buf[0 .. name.len + "/package.json".len];
+                        const result = bundler.resolver.resolve(bundler.fs.top_level_dir, package_json_import, .stmt) catch |err| {
+                            generator.log.addErrorFmt(null, logger.Loc.Empty, bundler.allocator, "{s} resolving always bundled module \"{s}\"", .{ @errorName(err), name }) catch unreachable;
+                            continue :inner;
+                        };
+
+                        var package_json: *PackageJSON = result.package_json orelse brk: {
+                            const read_dir = (bundler.resolver.readDirInfo(package_json_import) catch unreachable).?;
+                            if (read_dir.package_json == null) {
+                                generator.log.addWarningFmt(null, logger.Loc.Empty, bundler.allocator, "{s} missing package.json. It will not be bundled", .{name}) catch unreachable;
+                                continue :inner;
+                            }
+                            break :brk read_dir.package_json.?;
+                        };
+
+                        package_json.source.key_path = result.path_pair.primary;
+
+                        // if (!strings.contains(result.path_pair.primary.text, package_json.name)) {
+                        //     generator.log.addErrorFmt(
+                        //         null,
+                        //         logger.Loc.Empty,
+                        //         bundler.allocator,
+                        //         "Bundling \"{s}\" is not supported because the package isn.\n To fix this, move the package's code to a directory containing the name.\n Location: \"{s}\"",
+                        //         .{
+                        //             name,
+                        //             name,
+                        //             result.path_pair.primary.text,
+                        //         },
+                        //     ) catch unreachable;
+                        //     continue :inner;
+                        // }
+
+                        always_bundled_package_jsons[i] = package_json;
+                        always_bundled_package_hashes[i] = package_json.hash;
+                        i += 1;
                     }
+                    generator.always_bundled_package_hashes = always_bundled_package_hashes[0..i];
+                    generator.always_bundled_package_jsons = always_bundled_package_jsons[0..i];
                 }
-                if (generator.log.errors > 0) return error.BundleFailed;
-
-                const include_refresh_runtime =
-                    !this.bundler.options.production and
-                    this.bundler.options.jsx.supports_fast_refresh and
-                    bundler.options.platform.isWebLike();
-
-                const resolve_queue_estimate = bundler.options.entry_points.len +
-                    @intCast(usize, @boolToInt(framework_config != null)) +
-                    @intCast(usize, @boolToInt(include_refresh_runtime)) +
-                    @intCast(usize, @boolToInt(bundler.options.jsx.parse));
-
-                if (bundler.router) |router| {
-                    defer this.bundler.resetStore();
-
-                    const entry_points = try router.getEntryPoints(allocator);
-                    for (entry_points) |entry_point| {
-                        const source_dir = bundler.fs.top_level_dir;
-                        const resolved = try bundler.linker.resolver.resolve(source_dir, entry_point, .entry_point);
-                        try this.enqueueItem(resolved);
-                    }
-                    this.bundler.resetStore();
-                } else {}
+            }
+            if (generator.log.errors > 0) return error.BundleFailed;
+
+            const include_refresh_runtime =
+                !this.bundler.options.production and
+                this.bundler.options.jsx.supports_fast_refresh and
+                bundler.options.platform.isWebLike();
 
-                for (bundler.options.entry_points) |entry_point| {
-                    if (bundler.options.platform == .bun) continue;
-                    defer this.bundler.resetStore();
+            const resolve_queue_estimate = bundler.options.entry_points.len +
+                @intCast(usize, @boolToInt(framework_config != null)) +
+                @intCast(usize, @boolToInt(include_refresh_runtime)) +
+                @intCast(usize, @boolToInt(bundler.options.jsx.parse));
 
-                    const entry_point_path = bundler.normalizeEntryPointPath(entry_point);
+            if (bundler.router) |router| {
+                defer this.bundler.resetStore();
+
+                const entry_points = try router.getEntryPoints(allocator);
+                for (entry_points) |entry_point| {
                     const source_dir = bundler.fs.top_level_dir;
                     const resolved = try bundler.linker.resolver.resolve(source_dir, entry_point, .entry_point);
                     try this.enqueueItem(resolved);
                 }
+                this.bundler.resetStore();
+            } else {}
 
-                if (framework_config) |conf| {
-                    defer this.bundler.resetStore();
+            for (bundler.options.entry_points) |entry_point| {
+                if (bundler.options.platform == .bun) continue;
+                defer this.bundler.resetStore();
 
-                    try this.bundler.configureFramework(true);
-                    if (bundler.options.framework) |framework| {
-                        if (framework.override_modules.keys.len > 0) {
-                            bundler.options.framework.?.override_modules_hashes = allocator.alloc(u64, framework.override_modules.keys.len) catch unreachable;
-                            for (framework.override_modules.keys) |key, i| {
-                                bundler.options.framework.?.override_modules_hashes[i] = std.hash.Wyhash.hash(0, key);
-                            }
-                        }
-                        if (bundler.options.platform == .bun) {
-                            if (framework.server.isEnabled()) {
-                                const resolved = try bundler.linker.resolver.resolve(
-                                    bundler.fs.top_level_dir,
-                                    framework.server.path,
-                                    .entry_point,
-                                );
-                                try this.enqueueItem(resolved);
-                            }
-                        } else {
-                            if (framework.client.isEnabled()) {
-                                const resolved = try bundler.linker.resolver.resolve(
-                                    bundler.fs.top_level_dir,
-                                    framework.client.path,
-                                    .entry_point,
-                                );
-                                try this.enqueueItem(resolved);
-                            }
+                const entry_point_path = bundler.normalizeEntryPointPath(entry_point);
+                const source_dir = bundler.fs.top_level_dir;
+                const resolved = try bundler.linker.resolver.resolve(source_dir, entry_point, .entry_point);
+                try this.enqueueItem(resolved);
+            }
 
-                            if (framework.fallback.isEnabled()) {
-                                const resolved = try bundler.linker.resolver.resolve(
-                                    bundler.fs.top_level_dir,
-                                    framework.fallback.path,
-                                    .entry_point,
-                                );
-                                try this.enqueueItem(resolved);
-                            }
+            if (framework_config) |conf| {
+                defer this.bundler.resetStore();
+
+                try this.bundler.configureFramework(true);
+                if (bundler.options.framework) |framework| {
+                    if (framework.override_modules.keys.len > 0) {
+                        bundler.options.framework.?.override_modules_hashes = allocator.alloc(u64, framework.override_modules.keys.len) catch unreachable;
+                        for (framework.override_modules.keys) |key, i| {
+                            bundler.options.framework.?.override_modules_hashes[i] = std.hash.Wyhash.hash(0, key);
                         }
                     }
-                } else {}
-
-                // Normally, this is automatic
-                // However, since we only do the parsing pass, it may not get imported automatically.
-                if (bundler.options.jsx.parse) {
-                    defer this.bundler.resetStore();
-                    if (this.bundler.resolver.resolve(
-                        this.bundler.fs.top_level_dir,
-                        this.bundler.options.jsx.import_source,
-                        .require,
-                    )) |new_jsx_runtime| {
-                        try this.enqueueItem(new_jsx_runtime);
-                    } else |err| {}
-                }
+                    if (bundler.options.platform == .bun) {
+                        if (framework.server.isEnabled()) {
+                            const resolved = try bundler.linker.resolver.resolve(
+                                bundler.fs.top_level_dir,
+                                framework.server.path,
+                                .entry_point,
+                            );
+                            try this.enqueueItem(resolved);
+                        }
+                    } else {
+                        if (framework.client.isEnabled()) {
+                            const resolved = try bundler.linker.resolver.resolve(
+                                bundler.fs.top_level_dir,
+                                framework.client.path,
+                                .entry_point,
+                            );
+                            try this.enqueueItem(resolved);
+                        }
 
-                var refresh_runtime_module_id: u32 = 0;
-                if (include_refresh_runtime) {
-                    defer this.bundler.resetStore();
-
-                    if (this.bundler.resolver.resolve(
-                        this.bundler.fs.top_level_dir,
-                        this.bundler.options.jsx.refresh_runtime,
-                        .require,
-                    )) |refresh_runtime| {
-                        try this.enqueueItem(refresh_runtime);
-                        if (BundledModuleData.get(this, &refresh_runtime)) |mod| {
-                            refresh_runtime_module_id = mod.module_id;
+                        if (framework.fallback.isEnabled()) {
+                            const resolved = try bundler.linker.resolver.resolve(
+                                bundler.fs.top_level_dir,
+                                framework.fallback.path,
+                                .entry_point,
+                            );
+                            try this.enqueueItem(resolved);
                         }
-                    } else |err| {}
+                    }
                 }
+            } else {}
 
-                this.bundler.resetStore();
+            // Normally, this is automatic
+            // However, since we only do the parsing pass, it may not get imported automatically.
+            if (bundler.options.jsx.parse) {
+                defer this.bundler.resetStore();
+                if (this.bundler.resolver.resolve(
+                    this.bundler.fs.top_level_dir,
+                    this.bundler.options.jsx.import_source,
+                    .require,
+                )) |new_jsx_runtime| {
+                    try this.enqueueItem(new_jsx_runtime);
+                } else |err| {}
+            }
 
-                try this.pool.start(this);
-                try this.pool.wait(this);
-                estimated_input_lines_of_code.* = generator.estimated_input_lines_of_code;
+            var refresh_runtime_module_id: u32 = 0;
+            if (include_refresh_runtime) {
+                defer this.bundler.resetStore();
 
-                // if (comptime !isRelease) {
-                //     this.queue.checkDuplicatesSlow();
-                // }
+                if (this.bundler.resolver.resolve(
+                    this.bundler.fs.top_level_dir,
+                    this.bundler.options.jsx.refresh_runtime,
+                    .require,
+                )) |refresh_runtime| {
+                    try this.enqueueItem(refresh_runtime);
+                    if (BundledModuleData.get(this, &refresh_runtime)) |mod| {
+                        refresh_runtime_module_id = mod.module_id;
+                    }
+                } else |err| {}
+            }
 
-                if (this.log.errors > 0) {
-                    tmpfile.close();
-                    tmpdir.deleteFile(std.mem.span(tmpname)) catch {};
-                    // We stop here because if there are errors we don't know if the bundle is valid
-                    // This manifests as a crash when sorting through the module list because we may have added files to the bundle which were never actually finished being added.
-                    return null;
-                }
+            this.bundler.resetStore();
 
-                // Delay by one tick so that the rest of the file loads first
-                if (include_refresh_runtime and refresh_runtime_module_id > 0) {
-                    var refresh_runtime_injector_buf: [1024]u8 = undefined;
-                    var fixed_buffer = std.io.fixedBufferStream(&refresh_runtime_injector_buf);
-                    var fixed_buffer_writer = fixed_buffer.writer();
-
-                    fixed_buffer_writer.print(
-                        \\if ('window' in globalThis) {{
-                        \\  (async function() {{
-                        \\    BUN_RUNTIME.__injectFastRefresh(${x}());
-                        \\  }})();
-                        \\}}
-                    ,
-                        .{refresh_runtime_module_id},
-                    ) catch unreachable;
-                    try this.tmpfile.writeAll(fixed_buffer.buffer[0..fixed_buffer.pos]);
-                }
+            try this.pool.start(this);
+            try this.pool.wait(this);
+            estimated_input_lines_of_code.* = generator.estimated_input_lines_of_code;
 
-                // Ensure we never overflow
-                this.code_end_byte_offset = @truncate(
-                    u32,
-                    // Doing this math ourself seems to not necessarily produce correct results
-                    (try this.tmpfile.getPos()),
-                );
-
-                var javascript_bundle_container = std.mem.zeroes(Api.JavascriptBundleContainer);
+            // if (comptime !isRelease) {
+            //     this.queue.checkDuplicatesSlow();
+            // }
 
-                std.sort.sort(
-                    Api.JavascriptBundledModule,
-                    this.module_list.items,
-                    this,
-                    GenerateNodeModuleBundle.sortJavascriptModuleByPath,
-                );
+            if (this.log.errors > 0) {
+                tmpfile.close();
+                tmpdir.deleteFile(std.mem.span(tmpname)) catch {};
+                // We stop here because if there are errors we don't know if the bundle is valid
+                // This manifests as a crash when sorting through the module list because we may have added files to the bundle which were never actually finished being added.
+                return null;
+            }
 
-                if (comptime isDebug) {
-                    const SeenHash = std.AutoHashMap(u64, void);
-                    var map = SeenHash.init(this.allocator);
-                    var ids = SeenHash.init(this.allocator);
-                    try map.ensureTotalCapacity(@truncate(u32, this.module_list.items.len));
-                    try ids.ensureTotalCapacity(@truncate(u32, this.module_list.items.len));
-
-                    for (this.module_list.items) |a| {
-                        const a_pkg: Api.JavascriptBundledPackage = this.package_list.items[a.package_id];
-                        const a_name = this.metadataStringPointer(a_pkg.name);
-                        const a_version = this.metadataStringPointer(a_pkg.version);
-                        const a_path = this.metadataStringPointer(a.path);
-
-                        std.debug.assert(a_name.len > 0);
-                        std.debug.assert(a_version.len > 0);
-                        std.debug.assert(a_path.len > 0);
-                        var hash_print = std.mem.zeroes([4096]u8);
-                        const hash = std.hash.Wyhash.hash(0, std.fmt.bufPrint(&hash_print, "{s}@{s}/{s}", .{ a_name, a_version, a_path }) catch unreachable);
-                        var result1 = map.getOrPutAssumeCapacity(hash);
-                        std.debug.assert(!result1.found_existing);
-
-                        var result2 = ids.getOrPutAssumeCapacity(a.id);
-                        std.debug.assert(!result2.found_existing);
-                    }
-                }
+            // Delay by one tick so that the rest of the file loads first
+            if (include_refresh_runtime and refresh_runtime_module_id > 0) {
+                var refresh_runtime_injector_buf: [1024]u8 = undefined;
+                var fixed_buffer = std.io.fixedBufferStream(&refresh_runtime_injector_buf);
+                var fixed_buffer_writer = fixed_buffer.writer();
+
+                fixed_buffer_writer.print(
+                    \\if ('window' in globalThis) {{
+                    \\  (async function() {{
+                    \\    BUN_RUNTIME.__injectFastRefresh(${x}());
+                    \\  }})();
+                    \\}}
+                ,
+                    .{refresh_runtime_module_id},
+                ) catch unreachable;
+                try this.tmpfile.writeAll(fixed_buffer.buffer[0..fixed_buffer.pos]);
+            }
 
-                var hasher = std.hash.Wyhash.init(0);
-
-                // We want to sort the packages as well as the files
-                // The modules sort the packages already
-                // So can just copy it in the below loop.
-                var sorted_package_list = try allocator.alloc(Api.JavascriptBundledPackage, this.package_list.items.len);
-
-                // At this point, the module_list is sorted.
-                if (this.module_list.items.len > 0) {
-                    var package_id_i: u32 = 0;
-                    var i: usize = 0;
-                    // Assumption: node_modules are immutable
-                    // Assumption: module files are immutable
-                    // (They're not. But, for our purposes that's okay)
-                    // The etag is:
-                    // - The hash of each module's path in sorted order
-                    // - The hash of each module's code size in sorted order
-                    // - hash(hash(package_name, package_version))
-                    // If this doesn't prove strong enough, we will do a proper content hash
-                    // But I want to avoid that overhead unless proven necessary.
-                    // There's a good chance we don't even strictly need an etag here.
-                    var bytes: [4]u8 = undefined;
-                    while (i < this.module_list.items.len) {
-                        var current_package_id = this.module_list.items[i].package_id;
-                        this.module_list.items[i].package_id = package_id_i;
-                        var offset = @truncate(u32, i);
+            // Ensure we never overflow
+            this.code_end_byte_offset = @truncate(
+                u32,
+                // Doing this math ourself seems to not necessarily produce correct results
+                (try this.tmpfile.getPos()),
+            );
 
-                        i += 1;
+            var javascript_bundle_container = std.mem.zeroes(Api.JavascriptBundleContainer);
 
-                        while (i < this.module_list.items.len and this.module_list.items[i].package_id == current_package_id) : (i += 1) {
-                            this.module_list.items[i].package_id = package_id_i;
-                            // Hash the file path
-                            hasher.update(this.metadataStringPointer(this.module_list.items[i].path));
-                            // Then the length of the code
-                            std.mem.writeIntNative(u32, &bytes, this.module_list.items[i].code.length);
-                            hasher.update(&bytes);
-                        }
+            std.sort.sort(
+                Api.JavascriptBundledModule,
+                this.module_list.items,
+                this,
+                GenerateNodeModuleBundle.sortJavascriptModuleByPath,
+            );
 
-                        this.package_list.items[current_package_id].modules_offset = offset;
-                        this.package_list.items[current_package_id].modules_length = @truncate(u32, i) - offset;
+            if (comptime isDebug) {
+                const SeenHash = std.AutoHashMap(u64, void);
+                var map = SeenHash.init(this.allocator);
+                var ids = SeenHash.init(this.allocator);
+                try map.ensureTotalCapacity(@truncate(u32, this.module_list.items.len));
+                try ids.ensureTotalCapacity(@truncate(u32, this.module_list.items.len));
+
+                for (this.module_list.items) |a| {
+                    const a_pkg: Api.JavascriptBundledPackage = this.package_list.items[a.package_id];
+                    const a_name = this.metadataStringPointer(a_pkg.name);
+                    const a_version = this.metadataStringPointer(a_pkg.version);
+                    const a_path = this.metadataStringPointer(a.path);
+
+                    std.debug.assert(a_name.len > 0);
+                    std.debug.assert(a_version.len > 0);
+                    std.debug.assert(a_path.len > 0);
+                    var hash_print = std.mem.zeroes([4096]u8);
+                    const hash = std.hash.Wyhash.hash(0, std.fmt.bufPrint(&hash_print, "{s}@{s}/{s}", .{ a_name, a_version, a_path }) catch unreachable);
+                    var result1 = map.getOrPutAssumeCapacity(hash);
+                    std.debug.assert(!result1.found_existing);
+
+                    var result2 = ids.getOrPutAssumeCapacity(a.id);
+                    std.debug.assert(!result2.found_existing);
+                }
+            }
 
-                        // Hash the hash of the package name
-                        // it's hash(hash(package_name, package_version))
-                        std.mem.writeIntNative(u32, &bytes, this.package_list.items[current_package_id].hash);
+            var hasher = std.hash.Wyhash.init(0);
+
+            // We want to sort the packages as well as the files
+            // The modules sort the packages already
+            // So can just copy it in the below loop.
+            var sorted_package_list = try allocator.alloc(Api.JavascriptBundledPackage, this.package_list.items.len);
+
+            // At this point, the module_list is sorted.
+            if (this.module_list.items.len > 0) {
+                var package_id_i: u32 = 0;
+                var i: usize = 0;
+                // Assumption: node_modules are immutable
+                // Assumption: module files are immutable
+                // (They're not. But, for our purposes that's okay)
+                // The etag is:
+                // - The hash of each module's path in sorted order
+                // - The hash of each module's code size in sorted order
+                // - hash(hash(package_name, package_version))
+                // If this doesn't prove strong enough, we will do a proper content hash
+                // But I want to avoid that overhead unless proven necessary.
+                // There's a good chance we don't even strictly need an etag here.
+                var bytes: [4]u8 = undefined;
+                while (i < this.module_list.items.len) {
+                    var current_package_id = this.module_list.items[i].package_id;
+                    this.module_list.items[i].package_id = package_id_i;
+                    var offset = @truncate(u32, i);
+
+                    i += 1;
+
+                    while (i < this.module_list.items.len and this.module_list.items[i].package_id == current_package_id) : (i += 1) {
+                        this.module_list.items[i].package_id = package_id_i;
+                        // Hash the file path
+                        hasher.update(this.metadataStringPointer(this.module_list.items[i].path));
+                        // Then the length of the code
+                        std.mem.writeIntNative(u32, &bytes, this.module_list.items[i].code.length);
                         hasher.update(&bytes);
-
-                        sorted_package_list[package_id_i] = this.package_list.items[current_package_id];
-                        package_id_i += 1;
                     }
-                }
 
-                var javascript_bundle = std.mem.zeroes(Api.JavascriptBundle);
-                javascript_bundle.modules = this.module_list.items;
-                javascript_bundle.packages = sorted_package_list;
-                javascript_bundle.manifest_string = this.header_string_buffer.list.items;
-                const etag_u64 = hasher.final();
-                // We store the etag as a ascii hex encoded u64
-                // This is so we can send the bytes directly in the HTTP server instead of formatting it as hex each time.
-                javascript_bundle.etag = try std.fmt.allocPrint(allocator, "{x}", .{etag_u64});
-                javascript_bundle.generated_at = @truncate(u32, @intCast(u64, std.time.milliTimestamp()));
-
-                const basename = std.fs.path.basename(std.mem.span(destination));
-                const extname = std.fs.path.extension(basename);
-                javascript_bundle.import_from_name = if (bundler.options.platform == .bun)
-                    "/node_modules.server.bun"
-                else
-                    try std.fmt.allocPrint(
-                        this.allocator,
-                        "/{s}.{x}.bun",
-                        .{
-                            basename[0 .. basename.len - extname.len],
-                            etag_u64,
-                        },
-                    );
+                    this.package_list.items[current_package_id].modules_offset = offset;
+                    this.package_list.items[current_package_id].modules_length = @truncate(u32, i) - offset;
 
-                javascript_bundle_container.bundle_format_version = current_version;
-                javascript_bundle_container.bundle = javascript_bundle;
-                javascript_bundle_container.code_length = this.code_end_byte_offset;
-                javascript_bundle_container.framework = framework_config;
-                javascript_bundle_container.routes = route_config;
-
-                var start_pos = try this.tmpfile.getPos();
-                var tmpwriter = std.io.bufferedWriter(this.tmpfile.writer());
-                const SchemaWriter = schema.Writer(@TypeOf(tmpwriter.writer()));
-                var schema_file_writer = SchemaWriter.init(tmpwriter.writer());
-                try javascript_bundle_container.encode(&schema_file_writer);
-                try tmpwriter.flush();
-
-                // sanity check
-                if (isDebug) {
-                    try this.tmpfile.seekTo(start_pos);
-                    var contents = try allocator.alloc(u8, (try this.tmpfile.getEndPos()) - start_pos);
-                    var read_bytes = try this.tmpfile.read(contents);
-                    var buf = contents[0..read_bytes];
-                    var reader = schema.Reader.init(buf, allocator);
-
-                    var decoder = try Api.JavascriptBundleContainer.decode(
-                        &reader,
-                    );
-                    std.debug.assert(decoder.code_length.? == javascript_bundle_container.code_length.?);
+                    // Hash the hash of the package name
+                    // it's hash(hash(package_name, package_version))
+                    std.mem.writeIntNative(u32, &bytes, this.package_list.items[current_package_id].hash);
+                    hasher.update(&bytes);
+
+                    sorted_package_list[package_id_i] = this.package_list.items[current_package_id];
+                    package_id_i += 1;
                 }
+            }
 
-                var code_length_bytes: [4]u8 = undefined;
-                std.mem.writeIntNative(u32, &code_length_bytes, this.code_end_byte_offset);
-                _ = try std.os.pwrite(this.tmpfile.handle, &code_length_bytes, magic_bytes.len);
-
-                // Without his mutex, we get a crash at this location:
-                // try std.os.renameat(tmpdir.fd, tmpname, top_dir.fd, destination);
-                // ^
-                const top_dir = try std.fs.openDirAbsolute(Fs.FileSystem.instance.top_level_dir, .{});
-                _ = C.fchmod(
-                    this.tmpfile.handle,
-                    // chmod 777
-                    0000010 | 0000100 | 0000001 | 0001000 | 0000040 | 0000004 | 0000002 | 0000400 | 0000200 | 0000020,
+            var javascript_bundle = std.mem.zeroes(Api.JavascriptBundle);
+            javascript_bundle.modules = this.module_list.items;
+            javascript_bundle.packages = sorted_package_list;
+            javascript_bundle.manifest_string = this.header_string_buffer.list.items;
+            const etag_u64 = hasher.final();
+            // We store the etag as a ascii hex encoded u64
+            // This is so we can send the bytes directly in the HTTP server instead of formatting it as hex each time.
+            javascript_bundle.etag = try std.fmt.allocPrint(allocator, "{x}", .{etag_u64});
+            javascript_bundle.generated_at = @truncate(u32, @intCast(u64, std.time.milliTimestamp()));
+
+            const basename = std.fs.path.basename(std.mem.span(destination));
+            const extname = std.fs.path.extension(basename);
+            javascript_bundle.import_from_name = if (bundler.options.platform == .bun)
+                "/node_modules.server.bun"
+            else
+                try std.fmt.allocPrint(
+                    this.allocator,
+                    "/{s}.{x}.bun",
+                    .{
+                        basename[0 .. basename.len - extname.len],
+                        etag_u64,
+                    },
                 );
-                try std.os.renameatZ(tmpdir.fd, tmpname, top_dir.fd, destination);
-                // Print any errors at the end
-                // try this.log.print(Output.errorWriter());
-                return javascript_bundle_container;
-            }
 
-            pub fn metadataStringPointer(this: *GenerateNodeModuleBundle, ptr: Api.StringPointer) string {
-                return this.header_string_buffer.list.items[ptr.offset .. ptr.offset + ptr.length];
+            javascript_bundle_container.bundle_format_version = current_version;
+            javascript_bundle_container.bundle = javascript_bundle;
+            javascript_bundle_container.code_length = this.code_end_byte_offset;
+            javascript_bundle_container.framework = framework_config;
+            javascript_bundle_container.routes = route_config;
+
+            var start_pos = try this.tmpfile.getPos();
+            var tmpwriter = std.io.bufferedWriter(this.tmpfile.writer());
+            const SchemaWriter = schema.Writer(@TypeOf(tmpwriter.writer()));
+            var schema_file_writer = SchemaWriter.init(tmpwriter.writer());
+            try javascript_bundle_container.encode(&schema_file_writer);
+            try tmpwriter.flush();
+
+            // sanity check
+            if (isDebug) {
+                try this.tmpfile.seekTo(start_pos);
+                var contents = try allocator.alloc(u8, (try this.tmpfile.getEndPos()) - start_pos);
+                var read_bytes = try this.tmpfile.read(contents);
+                var buf = contents[0..read_bytes];
+                var reader = schema.Reader.init(buf, allocator);
+
+                var decoder = try Api.JavascriptBundleContainer.decode(
+                    &reader,
+                );
+                std.debug.assert(decoder.code_length.? == javascript_bundle_container.code_length.?);
             }
 
-            // Since we trim the prefixes, we must also compare the package name and version
-            pub fn sortJavascriptModuleByPath(ctx: *GenerateNodeModuleBundle, a: Api.JavascriptBundledModule, b: Api.JavascriptBundledModule) bool {
-                return switch (std.mem.order(
+            var code_length_bytes: [4]u8 = undefined;
+            std.mem.writeIntNative(u32, &code_length_bytes, this.code_end_byte_offset);
+            _ = try std.os.pwrite(this.tmpfile.handle, &code_length_bytes, magic_bytes.len);
+
+            // Without his mutex, we get a crash at this location:
+            // try std.os.renameat(tmpdir.fd, tmpname, top_dir.fd, destination);
+            // ^
+            const top_dir = try std.fs.openDirAbsolute(Fs.FileSystem.instance.top_level_dir, .{});
+            _ = C.fchmod(
+                this.tmpfile.handle,
+                // chmod 777
+                0000010 | 0000100 | 0000001 | 0001000 | 0000040 | 0000004 | 0000002 | 0000400 | 0000200 | 0000020,
+            );
+            try std.os.renameatZ(tmpdir.fd, tmpname, top_dir.fd, destination);
+            // Print any errors at the end
+            // try this.log.print(Output.errorWriter());
+            return javascript_bundle_container;
+        }
+
+        pub fn metadataStringPointer(this: *GenerateNodeModuleBundle, ptr: Api.StringPointer) string {
+            return this.header_string_buffer.list.items[ptr.offset .. ptr.offset + ptr.length];
+        }
+
+        // Since we trim the prefixes, we must also compare the package name and version
+        pub fn sortJavascriptModuleByPath(ctx: *GenerateNodeModuleBundle, a: Api.JavascriptBundledModule, b: Api.JavascriptBundledModule) bool {
+            return switch (std.mem.order(
+                u8,
+                ctx.metadataStringPointer(
+                    ctx.package_list.items[a.package_id].name,
+                ),
+                ctx.metadataStringPointer(
+                    ctx.package_list.items[b.package_id].name,
+                ),
+            )) {
+                .eq => switch (std.mem.order(
                     u8,
                     ctx.metadataStringPointer(
-                        ctx.package_list.items[a.package_id].name,
+                        ctx.package_list.items[a.package_id].version,
                     ),
                     ctx.metadataStringPointer(
-                        ctx.package_list.items[b.package_id].name,
+                        ctx.package_list.items[b.package_id].version,
                     ),
                 )) {
-                    .eq => switch (std.mem.order(
+                    .eq => std.mem.order(
                         u8,
-                        ctx.metadataStringPointer(
-                            ctx.package_list.items[a.package_id].version,
-                        ),
-                        ctx.metadataStringPointer(
-                            ctx.package_list.items[b.package_id].version,
-                        ),
-                    )) {
-                        .eq => std.mem.order(
-                            u8,
-                            ctx.metadataStringPointer(a.path),
-                            ctx.metadataStringPointer(b.path),
-                        ) == .lt,
-                        .lt => true,
-                        else => false,
-                    },
+                        ctx.metadataStringPointer(a.path),
+                        ctx.metadataStringPointer(b.path),
+                    ) == .lt,
                     .lt => true,
                     else => false,
-                };
-            }
+                },
+                .lt => true,
+                else => false,
+            };
+        }
 
-            // pub fn sortJavascriptPackageByName(ctx: *GenerateNodeModuleBundle, a: Api.JavascriptBundledPackage, b: Api.JavascriptBundledPackage) bool {
-            //     return std.mem.order(u8, ctx.metadataStringPointer(a.name), ctx.metadataStringPointer(b.name)) == .lt;
-            // }
+        // pub fn sortJavascriptPackageByName(ctx: *GenerateNodeModuleBundle, a: Api.JavascriptBundledPackage, b: Api.JavascriptBundledPackage) bool {
+        //     return std.mem.order(u8, ctx.metadataStringPointer(a.name), ctx.metadataStringPointer(b.name)) == .lt;
+        // }
+
+        pub fn appendBytes(generator: *GenerateNodeModuleBundle, bytes: anytype) !void {
+            try generator.tmpfile.writeAll(bytes);
+            generator.tmpfile_byte_offset += @truncate(u32, bytes.len);
+        }
 
-            pub fn appendBytes(generator: *GenerateNodeModuleBundle, bytes: anytype) !void {
-                try generator.tmpfile.writeAll(bytes);
-                generator.tmpfile_byte_offset += @truncate(u32, bytes.len);
+        const BundledModuleData = struct {
+            import_path: string,
+            package_path: string,
+            package: *const PackageJSON,
+            module_id: u32,
+
+            pub fn getForceBundle(this: *GenerateNodeModuleBundle, resolve_result: *const _resolver.Result) ?BundledModuleData {
+                return _get(this, resolve_result, true, false);
             }
 
-            const BundledModuleData = struct {
-                import_path: string,
-                package_path: string,
-                package: *const PackageJSON,
-                module_id: u32,
+            pub fn getForceBundleForMain(this: *GenerateNodeModuleBundle, resolve_result: *const _resolver.Result) ?BundledModuleData {
+                return _get(this, resolve_result, true, true);
+            }
 
-                pub fn getForceBundle(this: *GenerateNodeModuleBundle, resolve_result: *const _resolver.Result) ?BundledModuleData {
-                    return _get(this, resolve_result, true, false);
+            threadlocal var normalized_package_path: [512]u8 = undefined;
+            threadlocal var normalized_package_path2: [512]u8 = undefined;
+            inline fn _get(this: *GenerateNodeModuleBundle, resolve_result: *const _resolver.Result, comptime force: bool, comptime is_main: bool) ?BundledModuleData {
+                const path = resolve_result.pathConst() orelse return null;
+                if (strings.eqlComptime(path.namespace, "node")) {
+                    const _import_path = path.text["/bun-vfs/node_modules/".len..][resolve_result.package_json.?.name.len + 1 ..];
+                    return BundledModuleData{
+                        .import_path = _import_path,
+                        .package_path = path.text["/bun-vfs/node_modules/".len..],
+                        .package = resolve_result.package_json.?,
+                        .module_id = resolve_result.package_json.?.hashModule(_import_path),
+                    };
                 }
 
-                pub fn getForceBundleForMain(this: *GenerateNodeModuleBundle, resolve_result: *const _resolver.Result) ?BundledModuleData {
-                    return _get(this, resolve_result, true, true);
-                }
+                var import_path = path.text;
+                var package_path = path.text;
+                var file_path = path.text;
+
+                if (resolve_result.package_json) |pkg| {
+                    if (std.mem.indexOfScalar(u32, this.always_bundled_package_hashes, pkg.hash) != null) {
+                        const key_path_source_dir = pkg.source.key_path.sourceDir();
+                        const default_source_dir = pkg.source.path.sourceDir();
+                        if (strings.startsWith(path.text, key_path_source_dir)) {
+                            import_path = path.text[key_path_source_dir.len..];
+                        } else if (strings.startsWith(path.text, default_source_dir)) {
+                            import_path = path.text[default_source_dir.len..];
+                        } else if (strings.startsWith(path.pretty, pkg.name)) {
+                            import_path = path.pretty[pkg.name.len + 1 ..];
+                        }
 
-                threadlocal var normalized_package_path: [512]u8 = undefined;
-                threadlocal var normalized_package_path2: [512]u8 = undefined;
-                inline fn _get(this: *GenerateNodeModuleBundle, resolve_result: *const _resolver.Result, comptime force: bool, comptime is_main: bool) ?BundledModuleData {
-                    const path = resolve_result.pathConst() orelse return null;
-                    if (strings.eqlComptime(path.namespace, "node")) {
-                        const _import_path = path.text["/bun-vfs/node_modules/".len..][resolve_result.package_json.?.name.len + 1 ..];
+                        var buf_to_use: []u8 = if (is_main) &normalized_package_path2 else &normalized_package_path;
+
+                        std.mem.copy(u8, buf_to_use, pkg.name);
+                        buf_to_use[pkg.name.len] = '/';
+                        std.mem.copy(u8, buf_to_use[pkg.name.len + 1 ..], import_path);
+                        package_path = buf_to_use[0 .. pkg.name.len + import_path.len + 1];
                         return BundledModuleData{
-                            .import_path = _import_path,
-                            .package_path = path.text["/bun-vfs/node_modules/".len..],
-                            .package = resolve_result.package_json.?,
-                            .module_id = resolve_result.package_json.?.hashModule(_import_path),
+                            .import_path = import_path,
+                            .package_path = package_path,
+                            .package = pkg,
+                            .module_id = pkg.hashModule(package_path),
                         };
                     }
+                }
 
-                    var import_path = path.text;
-                    var package_path = path.text;
-                    var file_path = path.text;
-
-                    if (resolve_result.package_json) |pkg| {
-                        if (std.mem.indexOfScalar(u32, this.always_bundled_package_hashes, pkg.hash) != null) {
-                            const key_path_source_dir = pkg.source.key_path.sourceDir();
-                            const default_source_dir = pkg.source.path.sourceDir();
-                            if (strings.startsWith(path.text, key_path_source_dir)) {
-                                import_path = path.text[key_path_source_dir.len..];
-                            } else if (strings.startsWith(path.text, default_source_dir)) {
-                                import_path = path.text[default_source_dir.len..];
-                            } else if (strings.startsWith(path.pretty, pkg.name)) {
-                                import_path = path.pretty[pkg.name.len + 1 ..];
-                            }
+                const root: _resolver.RootPathPair = this.bundler.resolver.rootNodeModulePackageJSON(
+                    resolve_result,
+                ) orelse return null;
+
+                var base_path = root.base_path;
+                const package_json = root.package_json;
+
+                // Easymode: the file path doesn't need to be remapped.
+                if (strings.startsWith(file_path, base_path)) {
+                    import_path = std.mem.trimLeft(u8, path.text[base_path.len..], "/");
+                    package_path = std.mem.trim(u8, path.text[base_path.len - package_json.name.len - 1 ..], "/");
+                    std.debug.assert(import_path.len > 0);
+                    return BundledModuleData{
+                        .import_path = import_path,
+                        .package_path = package_path,
+                        .package = package_json,
+                        .module_id = package_json.hashModule(package_path),
+                    };
+                }
+
+                if (std.mem.lastIndexOf(u8, file_path, package_json.name)) |i| {
+                    package_path = file_path[i..];
+                    import_path = package_path[package_json.name.len + 1 ..];
+                    std.debug.assert(import_path.len > 0);
+                    return BundledModuleData{
+                        .import_path = import_path,
+                        .package_path = package_path,
+                        .package = package_json,
+                        .module_id = package_json.hashModule(package_path),
+                    };
+                }
 
-                            var buf_to_use: []u8 = if (is_main) &normalized_package_path2 else &normalized_package_path;
+                if (comptime force) {
+                    if (std.mem.indexOfScalar(u32, this.always_bundled_package_hashes, root.package_json.hash)) |pkg_json_i| {
+                        const pkg_json = this.always_bundled_package_jsons[pkg_json_i];
+                        base_path = pkg_json.source.key_path.sourceDir();
 
-                            std.mem.copy(u8, buf_to_use, pkg.name);
-                            buf_to_use[pkg.name.len] = '/';
-                            std.mem.copy(u8, buf_to_use[pkg.name.len + 1 ..], import_path);
-                            package_path = buf_to_use[0 .. pkg.name.len + import_path.len + 1];
+                        if (strings.startsWith(file_path, base_path)) {
+                            import_path = std.mem.trimLeft(u8, path.text[base_path.len..], "/");
+                            package_path = std.mem.trim(u8, path.text[base_path.len - package_json.name.len - 1 ..], "/");
+                            std.debug.assert(import_path.len > 0);
                             return BundledModuleData{
                                 .import_path = import_path,
                                 .package_path = package_path,
-                                .package = pkg,
-                                .module_id = pkg.hashModule(package_path),
+                                .package = package_json,
+                                .module_id = package_json.hashModule(package_path),
                             };
                         }
-                    }
-
-                    const root: _resolver.RootPathPair = this.bundler.resolver.rootNodeModulePackageJSON(
-                        resolve_result,
-                    ) orelse return null;
-
-                    var base_path = root.base_path;
-                    const package_json = root.package_json;
-
-                    // Easymode: the file path doesn't need to be remapped.
-                    if (strings.startsWith(file_path, base_path)) {
-                        import_path = std.mem.trimLeft(u8, path.text[base_path.len..], "/");
-                        package_path = std.mem.trim(u8, path.text[base_path.len - package_json.name.len - 1 ..], "/");
-                        std.debug.assert(import_path.len > 0);
-                        return BundledModuleData{
-                            .import_path = import_path,
-                            .package_path = package_path,
-                            .package = package_json,
-                            .module_id = package_json.hashModule(package_path),
-                        };
-                    }
-
-                    if (std.mem.lastIndexOf(u8, file_path, package_json.name)) |i| {
-                        package_path = file_path[i..];
-                        import_path = package_path[package_json.name.len + 1 ..];
-                        std.debug.assert(import_path.len > 0);
-                        return BundledModuleData{
-                            .import_path = import_path,
-                            .package_path = package_path,
-                            .package = package_json,
-                            .module_id = package_json.hashModule(package_path),
-                        };
-                    }
-
-                    if (comptime force) {
-                        if (std.mem.indexOfScalar(u32, this.always_bundled_package_hashes, root.package_json.hash)) |pkg_json_i| {
-                            const pkg_json = this.always_bundled_package_jsons[pkg_json_i];
-                            base_path = pkg_json.source.key_path.sourceDir();
-
-                            if (strings.startsWith(file_path, base_path)) {
-                                import_path = std.mem.trimLeft(u8, path.text[base_path.len..], "/");
-                                package_path = std.mem.trim(u8, path.text[base_path.len - package_json.name.len - 1 ..], "/");
-                                std.debug.assert(import_path.len > 0);
-                                return BundledModuleData{
-                                    .import_path = import_path,
-                                    .package_path = package_path,
-                                    .package = package_json,
-                                    .module_id = package_json.hashModule(package_path),
-                                };
-                            }
 
-                            if (std.mem.lastIndexOf(u8, file_path, package_json.name)) |i| {
-                                package_path = file_path[i..];
-                                import_path = package_path[package_json.name.len + 1 ..];
-                                std.debug.assert(import_path.len > 0);
-                                return BundledModuleData{
-                                    .import_path = import_path,
-                                    .package_path = package_path,
-                                    .package = package_json,
-                                    .module_id = package_json.hashModule(package_path),
-                                };
-                            }
+                        if (std.mem.lastIndexOf(u8, file_path, package_json.name)) |i| {
+                            package_path = file_path[i..];
+                            import_path = package_path[package_json.name.len + 1 ..];
+                            std.debug.assert(import_path.len > 0);
+                            return BundledModuleData{
+                                .import_path = import_path,
+                                .package_path = package_path,
+                                .package = package_json,
+                                .module_id = package_json.hashModule(package_path),
+                            };
                         }
-                        unreachable;
                     }
-
-                    return null;
+                    unreachable;
                 }
 
-                pub fn get(this: *GenerateNodeModuleBundle, resolve_result: *const _resolver.Result) ?BundledModuleData {
-                    return _get(this, resolve_result, false, false);
-                }
-            };
+                return null;
+            }
 
-            fn writeEmptyModule(this: *GenerateNodeModuleBundle, package_relative_path: string, module_id: u32) !u32 {
-                this.write_lock.lock();
-                defer this.write_lock.unlock();
-                var code_offset = @truncate(u32, try this.tmpfile.getPos());
-                var writer = this.tmpfile.writer();
-                var buffered = std.io.bufferedWriter(writer);
-
-                var bufwriter = buffered.writer();
-                try bufwriter.writeAll("// ");
-                try bufwriter.writeAll(package_relative_path);
-                try bufwriter.writeAll(" (disabled/empty)\nexport var $");
-                std.fmt.formatInt(module_id, 16, .lower, .{}, bufwriter) catch unreachable;
-                try bufwriter.writeAll(" = () => { var obj = {}; Object.defineProperty(obj, 'default', { value: obj, enumerable: false, configurable: true }, obj); return obj; }; \n");
-                try buffered.flush();
-                this.tmpfile_byte_offset = @truncate(u32, try this.tmpfile.getPos());
-                return code_offset;
+            pub fn get(this: *GenerateNodeModuleBundle, resolve_result: *const _resolver.Result) ?BundledModuleData {
+                return _get(this, resolve_result, false, false);
             }
+        };
 
-            fn processImportRecord(this: *GenerateNodeModuleBundle, import_record: ImportRecord) !void {}
-            var json_ast_symbols = [_]js_ast.Symbol{
-                js_ast.Symbol{ .original_name = "$$m" },
-                js_ast.Symbol{ .original_name = "exports" },
-                js_ast.Symbol{ .original_name = "module" },
-                js_ast.Symbol{ .original_name = "CONGRATS_YOU_FOUND_A_BUG" },
-                js_ast.Symbol{ .original_name = "$$bun_runtime_json_parse" },
-            };
-            const json_parse_string = "parse";
-            var json_ast_symbols_list = std.mem.span(&json_ast_symbols);
-            threadlocal var override_file_path_buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
-
-            pub fn appendToModuleList(
-                this: *GenerateNodeModuleBundle,
-                package: *const PackageJSON,
-                module_id: u32,
-                code_offset: u32,
-                package_relative_path: string,
-            ) !void {
-                this.list_lock.lock();
-                defer this.list_lock.unlock();
-
-                const code_length = @atomicLoad(u32, &this.tmpfile_byte_offset, .SeqCst) - code_offset;
+        fn writeEmptyModule(this: *GenerateNodeModuleBundle, package_relative_path: string, module_id: u32) !u32 {
+            this.write_lock.lock();
+            defer this.write_lock.unlock();
+            var code_offset = @truncate(u32, try this.tmpfile.getPos());
+            var writer = this.tmpfile.writer();
+            var buffered = std.io.bufferedWriter(writer);
+
+            var bufwriter = buffered.writer();
+            try bufwriter.writeAll("// ");
+            try bufwriter.writeAll(package_relative_path);
+            try bufwriter.writeAll(" (disabled/empty)\nexport var $");
+            std.fmt.formatInt(module_id, 16, .lower, .{}, bufwriter) catch unreachable;
+            try bufwriter.writeAll(" = () => { var obj = {}; Object.defineProperty(obj, 'default', { value: obj, enumerable: false, configurable: true }, obj); return obj; }; \n");
+            try buffered.flush();
+            this.tmpfile_byte_offset = @truncate(u32, try this.tmpfile.getPos());
+            return code_offset;
+        }
 
-                if (comptime isDebug) {
-                    std.debug.assert(code_length > 0);
-                    std.debug.assert(package.hash != 0);
-                    std.debug.assert(package.version.len > 0);
-                    std.debug.assert(package.name.len > 0);
-                    std.debug.assert(module_id > 0);
-                }
+        fn processImportRecord(this: *GenerateNodeModuleBundle, import_record: ImportRecord) !void {}
+        var json_ast_symbols = [_]js_ast.Symbol{
+            js_ast.Symbol{ .original_name = "$$m" },
+            js_ast.Symbol{ .original_name = "exports" },
+            js_ast.Symbol{ .original_name = "module" },
+            js_ast.Symbol{ .original_name = "CONGRATS_YOU_FOUND_A_BUG" },
+            js_ast.Symbol{ .original_name = "$$bun_runtime_json_parse" },
+        };
+        const json_parse_string = "parse";
+        var json_ast_symbols_list = std.mem.span(&json_ast_symbols);
+        threadlocal var override_file_path_buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
+
+        pub fn appendToModuleList(
+            this: *GenerateNodeModuleBundle,
+            package: *const PackageJSON,
+            module_id: u32,
+            code_offset: u32,
+            package_relative_path: string,
+        ) !void {
+            this.list_lock.lock();
+            defer this.list_lock.unlock();
 
-                var package_get_or_put_entry = try this.package_list_map.getOrPut(package.hash);
+            const code_length = @atomicLoad(u32, &this.tmpfile_byte_offset, .SeqCst) - code_offset;
 
-                if (!package_get_or_put_entry.found_existing) {
-                    package_get_or_put_entry.value_ptr.* = @truncate(u32, this.package_list.items.len);
-                    try this.package_list.append(
-                        Api.JavascriptBundledPackage{
-                            .name = try this.appendHeaderString(package.name),
-                            .version = try this.appendHeaderString(package.version),
-                            .hash = package.hash,
-                        },
-                    );
-                    this.has_jsx = this.has_jsx or strings.eql(package.name, this.bundler.options.jsx.package_name);
-                }
+            if (comptime isDebug) {
+                std.debug.assert(code_length > 0);
+                std.debug.assert(package.hash != 0);
+                std.debug.assert(package.version.len > 0);
+                std.debug.assert(package.name.len > 0);
+                std.debug.assert(module_id > 0);
+            }
 
-                var path_extname_length = @truncate(u8, std.fs.path.extension(package_relative_path).len);
-                try this.module_list.append(
-                    Api.JavascriptBundledModule{
-                        .path = try this.appendHeaderString(
-                            package_relative_path,
-                        ),
-                        .path_extname_length = path_extname_length,
-                        .package_id = package_get_or_put_entry.value_ptr.*,
-                        .id = module_id,
-                        .code = Api.StringPointer{
-                            .length = @truncate(u32, code_length),
-                            .offset = @truncate(u32, code_offset),
-                        },
+            var package_get_or_put_entry = try this.package_list_map.getOrPut(package.hash);
+
+            if (!package_get_or_put_entry.found_existing) {
+                package_get_or_put_entry.value_ptr.* = @truncate(u32, this.package_list.items.len);
+                try this.package_list.append(
+                    Api.JavascriptBundledPackage{
+                        .name = try this.appendHeaderString(package.name),
+                        .version = try this.appendHeaderString(package.version),
+                        .hash = package.hash,
                     },
                 );
+                this.has_jsx = this.has_jsx or strings.eql(package.name, this.bundler.options.jsx.package_name);
             }
-            threadlocal var json_e_string: js_ast.E.String = undefined;
-            threadlocal var json_e_call: js_ast.E.Call = undefined;
-            threadlocal var json_e_identifier: js_ast.E.Identifier = undefined;
-            threadlocal var json_call_args: [1]js_ast.Expr = undefined;
-            pub fn processFile(this: *GenerateNodeModuleBundle, worker: *ThreadPool.Worker, _resolve: _resolver.Result) !void {
-                const resolve = _resolve;
-                if (resolve.is_external) return;
-
-                var shared_buffer = &worker.data.shared_buffer;
-                var scan_pass_result = &worker.data.scan_pass_result;
-
-                const is_from_node_modules = resolve.isLikelyNodeModule() or brk: {
-                    if (resolve.package_json) |pkg| {
-                        break :brk std.mem.indexOfScalar(u32, this.always_bundled_package_hashes, pkg.hash) != null;
-                    }
-                    break :brk false;
+
+            var path_extname_length = @truncate(u8, std.fs.path.extension(package_relative_path).len);
+            try this.module_list.append(
+                Api.JavascriptBundledModule{
+                    .path = try this.appendHeaderString(
+                        package_relative_path,
+                    ),
+                    .path_extname_length = path_extname_length,
+                    .package_id = package_get_or_put_entry.value_ptr.*,
+                    .id = module_id,
+                    .code = Api.StringPointer{
+                        .length = @truncate(u32, code_length),
+                        .offset = @truncate(u32, code_offset),
+                    },
+                },
+            );
+        }
+        threadlocal var json_e_string: js_ast.E.String = undefined;
+        threadlocal var json_e_call: js_ast.E.Call = undefined;
+        threadlocal var json_e_identifier: js_ast.E.Identifier = undefined;
+        threadlocal var json_call_args: [1]js_ast.Expr = undefined;
+        pub fn processFile(this: *GenerateNodeModuleBundle, worker: *ThreadPool.Worker, _resolve: _resolver.Result) !void {
+            const resolve = _resolve;
+            if (resolve.is_external) return;
+
+            var shared_buffer = &worker.data.shared_buffer;
+            var scan_pass_result = &worker.data.scan_pass_result;
+
+            const is_from_node_modules = resolve.isLikelyNodeModule() or brk: {
+                if (resolve.package_json) |pkg| {
+                    break :brk std.mem.indexOfScalar(u32, this.always_bundled_package_hashes, pkg.hash) != null;
+                }
+                break :brk false;
+            };
+            var file_path = (resolve.pathConst() orelse unreachable).*;
+            const source_dir = file_path.sourceDir();
+            const loader = this.bundler.options.loader(file_path.name.ext);
+            var bundler = this.bundler;
+            defer scan_pass_result.reset();
+            defer shared_buffer.reset();
+            defer this.bundler.resetStore();
+            var log = worker.data.log;
+
+            // If we're in a node_module, build that almost normally
+            if (is_from_node_modules) {
+                var written: usize = undefined;
+                var code_offset: u32 = 0;
+
+                const module_data = BundledModuleData.getForceBundleForMain(this, &resolve) orelse {
+                    const fake_path = logger.Source.initPathString(file_path.text, "");
+                    log.addResolveError(
+                        &fake_path,
+                        logger.Range.None,
+                        this.allocator,
+                        "Bug while resolving: \"{s}\"",
+                        .{file_path.text},
+                        resolve.import_kind,
+                    ) catch {};
+                    return error.ResolveError;
                 };
-                var file_path = (resolve.pathConst() orelse unreachable).*;
-                const source_dir = file_path.sourceDir();
-                const loader = this.bundler.options.loader(file_path.name.ext);
-                var bundler = this.bundler;
-                defer scan_pass_result.reset();
-                defer shared_buffer.reset();
-                defer this.bundler.resetStore();
-                var log = worker.data.log;
-
-                // If we're in a node_module, build that almost normally
-                if (is_from_node_modules) {
-                    var written: usize = undefined;
-                    var code_offset: u32 = 0;
-
-                    const module_data = BundledModuleData.getForceBundleForMain(this, &resolve) orelse {
-                        const fake_path = logger.Source.initPathString(file_path.text, "");
-                        log.addResolveError(
-                            &fake_path,
-                            logger.Range.None,
-                            this.allocator,
-                            "Bug while resolving: \"{s}\"",
-                            .{file_path.text},
-                            resolve.import_kind,
-                        ) catch {};
-                        return error.ResolveError;
-                    };
 
-                    const module_id = module_data.module_id;
-                    const package = module_data.package;
-                    const package_relative_path = module_data.import_path;
-
-                    file_path.pretty = module_data.package_path;
-
-                    const entry: CacheEntry = brk: {
-                        if (this.bundler.options.framework) |framework| {
-                            if (framework.override_modules_hashes.len > 0) {
-                                const package_relative_path_hash = std.hash.Wyhash.hash(0, module_data.package_path);
-                                if (std.mem.indexOfScalar(
-                                    u64,
-                                    framework.override_modules_hashes,
-                                    package_relative_path_hash,
-                                )) |index| {
-                                    const relative_path = [_]string{
-                                        framework.resolved_dir,
-                                        framework.override_modules.values[index],
-                                    };
-                                    var override_path = this.bundler.fs.absBuf(
-                                        &relative_path,
-                                        &override_file_path_buf,
-                                    );
-                                    override_file_path_buf[override_path.len] = 0;
-                                    var override_pathZ = override_file_path_buf[0..override_path.len :0];
-                                    break :brk try bundler.resolver.caches.fs.readFileShared(
-                                        bundler.fs,
-                                        override_pathZ,
-                                        0,
-                                        null,
-                                        shared_buffer,
-                                    );
-                                }
+                const module_id = module_data.module_id;
+                const package = module_data.package;
+                const package_relative_path = module_data.import_path;
+
+                file_path.pretty = module_data.package_path;
+
+                const entry: CacheEntry = brk: {
+                    if (this.bundler.options.framework) |framework| {
+                        if (framework.override_modules_hashes.len > 0) {
+                            const package_relative_path_hash = std.hash.Wyhash.hash(0, module_data.package_path);
+                            if (std.mem.indexOfScalar(
+                                u64,
+                                framework.override_modules_hashes,
+                                package_relative_path_hash,
+                            )) |index| {
+                                const relative_path = [_]string{
+                                    framework.resolved_dir,
+                                    framework.override_modules.values[index],
+                                };
+                                var override_path = this.bundler.fs.absBuf(
+                                    &relative_path,
+                                    &override_file_path_buf,
+                                );
+                                override_file_path_buf[override_path.len] = 0;
+                                var override_pathZ = override_file_path_buf[0..override_path.len :0];
+                                break :brk try bundler.resolver.caches.fs.readFileShared(
+                                    bundler.fs,
+                                    override_pathZ,
+                                    0,
+                                    null,
+                                    shared_buffer,
+                                );
                             }
                         }
+                    }
 
-                        if (!strings.eqlComptime(file_path.namespace, "node"))
-                            break :brk try bundler.resolver.caches.fs.readFileShared(
-                                bundler.fs,
-                                file_path.textZ(),
-                                resolve.dirname_fd,
-                                if (resolve.file_fd != 0) resolve.file_fd else null,
-                                shared_buffer,
-                            );
+                    if (!strings.eqlComptime(file_path.namespace, "node"))
+                        break :brk try bundler.resolver.caches.fs.readFileShared(
+                            bundler.fs,
+                            file_path.textZ(),
+                            resolve.dirname_fd,
+                            if (resolve.file_fd != 0) resolve.file_fd else null,
+                            shared_buffer,
+                        );
 
-                        break :brk CacheEntry{
-                            .contents = NodeFallbackModules.contentsFromPath(file_path.text) orelse "",
-                        };
+                    break :brk CacheEntry{
+                        .contents = NodeFallbackModules.contentsFromPath(file_path.text) orelse "",
                     };
+                };
 
-                    var approximate_newline_count: usize = 0;
-                    defer worker.data.estimated_input_lines_of_code += approximate_newline_count;
-
-                    // Handle empty files
-                    // We can't just ignore them. Sometimes code will try to import it. Often because of TypeScript types.
-                    // So we just say it's an empty object. Empty object mimicks what "browser": false does as well.
-                    // TODO: optimize this so that all the exports for these are done in one line instead of writing repeatedly
-                    if (entry.contents.len == 0 or (entry.contents.len < 33 and strings.trim(entry.contents, " \n\r").len == 0)) {
-                        code_offset = try this.writeEmptyModule(module_data.package_path, module_id);
-                    } else {
-                        var ast: js_ast.Ast = undefined;
-
-                        const source = logger.Source.initRecycledFile(
-                            Fs.File{
-                                .path = file_path,
-                                .contents = entry.contents,
-                            },
-                            bundler.allocator,
-                        ) catch return null;
-
-                        switch (loader) {
-                            .jsx,
-                            .tsx,
-                            .js,
-                            .ts,
-                            => {
-                                var jsx = bundler.options.jsx;
-                                jsx.parse = loader.isJSX();
-
-                                var opts = js_parser.Parser.Options.init(jsx, loader);
-                                opts.transform_require_to_import = false;
-                                opts.enable_bundling = true;
-                                opts.warn_about_unbundled_modules = false;
-
-                                ast = (try bundler.resolver.caches.js.parse(
-                                    bundler.allocator,
-                                    opts,
-                                    bundler.options.define,
-                                    log,
-                                    &source,
-                                )) orelse return;
-                                approximate_newline_count = ast.approximate_newline_count;
-                                if (ast.import_records.len > 0) {
-                                    for (ast.import_records) |*import_record, record_id| {
-
-                                        // Don't resolve the runtime
-                                        if (import_record.is_internal or import_record.is_unused) {
-                                            continue;
-                                        }
-
-                                        if (bundler.linker.resolver.resolve(source_dir, import_record.path.text, import_record.kind)) |*_resolved_import| {
-                                            if (_resolved_import.is_external) {
-                                                continue;
-                                            }
-                                            var path = _resolved_import.path() orelse {
-                                                import_record.path.is_disabled = true;
-                                                import_record.is_bundled = true;
-                                                continue;
-                                            };
-
-                                            const loader_ = bundler.options.loader(path.name.ext);
-
-                                            if (!loader_.isJavaScriptLikeOrJSON()) {
-                                                import_record.path.is_disabled = true;
-                                                import_record.is_bundled = true;
-                                                continue;
-                                            }
-
-                                            // if (_resolved_import.package_json == null) |pkg_json| {
-                                            //     _resolved_import.package_json = if (pkg_json.hash == resolve.package_json.?.hash)
-                                            //         resolve.package_json
-                                            //     else
-                                            //         _resolved_import.package_json;
-                                            // }
-
-                                            const resolved_import: *const _resolver.Result = _resolved_import;
-
-                                            const _module_data = BundledModuleData.getForceBundle(this, resolved_import) orelse unreachable;
-                                            import_record.module_id = _module_data.module_id;
-                                            std.debug.assert(import_record.module_id != 0);
-                                            import_record.is_bundled = true;
-
-                                            path.* = try path.dupeAlloc(this.allocator);
-
-                                            import_record.path = path.*;
-
-                                            try this.queue.upsert(
-                                                _module_data.module_id,
-                                                _resolved_import.*,
-                                            );
-                                        } else |err| {
-                                            if (comptime isDebug) {
-                                                Output.prettyErrorln("\n<r><red>{s}<r> on resolving \"{s}\" from \"{s}\"", .{
-                                                    @errorName(err),
-                                                    import_record.path.text,
-                                                    file_path.text,
-                                                });
-                                            }
-
-                                            switch (err) {
-                                                error.ModuleNotFound => {
-                                                    if (isPackagePath(import_record.path.text)) {
-                                                        if (this.bundler.options.platform.isWebLike() and options.ExternalModules.isNodeBuiltin(import_record.path.text)) {
-                                                            try log.addResolveErrorWithTextDupe(
-                                                                &source,
-                                                                import_record.range,
-                                                                this.allocator,
-                                                                "Could not resolve Node.js builtin: \"{s}\".",
-                                                                .{import_record.path.text},
-                                                                import_record.kind,
-                                                            );
-                                                        } else {
-                                                            try log.addResolveErrorWithTextDupe(
-                                                                &source,
-                                                                import_record.range,
-                                                                this.allocator,
-                                                                "Could not resolve: \"{s}\". Maybe you need to \"npm install\" (or yarn/pnpm)?",
-                                                                .{import_record.path.text},
-                                                                import_record.kind,
-                                                            );
-                                                        }
-                                                    } else {
-                                                        try log.addResolveErrorWithTextDupe(
-                                                            &source,
-                                                            import_record.range,
-                                                            this.allocator,
-                                                            "Could not resolve: \"{s}\"",
-                                                            .{
-                                                                import_record.path.text,
-                                                            },
-                                                            import_record.kind,
-                                                        );
-                                                    }
-                                                },
-                                                // assume other errors are already in the log
-                                                else => {},
-                                            }
-                                        }
-                                    }
-                                }
-                            },
-                            .json => {
-                                // parse the JSON _only_ to catch errors at build time.
-                                const json_parse_result = json_parser.ParseJSONForBundling(&source, worker.data.log, worker.allocator) catch return;
-
-                                if (json_parse_result.tag != .empty) {
-                                    const expr = brk: {
-                                        // If it's an ascii string, we just print it out with a big old JSON.parse()
-                                        if (json_parse_result.tag == .ascii) {
-                                            json_e_string = js_ast.E.String{ .utf8 = source.contents, .prefer_template = true };
-                                            var json_string_expr = js_ast.Expr{ .data = .{ .e_string = &json_e_string }, .loc = logger.Loc{ .start = 0 } };
-                                            json_call_args[0] = json_string_expr;
-                                            json_e_identifier = js_ast.E.Identifier{ .ref = Ref{ .source_index = 0, .inner_index = @intCast(Ref.Int, json_ast_symbols_list.len - 1) } };
-
-                                            json_e_call = js_ast.E.Call{
-                                                .target = js_ast.Expr{ .data = .{ .e_identifier = &json_e_identifier }, .loc = logger.Loc{ .start = 0 } },
-                                                .args = std.mem.span(&json_call_args),
-                                            };
-                                            break :brk js_ast.Expr{ .data = .{ .e_call = &json_e_call }, .loc = logger.Loc{ .start = 0 } };
-                                            // If we're going to have to convert it to a UTF16, just make it an object actually
-                                        } else {
-                                            break :brk json_parse_result.expr;
-                                        }
-                                    };
-
-                                    var stmt = js_ast.Stmt.alloc(worker.allocator, js_ast.S.ExportDefault, js_ast.S.ExportDefault{
-                                        .value = js_ast.StmtOrExpr{ .expr = expr },
-                                        .default_name = js_ast.LocRef{ .loc = logger.Loc{}, .ref = Ref{} },
-                                    }, logger.Loc{ .start = 0 });
-                                    var stmts = worker.allocator.alloc(js_ast.Stmt, 1) catch unreachable;
-                                    stmts[0] = stmt;
-                                    var parts = worker.allocator.alloc(js_ast.Part, 1) catch unreachable;
-                                    parts[0] = js_ast.Part{ .stmts = stmts };
-                                    ast = js_ast.Ast.initTest(parts);
-
-                                    ast.runtime_imports = runtime.Runtime.Imports{};
-                                    ast.runtime_imports.@"$$m" = .{ .ref = Ref{ .source_index = 0, .inner_index = 0 }, .primary = Ref.None, .backup = Ref.None };
-                                    ast.runtime_imports.__export = .{ .ref = Ref{ .source_index = 0, .inner_index = 1 }, .primary = Ref.None, .backup = Ref.None };
-                                    ast.symbols = json_ast_symbols_list;
-                                    ast.module_ref = Ref{ .source_index = 0, .inner_index = 2 };
-                                    ast.exports_ref = ast.runtime_imports.__export.?.ref;
-                                    ast.bundle_export_ref = Ref{ .source_index = 0, .inner_index = 3 };
-                                } else {
-                                    var parts = &[_]js_ast.Part{};
-                                    ast = js_ast.Ast.initTest(parts);
-                                }
-                            },
-                            else => {
-                                return;
-                            },
-                        }
-
-                        switch (ast.parts.len) {
-                            // It can be empty after parsing too
-                            // A file like this is an example:
-                            // "//# sourceMappingURL=validator.js.map"
-                            0 => {
-                                code_offset = try this.writeEmptyModule(module_data.package_path, module_id);
-                            },
-                            else => {
-                                const register_ref = ast.runtime_imports.@"$$m".?.ref;
-                                const E = js_ast.E;
-                                const Expr = js_ast.Expr;
-                                const Stmt = js_ast.Stmt;
-
-                                var prepend_part: js_ast.Part = undefined;
-                                var needs_prepend_part = false;
-                                if (ast.parts.len > 1) {
-                                    for (ast.parts) |part| {
-                                        if (part.tag != .none and part.stmts.len > 0) {
-                                            prepend_part = part;
-                                            needs_prepend_part = true;
-                                            break;
-                                        }
-                                    }
-                                }
-
-                                var package_path = js_ast.E.String{ .utf8 = module_data.package_path };
-
-                                var target_identifier = E.Identifier{ .ref = register_ref };
-                                var cjs_args: [2]js_ast.G.Arg = undefined;
-                                var module_binding = js_ast.B.Identifier{ .ref = ast.module_ref.? };
-                                var exports_binding = js_ast.B.Identifier{ .ref = ast.exports_ref.? };
-
-                                var part = &ast.parts[ast.parts.len - 1];
-
-                                var new_stmts: [1]Stmt = undefined;
-                                var register_args: [1]Expr = undefined;
-                                var closure = E.Arrow{
-                                    .args = &cjs_args,
-                                    .body = .{
-                                        .loc = logger.Loc.Empty,
-                                        .stmts = part.stmts,
-                                    },
-                                };
-
-                                cjs_args[0] = js_ast.G.Arg{
-                                    .binding = js_ast.Binding{
-                                        .loc = logger.Loc.Empty,
-                                        .data = .{ .b_identifier = &module_binding },
-                                    },
-                                };
-                                cjs_args[1] = js_ast.G.Arg{
-                                    .binding = js_ast.Binding{
-                                        .loc = logger.Loc.Empty,
-                                        .data = .{ .b_identifier = &exports_binding },
-                                    },
-                                };
-
-                                var properties: [1]js_ast.G.Property = undefined;
-                                var e_object = E.Object{
-                                    .properties = &properties,
-                                };
-                                const module_path_str = js_ast.Expr{ .data = .{ .e_string = &package_path }, .loc = logger.Loc.Empty };
-                                properties[0] = js_ast.G.Property{
-                                    .key = module_path_str,
-                                    .value = Expr{ .loc = logger.Loc.Empty, .data = .{ .e_arrow = &closure } },
-                                };
-
-                                // if (!ast.uses_module_ref) {
-                                //     var symbol = &ast.symbols[ast.module_ref.?.inner_index];
-                                //     symbol.original_name = "_$$";
-                                // }
-
-                                // $$m(12345, "react", "index.js", function(module, exports) {
-
-                                // })
-                                var accessor = js_ast.E.Index{ .index = module_path_str, .target = js_ast.Expr{
-                                    .data = .{ .e_object = &e_object },
-                                    .loc = logger.Loc.Empty,
-                                } };
-                                register_args[0] = Expr{ .loc = logger.Loc.Empty, .data = .{ .e_index = &accessor } };
-
-                                var call_register = E.Call{
-                                    .target = Expr{
-                                        .data = .{ .e_identifier = &target_identifier },
-                                        .loc = logger.Loc{ .start = 0 },
-                                    },
-                                    .args = &register_args,
-                                };
-                                var register_expr = Expr{ .loc = call_register.target.loc, .data = .{ .e_call = &call_register } };
-                                var decls: [1]js_ast.G.Decl = undefined;
-                                var bundle_export_binding = js_ast.B.Identifier{ .ref = ast.runtime_imports.@"$$m".?.ref };
-                                var binding = js_ast.Binding{
-                                    .loc = register_expr.loc,
-                                    .data = .{ .b_identifier = &bundle_export_binding },
-                                };
-                                decls[0] = js_ast.G.Decl{
-                                    .value = register_expr,
-                                    .binding = binding,
-                                };
-                                var export_var = js_ast.S.Local{
-                                    .decls = &decls,
-                                    .is_export = true,
-                                };
-                                new_stmts[0] = Stmt{ .loc = register_expr.loc, .data = .{ .s_local = &export_var } };
-                                part.stmts = &new_stmts;
-
-                                var writer = js_printer.NewFileWriter(this.tmpfile);
-                                var symbols: [][]js_ast.Symbol = &([_][]js_ast.Symbol{ast.symbols});
-
-                                // It should only have one part.
-                                ast.parts = ast.parts[ast.parts.len - 1 ..];
-                                const write_result =
-                                    try js_printer.printCommonJSThreaded(
-                                    @TypeOf(writer),
-                                    writer,
-                                    ast,
-                                    js_ast.Symbol.Map.initList(symbols),
-                                    &source,
-                                    false,
-                                    js_printer.Options{
-                                        .to_module_ref = Ref.RuntimeRef,
-                                        .bundle_export_ref = ast.runtime_imports.@"$$m".?.ref,
-                                        .source_path = file_path,
-                                        .externals = ast.externals,
-                                        .indent = 0,
-                                        .require_ref = ast.require_ref,
-                                        .module_hash = module_id,
-                                        .runtime_imports = ast.runtime_imports,
-                                        .prepend_part_value = &prepend_part,
-                                        .prepend_part_key = if (needs_prepend_part) closure.body.stmts.ptr else null,
-                                    },
-                                    Linker,
-                                    &bundler.linker,
-                                    &this.write_lock,
-                                    std.fs.File,
-                                    this.tmpfile,
-                                    std.fs.File.getPos,
-                                    &this.tmpfile_byte_offset,
-                                );
+                var approximate_newline_count: usize = 0;
+                defer worker.data.estimated_input_lines_of_code += approximate_newline_count;
 
-                                code_offset = write_result.off;
-                            },
-                        }
-                    }
+                // Handle empty files
+                // We can't just ignore them. Sometimes code will try to import it. Often because of TypeScript types.
+                // So we just say it's an empty object. Empty object mimicks what "browser": false does as well.
+                // TODO: optimize this so that all the exports for these are done in one line instead of writing repeatedly
+                if (entry.contents.len == 0 or (entry.contents.len < 33 and strings.trim(entry.contents, " \n\r").len == 0)) {
+                    code_offset = try this.writeEmptyModule(module_data.package_path, module_id);
+                } else {
+                    var ast: js_ast.Ast = undefined;
 
-                    if (comptime isDebug) {
-                        Output.prettyln("{s}@{s}/{s} - {d}:{d} \n", .{ package.name, package.version, package_relative_path, package.hash, module_id });
-                        Output.flush();
-                        std.debug.assert(package_relative_path.len > 0);
-                    }
+                    const source = logger.Source.initRecycledFile(
+                        Fs.File{
+                            .path = file_path,
+                            .contents = entry.contents,
+                        },
+                        bundler.allocator,
+                    ) catch return null;
 
-                    try this.appendToModuleList(
-                        package,
-                        module_id,
-                        code_offset,
-                        package_relative_path,
-                    );
-                } else {
-                    // If it's app code, scan but do not fully parse.
                     switch (loader) {
                         .jsx,
                         .tsx,
                         .js,
                         .ts,
                         => {
-                            const entry = bundler.resolver.caches.fs.readFileShared(
-                                bundler.fs,
-                                file_path.textZ(),
-                                resolve.dirname_fd,
-                                if (resolve.file_fd != 0) resolve.file_fd else null,
-                                shared_buffer,
-                            ) catch return;
-                            if (entry.contents.len == 0 or (entry.contents.len < 33 and strings.trim(entry.contents, " \n\r").len == 0)) return;
-
-                            const source = logger.Source.initRecycledFile(Fs.File{ .path = file_path, .contents = entry.contents }, bundler.allocator) catch return null;
-
                             var jsx = bundler.options.jsx;
                             jsx.parse = loader.isJSX();
+
                             var opts = js_parser.Parser.Options.init(jsx, loader);
+                            opts.transform_require_to_import = false;
+                            opts.enable_bundling = true;
+                            opts.warn_about_unbundled_modules = false;
 
-                            try bundler.resolver.caches.js.scan(
+                            ast = (try bundler.resolver.caches.js.parse(
                                 bundler.allocator,
-                                scan_pass_result,
                                 opts,
                                 bundler.options.define,
                                 log,
                                 &source,
-                            );
-                            worker.data.estimated_input_lines_of_code += scan_pass_result.approximate_newline_count;
+                            )) orelse return;
+                            approximate_newline_count = ast.approximate_newline_count;
+                            if (ast.import_records.len > 0) {
+                                for (ast.import_records) |*import_record, record_id| {
 
-                            {
-                                for (scan_pass_result.import_records.items) |*import_record, i| {
+                                    // Don't resolve the runtime
                                     if (import_record.is_internal or import_record.is_unused) {
                                         continue;
                                     }
@@ -1844,93 +1508,51 @@ pub fn NewBundler(cache_files: bool) type {
                                         if (_resolved_import.is_external) {
                                             continue;
                                         }
+                                        var path = _resolved_import.path() orelse {
+                                            import_record.path.is_disabled = true;
+                                            import_record.is_bundled = true;
+                                            continue;
+                                        };
 
-                                        var path = _resolved_import.path() orelse continue;
+                                        const loader_ = bundler.options.loader(path.name.ext);
 
-                                        const loader_ = this.bundler.options.loader(path.name.ext);
-                                        if (!loader_.isJavaScriptLikeOrJSON()) continue;
+                                        if (!loader_.isJavaScriptLikeOrJSON()) {
+                                            import_record.path.is_disabled = true;
+                                            import_record.is_bundled = true;
+                                            continue;
+                                        }
 
-                                        path.* = try path.dupeAlloc(this.allocator);
+                                        // if (_resolved_import.package_json == null) |pkg_json| {
+                                        //     _resolved_import.package_json = if (pkg_json.hash == resolve.package_json.?.hash)
+                                        //         resolve.package_json
+                                        //     else
+                                        //         _resolved_import.package_json;
+                                        // }
 
-                                        if (BundledModuleData.get(this, _resolved_import)) |mod| {
-                                            if (comptime !FeatureFlags.bundle_dynamic_import) {
-                                                if (import_record.kind == .dynamic)
-                                                    continue;
-                                            } else {
-                                                // When app code dynamically imports a large file
-                                                // Don't bundle it. Leave it as a separate file.
-                                                // The main value from bundling in development is to minimize tiny, waterfall http requests
-                                                // If you're importing > 100 KB file dynamically, developer is probably explicitly trying to do that.
-                                                // There's a tradeoff between "I want to minimize page load time"
-                                                if (import_record.kind == .dynamic) {
-                                                    this.dynamic_import_file_size_store_lock.lock();
-                                                    defer this.dynamic_import_file_size_store_lock.unlock();
-                                                    var dynamic_import_file_size = this.dynamic_import_file_size_store.getOrPut(mod.module_id) catch unreachable;
-                                                    if (!dynamic_import_file_size.found_existing) {
-                                                        var fd = _resolved_import.file_fd;
-                                                        var can_close = false;
-                                                        if (fd == 0) {
-                                                            dynamic_import_file_size.value_ptr.* = 0;
-                                                            fd = (std.fs.openFileAbsolute(path.textZ(), .{}) catch |err| {
-                                                                this.log.addRangeWarningFmt(
-                                                                    &source,
-                                                                    import_record.range,
-                                                                    worker.allocator,
-                                                                    "{s} opening file: \"{s}\"",
-                                                                    .{ @errorName(err), path.text },
-                                                                ) catch unreachable;
-                                                                continue;
-                                                            }).handle;
-                                                            can_close = true;
-                                                            Fs.FileSystem.setMaxFd(fd);
-                                                        }
-
-                                                        defer {
-                                                            if (can_close and bundler.fs.fs.needToCloseFiles()) {
-                                                                var _file = std.fs.File{ .handle = fd };
-                                                                _file.close();
-                                                                _resolved_import.file_fd = 0;
-                                                            } else if (FeatureFlags.store_file_descriptors) {
-                                                                _resolved_import.file_fd = fd;
-                                                            }
-                                                        }
+                                        const resolved_import: *const _resolver.Result = _resolved_import;
 
-                                                        var file = std.fs.File{ .handle = fd };
-                                                        var stat = file.stat() catch |err| {
-                                                            this.log.addRangeWarningFmt(
-                                                                &source,
-                                                                import_record.range,
-                                                                worker.allocator,
-                                                                "{s} stat'ing file: \"{s}\"",
-                                                                .{ @errorName(err), path.text },
-                                                            ) catch unreachable;
-                                                            dynamic_import_file_size.value_ptr.* = 0;
-                                                            continue;
-                                                        };
+                                        const _module_data = BundledModuleData.getForceBundle(this, resolved_import) orelse unreachable;
+                                        import_record.module_id = _module_data.module_id;
+                                        std.debug.assert(import_record.module_id != 0);
+                                        import_record.is_bundled = true;
 
-                                                        dynamic_import_file_size.value_ptr.* = @truncate(u32, stat.size);
-                                                    }
+                                        path.* = try path.dupeAlloc(this.allocator);
 
-                                                    if (dynamic_import_file_size.value_ptr.* > 1024 * 100)
-                                                        continue;
-                                                }
-                                            }
+                                        import_record.path = path.*;
 
-                                            std.debug.assert(mod.module_id != 0);
-                                            try this.queue.upsert(
-                                                mod.module_id,
-                                                _resolved_import.*,
-                                            );
-                                        } else {
-                                            try this.queue.upsert(
-                                                _resolved_import.hash(
-                                                    this.bundler.fs.top_level_dir,
-                                                    loader_,
-                                                ),
-                                                _resolved_import.*,
-                                            );
-                                        }
+                                        try this.queue.upsert(
+                                            _module_data.module_id,
+                                            _resolved_import.*,
+                                        );
                                     } else |err| {
+                                        if (comptime isDebug) {
+                                            Output.prettyErrorln("\n<r><red>{s}<r> on resolving \"{s}\" from \"{s}\"", .{
+                                                @errorName(err),
+                                                import_record.path.text,
+                                                file_path.text,
+                                            });
+                                        }
+
                                         switch (err) {
                                             error.ModuleNotFound => {
                                                 if (isPackagePath(import_record.path.text)) {
@@ -1973,862 +1595,1238 @@ pub fn NewBundler(cache_files: bool) type {
                                 }
                             }
                         },
-                        else => {},
+                        .json => {
+                            // parse the JSON _only_ to catch errors at build time.
+                            const json_parse_result = json_parser.ParseJSONForBundling(&source, worker.data.log, worker.allocator) catch return;
+
+                            if (json_parse_result.tag != .empty) {
+                                const expr = brk: {
+                                    // If it's an ascii string, we just print it out with a big old JSON.parse()
+                                    if (json_parse_result.tag == .ascii) {
+                                        json_e_string = js_ast.E.String{ .utf8 = source.contents, .prefer_template = true };
+                                        var json_string_expr = js_ast.Expr{ .data = .{ .e_string = &json_e_string }, .loc = logger.Loc{ .start = 0 } };
+                                        json_call_args[0] = json_string_expr;
+                                        json_e_identifier = js_ast.E.Identifier{ .ref = Ref{ .source_index = 0, .inner_index = @intCast(Ref.Int, json_ast_symbols_list.len - 1) } };
+
+                                        json_e_call = js_ast.E.Call{
+                                            .target = js_ast.Expr{ .data = .{ .e_identifier = &json_e_identifier }, .loc = logger.Loc{ .start = 0 } },
+                                            .args = std.mem.span(&json_call_args),
+                                        };
+                                        break :brk js_ast.Expr{ .data = .{ .e_call = &json_e_call }, .loc = logger.Loc{ .start = 0 } };
+                                        // If we're going to have to convert it to a UTF16, just make it an object actually
+                                    } else {
+                                        break :brk json_parse_result.expr;
+                                    }
+                                };
+
+                                var stmt = js_ast.Stmt.alloc(worker.allocator, js_ast.S.ExportDefault, js_ast.S.ExportDefault{
+                                    .value = js_ast.StmtOrExpr{ .expr = expr },
+                                    .default_name = js_ast.LocRef{ .loc = logger.Loc{}, .ref = Ref{} },
+                                }, logger.Loc{ .start = 0 });
+                                var stmts = worker.allocator.alloc(js_ast.Stmt, 1) catch unreachable;
+                                stmts[0] = stmt;
+                                var parts = worker.allocator.alloc(js_ast.Part, 1) catch unreachable;
+                                parts[0] = js_ast.Part{ .stmts = stmts };
+                                ast = js_ast.Ast.initTest(parts);
+
+                                ast.runtime_imports = runtime.Runtime.Imports{};
+                                ast.runtime_imports.@"$$m" = .{ .ref = Ref{ .source_index = 0, .inner_index = 0 }, .primary = Ref.None, .backup = Ref.None };
+                                ast.runtime_imports.__export = .{ .ref = Ref{ .source_index = 0, .inner_index = 1 }, .primary = Ref.None, .backup = Ref.None };
+                                ast.symbols = json_ast_symbols_list;
+                                ast.module_ref = Ref{ .source_index = 0, .inner_index = 2 };
+                                ast.exports_ref = ast.runtime_imports.__export.?.ref;
+                                ast.bundle_export_ref = Ref{ .source_index = 0, .inner_index = 3 };
+                            } else {
+                                var parts = &[_]js_ast.Part{};
+                                ast = js_ast.Ast.initTest(parts);
+                            }
+                        },
+                        else => {
+                            return;
+                        },
                     }
-                }
-            }
-        };
 
-        pub const BuildResolveResultPair = struct {
-            written: usize,
-            input_fd: ?StoredFileDescriptorType,
-            empty: bool = false,
-        };
-        pub fn buildWithResolveResult(
-            bundler: *ThisBundler,
-            resolve_result: _resolver.Result,
-            allocator: *std.mem.Allocator,
-            loader: options.Loader,
-            comptime Writer: type,
-            writer: Writer,
-            comptime import_path_format: options.BundleOptions.ImportPathFormat,
-            file_descriptor: ?StoredFileDescriptorType,
-            filepath_hash: u32,
-            comptime WatcherType: type,
-            watcher: *WatcherType,
-            client_entry_point: ?*ClientEntryPoint,
-        ) !BuildResolveResultPair {
-            if (resolve_result.is_external) {
-                return BuildResolveResultPair{
-                    .written = 0,
-                    .input_fd = null,
-                };
-            }
+                    switch (ast.parts.len) {
+                        // It can be empty after parsing too
+                        // A file like this is an example:
+                        // "//# sourceMappingURL=validator.js.map"
+                        0 => {
+                            code_offset = try this.writeEmptyModule(module_data.package_path, module_id);
+                        },
+                        else => {
+                            const register_ref = ast.runtime_imports.@"$$m".?.ref;
+                            const E = js_ast.E;
+                            const Expr = js_ast.Expr;
+                            const Stmt = js_ast.Stmt;
+
+                            var prepend_part: js_ast.Part = undefined;
+                            var needs_prepend_part = false;
+                            if (ast.parts.len > 1) {
+                                for (ast.parts) |part| {
+                                    if (part.tag != .none and part.stmts.len > 0) {
+                                        prepend_part = part;
+                                        needs_prepend_part = true;
+                                        break;
+                                    }
+                                }
+                            }
 
-            errdefer bundler.resetStore();
+                            var package_path = js_ast.E.String{ .utf8 = module_data.package_path };
 
-            var file_path = (resolve_result.pathConst() orelse {
-                return BuildResolveResultPair{
-                    .written = 0,
-                    .input_fd = null,
-                };
-            }).*;
+                            var target_identifier = E.Identifier{ .ref = register_ref };
+                            var cjs_args: [2]js_ast.G.Arg = undefined;
+                            var module_binding = js_ast.B.Identifier{ .ref = ast.module_ref.? };
+                            var exports_binding = js_ast.B.Identifier{ .ref = ast.exports_ref.? };
 
-            if (strings.indexOf(file_path.text, bundler.fs.top_level_dir)) |i| {
-                file_path.pretty = file_path.text[i + bundler.fs.top_level_dir.len ..];
-            } else if (!file_path.is_symlink) {
-                file_path.pretty = allocator.dupe(u8, bundler.fs.relativeTo(file_path.text)) catch unreachable;
-            }
+                            var part = &ast.parts[ast.parts.len - 1];
 
-            var old_bundler_allocator = bundler.allocator;
-            bundler.allocator = allocator;
-            defer bundler.allocator = old_bundler_allocator;
-            var old_linker_allocator = bundler.linker.allocator;
-            defer bundler.linker.allocator = old_linker_allocator;
-            bundler.linker.allocator = allocator;
-
-            switch (loader) {
-                .css => {
-                    const CSSBundlerHMR = Css.NewBundler(
-                        Writer,
-                        @TypeOf(&bundler.linker),
-                        @TypeOf(&bundler.resolver.caches.fs),
-                        WatcherType,
-                        @TypeOf(bundler.fs),
-                        true,
-                    );
+                            var new_stmts: [1]Stmt = undefined;
+                            var register_args: [1]Expr = undefined;
+                            var closure = E.Arrow{
+                                .args = &cjs_args,
+                                .body = .{
+                                    .loc = logger.Loc.Empty,
+                                    .stmts = part.stmts,
+                                },
+                            };
 
-                    const CSSBundler = Css.NewBundler(
-                        Writer,
-                        @TypeOf(&bundler.linker),
-                        @TypeOf(&bundler.resolver.caches.fs),
-                        WatcherType,
-                        @TypeOf(bundler.fs),
-                        false,
-                    );
+                            cjs_args[0] = js_ast.G.Arg{
+                                .binding = js_ast.Binding{
+                                    .loc = logger.Loc.Empty,
+                                    .data = .{ .b_identifier = &module_binding },
+                                },
+                            };
+                            cjs_args[1] = js_ast.G.Arg{
+                                .binding = js_ast.Binding{
+                                    .loc = logger.Loc.Empty,
+                                    .data = .{ .b_identifier = &exports_binding },
+                                },
+                            };
 
-                    return BuildResolveResultPair{
-                        .written = brk: {
-                            if (bundler.options.hot_module_reloading) {
-                                break :brk (try CSSBundlerHMR.bundle(
-                                    file_path.text,
-                                    bundler.fs,
-                                    writer,
-                                    watcher,
-                                    &bundler.resolver.caches.fs,
-                                    filepath_hash,
-                                    file_descriptor,
-                                    allocator,
-                                    bundler.log,
-                                    &bundler.linker,
-                                )).written;
-                            } else {
-                                break :brk (try CSSBundler.bundle(
-                                    file_path.text,
-                                    bundler.fs,
-                                    writer,
-                                    watcher,
-                                    &bundler.resolver.caches.fs,
-                                    filepath_hash,
-                                    file_descriptor,
-                                    allocator,
-                                    bundler.log,
-                                    &bundler.linker,
-                                )).written;
-                            }
-                        },
-                        .input_fd = file_descriptor,
-                    };
-                },
-                else => {
-                    var result = bundler.parse(
-                        allocator,
-                        file_path,
-                        loader,
-                        resolve_result.dirname_fd,
-                        file_descriptor,
-                        filepath_hash,
-                        client_entry_point,
-                    ) orelse {
-                        bundler.resetStore();
-                        return BuildResolveResultPair{
-                            .written = 0,
-                            .input_fd = null,
-                        };
-                    };
+                            var properties: [1]js_ast.G.Property = undefined;
+                            var e_object = E.Object{
+                                .properties = &properties,
+                            };
+                            const module_path_str = js_ast.Expr{ .data = .{ .e_string = &package_path }, .loc = logger.Loc.Empty };
+                            properties[0] = js_ast.G.Property{
+                                .key = module_path_str,
+                                .value = Expr{ .loc = logger.Loc.Empty, .data = .{ .e_arrow = &closure } },
+                            };
 
-                    if (result.empty) {
-                        return BuildResolveResultPair{ .written = 0, .input_fd = result.input_fd, .empty = true };
-                    }
+                            // if (!ast.uses_module_ref) {
+                            //     var symbol = &ast.symbols[ast.module_ref.?.inner_index];
+                            //     symbol.original_name = "_$$";
+                            // }
 
-                    try bundler.linker.link(file_path, &result, import_path_format, false);
+                            // $$m(12345, "react", "index.js", function(module, exports) {
+
+                            // })
+                            var accessor = js_ast.E.Index{ .index = module_path_str, .target = js_ast.Expr{
+                                .data = .{ .e_object = &e_object },
+                                .loc = logger.Loc.Empty,
+                            } };
+                            register_args[0] = Expr{ .loc = logger.Loc.Empty, .data = .{ .e_index = &accessor } };
+
+                            var call_register = E.Call{
+                                .target = Expr{
+                                    .data = .{ .e_identifier = &target_identifier },
+                                    .loc = logger.Loc{ .start = 0 },
+                                },
+                                .args = &register_args,
+                            };
+                            var register_expr = Expr{ .loc = call_register.target.loc, .data = .{ .e_call = &call_register } };
+                            var decls: [1]js_ast.G.Decl = undefined;
+                            var bundle_export_binding = js_ast.B.Identifier{ .ref = ast.runtime_imports.@"$$m".?.ref };
+                            var binding = js_ast.Binding{
+                                .loc = register_expr.loc,
+                                .data = .{ .b_identifier = &bundle_export_binding },
+                            };
+                            decls[0] = js_ast.G.Decl{
+                                .value = register_expr,
+                                .binding = binding,
+                            };
+                            var export_var = js_ast.S.Local{
+                                .decls = &decls,
+                                .is_export = true,
+                            };
+                            new_stmts[0] = Stmt{ .loc = register_expr.loc, .data = .{ .s_local = &export_var } };
+                            part.stmts = &new_stmts;
 
-                    return BuildResolveResultPair{
-                        .written = switch (result.ast.exports_kind) {
-                            .esm => try bundler.print(
-                                result,
-                                Writer,
-                                writer,
-                                .esm,
-                            ),
-                            .cjs => try bundler.print(
-                                result,
-                                Writer,
+                            var writer = js_printer.NewFileWriter(this.tmpfile);
+                            var symbols: [][]js_ast.Symbol = &([_][]js_ast.Symbol{ast.symbols});
+
+                            // It should only have one part.
+                            ast.parts = ast.parts[ast.parts.len - 1 ..];
+                            const write_result =
+                                try js_printer.printCommonJSThreaded(
+                                @TypeOf(writer),
                                 writer,
-                                .cjs,
-                            ),
-                            else => unreachable,
+                                ast,
+                                js_ast.Symbol.Map.initList(symbols),
+                                &source,
+                                false,
+                                js_printer.Options{
+                                    .to_module_ref = Ref.RuntimeRef,
+                                    .bundle_export_ref = ast.runtime_imports.@"$$m".?.ref,
+                                    .source_path = file_path,
+                                    .externals = ast.externals,
+                                    .indent = 0,
+                                    .require_ref = ast.require_ref,
+                                    .module_hash = module_id,
+                                    .runtime_imports = ast.runtime_imports,
+                                    .prepend_part_value = &prepend_part,
+                                    .prepend_part_key = if (needs_prepend_part) closure.body.stmts.ptr else null,
+                                },
+                                Linker,
+                                &bundler.linker,
+                                &this.write_lock,
+                                std.fs.File,
+                                this.tmpfile,
+                                std.fs.File.getPos,
+                                &this.tmpfile_byte_offset,
+                            );
+
+                            code_offset = write_result.off;
                         },
-                        .input_fd = result.input_fd,
-                    };
-                },
-            }
-        }
+                    }
+                }
 
-        pub fn buildWithResolveResultEager(
-            bundler: *ThisBundler,
-            resolve_result: _resolver.Result,
-            comptime import_path_format: options.BundleOptions.ImportPathFormat,
-            comptime Outstream: type,
-            outstream: Outstream,
-            client_entry_point_: ?*ClientEntryPoint,
-        ) !?options.OutputFile {
-            if (resolve_result.is_external) {
-                return null;
-            }
+                if (comptime isDebug) {
+                    Output.prettyln("{s}@{s}/{s} - {d}:{d} \n", .{ package.name, package.version, package_relative_path, package.hash, module_id });
+                    Output.flush();
+                    std.debug.assert(package_relative_path.len > 0);
+                }
 
-            var file_path = (resolve_result.pathConst() orelse return null).*;
+                try this.appendToModuleList(
+                    package,
+                    module_id,
+                    code_offset,
+                    package_relative_path,
+                );
+            } else {
+                // If it's app code, scan but do not fully parse.
+                switch (loader) {
+                    .jsx,
+                    .tsx,
+                    .js,
+                    .ts,
+                    => {
+                        const entry = bundler.resolver.caches.fs.readFileShared(
+                            bundler.fs,
+                            file_path.textZ(),
+                            resolve.dirname_fd,
+                            if (resolve.file_fd != 0) resolve.file_fd else null,
+                            shared_buffer,
+                        ) catch return;
+                        if (entry.contents.len == 0 or (entry.contents.len < 33 and strings.trim(entry.contents, " \n\r").len == 0)) return;
+
+                        const source = logger.Source.initRecycledFile(Fs.File{ .path = file_path, .contents = entry.contents }, bundler.allocator) catch return null;
+
+                        var jsx = bundler.options.jsx;
+                        jsx.parse = loader.isJSX();
+                        var opts = js_parser.Parser.Options.init(jsx, loader);
+
+                        try bundler.resolver.caches.js.scan(
+                            bundler.allocator,
+                            scan_pass_result,
+                            opts,
+                            bundler.options.define,
+                            log,
+                            &source,
+                        );
+                        worker.data.estimated_input_lines_of_code += scan_pass_result.approximate_newline_count;
 
-            // Step 1. Parse & scan
-            const loader = bundler.options.loader(file_path.name.ext);
+                        {
+                            for (scan_pass_result.import_records.items) |*import_record, i| {
+                                if (import_record.is_internal or import_record.is_unused) {
+                                    continue;
+                                }
 
-            if (client_entry_point_) |client_entry_point| {
-                file_path = client_entry_point.source.path;
-            }
+                                if (bundler.linker.resolver.resolve(source_dir, import_record.path.text, import_record.kind)) |*_resolved_import| {
+                                    if (_resolved_import.is_external) {
+                                        continue;
+                                    }
 
-            file_path.pretty = Linker.relative_paths_list.append(string, bundler.fs.relativeTo(file_path.text)) catch unreachable;
+                                    var path = _resolved_import.path() orelse continue;
 
-            var output_file = options.OutputFile{
-                .input = file_path,
-                .loader = loader,
-                .value = undefined,
-            };
+                                    const loader_ = this.bundler.options.loader(path.name.ext);
+                                    if (!loader_.isJavaScriptLikeOrJSON()) continue;
 
-            var file: std.fs.File = undefined;
+                                    path.* = try path.dupeAlloc(this.allocator);
 
-            if (Outstream == std.fs.Dir) {
-                const output_dir = outstream;
+                                    if (BundledModuleData.get(this, _resolved_import)) |mod| {
+                                        if (comptime !FeatureFlags.bundle_dynamic_import) {
+                                            if (import_record.kind == .dynamic)
+                                                continue;
+                                        } else {
+                                            // When app code dynamically imports a large file
+                                            // Don't bundle it. Leave it as a separate file.
+                                            // The main value from bundling in development is to minimize tiny, waterfall http requests
+                                            // If you're importing > 100 KB file dynamically, developer is probably explicitly trying to do that.
+                                            // There's a tradeoff between "I want to minimize page load time"
+                                            if (import_record.kind == .dynamic) {
+                                                this.dynamic_import_file_size_store_lock.lock();
+                                                defer this.dynamic_import_file_size_store_lock.unlock();
+                                                var dynamic_import_file_size = this.dynamic_import_file_size_store.getOrPut(mod.module_id) catch unreachable;
+                                                if (!dynamic_import_file_size.found_existing) {
+                                                    var fd = _resolved_import.file_fd;
+                                                    var can_close = false;
+                                                    if (fd == 0) {
+                                                        dynamic_import_file_size.value_ptr.* = 0;
+                                                        fd = (std.fs.openFileAbsolute(path.textZ(), .{}) catch |err| {
+                                                            this.log.addRangeWarningFmt(
+                                                                &source,
+                                                                import_record.range,
+                                                                worker.allocator,
+                                                                "{s} opening file: \"{s}\"",
+                                                                .{ @errorName(err), path.text },
+                                                            ) catch unreachable;
+                                                            continue;
+                                                        }).handle;
+                                                        can_close = true;
+                                                        Fs.FileSystem.setMaxFd(fd);
+                                                    }
+
+                                                    defer {
+                                                        if (can_close and bundler.fs.fs.needToCloseFiles()) {
+                                                            var _file = std.fs.File{ .handle = fd };
+                                                            _file.close();
+                                                            _resolved_import.file_fd = 0;
+                                                        } else if (FeatureFlags.store_file_descriptors) {
+                                                            _resolved_import.file_fd = fd;
+                                                        }
+                                                    }
 
-                if (std.fs.path.dirname(file_path.pretty)) |dirname| {
-                    try output_dir.makePath(dirname);
+                                                    var file = std.fs.File{ .handle = fd };
+                                                    var stat = file.stat() catch |err| {
+                                                        this.log.addRangeWarningFmt(
+                                                            &source,
+                                                            import_record.range,
+                                                            worker.allocator,
+                                                            "{s} stat'ing file: \"{s}\"",
+                                                            .{ @errorName(err), path.text },
+                                                        ) catch unreachable;
+                                                        dynamic_import_file_size.value_ptr.* = 0;
+                                                        continue;
+                                                    };
+
+                                                    dynamic_import_file_size.value_ptr.* = @truncate(u32, stat.size);
+                                                }
+
+                                                if (dynamic_import_file_size.value_ptr.* > 1024 * 100)
+                                                    continue;
+                                            }
+                                        }
+
+                                        std.debug.assert(mod.module_id != 0);
+                                        try this.queue.upsert(
+                                            mod.module_id,
+                                            _resolved_import.*,
+                                        );
+                                    } else {
+                                        try this.queue.upsert(
+                                            _resolved_import.hash(
+                                                this.bundler.fs.top_level_dir,
+                                                loader_,
+                                            ),
+                                            _resolved_import.*,
+                                        );
+                                    }
+                                } else |err| {
+                                    switch (err) {
+                                        error.ModuleNotFound => {
+                                            if (isPackagePath(import_record.path.text)) {
+                                                if (this.bundler.options.platform.isWebLike() and options.ExternalModules.isNodeBuiltin(import_record.path.text)) {
+                                                    try log.addResolveErrorWithTextDupe(
+                                                        &source,
+                                                        import_record.range,
+                                                        this.allocator,
+                                                        "Could not resolve Node.js builtin: \"{s}\".",
+                                                        .{import_record.path.text},
+                                                        import_record.kind,
+                                                    );
+                                                } else {
+                                                    try log.addResolveErrorWithTextDupe(
+                                                        &source,
+                                                        import_record.range,
+                                                        this.allocator,
+                                                        "Could not resolve: \"{s}\". Maybe you need to \"npm install\" (or yarn/pnpm)?",
+                                                        .{import_record.path.text},
+                                                        import_record.kind,
+                                                    );
+                                                }
+                                            } else {
+                                                try log.addResolveErrorWithTextDupe(
+                                                    &source,
+                                                    import_record.range,
+                                                    this.allocator,
+                                                    "Could not resolve: \"{s}\"",
+                                                    .{
+                                                        import_record.path.text,
+                                                    },
+                                                    import_record.kind,
+                                                );
+                                            }
+                                        },
+                                        // assume other errors are already in the log
+                                        else => {},
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    else => {},
                 }
-                file = try output_dir.createFile(file_path.pretty, .{});
-            } else {
-                file = outstream;
             }
+        }
+    };
 
-            switch (loader) {
-                .jsx, .tsx, .js, .ts, .json => {
-                    var result = bundler.parse(
-                        bundler.allocator,
-                        file_path,
-                        loader,
-                        resolve_result.dirname_fd,
-                        null,
-                        null,
-                        client_entry_point_,
-                    ) orelse {
-                        return null;
-                    };
+    pub const BuildResolveResultPair = struct {
+        written: usize,
+        input_fd: ?StoredFileDescriptorType,
+        empty: bool = false,
+    };
+    pub fn buildWithResolveResult(
+        bundler: *ThisBundler,
+        resolve_result: _resolver.Result,
+        allocator: *std.mem.Allocator,
+        loader: options.Loader,
+        comptime Writer: type,
+        writer: Writer,
+        comptime import_path_format: options.BundleOptions.ImportPathFormat,
+        file_descriptor: ?StoredFileDescriptorType,
+        filepath_hash: u32,
+        comptime WatcherType: type,
+        watcher: *WatcherType,
+        client_entry_point: ?*ClientEntryPoint,
+    ) !BuildResolveResultPair {
+        if (resolve_result.is_external) {
+            return BuildResolveResultPair{
+                .written = 0,
+                .input_fd = null,
+            };
+        }
 
-                    try bundler.linker.link(
-                        file_path,
-                        &result,
-                        import_path_format,
-                        false,
-                    );
+        errdefer bundler.resetStore();
 
-                    output_file.size = try bundler.print(
-                        result,
-                        js_printer.FileWriter,
-                        js_printer.NewFileWriter(file),
-                        .esm,
-                    );
+        var file_path = (resolve_result.pathConst() orelse {
+            return BuildResolveResultPair{
+                .written = 0,
+                .input_fd = null,
+            };
+        }).*;
 
-                    var file_op = options.OutputFile.FileOperation.fromFile(file.handle, file_path.pretty);
+        if (strings.indexOf(file_path.text, bundler.fs.top_level_dir)) |i| {
+            file_path.pretty = file_path.text[i + bundler.fs.top_level_dir.len ..];
+        } else if (!file_path.is_symlink) {
+            file_path.pretty = allocator.dupe(u8, bundler.fs.relativeTo(file_path.text)) catch unreachable;
+        }
 
-                    file_op.fd = file.handle;
+        var old_bundler_allocator = bundler.allocator;
+        bundler.allocator = allocator;
+        defer bundler.allocator = old_bundler_allocator;
+        var old_linker_allocator = bundler.linker.allocator;
+        defer bundler.linker.allocator = old_linker_allocator;
+        bundler.linker.allocator = allocator;
 
-                    file_op.is_tmpdir = false;
+        switch (loader) {
+            .css => {
+                const CSSBundlerHMR = Css.NewBundler(
+                    Writer,
+                    @TypeOf(&bundler.linker),
+                    @TypeOf(&bundler.resolver.caches.fs),
+                    WatcherType,
+                    @TypeOf(bundler.fs),
+                    true,
+                );
 
-                    if (Outstream == std.fs.Dir) {
-                        file_op.dir = outstream.fd;
+                const CSSBundler = Css.NewBundler(
+                    Writer,
+                    @TypeOf(&bundler.linker),
+                    @TypeOf(&bundler.resolver.caches.fs),
+                    WatcherType,
+                    @TypeOf(bundler.fs),
+                    false,
+                );
 
-                        if (bundler.fs.fs.needToCloseFiles()) {
-                            file.close();
-                            file_op.fd = 0;
+                return BuildResolveResultPair{
+                    .written = brk: {
+                        if (bundler.options.hot_module_reloading) {
+                            break :brk (try CSSBundlerHMR.bundle(
+                                file_path.text,
+                                bundler.fs,
+                                writer,
+                                watcher,
+                                &bundler.resolver.caches.fs,
+                                filepath_hash,
+                                file_descriptor,
+                                allocator,
+                                bundler.log,
+                                &bundler.linker,
+                            )).written;
+                        } else {
+                            break :brk (try CSSBundler.bundle(
+                                file_path.text,
+                                bundler.fs,
+                                writer,
+                                watcher,
+                                &bundler.resolver.caches.fs,
+                                filepath_hash,
+                                file_descriptor,
+                                allocator,
+                                bundler.log,
+                                &bundler.linker,
+                            )).written;
                         }
-                    }
+                    },
+                    .input_fd = file_descriptor,
+                };
+            },
+            else => {
+                var result = bundler.parse(
+                    allocator,
+                    file_path,
+                    loader,
+                    resolve_result.dirname_fd,
+                    file_descriptor,
+                    filepath_hash,
+                    client_entry_point,
+                ) orelse {
+                    bundler.resetStore();
+                    return BuildResolveResultPair{
+                        .written = 0,
+                        .input_fd = null,
+                    };
+                };
 
-                    output_file.value = .{ .move = file_op };
-                },
-                .css => {
-                    const CSSWriter = Css.NewWriter(
-                        std.fs.File,
-                        @TypeOf(&bundler.linker),
-                        import_path_format,
-                        void,
-                    );
-                    const entry = bundler.resolver.caches.fs.readFile(
-                        bundler.fs,
-                        file_path.text,
-                        resolve_result.dirname_fd,
-                        !cache_files,
-                        null,
-                    ) catch return null;
+                if (result.empty) {
+                    return BuildResolveResultPair{ .written = 0, .input_fd = result.input_fd, .empty = true };
+                }
 
-                    const _file = Fs.File{ .path = file_path, .contents = entry.contents };
-                    var source = try logger.Source.initFile(_file, bundler.allocator);
-                    source.contents_is_recycled = !cache_files;
-                    var css_writer = CSSWriter.init(
-                        &source,
-                        file,
-                        &bundler.linker,
-                        bundler.log,
-                    );
-                    var did_warn = false;
-                    try css_writer.run(bundler.log, bundler.allocator, &did_warn);
-                    output_file.size = css_writer.written;
-                    var file_op = options.OutputFile.FileOperation.fromFile(file.handle, file_path.pretty);
+                try bundler.linker.link(file_path, &result, import_path_format, false);
 
-                    file_op.fd = file.handle;
+                return BuildResolveResultPair{
+                    .written = switch (result.ast.exports_kind) {
+                        .esm => try bundler.print(
+                            result,
+                            Writer,
+                            writer,
+                            .esm,
+                        ),
+                        .cjs => try bundler.print(
+                            result,
+                            Writer,
+                            writer,
+                            .cjs,
+                        ),
+                        else => unreachable,
+                    },
+                    .input_fd = result.input_fd,
+                };
+            },
+        }
+    }
 
-                    file_op.is_tmpdir = false;
+    pub fn buildWithResolveResultEager(
+        bundler: *ThisBundler,
+        resolve_result: _resolver.Result,
+        comptime import_path_format: options.BundleOptions.ImportPathFormat,
+        comptime Outstream: type,
+        outstream: Outstream,
+        client_entry_point_: ?*ClientEntryPoint,
+    ) !?options.OutputFile {
+        if (resolve_result.is_external) {
+            return null;
+        }
 
-                    if (Outstream == std.fs.Dir) {
-                        file_op.dir = outstream.fd;
+        var file_path = (resolve_result.pathConst() orelse return null).*;
 
-                        if (bundler.fs.fs.needToCloseFiles()) {
-                            file.close();
-                            file_op.fd = 0;
-                        }
-                    }
+        // Step 1. Parse & scan
+        const loader = bundler.options.loader(file_path.name.ext);
 
-                    output_file.value = .{ .move = file_op };
-                },
-                .file => {
-                    var hashed_name = try bundler.linker.getHashedFilename(file_path, null);
-                    var pathname = try bundler.allocator.alloc(u8, hashed_name.len + file_path.name.ext.len);
-                    std.mem.copy(u8, pathname, hashed_name);
-                    std.mem.copy(u8, pathname[hashed_name.len..], file_path.name.ext);
-                    const dir = if (bundler.options.output_dir_handle) |output_handle| output_handle.fd else 0;
-
-                    output_file.value = .{
-                        .copy = options.OutputFile.FileOperation{
-                            .pathname = pathname,
-                            .dir = dir,
-                            .is_outdir = true,
-                        },
-                    };
-                },
+        if (client_entry_point_) |client_entry_point| {
+            file_path = client_entry_point.source.path;
+        }
 
-                // // TODO:
-                // else => {},
-            }
+        file_path.pretty = Linker.relative_paths_list.append(string, bundler.fs.relativeTo(file_path.text)) catch unreachable;
+
+        var output_file = options.OutputFile{
+            .input = file_path,
+            .loader = loader,
+            .value = undefined,
+        };
 
-            return output_file;
+        var file: std.fs.File = undefined;
+
+        if (Outstream == std.fs.Dir) {
+            const output_dir = outstream;
+
+            if (std.fs.path.dirname(file_path.pretty)) |dirname| {
+                try output_dir.makePath(dirname);
+            }
+            file = try output_dir.createFile(file_path.pretty, .{});
+        } else {
+            file = outstream;
         }
 
-        pub fn print(
-            bundler: *ThisBundler,
-            result: ParseResult,
-            comptime Writer: type,
-            writer: Writer,
-            comptime format: js_printer.Format,
-        ) !usize {
-            const ast = result.ast;
-            var symbols: [][]js_ast.Symbol = &([_][]js_ast.Symbol{ast.symbols});
-
-            return switch (format) {
-                .cjs => try js_printer.printCommonJS(
-                    Writer,
-                    writer,
-                    ast,
-                    js_ast.Symbol.Map.initList(symbols),
-                    &result.source,
-                    false,
-                    js_printer.Options{
-                        .to_module_ref = Ref.RuntimeRef,
-                        .externals = ast.externals,
-                        .runtime_imports = ast.runtime_imports,
-                        .require_ref = ast.require_ref,
-                        .css_import_behavior = bundler.options.cssImportBehavior(),
-                    },
-                    Linker,
-                    &bundler.linker,
-                ),
-                .esm => try js_printer.printAst(
-                    Writer,
-                    writer,
-                    ast,
-                    js_ast.Symbol.Map.initList(symbols),
-                    &result.source,
+        switch (loader) {
+            .jsx, .tsx, .js, .ts, .json => {
+                var result = bundler.parse(
+                    bundler.allocator,
+                    file_path,
+                    loader,
+                    resolve_result.dirname_fd,
+                    null,
+                    null,
+                    client_entry_point_,
+                ) orelse {
+                    return null;
+                };
+
+                try bundler.linker.link(
+                    file_path,
+                    &result,
+                    import_path_format,
                     false,
-                    js_printer.Options{
-                        .to_module_ref = Ref.RuntimeRef,
-                        .externals = ast.externals,
-                        .runtime_imports = ast.runtime_imports,
-                        .require_ref = ast.require_ref,
+                );
 
-                        .css_import_behavior = bundler.options.cssImportBehavior(),
-                    },
-                    Linker,
-                    &bundler.linker,
-                ),
-            };
-        }
+                output_file.size = try bundler.print(
+                    result,
+                    js_printer.FileWriter,
+                    js_printer.NewFileWriter(file),
+                    .esm,
+                );
 
-        pub fn parse(
-            bundler: *ThisBundler,
-            allocator: *std.mem.Allocator,
-            path: Fs.Path,
-            loader: options.Loader,
-            // only used when file_descriptor is null
-            dirname_fd: StoredFileDescriptorType,
-            file_descriptor: ?StoredFileDescriptorType,
-            file_hash: ?u32,
-            client_entry_point_: anytype,
-        ) ?ParseResult {
-            if (FeatureFlags.tracing) {
-                bundler.timer.start();
-            }
-            defer {
-                if (FeatureFlags.tracing) {
-                    bundler.timer.stop();
-                    bundler.elapsed += bundler.timer.elapsed;
-                }
-            }
-            var result: ParseResult = undefined;
-            var input_fd: ?StoredFileDescriptorType = null;
+                var file_op = options.OutputFile.FileOperation.fromFile(file.handle, file_path.pretty);
 
-            const source: logger.Source = brk: {
-                if (client_entry_point_) |client_entry_point| {
-                    if (@hasField(std.meta.Child(@TypeOf(client_entry_point)), "source")) {
-                        break :brk client_entry_point.source;
-                    }
-                }
+                file_op.fd = file.handle;
 
-                if (strings.eqlComptime(path.namespace, "node")) {
-                    if (NodeFallbackModules.contentsFromPath(path.text)) |code| {
-                        break :brk logger.Source.initPathString(path.text, code);
-                    }
+                file_op.is_tmpdir = false;
 
-                    break :brk logger.Source.initPathString(path.text, "");
+                if (Outstream == std.fs.Dir) {
+                    file_op.dir = outstream.fd;
+
+                    if (bundler.fs.fs.needToCloseFiles()) {
+                        file.close();
+                        file_op.fd = 0;
+                    }
                 }
 
+                output_file.value = .{ .move = file_op };
+            },
+            .css => {
+                const CSSWriter = Css.NewWriter(
+                    std.fs.File,
+                    @TypeOf(&bundler.linker),
+                    import_path_format,
+                    void,
+                );
                 const entry = bundler.resolver.caches.fs.readFile(
                     bundler.fs,
-                    path.text,
-                    dirname_fd,
-                    true,
-                    file_descriptor,
-                ) catch |err| {
-                    bundler.log.addErrorFmt(null, logger.Loc.Empty, bundler.allocator, "{s} reading \"{s}\"", .{ @errorName(err), path.text }) catch {};
-                    return null;
-                };
-                input_fd = entry.fd;
-                break :brk logger.Source.initRecycledFile(Fs.File{ .path = path, .contents = entry.contents }, bundler.allocator) catch return null;
-            };
+                    file_path.text,
+                    resolve_result.dirname_fd,
+                    !cache_files,
+                    null,
+                ) catch return null;
+
+                const _file = Fs.File{ .path = file_path, .contents = entry.contents };
+                var source = try logger.Source.initFile(_file, bundler.allocator);
+                source.contents_is_recycled = !cache_files;
+                var css_writer = CSSWriter.init(
+                    &source,
+                    file,
+                    &bundler.linker,
+                    bundler.log,
+                );
+                var did_warn = false;
+                try css_writer.run(bundler.log, bundler.allocator, &did_warn);
+                output_file.size = css_writer.written;
+                var file_op = options.OutputFile.FileOperation.fromFile(file.handle, file_path.pretty);
 
-            if (source.contents.len == 0 or (source.contents.len < 33 and std.mem.trim(u8, source.contents, "\n\r ").len == 0)) {
-                return ParseResult{ .source = source, .input_fd = input_fd, .loader = loader, .empty = true, .ast = js_ast.Ast.empty };
-            }
+                file_op.fd = file.handle;
 
-            switch (loader) {
-                .js,
-                .jsx,
-                .ts,
-                .tsx,
-                => {
-                    var jsx = bundler.options.jsx;
-                    jsx.parse = loader.isJSX();
-                    var opts = js_parser.Parser.Options.init(jsx, loader);
-                    opts.enable_bundling = false;
-                    opts.transform_require_to_import = true;
-                    opts.can_import_from_bundle = bundler.options.node_modules_bundle != null;
-
-                    // HMR is enabled when devserver is running
-                    // unless you've explicitly disabled it
-                    // or you're running in SSR
-                    // or the file is a node_module
-                    opts.features.hot_module_reloading = bundler.options.hot_module_reloading and
-                        bundler.options.platform != .bun and
-                        (!opts.can_import_from_bundle or
-                        (opts.can_import_from_bundle and !path.isNodeModule()));
-                    opts.features.react_fast_refresh = opts.features.hot_module_reloading and
-                        jsx.parse and
-                        bundler.options.jsx.supports_fast_refresh;
-                    opts.filepath_hash_for_hmr = file_hash orelse 0;
-                    opts.warn_about_unbundled_modules = bundler.options.platform != .bun;
-                    const value = (bundler.resolver.caches.js.parse(
-                        allocator,
-                        opts,
-                        bundler.options.define,
-                        bundler.log,
-                        &source,
-                    ) catch null) orelse return null;
-                    return ParseResult{
-                        .ast = value,
-                        .source = source,
-                        .loader = loader,
-                        .input_fd = input_fd,
-                    };
-                },
-                .json => {
-                    var expr = json_parser.ParseJSON(&source, bundler.log, allocator) catch return null;
-                    var stmt = js_ast.Stmt.alloc(allocator, js_ast.S.ExportDefault, js_ast.S.ExportDefault{
-                        .value = js_ast.StmtOrExpr{ .expr = expr },
-                        .default_name = js_ast.LocRef{ .loc = logger.Loc{}, .ref = Ref{} },
-                    }, logger.Loc{ .start = 0 });
-                    var stmts = allocator.alloc(js_ast.Stmt, 1) catch unreachable;
-                    stmts[0] = stmt;
-                    var parts = allocator.alloc(js_ast.Part, 1) catch unreachable;
-                    parts[0] = js_ast.Part{ .stmts = stmts };
-
-                    return ParseResult{
-                        .ast = js_ast.Ast.initTest(parts),
-                        .source = source,
-                        .loader = loader,
-                        .input_fd = input_fd,
-                    };
-                },
-                .css => {},
-                else => Global.panic("Unsupported loader {s} for path: {s}", .{ loader, source.path.text }),
-            }
+                file_op.is_tmpdir = false;
 
-            return null;
-        }
+                if (Outstream == std.fs.Dir) {
+                    file_op.dir = outstream.fd;
 
-        // This is public so it can be used by the HTTP handler when matching against public dir.
-        pub threadlocal var tmp_buildfile_buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
-        threadlocal var tmp_buildfile_buf2: [std.fs.MAX_PATH_BYTES]u8 = undefined;
+                    if (bundler.fs.fs.needToCloseFiles()) {
+                        file.close();
+                        file_op.fd = 0;
+                    }
+                }
 
-        // We try to be mostly stateless when serving
-        // This means we need a slightly different resolver setup
-        pub fn buildFile(
-            bundler: *ThisBundler,
-            log: *logger.Log,
-            allocator: *std.mem.Allocator,
-            relative_path: string,
-            _extension: string,
-            comptime client_entry_point_enabled: bool,
-            comptime serve_as_package_path: bool,
-        ) !ServeResult {
-            var extension = _extension;
-            var old_log = bundler.log;
-            var old_allocator = bundler.allocator;
-
-            bundler.setLog(log);
-            defer bundler.setLog(old_log);
-
-            if (strings.eqlComptime(relative_path, "__runtime.js")) {
-                return ServeResult{
-                    .file = options.OutputFile.initBuf(runtime.Runtime.sourceContent(), "__runtime.js", .js),
-                    .mime_type = MimeType.javascript,
+                output_file.value = .{ .move = file_op };
+            },
+            .file => {
+                var hashed_name = try bundler.linker.getHashedFilename(file_path, null);
+                var pathname = try bundler.allocator.alloc(u8, hashed_name.len + file_path.name.ext.len);
+                std.mem.copy(u8, pathname, hashed_name);
+                std.mem.copy(u8, pathname[hashed_name.len..], file_path.name.ext);
+                const dir = if (bundler.options.output_dir_handle) |output_handle| output_handle.fd else 0;
+
+                output_file.value = .{
+                    .copy = options.OutputFile.FileOperation{
+                        .pathname = pathname,
+                        .dir = dir,
+                        .is_outdir = true,
+                    },
                 };
-            }
+            },
 
-            var absolute_path = if (comptime serve_as_package_path)
-                relative_path
-            else
-                resolve_path.joinAbsStringBuf(
-                    bundler.fs.top_level_dir,
-                    &tmp_buildfile_buf,
-                    &([_][]const u8{relative_path}),
-                    .auto,
-                );
+            // // TODO:
+            // else => {},
+        }
 
-            defer {
-                js_ast.Expr.Data.Store.reset();
-                js_ast.Stmt.Data.Store.reset();
+        return output_file;
+    }
+
+    pub fn print(
+        bundler: *ThisBundler,
+        result: ParseResult,
+        comptime Writer: type,
+        writer: Writer,
+        comptime format: js_printer.Format,
+    ) !usize {
+        const ast = result.ast;
+        var symbols: [][]js_ast.Symbol = &([_][]js_ast.Symbol{ast.symbols});
+
+        return switch (format) {
+            .cjs => try js_printer.printCommonJS(
+                Writer,
+                writer,
+                ast,
+                js_ast.Symbol.Map.initList(symbols),
+                &result.source,
+                false,
+                js_printer.Options{
+                    .to_module_ref = Ref.RuntimeRef,
+                    .externals = ast.externals,
+                    .runtime_imports = ast.runtime_imports,
+                    .require_ref = ast.require_ref,
+                    .css_import_behavior = bundler.options.cssImportBehavior(),
+                },
+                Linker,
+                &bundler.linker,
+            ),
+            .esm => try js_printer.printAst(
+                Writer,
+                writer,
+                ast,
+                js_ast.Symbol.Map.initList(symbols),
+                &result.source,
+                false,
+                js_printer.Options{
+                    .to_module_ref = Ref.RuntimeRef,
+                    .externals = ast.externals,
+                    .runtime_imports = ast.runtime_imports,
+                    .require_ref = ast.require_ref,
+
+                    .css_import_behavior = bundler.options.cssImportBehavior(),
+                },
+                Linker,
+                &bundler.linker,
+            ),
+        };
+    }
+
+    pub fn parse(
+        bundler: *ThisBundler,
+        allocator: *std.mem.Allocator,
+        path: Fs.Path,
+        loader: options.Loader,
+        // only used when file_descriptor is null
+        dirname_fd: StoredFileDescriptorType,
+        file_descriptor: ?StoredFileDescriptorType,
+        file_hash: ?u32,
+        client_entry_point_: anytype,
+    ) ?ParseResult {
+        if (FeatureFlags.tracing) {
+            bundler.timer.start();
+        }
+        defer {
+            if (FeatureFlags.tracing) {
+                bundler.timer.stop();
+                bundler.elapsed += bundler.timer.elapsed;
             }
+        }
+        var result: ParseResult = undefined;
+        var input_fd: ?StoredFileDescriptorType = null;
 
-            // If the extension is .js, omit it.
-            // if (absolute_path.len > ".js".len and strings.eqlComptime(absolute_path[absolute_path.len - ".js".len ..], ".js")) {
-            //     absolute_path = absolute_path[0 .. absolute_path.len - ".js".len];
-            // }
+        const source: logger.Source = brk: {
+            if (client_entry_point_) |client_entry_point| {
+                if (@hasField(std.meta.Child(@TypeOf(client_entry_point)), "source")) {
+                    break :brk client_entry_point.source;
+                }
+            }
 
-            const resolved = if (comptime !client_entry_point_enabled) (try bundler.resolver.resolve(bundler.fs.top_level_dir, absolute_path, .stmt)) else brk: {
-                const absolute_pathname = Fs.PathName.init(absolute_path);
-
-                const loader_for_ext = bundler.options.loader(absolute_pathname.ext);
-
-                // The expected pathname looks like:
-                // /pages/index.entry.tsx
-                // /pages/index.entry.js
-                // /pages/index.entry.ts
-                // /pages/index.entry.jsx
-                if (loader_for_ext.supportsClientEntryPoint()) {
-                    const absolute_pathname_pathname = Fs.PathName.init(absolute_pathname.base);
-
-                    if (strings.eqlComptime(absolute_pathname_pathname.ext, ".entry")) {
-                        const trail_dir = absolute_pathname.dirWithTrailingSlash();
-                        var len: usize = trail_dir.len;
-                        std.mem.copy(u8, tmp_buildfile_buf2[0..len], trail_dir);
-
-                        std.mem.copy(u8, tmp_buildfile_buf2[len..], absolute_pathname_pathname.base);
-                        len += absolute_pathname_pathname.base.len;
-                        std.mem.copy(u8, tmp_buildfile_buf2[len..], absolute_pathname.ext);
-                        len += absolute_pathname.ext.len;
-                        std.debug.assert(len > 0);
-                        const decoded_entry_point_path = tmp_buildfile_buf2[0..len];
-                        break :brk (try bundler.resolver.resolve(bundler.fs.top_level_dir, decoded_entry_point_path, .entry_point));
-                    }
+            if (strings.eqlComptime(path.namespace, "node")) {
+                if (NodeFallbackModules.contentsFromPath(path.text)) |code| {
+                    break :brk logger.Source.initPathString(path.text, code);
                 }
 
-                break :brk (try bundler.resolver.resolve(bundler.fs.top_level_dir, absolute_path, .stmt));
+                break :brk logger.Source.initPathString(path.text, "");
+            }
+
+            const entry = bundler.resolver.caches.fs.readFile(
+                bundler.fs,
+                path.text,
+                dirname_fd,
+                true,
+                file_descriptor,
+            ) catch |err| {
+                bundler.log.addErrorFmt(null, logger.Loc.Empty, bundler.allocator, "{s} reading \"{s}\"", .{ @errorName(err), path.text }) catch {};
+                return null;
             };
+            input_fd = entry.fd;
+            break :brk logger.Source.initRecycledFile(Fs.File{ .path = path, .contents = entry.contents }, bundler.allocator) catch return null;
+        };
 
-            const path = (resolved.pathConst() orelse return error.ModuleNotFound);
+        if (source.contents.len == 0 or (source.contents.len < 33 and std.mem.trim(u8, source.contents, "\n\r ").len == 0)) {
+            return ParseResult{ .source = source, .input_fd = input_fd, .loader = loader, .empty = true, .ast = js_ast.Ast.empty };
+        }
 
-            const loader = bundler.options.loader(path.name.ext);
-            const mime_type_ext = bundler.options.out_extensions.get(path.name.ext) orelse path.name.ext;
+        switch (loader) {
+            .js,
+            .jsx,
+            .ts,
+            .tsx,
+            => {
+                var jsx = bundler.options.jsx;
+                jsx.parse = loader.isJSX();
+                var opts = js_parser.Parser.Options.init(jsx, loader);
+                opts.enable_bundling = false;
+                opts.transform_require_to_import = true;
+                opts.can_import_from_bundle = bundler.options.node_modules_bundle != null;
+
+                // HMR is enabled when devserver is running
+                // unless you've explicitly disabled it
+                // or you're running in SSR
+                // or the file is a node_module
+                opts.features.hot_module_reloading = bundler.options.hot_module_reloading and
+                    bundler.options.platform != .bun and
+                    (!opts.can_import_from_bundle or
+                    (opts.can_import_from_bundle and !path.isNodeModule()));
+                opts.features.react_fast_refresh = opts.features.hot_module_reloading and
+                    jsx.parse and
+                    bundler.options.jsx.supports_fast_refresh;
+                opts.filepath_hash_for_hmr = file_hash orelse 0;
+                opts.warn_about_unbundled_modules = bundler.options.platform != .bun;
+                const value = (bundler.resolver.caches.js.parse(
+                    allocator,
+                    opts,
+                    bundler.options.define,
+                    bundler.log,
+                    &source,
+                ) catch null) orelse return null;
+                return ParseResult{
+                    .ast = value,
+                    .source = source,
+                    .loader = loader,
+                    .input_fd = input_fd,
+                };
+            },
+            .json => {
+                var expr = json_parser.ParseJSON(&source, bundler.log, allocator) catch return null;
+                var stmt = js_ast.Stmt.alloc(allocator, js_ast.S.ExportDefault, js_ast.S.ExportDefault{
+                    .value = js_ast.StmtOrExpr{ .expr = expr },
+                    .default_name = js_ast.LocRef{ .loc = logger.Loc{}, .ref = Ref{} },
+                }, logger.Loc{ .start = 0 });
+                var stmts = allocator.alloc(js_ast.Stmt, 1) catch unreachable;
+                stmts[0] = stmt;
+                var parts = allocator.alloc(js_ast.Part, 1) catch unreachable;
+                parts[0] = js_ast.Part{ .stmts = stmts };
 
-            switch (loader) {
-                .js, .jsx, .ts, .tsx, .css => {
-                    return ServeResult{
-                        .file = options.OutputFile.initPending(loader, resolved),
-                        .mime_type = MimeType.byLoader(
-                            loader,
-                            mime_type_ext[1..],
-                        ),
-                    };
-                },
-                .json => {
-                    return ServeResult{
-                        .file = options.OutputFile.initPending(loader, resolved),
-                        .mime_type = MimeType.transpiled_json,
-                    };
-                },
-                else => {
-                    var abs_path = path.text;
-                    const file = try std.fs.openFileAbsolute(abs_path, .{ .read = true });
-                    var stat = try file.stat();
-                    return ServeResult{
-                        .file = options.OutputFile.initFile(file, abs_path, stat.size),
-                        .mime_type = MimeType.byLoader(
-                            loader,
-                            mime_type_ext[1..],
-                        ),
-                    };
-                },
-            }
+                return ParseResult{
+                    .ast = js_ast.Ast.initTest(parts),
+                    .source = source,
+                    .loader = loader,
+                    .input_fd = input_fd,
+                };
+            },
+            .css => {},
+            else => Global.panic("Unsupported loader {s} for path: {s}", .{ loader, source.path.text }),
         }
 
-        pub fn normalizeEntryPointPath(bundler: *ThisBundler, _entry: string) string {
-            var paths = [_]string{_entry};
-            var entry = bundler.fs.abs(&paths);
+        return null;
+    }
+
+    // This is public so it can be used by the HTTP handler when matching against public dir.
+    pub threadlocal var tmp_buildfile_buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
+    threadlocal var tmp_buildfile_buf2: [std.fs.MAX_PATH_BYTES]u8 = undefined;
 
-            std.fs.accessAbsolute(entry, .{}) catch |err| {
-                return _entry;
+    // We try to be mostly stateless when serving
+    // This means we need a slightly different resolver setup
+    pub fn buildFile(
+        bundler: *ThisBundler,
+        log: *logger.Log,
+        allocator: *std.mem.Allocator,
+        relative_path: string,
+        _extension: string,
+        comptime client_entry_point_enabled: bool,
+        comptime serve_as_package_path: bool,
+    ) !ServeResult {
+        var extension = _extension;
+        var old_log = bundler.log;
+        var old_allocator = bundler.allocator;
+
+        bundler.setLog(log);
+        defer bundler.setLog(old_log);
+
+        if (strings.eqlComptime(relative_path, "__runtime.js")) {
+            return ServeResult{
+                .file = options.OutputFile.initBuf(runtime.Runtime.sourceContent(), "__runtime.js", .js),
+                .mime_type = MimeType.javascript,
             };
+        }
 
-            entry = bundler.fs.relativeTo(entry);
-
-            if (!strings.startsWith(entry, "./")) {
-                // Entry point paths without a leading "./" are interpreted as package
-                // paths. This happens because they go through general path resolution
-                // like all other import paths so that plugins can run on them. Requiring
-                // a leading "./" for a relative path simplifies writing plugins because
-                // entry points aren't a special case.
-                //
-                // However, requiring a leading "./" also breaks backward compatibility
-                // and makes working with the CLI more difficult. So attempt to insert
-                // "./" automatically when needed. We don't want to unconditionally insert
-                // a leading "./" because the path may not be a file system path. For
-                // example, it may be a URL. So only insert a leading "./" when the path
-                // is an exact match for an existing file.
-                var __entry = bundler.allocator.alloc(u8, "./".len + entry.len) catch unreachable;
-                __entry[0] = '.';
-                __entry[1] = '/';
-                std.mem.copy(u8, __entry[2..__entry.len], entry);
-                entry = __entry;
-            }
+        var absolute_path = if (comptime serve_as_package_path)
+            relative_path
+        else
+            resolve_path.joinAbsStringBuf(
+                bundler.fs.top_level_dir,
+                &tmp_buildfile_buf,
+                &([_][]const u8{relative_path}),
+                .auto,
+            );
 
-            return entry;
+        defer {
+            js_ast.Expr.Data.Store.reset();
+            js_ast.Stmt.Data.Store.reset();
         }
 
-        fn enqueueEntryPoints(bundler: *ThisBundler, entry_points: []_resolver.Result, comptime normalize_entry_point: bool) usize {
-            var entry_point_i: usize = 0;
+        // If the extension is .js, omit it.
+        // if (absolute_path.len > ".js".len and strings.eqlComptime(absolute_path[absolute_path.len - ".js".len ..], ".js")) {
+        //     absolute_path = absolute_path[0 .. absolute_path.len - ".js".len];
+        // }
+
+        const resolved = if (comptime !client_entry_point_enabled) (try bundler.resolver.resolve(bundler.fs.top_level_dir, absolute_path, .stmt)) else brk: {
+            const absolute_pathname = Fs.PathName.init(absolute_path);
+
+            const loader_for_ext = bundler.options.loader(absolute_pathname.ext);
+
+            // The expected pathname looks like:
+            // /pages/index.entry.tsx
+            // /pages/index.entry.js
+            // /pages/index.entry.ts
+            // /pages/index.entry.jsx
+            if (loader_for_ext.supportsClientEntryPoint()) {
+                const absolute_pathname_pathname = Fs.PathName.init(absolute_pathname.base);
+
+                if (strings.eqlComptime(absolute_pathname_pathname.ext, ".entry")) {
+                    const trail_dir = absolute_pathname.dirWithTrailingSlash();
+                    var len: usize = trail_dir.len;
+                    std.mem.copy(u8, tmp_buildfile_buf2[0..len], trail_dir);
+
+                    std.mem.copy(u8, tmp_buildfile_buf2[len..], absolute_pathname_pathname.base);
+                    len += absolute_pathname_pathname.base.len;
+                    std.mem.copy(u8, tmp_buildfile_buf2[len..], absolute_pathname.ext);
+                    len += absolute_pathname.ext.len;
+                    std.debug.assert(len > 0);
+                    const decoded_entry_point_path = tmp_buildfile_buf2[0..len];
+                    break :brk (try bundler.resolver.resolve(bundler.fs.top_level_dir, decoded_entry_point_path, .entry_point));
+                }
+            }
 
-            for (bundler.options.entry_points) |_entry| {
-                var entry: string = if (comptime normalize_entry_point) bundler.normalizeEntryPointPath(_entry) else _entry;
+            break :brk (try bundler.resolver.resolve(bundler.fs.top_level_dir, absolute_path, .stmt));
+        };
 
-                defer {
-                    js_ast.Expr.Data.Store.reset();
-                    js_ast.Stmt.Data.Store.reset();
-                }
+        const path = (resolved.pathConst() orelse return error.ModuleNotFound);
 
-                const result = bundler.resolver.resolve(bundler.fs.top_level_dir, entry, .entry_point) catch |err| {
-                    Output.prettyError("Error resolving \"{s}\": {s}\n", .{ entry, @errorName(err) });
-                    continue;
+        const loader = bundler.options.loader(path.name.ext);
+        const mime_type_ext = bundler.options.out_extensions.get(path.name.ext) orelse path.name.ext;
+
+        switch (loader) {
+            .js, .jsx, .ts, .tsx, .css => {
+                return ServeResult{
+                    .file = options.OutputFile.initPending(loader, resolved),
+                    .mime_type = MimeType.byLoader(
+                        loader,
+                        mime_type_ext[1..],
+                    ),
+                };
+            },
+            .json => {
+                return ServeResult{
+                    .file = options.OutputFile.initPending(loader, resolved),
+                    .mime_type = MimeType.transpiled_json,
+                };
+            },
+            else => {
+                var abs_path = path.text;
+                const file = try std.fs.openFileAbsolute(abs_path, .{ .read = true });
+                var stat = try file.stat();
+                return ServeResult{
+                    .file = options.OutputFile.initFile(file, abs_path, stat.size),
+                    .mime_type = MimeType.byLoader(
+                        loader,
+                        mime_type_ext[1..],
+                    ),
                 };
+            },
+        }
+    }
 
-                if (result.pathConst() == null) {
-                    Output.prettyError("\"{s}\" is disabled due to \"browser\" field in package.json.\n", .{
-                        entry,
-                    });
-                    continue;
-                }
+    pub fn normalizeEntryPointPath(bundler: *ThisBundler, _entry: string) string {
+        var paths = [_]string{_entry};
+        var entry = bundler.fs.abs(&paths);
 
-                if (bundler.linker.enqueueResolveResult(&result) catch unreachable) {
-                    entry_points[entry_point_i] = result;
-                    entry_point_i += 1;
-                }
-            }
+        std.fs.accessAbsolute(entry, .{}) catch |err| {
+            return _entry;
+        };
 
-            return entry_point_i;
+        entry = bundler.fs.relativeTo(entry);
+
+        if (!strings.startsWith(entry, "./")) {
+            // Entry point paths without a leading "./" are interpreted as package
+            // paths. This happens because they go through general path resolution
+            // like all other import paths so that plugins can run on them. Requiring
+            // a leading "./" for a relative path simplifies writing plugins because
+            // entry points aren't a special case.
+            //
+            // However, requiring a leading "./" also breaks backward compatibility
+            // and makes working with the CLI more difficult. So attempt to insert
+            // "./" automatically when needed. We don't want to unconditionally insert
+            // a leading "./" because the path may not be a file system path. For
+            // example, it may be a URL. So only insert a leading "./" when the path
+            // is an exact match for an existing file.
+            var __entry = bundler.allocator.alloc(u8, "./".len + entry.len) catch unreachable;
+            __entry[0] = '.';
+            __entry[1] = '/';
+            std.mem.copy(u8, __entry[2..__entry.len], entry);
+            entry = __entry;
         }
 
-        pub fn bundle(
-            allocator: *std.mem.Allocator,
-            log: *logger.Log,
-            opts: Api.TransformOptions,
-        ) !options.TransformResult {
-            var bundler = try ThisBundler.init(allocator, log, opts, null, null);
-            bundler.configureLinker();
-            try bundler.configureRouter(false);
-            try bundler.configureDefines();
+        return entry;
+    }
 
-            var skip_normalize = false;
-            var load_from_routes = false;
-            if (bundler.options.routes.routes_enabled and bundler.options.entry_points.len == 0) {
-                if (bundler.router) |router| {
-                    bundler.options.entry_points = try router.getEntryPoints(allocator);
-                    skip_normalize = true;
-                    load_from_routes = true;
-                }
+    fn enqueueEntryPoints(bundler: *ThisBundler, entry_points: []_resolver.Result, comptime normalize_entry_point: bool) usize {
+        var entry_point_i: usize = 0;
+
+        for (bundler.options.entry_points) |_entry| {
+            var entry: string = if (comptime normalize_entry_point) bundler.normalizeEntryPointPath(_entry) else _entry;
+
+            defer {
+                js_ast.Expr.Data.Store.reset();
+                js_ast.Stmt.Data.Store.reset();
             }
 
-            if (bundler.options.write and bundler.options.output_dir.len > 0) {}
+            const result = bundler.resolver.resolve(bundler.fs.top_level_dir, entry, .entry_point) catch |err| {
+                Output.prettyError("Error resolving \"{s}\": {s}\n", .{ entry, @errorName(err) });
+                continue;
+            };
 
-            //  100.00 µs std.fifo.LinearFifo(resolver.Result,std.fifo.LinearFifoBufferType { .Dynamic = {}}).writeItemAssumeCapacity
-            if (bundler.options.resolve_mode != .lazy) {
-                try bundler.resolve_queue.ensureUnusedCapacity(3);
+            if (result.pathConst() == null) {
+                Output.prettyError("\"{s}\" is disabled due to \"browser\" field in package.json.\n", .{
+                    entry,
+                });
+                continue;
             }
 
-            var entry_points = try allocator.alloc(_resolver.Result, bundler.options.entry_points.len);
-            if (skip_normalize) {
-                entry_points = entry_points[0..bundler.enqueueEntryPoints(entry_points, false)];
-            } else {
-                entry_points = entry_points[0..bundler.enqueueEntryPoints(entry_points, true)];
+            if (bundler.linker.enqueueResolveResult(&result) catch unreachable) {
+                entry_points[entry_point_i] = result;
+                entry_point_i += 1;
             }
+        }
 
-            if (log.level == .verbose) {
-                bundler.resolver.debug_logs = try DebugLogs.init(allocator);
+        return entry_point_i;
+    }
+
+    pub fn bundle(
+        allocator: *std.mem.Allocator,
+        log: *logger.Log,
+        opts: Api.TransformOptions,
+    ) !options.TransformResult {
+        var bundler = try ThisBundler.init(allocator, log, opts, null, null);
+        bundler.configureLinker();
+        try bundler.configureRouter(false);
+        try bundler.configureDefines();
+
+        var skip_normalize = false;
+        var load_from_routes = false;
+        if (bundler.options.routes.routes_enabled and bundler.options.entry_points.len == 0) {
+            if (bundler.router) |router| {
+                bundler.options.entry_points = try router.getEntryPoints(allocator);
+                skip_normalize = true;
+                load_from_routes = true;
             }
+        }
 
-            var did_start = false;
+        if (bundler.options.write and bundler.options.output_dir.len > 0) {}
 
-            if (bundler.options.output_dir_handle == null) {
-                const outstream = std.io.getStdOut();
+        //  100.00 µs std.fifo.LinearFifo(resolver.Result,std.fifo.LinearFifoBufferType { .Dynamic = {}}).writeItemAssumeCapacity
+        if (bundler.options.resolve_mode != .lazy) {
+            try bundler.resolve_queue.ensureUnusedCapacity(3);
+        }
 
-                if (load_from_routes) {
-                    if (bundler.options.framework) |*framework| {
-                        if (framework.client.isEnabled()) {
-                            did_start = true;
-                            try switch (bundler.options.import_path_format) {
-                                .relative => bundler.processResolveQueue(.relative, true, @TypeOf(outstream), outstream),
-                                .relative_nodejs => bundler.processResolveQueue(.relative_nodejs, true, @TypeOf(outstream), outstream),
-                                .absolute_url => bundler.processResolveQueue(.absolute_url, true, @TypeOf(outstream), outstream),
-                                .absolute_path => bundler.processResolveQueue(.absolute_path, true, @TypeOf(outstream), outstream),
-                                .package_path => bundler.processResolveQueue(.package_path, true, @TypeOf(outstream), outstream),
-                            };
-                        }
+        var entry_points = try allocator.alloc(_resolver.Result, bundler.options.entry_points.len);
+        if (skip_normalize) {
+            entry_points = entry_points[0..bundler.enqueueEntryPoints(entry_points, false)];
+        } else {
+            entry_points = entry_points[0..bundler.enqueueEntryPoints(entry_points, true)];
+        }
+
+        if (log.level == .verbose) {
+            bundler.resolver.debug_logs = try DebugLogs.init(allocator);
+        }
+
+        var did_start = false;
+
+        if (bundler.options.output_dir_handle == null) {
+            const outstream = std.io.getStdOut();
+
+            if (load_from_routes) {
+                if (bundler.options.framework) |*framework| {
+                    if (framework.client.isEnabled()) {
+                        did_start = true;
+                        try switch (bundler.options.import_path_format) {
+                            .relative => bundler.processResolveQueue(.relative, true, @TypeOf(outstream), outstream),
+                            .relative_nodejs => bundler.processResolveQueue(.relative_nodejs, true, @TypeOf(outstream), outstream),
+                            .absolute_url => bundler.processResolveQueue(.absolute_url, true, @TypeOf(outstream), outstream),
+                            .absolute_path => bundler.processResolveQueue(.absolute_path, true, @TypeOf(outstream), outstream),
+                            .package_path => bundler.processResolveQueue(.package_path, true, @TypeOf(outstream), outstream),
+                        };
                     }
                 }
+            }
 
-                if (!did_start) {
-                    try switch (bundler.options.import_path_format) {
-                        .relative => bundler.processResolveQueue(.relative, false, @TypeOf(outstream), outstream),
-                        .relative_nodejs => bundler.processResolveQueue(.relative_nodejs, false, @TypeOf(outstream), outstream),
-                        .absolute_url => bundler.processResolveQueue(.absolute_url, false, @TypeOf(outstream), outstream),
-                        .absolute_path => bundler.processResolveQueue(.absolute_path, false, @TypeOf(outstream), outstream),
-                        .package_path => bundler.processResolveQueue(.package_path, false, @TypeOf(outstream), outstream),
-                    };
-                }
-            } else {
-                const output_dir = bundler.options.output_dir_handle orelse {
-                    Output.printError("Invalid or missing output directory.", .{});
-                    Output.flush();
-                    Global.crash();
+            if (!did_start) {
+                try switch (bundler.options.import_path_format) {
+                    .relative => bundler.processResolveQueue(.relative, false, @TypeOf(outstream), outstream),
+                    .relative_nodejs => bundler.processResolveQueue(.relative_nodejs, false, @TypeOf(outstream), outstream),
+                    .absolute_url => bundler.processResolveQueue(.absolute_url, false, @TypeOf(outstream), outstream),
+                    .absolute_path => bundler.processResolveQueue(.absolute_path, false, @TypeOf(outstream), outstream),
+                    .package_path => bundler.processResolveQueue(.package_path, false, @TypeOf(outstream), outstream),
                 };
+            }
+        } else {
+            const output_dir = bundler.options.output_dir_handle orelse {
+                Output.printError("Invalid or missing output directory.", .{});
+                Output.flush();
+                Global.crash();
+            };
 
-                if (load_from_routes) {
-                    if (bundler.options.framework) |*framework| {
-                        if (framework.client.isEnabled()) {
-                            did_start = true;
-                            try switch (bundler.options.import_path_format) {
-                                .relative => bundler.processResolveQueue(.relative, true, std.fs.Dir, output_dir),
-                                .relative_nodejs => bundler.processResolveQueue(.relative_nodejs, true, std.fs.Dir, output_dir),
-                                .absolute_url => bundler.processResolveQueue(.absolute_url, true, std.fs.Dir, output_dir),
-                                .absolute_path => bundler.processResolveQueue(.absolute_path, true, std.fs.Dir, output_dir),
-                                .package_path => bundler.processResolveQueue(.package_path, true, std.fs.Dir, output_dir),
-                            };
-                        }
+            if (load_from_routes) {
+                if (bundler.options.framework) |*framework| {
+                    if (framework.client.isEnabled()) {
+                        did_start = true;
+                        try switch (bundler.options.import_path_format) {
+                            .relative => bundler.processResolveQueue(.relative, true, std.fs.Dir, output_dir),
+                            .relative_nodejs => bundler.processResolveQueue(.relative_nodejs, true, std.fs.Dir, output_dir),
+                            .absolute_url => bundler.processResolveQueue(.absolute_url, true, std.fs.Dir, output_dir),
+                            .absolute_path => bundler.processResolveQueue(.absolute_path, true, std.fs.Dir, output_dir),
+                            .package_path => bundler.processResolveQueue(.package_path, true, std.fs.Dir, output_dir),
+                        };
                     }
                 }
-
-                if (!did_start) {
-                    try switch (bundler.options.import_path_format) {
-                        .relative => bundler.processResolveQueue(.relative, false, std.fs.Dir, output_dir),
-                        .relative_nodejs => bundler.processResolveQueue(.relative_nodejs, false, std.fs.Dir, output_dir),
-                        .absolute_url => bundler.processResolveQueue(.absolute_url, false, std.fs.Dir, output_dir),
-                        .absolute_path => bundler.processResolveQueue(.absolute_path, false, std.fs.Dir, output_dir),
-                        .package_path => bundler.processResolveQueue(.package_path, false, std.fs.Dir, output_dir),
-                    };
-                }
             }
 
-            // if (log.level == .verbose) {
-            //     for (log.msgs.items) |msg| {
-            //         try msg.writeFormat(std.io.getStdOut().writer());
-            //     }
-            // }
-
-            if (bundler.linker.any_needs_runtime) {
-                try bundler.output_files.append(
-                    options.OutputFile.initBuf(runtime.Runtime.sourceContent(), bundler.linker.runtime_source_path, .js),
-                );
+            if (!did_start) {
+                try switch (bundler.options.import_path_format) {
+                    .relative => bundler.processResolveQueue(.relative, false, std.fs.Dir, output_dir),
+                    .relative_nodejs => bundler.processResolveQueue(.relative_nodejs, false, std.fs.Dir, output_dir),
+                    .absolute_url => bundler.processResolveQueue(.absolute_url, false, std.fs.Dir, output_dir),
+                    .absolute_path => bundler.processResolveQueue(.absolute_path, false, std.fs.Dir, output_dir),
+                    .package_path => bundler.processResolveQueue(.package_path, false, std.fs.Dir, output_dir),
+                };
             }
+        }
 
-            if (FeatureFlags.tracing) {
-                Output.prettyErrorln(
-                    "<r><d>\n---Tracing---\nResolve time:      {d}\nParsing time:      {d}\n---Tracing--\n\n<r>",
-                    .{
-                        bundler.resolver.elapsed,
-                        bundler.elapsed,
-                    },
-                );
-            }
+        // if (log.level == .verbose) {
+        //     for (log.msgs.items) |msg| {
+        //         try msg.writeFormat(std.io.getStdOut().writer());
+        //     }
+        // }
 
-            var final_result = try options.TransformResult.init(try allocator.dupe(u8, bundler.result.outbase), bundler.output_files.toOwnedSlice(), log, allocator);
-            final_result.root_dir = bundler.options.output_dir_handle;
-            return final_result;
+        if (bundler.linker.any_needs_runtime) {
+            try bundler.output_files.append(
+                options.OutputFile.initBuf(runtime.Runtime.sourceContent(), bundler.linker.runtime_source_path, .js),
+            );
         }
 
-        // pub fn processResolveQueueWithThreadPool(bundler)
+        if (FeatureFlags.tracing) {
+            Output.prettyErrorln(
+                "<r><d>\n---Tracing---\nResolve time:      {d}\nParsing time:      {d}\n---Tracing--\n\n<r>",
+                .{
+                    bundler.resolver.elapsed,
+                    bundler.elapsed,
+                },
+            );
+        }
 
-        pub fn processResolveQueue(
-            bundler: *ThisBundler,
-            comptime import_path_format: options.BundleOptions.ImportPathFormat,
-            comptime wrap_entry_point: bool,
-            comptime Outstream: type,
-            outstream: Outstream,
-        ) !void {
-            // var count: u8 = 0;
-            while (bundler.resolve_queue.readItem()) |item| {
-                js_ast.Expr.Data.Store.reset();
-                js_ast.Stmt.Data.Store.reset();
+        var final_result = try options.TransformResult.init(try allocator.dupe(u8, bundler.result.outbase), bundler.output_files.toOwnedSlice(), log, allocator);
+        final_result.root_dir = bundler.options.output_dir_handle;
+        return final_result;
+    }
 
-                // defer count += 1;
-
-                if (comptime wrap_entry_point) {
-                    var path = item.pathConst() orelse unreachable;
-                    const loader = bundler.options.loader(path.name.ext);
-
-                    if (item.import_kind == .entry_point and loader.supportsClientEntryPoint()) {
-                        var client_entry_point = try bundler.allocator.create(ClientEntryPoint);
-                        client_entry_point.* = ClientEntryPoint{};
-                        try client_entry_point.generate(ThisBundler, bundler, path.name, bundler.options.framework.?.client.path);
-                        try bundler.virtual_modules.append(client_entry_point);
-
-                        const entry_point_output_file = bundler.buildWithResolveResultEager(
-                            item,
-                            import_path_format,
-                            Outstream,
-                            outstream,
-                            client_entry_point,
-                        ) catch continue orelse continue;
-                        bundler.output_files.append(entry_point_output_file) catch unreachable;
-
-                        js_ast.Expr.Data.Store.reset();
-                        js_ast.Stmt.Data.Store.reset();
-
-                        // At this point, the entry point will be de-duped.
-                        // So we just immediately build it.
-                        var item_not_entrypointed = item;
-                        item_not_entrypointed.import_kind = .stmt;
-                        const original_output_file = bundler.buildWithResolveResultEager(
-                            item_not_entrypointed,
-                            import_path_format,
-                            Outstream,
-                            outstream,
-                            null,
-                        ) catch continue orelse continue;
-                        bundler.output_files.append(original_output_file) catch unreachable;
-
-                        continue;
-                    }
-                }
+    // pub fn processResolveQueueWithThreadPool(bundler)
 
-                const output_file = bundler.buildWithResolveResultEager(
-                    item,
-                    import_path_format,
-                    Outstream,
-                    outstream,
-                    null,
-                ) catch continue orelse continue;
-                bundler.output_files.append(output_file) catch unreachable;
+    pub fn processResolveQueue(
+        bundler: *ThisBundler,
+        comptime import_path_format: options.BundleOptions.ImportPathFormat,
+        comptime wrap_entry_point: bool,
+        comptime Outstream: type,
+        outstream: Outstream,
+    ) !void {
+        // var count: u8 = 0;
+        while (bundler.resolve_queue.readItem()) |item| {
+            js_ast.Expr.Data.Store.reset();
+            js_ast.Stmt.Data.Store.reset();
+
+            // defer count += 1;
+
+            if (comptime wrap_entry_point) {
+                var path = item.pathConst() orelse unreachable;
+                const loader = bundler.options.loader(path.name.ext);
+
+                if (item.import_kind == .entry_point and loader.supportsClientEntryPoint()) {
+                    var client_entry_point = try bundler.allocator.create(ClientEntryPoint);
+                    client_entry_point.* = ClientEntryPoint{};
+                    try client_entry_point.generate(ThisBundler, bundler, path.name, bundler.options.framework.?.client.path);
+                    try bundler.virtual_modules.append(client_entry_point);
+
+                    const entry_point_output_file = bundler.buildWithResolveResultEager(
+                        item,
+                        import_path_format,
+                        Outstream,
+                        outstream,
+                        client_entry_point,
+                    ) catch continue orelse continue;
+                    bundler.output_files.append(entry_point_output_file) catch unreachable;
 
-                // if (count >= 3) return try bundler.processResolveQueueWithThreadPool(import_path_format, wrap_entry_point, Outstream, outstream);
+                    js_ast.Expr.Data.Store.reset();
+                    js_ast.Stmt.Data.Store.reset();
+
+                    // At this point, the entry point will be de-duped.
+                    // So we just immediately build it.
+                    var item_not_entrypointed = item;
+                    item_not_entrypointed.import_kind = .stmt;
+                    const original_output_file = bundler.buildWithResolveResultEager(
+                        item_not_entrypointed,
+                        import_path_format,
+                        Outstream,
+                        outstream,
+                        null,
+                    ) catch continue orelse continue;
+                    bundler.output_files.append(original_output_file) catch unreachable;
+
+                    continue;
+                }
             }
-        }
-    };
-}
 
-pub const Bundler = NewBundler(true);
-pub const ServeBundler = NewBundler(false);
+            const output_file = bundler.buildWithResolveResultEager(
+                item,
+                import_path_format,
+                Outstream,
+                outstream,
+                null,
+            ) catch continue orelse continue;
+            bundler.output_files.append(output_file) catch unreachable;
+
+            // if (count >= 3) return try bundler.processResolveQueueWithThreadPool(import_path_format, wrap_entry_point, Outstream, outstream);
+        }
+    }
+};
 
 pub const Transformer = struct {
     opts: Api.TransformOptions,
diff --git a/src/cache.zig b/src/cache.zig
index 73c093d57..8bd1221f7 100644
--- a/src/cache.zig
+++ b/src/cache.zig
@@ -28,328 +28,251 @@ pub const FsCacheEntry = struct {
     }
 };
 
-pub fn NewCache(comptime cache_files: bool) type {
-    return struct {
-        pub const Set = struct {
-            js: JavaScript,
-            fs: Fs,
-            json: Json,
-
-            pub fn init(allocator: *std.mem.Allocator) Set {
-                return Set{
-                    .js = JavaScript.init(allocator),
-                    .fs = Fs{
-                        .mutex = Mutex.init(),
-                        .entries = std.StringHashMap(Fs.Entry).init(allocator),
-                        .shared_buffer = MutableString.init(allocator, 0) catch unreachable,
-                    },
-                    .json = Json{
-                        .mutex = Mutex.init(),
-                        .entries = std.StringHashMap(*Json.Entry).init(allocator),
-                    },
-                };
-            }
+pub const Set = struct {
+    js: JavaScript,
+    fs: Fs,
+    json: Json,
+
+    pub fn init(allocator: *std.mem.Allocator) Set {
+        return Set{
+            .js = JavaScript.init(allocator),
+            .fs = Fs{
+                .shared_buffer = MutableString.init(allocator, 0) catch unreachable,
+            },
+            .json = Json{},
         };
-        pub const Fs = struct {
-            const Entry = FsCacheEntry;
-
-            mutex: Mutex,
-            entries: std.StringHashMap(Entry),
-            shared_buffer: MutableString,
-
-            pub fn deinit(c: *Fs) void {
-                var iter = c.entries.iterator();
-                while (iter.next()) |entry| {
-                    entry.value.deinit(c.entries.allocator);
-                }
-                c.entries.deinit();
-            }
-
-            pub fn readFileShared(
-                c: *Fs,
-                _fs: *fs.FileSystem,
-                path: [:0]const u8,
-                dirname_fd: StoredFileDescriptorType,
-                _file_handle: ?StoredFileDescriptorType,
-                shared: *MutableString,
-            ) !Entry {
-                var rfs = _fs.fs;
-
-                if (comptime cache_files) {
-                    {
-                        c.mutex.lock();
-                        defer c.mutex.unlock();
-                        if (c.entries.get(path)) |entry| {
-                            return entry;
-                        }
-                    }
-                }
+    }
+};
+pub const Fs = struct {
+    const Entry = FsCacheEntry;
 
-                var file_handle: std.fs.File = if (_file_handle) |__file| std.fs.File{ .handle = __file } else undefined;
+    shared_buffer: MutableString,
 
-                if (_file_handle == null) {
-                    file_handle = try std.fs.openFileAbsoluteZ(path, .{ .read = true });
-                }
+    pub fn deinit(c: *Fs) void {
+        var iter = c.entries.iterator();
+        while (iter.next()) |entry| {
+            entry.value.deinit(c.entries.allocator);
+        }
+        c.entries.deinit();
+    }
 
-                defer {
-                    if (rfs.needToCloseFiles() and _file_handle == null) {
-                        file_handle.close();
-                    }
-                }
+    pub fn readFileShared(
+        c: *Fs,
+        _fs: *fs.FileSystem,
+        path: [:0]const u8,
+        dirname_fd: StoredFileDescriptorType,
+        _file_handle: ?StoredFileDescriptorType,
+        shared: *MutableString,
+    ) !Entry {
+        var rfs = _fs.fs;
 
-                // If the file's modification key hasn't changed since it was cached, assume
-                // the contents of the file are also the same and skip reading the file.
-                var mod_key: ?fs.FileSystem.Implementation.ModKey = rfs.modKeyWithFile(path, file_handle) catch |err| handler: {
-                    switch (err) {
-                        error.FileNotFound, error.AccessDenied => {
-                            return err;
-                        },
-                        else => {
-                            if (isDebug) {
-                                Output.printError("modkey error: {s}", .{@errorName(err)});
-                            }
-                            break :handler null;
-                        },
-                    }
-                };
-
-                var file: fs.File = undefined;
-                if (mod_key) |modk| {
-                    file = rfs.readFileWithHandle(path, modk.size, file_handle, true, shared) catch |err| {
-                        if (isDebug) {
-                            Output.printError("{s}: readFile error -- {s}", .{ path, @errorName(err) });
-                        }
-                        return err;
-                    };
-                } else {
-                    file = rfs.readFileWithHandle(path, null, file_handle, true, shared) catch |err| {
-                        if (isDebug) {
-                            Output.printError("{s}: readFile error -- {s}", .{ path, @errorName(err) });
-                        }
-                        return err;
-                    };
-                }
+        var file_handle: std.fs.File = if (_file_handle) |__file| std.fs.File{ .handle = __file } else undefined;
 
-                const entry = Entry{
-                    .contents = file.contents,
-                    .mod_key = mod_key,
-                    .fd = if (FeatureFlags.store_file_descriptors) file_handle.handle else 0,
-                };
+        if (_file_handle == null) {
+            file_handle = try std.fs.openFileAbsoluteZ(path, .{ .read = true });
+        }
 
-                if (comptime cache_files) {
-                    c.mutex.lock();
-                    defer c.mutex.unlock();
-                    var res = c.entries.getOrPut(path) catch unreachable;
+        defer {
+            if (rfs.needToCloseFiles() and _file_handle == null) {
+                file_handle.close();
+            }
+        }
 
-                    if (res.found_existing) {
-                        res.value_ptr.*.deinit(c.entries.allocator);
+        // If the file's modification key hasn't changed since it was cached, assume
+        // the contents of the file are also the same and skip reading the file.
+        var mod_key: ?fs.FileSystem.Implementation.ModKey = rfs.modKeyWithFile(path, file_handle) catch |err| handler: {
+            switch (err) {
+                error.FileNotFound, error.AccessDenied => {
+                    return err;
+                },
+                else => {
+                    if (isDebug) {
+                        Output.printError("modkey error: {s}", .{@errorName(err)});
                     }
-                    res.value_ptr.* = entry;
-                    return res.value_ptr.*;
-                } else {
-                    return entry;
-                }
+                    break :handler null;
+                },
             }
+        };
 
-            pub fn readFile(
-                c: *Fs,
-                _fs: *fs.FileSystem,
-                path: string,
-                dirname_fd: StoredFileDescriptorType,
-                comptime use_shared_buffer: bool,
-                _file_handle: ?StoredFileDescriptorType,
-            ) !Entry {
-                var rfs = _fs.fs;
-
-                if (comptime cache_files) {
-                    {
-                        c.mutex.lock();
-                        defer c.mutex.unlock();
-                        if (c.entries.get(path)) |entry| {
-                            return entry;
-                        }
-                    }
+        var file: fs.File = undefined;
+        if (mod_key) |modk| {
+            file = rfs.readFileWithHandle(path, modk.size, file_handle, true, shared) catch |err| {
+                if (isDebug) {
+                    Output.printError("{s}: readFile error -- {s}", .{ path, @errorName(err) });
                 }
-
-                var file_handle: std.fs.File = if (_file_handle) |__file| std.fs.File{ .handle = __file } else undefined;
-
-                if (_file_handle == null) {
-                    if (FeatureFlags.store_file_descriptors and dirname_fd > 0) {
-                        file_handle = std.fs.Dir.openFile(std.fs.Dir{ .fd = dirname_fd }, std.fs.path.basename(path), .{ .read = true }) catch |err| brk: {
-                            switch (err) {
-                                error.FileNotFound => {
-                                    const handle = try std.fs.openFileAbsolute(path, .{ .read = true });
-                                    Output.prettyErrorln(
-                                        "<r><d>Internal error: directory mismatch for directory \"{s}\", fd {d}<r>. You don't need to do anything, but this indicates a bug.",
-                                        .{ path, dirname_fd },
-                                    );
-                                    break :brk handle;
-                                },
-                                else => return err,
-                            }
-                        };
-                    } else {
-                        file_handle = try std.fs.openFileAbsolute(path, .{ .read = true });
-                    }
+                return err;
+            };
+        } else {
+            file = rfs.readFileWithHandle(path, null, file_handle, true, shared) catch |err| {
+                if (isDebug) {
+                    Output.printError("{s}: readFile error -- {s}", .{ path, @errorName(err) });
                 }
+                return err;
+            };
+        }
 
-                defer {
-                    if (rfs.needToCloseFiles() and _file_handle == null) {
-                        file_handle.close();
-                    }
-                }
+        return Entry{
+            .contents = file.contents,
+            .mod_key = mod_key,
+            .fd = if (FeatureFlags.store_file_descriptors) file_handle.handle else 0,
+        };
+    }
 
-                // If the file's modification key hasn't changed since it was cached, assume
-                // the contents of the file are also the same and skip reading the file.
-                var mod_key: ?fs.FileSystem.Implementation.ModKey = rfs.modKeyWithFile(path, file_handle) catch |err| handler: {
+    pub fn readFile(
+        c: *Fs,
+        _fs: *fs.FileSystem,
+        path: string,
+        dirname_fd: StoredFileDescriptorType,
+        comptime use_shared_buffer: bool,
+        _file_handle: ?StoredFileDescriptorType,
+    ) !Entry {
+        var rfs = _fs.fs;
+
+        var file_handle: std.fs.File = if (_file_handle) |__file| std.fs.File{ .handle = __file } else undefined;
+
+        if (_file_handle == null) {
+            if (FeatureFlags.store_file_descriptors and dirname_fd > 0) {
+                file_handle = std.fs.Dir.openFile(std.fs.Dir{ .fd = dirname_fd }, std.fs.path.basename(path), .{ .read = true }) catch |err| brk: {
                     switch (err) {
-                        error.FileNotFound, error.AccessDenied => {
-                            return err;
-                        },
-                        else => {
-                            if (isDebug) {
-                                Output.printError("modkey error: {s}", .{@errorName(err)});
-                            }
-                            break :handler null;
+                        error.FileNotFound => {
+                            const handle = try std.fs.openFileAbsolute(path, .{ .read = true });
+                            Output.prettyErrorln(
+                                "<r><d>Internal error: directory mismatch for directory \"{s}\", fd {d}<r>. You don't need to do anything, but this indicates a bug.",
+                                .{ path, dirname_fd },
+                            );
+                            break :brk handle;
                         },
+                        else => return err,
                     }
                 };
+            } else {
+                file_handle = try std.fs.openFileAbsolute(path, .{ .read = true });
+            }
+        }
 
-                var file: fs.File = undefined;
-                if (mod_key) |modk| {
-                    file = rfs.readFileWithHandle(path, modk.size, file_handle, use_shared_buffer, &c.shared_buffer) catch |err| {
-                        if (isDebug) {
-                            Output.printError("{s}: readFile error -- {s}", .{ path, @errorName(err) });
-                        }
-                        return err;
-                    };
-                } else {
-                    file = rfs.readFileWithHandle(path, null, file_handle, use_shared_buffer, &c.shared_buffer) catch |err| {
-                        if (isDebug) {
-                            Output.printError("{s}: readFile error -- {s}", .{ path, @errorName(err) });
-                        }
-                        return err;
-                    };
-                }
-
-                const entry = Entry{
-                    .contents = file.contents,
-                    .mod_key = mod_key,
-                    .fd = if (FeatureFlags.store_file_descriptors) file_handle.handle else 0,
-                };
-
-                if (comptime cache_files) {
-                    c.mutex.lock();
-                    defer c.mutex.unlock();
-                    var res = c.entries.getOrPut(path) catch unreachable;
+        defer {
+            if (rfs.needToCloseFiles() and _file_handle == null) {
+                file_handle.close();
+            }
+        }
 
-                    if (res.found_existing) {
-                        res.value_ptr.*.deinit(c.entries.allocator);
+        // If the file's modification key hasn't changed since it was cached, assume
+        // the contents of the file are also the same and skip reading the file.
+        var mod_key: ?fs.FileSystem.Implementation.ModKey = rfs.modKeyWithFile(path, file_handle) catch |err| handler: {
+            switch (err) {
+                error.FileNotFound, error.AccessDenied => {
+                    return err;
+                },
+                else => {
+                    if (isDebug) {
+                        Output.printError("modkey error: {s}", .{@errorName(err)});
                     }
-                    res.value_ptr.* = entry;
-                    return res.value_ptr.*;
-                } else {
-                    return entry;
-                }
+                    break :handler null;
+                },
             }
         };
 
-        pub const Css = struct {
-            pub const Entry = struct {};
-            pub const Result = struct {
-                ok: bool,
-                value: void,
+        var file: fs.File = undefined;
+        if (mod_key) |modk| {
+            file = rfs.readFileWithHandle(path, modk.size, file_handle, use_shared_buffer, &c.shared_buffer) catch |err| {
+                if (isDebug) {
+                    Output.printError("{s}: readFile error -- {s}", .{ path, @errorName(err) });
+                }
+                return err;
             };
-            pub fn parse(cache: *@This(), log: *logger.Log, source: logger.Source) !Result {
-                Global.notimpl();
-            }
-        };
+        } else {
+            file = rfs.readFileWithHandle(path, null, file_handle, use_shared_buffer, &c.shared_buffer) catch |err| {
+                if (isDebug) {
+                    Output.printError("{s}: readFile error -- {s}", .{ path, @errorName(err) });
+                }
+                return err;
+            };
+        }
 
-        pub const JavaScript = struct {
-            mutex: Mutex,
-            entries: std.StringHashMap(Result),
+        return Entry{
+            .contents = file.contents,
+            .mod_key = mod_key,
+            .fd = if (FeatureFlags.store_file_descriptors) file_handle.handle else 0,
+        };
+    }
+};
 
-            pub const Result = js_ast.Result;
+pub const Css = struct {
+    pub const Entry = struct {};
+    pub const Result = struct {
+        ok: bool,
+        value: void,
+    };
+    pub fn parse(cache: *@This(), log: *logger.Log, source: logger.Source) !Result {
+        Global.notimpl();
+    }
+};
 
-            pub fn init(allocator: *std.mem.Allocator) JavaScript {
-                return JavaScript{ .mutex = Mutex.init(), .entries = std.StringHashMap(Result).init(allocator) };
-            }
-            // For now, we're not going to cache JavaScript ASTs.
-            // It's probably only relevant when bundling for production.
-            pub fn parse(
-                cache: *@This(),
-                allocator: *std.mem.Allocator,
-                opts: js_parser.Parser.Options,
-                defines: *Define,
-                log: *logger.Log,
-                source: *const logger.Source,
-            ) anyerror!?js_ast.Ast {
-                var temp_log = logger.Log.init(allocator);
-                defer temp_log.appendToMaybeRecycled(log, source) catch {};
-                var parser = js_parser.Parser.init(opts, &temp_log, source, defines, allocator) catch |err| {
-                    return null;
-                };
+pub const JavaScript = struct {
+    pub const Result = js_ast.Result;
 
-                const result = try parser.parse();
+    pub fn init(allocator: *std.mem.Allocator) JavaScript {
+        return JavaScript{};
+    }
+    // For now, we're not going to cache JavaScript ASTs.
+    // It's probably only relevant when bundling for production.
+    pub fn parse(
+        cache: *@This(),
+        allocator: *std.mem.Allocator,
+        opts: js_parser.Parser.Options,
+        defines: *Define,
+        log: *logger.Log,
+        source: *const logger.Source,
+    ) anyerror!?js_ast.Ast {
+        var temp_log = logger.Log.init(allocator);
+        defer temp_log.appendToMaybeRecycled(log, source) catch {};
+        var parser = js_parser.Parser.init(opts, &temp_log, source, defines, allocator) catch |err| {
+            return null;
+        };
 
-                return if (result.ok) result.ast else null;
-            }
+        const result = try parser.parse();
 
-            pub fn scan(
-                cache: *@This(),
-                allocator: *std.mem.Allocator,
-                scan_pass_result: *js_parser.ScanPassResult,
-                opts: js_parser.Parser.Options,
-                defines: *Define,
-                log: *logger.Log,
-                source: *const logger.Source,
-            ) anyerror!void {
-                var temp_log = logger.Log.init(allocator);
-                defer temp_log.appendToMaybeRecycled(log, source) catch {};
-
-                var parser = js_parser.Parser.init(opts, &temp_log, source, defines, allocator) catch |err| {
-                    return;
-                };
+        return if (result.ok) result.ast else null;
+    }
 
-                return try parser.scanImports(scan_pass_result);
-            }
+    pub fn scan(
+        cache: *@This(),
+        allocator: *std.mem.Allocator,
+        scan_pass_result: *js_parser.ScanPassResult,
+        opts: js_parser.Parser.Options,
+        defines: *Define,
+        log: *logger.Log,
+        source: *const logger.Source,
+    ) anyerror!void {
+        var temp_log = logger.Log.init(allocator);
+        defer temp_log.appendToMaybeRecycled(log, source) catch {};
+
+        var parser = js_parser.Parser.init(opts, &temp_log, source, defines, allocator) catch |err| {
+            return;
         };
 
-        pub const Json = struct {
-            pub const Entry = struct {
-                is_tsconfig: bool = false,
-                source: logger.Source,
-                expr: ?js_ast.Expr = null,
-                ok: bool = false,
-                // msgs: []logger.Msg,
-            };
-            mutex: Mutex,
-            entries: std.StringHashMap(*Entry),
-            pub fn init(allocator: *std.mem.Allocator) Json {
-                return Json{
-                    .mutex = Mutex.init(),
-                    .entries = std.StringHashMap(Entry).init(allocator),
-                };
-            }
-            fn parse(cache: *@This(), log: *logger.Log, source: logger.Source, allocator: *std.mem.Allocator, is_tsconfig: bool, func: anytype) anyerror!?js_ast.Expr {
-                var temp_log = logger.Log.init(allocator);
-                defer {
-                    temp_log.appendTo(log) catch {};
-                }
-                return func(&source, &temp_log, allocator) catch handler: {
-                    break :handler null;
-                };
-            }
-            pub fn parseJSON(cache: *@This(), log: *logger.Log, source: logger.Source, allocator: *std.mem.Allocator) anyerror!?js_ast.Expr {
-                return try parse(cache, log, source, allocator, false, json_parser.ParseJSON);
-            }
+        return try parser.scanImports(scan_pass_result);
+    }
+};
 
-            pub fn parseTSConfig(cache: *@This(), log: *logger.Log, source: logger.Source, allocator: *std.mem.Allocator) anyerror!?js_ast.Expr {
-                return try parse(cache, log, source, allocator, true, json_parser.ParseTSConfig);
-            }
+pub const Json = struct {
+    pub fn init(allocator: *std.mem.Allocator) Json {
+        return Json{};
+    }
+    fn parse(cache: *@This(), log: *logger.Log, source: logger.Source, allocator: *std.mem.Allocator, is_tsconfig: bool, func: anytype) anyerror!?js_ast.Expr {
+        var temp_log = logger.Log.init(allocator);
+        defer {
+            temp_log.appendTo(log) catch {};
+        }
+        return func(&source, &temp_log, allocator) catch handler: {
+            break :handler null;
         };
-    };
-}
+    }
+    pub fn parseJSON(cache: *@This(), log: *logger.Log, source: logger.Source, allocator: *std.mem.Allocator) anyerror!?js_ast.Expr {
+        return try parse(cache, log, source, allocator, false, json_parser.ParseJSON);
+    }
 
-pub const Cache = NewCache(true);
-pub const ServeCache = NewCache(false);
+    pub fn parseTSConfig(cache: *@This(), log: *logger.Log, source: logger.Source, allocator: *std.mem.Allocator) anyerror!?js_ast.Expr {
+        return try parse(cache, log, source, allocator, true, json_parser.ParseTSConfig);
+    }
+};
diff --git a/src/cli/build_command.zig b/src/cli/build_command.zig
index 2a85f48b2..ed81e3572 100644
--- a/src/cli/build_command.zig
+++ b/src/cli/build_command.zig
@@ -33,7 +33,7 @@ pub const BuildCommand = struct {
                 );
             },
             .lazy => {
-                result = try bundler.ServeBundler.bundle(
+                result = try bundler.Bundler.bundle(
                     ctx.allocator,
                     ctx.log,
                     ctx.args,
diff --git a/src/cli/bun_command.zig b/src/cli/bun_command.zig
index 66bd2ccee..74e8e7654 100644
--- a/src/cli/bun_command.zig
+++ b/src/cli/bun_command.zig
@@ -38,7 +38,7 @@ const ServerBundleGeneratorThread = struct {
         route_conf_: ?Api.LoadedRouteConfig,
         router: ?Router,
     ) !void {
-        var server_bundler = try bundler.ServeBundler.init(
+        var server_bundler = try bundler.Bundler.init(
             allocator_,
             logs,
             try configureTransformOptionsForBun(allocator_, transform_args),
@@ -53,7 +53,7 @@ const ServerBundleGeneratorThread = struct {
             return err;
         };
         var estimated_input_lines_of_code: usize = 0;
-        _ = try bundler.ServeBundler.GenerateNodeModuleBundle.generate(
+        _ = try bundler.Bundler.GenerateNodeModuleBundle.generate(
             &server_bundler,
             allocator_,
             server_conf,
@@ -99,7 +99,7 @@ pub const BunCommand = struct {
         var log = ctx.log;
         estimated_input_lines_of_code_ = 0;
 
-        var this_bundler = try bundler.ServeBundler.init(allocator, log, ctx.args, null, null);
+        var this_bundler = try bundler.Bundler.init(allocator, log, ctx.args, null, null);
         this_bundler.configureLinker();
         var filepath: [*:0]const u8 = "node_modules.bun";
         var server_bundle_filepath: [*:0]const u8 = "node_modules.server.bun";
@@ -170,7 +170,7 @@ pub const BunCommand = struct {
 
             // Always generate the client-only bundle
             // we can revisit this decision if people ask
-            var node_modules_ = try bundler.ServeBundler.GenerateNodeModuleBundle.generate(
+            var node_modules_ = try bundler.Bundler.GenerateNodeModuleBundle.generate(
                 &this_bundler,
                 allocator,
                 loaded_framework,
diff --git a/src/http.zig b/src/http.zig
index 2a653ad61..b46151fda 100644
--- a/src/http.zig
+++ b/src/http.zig
@@ -40,7 +40,7 @@ const Request = picohttp.Request;
 const Response = picohttp.Response;
 pub const Headers = picohttp.Headers;
 pub const MimeType = @import("./http/mime_type.zig");
-const Bundler = bundler.ServeBundler;
+const Bundler = bundler.Bundler;
 const Websocket = @import("./http/websocket.zig");
 const js_printer = @import("./js_printer.zig");
 const SOCKET_FLAGS = os.SOCK_CLOEXEC;
diff --git a/src/javascript/jsc/javascript.zig b/src/javascript/jsc/javascript.zig
index 50585bf91..352b9caac 100644
--- a/src/javascript/jsc/javascript.zig
+++ b/src/javascript/jsc/javascript.zig
@@ -7,7 +7,7 @@ const NodeModuleBundle = @import("../../node_module_bundle.zig").NodeModuleBundl
 const logger = @import("../../logger.zig");
 const Api = @import("../../api/schema.zig").Api;
 const options = @import("../../options.zig");
-const Bundler = @import("../../bundler.zig").ServeBundler;
+const Bundler = @import("../../bundler.zig").Bundler;
 const ServerEntryPoint = @import("../../bundler.zig").ServerEntryPoint;
 const js_printer = @import("../../js_printer.zig");
 const js_parser = @import("../../js_parser.zig");
diff --git a/src/linker.zig b/src/linker.zig
index ff13198c1..4e42423b8 100644
--- a/src/linker.zig
+++ b/src/linker.zig
@@ -26,671 +26,667 @@ const resolve_path = @import("./resolver/resolve_path.zig");
 const _bundler = @import("./bundler.zig");
 const Bundler = _bundler.Bundler;
 const ResolveQueue = _bundler.ResolveQueue;
+const ResolverType = Resolver.Resolver;
 const Runtime = @import("./runtime.zig").Runtime;
 
 pub const CSSResolveError = error{ResolveError};
 
 pub const OnImportCallback = fn (resolve_result: *const Resolver.Result, import_record: *ImportRecord, source_dir: string) void;
 
-pub fn NewLinker(comptime BundlerType: type) type {
-    return struct {
-        const HashedFileNameMap = std.AutoHashMap(u64, string);
-        const ThisLinker = @This();
+pub const Linker = struct {
+    const HashedFileNameMap = std.AutoHashMap(u64, string);
+    const ThisLinker = @This();
+    allocator: *std.mem.Allocator,
+    options: *Options.BundleOptions,
+    fs: *Fs.FileSystem,
+    log: *logger.Log,
+    resolve_queue: *ResolveQueue,
+    resolver: *ResolverType,
+    resolve_results: *_bundler.ResolveResults,
+    any_needs_runtime: bool = false,
+    runtime_import_record: ?ImportRecord = null,
+    runtime_source_path: string,
+    hashed_filenames: HashedFileNameMap,
+    import_counter: usize = 0,
+
+    onImportCSS: ?OnImportCallback = null,
+
+    pub fn init(
         allocator: *std.mem.Allocator,
-        options: *Options.BundleOptions,
-        fs: *Fs.FileSystem,
         log: *logger.Log,
         resolve_queue: *ResolveQueue,
-        resolver: *BundlerType.Resolver,
+        options: *Options.BundleOptions,
+        resolver: *ResolverType,
         resolve_results: *_bundler.ResolveResults,
-        any_needs_runtime: bool = false,
-        runtime_import_record: ?ImportRecord = null,
-        runtime_source_path: string,
-        hashed_filenames: HashedFileNameMap,
-        import_counter: usize = 0,
-
-        onImportCSS: ?OnImportCallback = null,
-
-        pub fn init(
-            allocator: *std.mem.Allocator,
-            log: *logger.Log,
-            resolve_queue: *ResolveQueue,
-            options: *Options.BundleOptions,
-            resolver: *BundlerType.Resolver,
-            resolve_results: *_bundler.ResolveResults,
-            fs: *Fs.FileSystem,
-        ) ThisLinker {
-            relative_paths_list = ImportPathsList.init(allocator);
-
-            return ThisLinker{
-                .allocator = allocator,
-                .options = options,
-                .fs = fs,
-                .log = log,
-                .resolve_queue = resolve_queue,
-                .resolver = resolver,
-                .resolve_results = resolve_results,
-                .runtime_source_path = fs.absAlloc(allocator, &([_]string{"__runtime.js"})) catch unreachable,
-                .hashed_filenames = HashedFileNameMap.init(allocator),
-            };
-        }
-
-        // fs: fs.FileSystem,
-        // TODO:
-        pub fn requireOrImportMetaForSource(c: ThisLinker, source_index: Ref.Int) RequireOrImportMeta {
-            return RequireOrImportMeta{};
-        }
-
-        pub fn getHashedFilename(
-            this: *ThisLinker,
-            file_path: Fs.Path,
-            fd: ?FileDescriptorType,
-        ) !string {
-            if (BundlerType.isCacheEnabled) {
-                var hashed = std.hash.Wyhash.hash(0, file_path.text);
-                var hashed_result = try this.hashed_filenames.getOrPut(hashed);
-                if (hashed_result.found_existing) {
-                    return hashed_result.value_ptr.*;
-                }
-            }
-
-            var file: std.fs.File = if (fd) |_fd| std.fs.File{ .handle = _fd } else try std.fs.openFileAbsolute(file_path.text, .{ .read = true });
-            Fs.FileSystem.setMaxFd(file.handle);
-            var modkey = try Fs.FileSystem.RealFS.ModKey.generate(&this.fs.fs, file_path.text, file);
-            const hash_name = try modkey.hashName(file_path.name.base);
-
-            if (BundlerType.isCacheEnabled) {
-                var hashed = std.hash.Wyhash.hash(0, file_path.text);
-                try this.hashed_filenames.put(hashed, try this.allocator.dupe(u8, hash_name));
+        fs: *Fs.FileSystem,
+    ) ThisLinker {
+        relative_paths_list = ImportPathsList.init(allocator);
+
+        return ThisLinker{
+            .allocator = allocator,
+            .options = options,
+            .fs = fs,
+            .log = log,
+            .resolve_queue = resolve_queue,
+            .resolver = resolver,
+            .resolve_results = resolve_results,
+            .runtime_source_path = fs.absAlloc(allocator, &([_]string{"__runtime.js"})) catch unreachable,
+            .hashed_filenames = HashedFileNameMap.init(allocator),
+        };
+    }
+
+    // fs: fs.FileSystem,
+    // TODO:
+    pub fn requireOrImportMetaForSource(c: ThisLinker, source_index: Ref.Int) RequireOrImportMeta {
+        return RequireOrImportMeta{};
+    }
+
+    pub fn getHashedFilename(
+        this: *ThisLinker,
+        file_path: Fs.Path,
+        fd: ?FileDescriptorType,
+    ) !string {
+        if (Bundler.isCacheEnabled) {
+            var hashed = std.hash.Wyhash.hash(0, file_path.text);
+            var hashed_result = try this.hashed_filenames.getOrPut(hashed);
+            if (hashed_result.found_existing) {
+                return hashed_result.value_ptr.*;
             }
+        }
 
-            if (this.fs.fs.needToCloseFiles() and fd == null) {
-                file.close();
-            }
+        var file: std.fs.File = if (fd) |_fd| std.fs.File{ .handle = _fd } else try std.fs.openFileAbsolute(file_path.text, .{ .read = true });
+        Fs.FileSystem.setMaxFd(file.handle);
+        var modkey = try Fs.FileSystem.RealFS.ModKey.generate(&this.fs.fs, file_path.text, file);
+        const hash_name = try modkey.hashName(file_path.name.base);
 
-            return hash_name;
+        if (Bundler.isCacheEnabled) {
+            var hashed = std.hash.Wyhash.hash(0, file_path.text);
+            try this.hashed_filenames.put(hashed, try this.allocator.dupe(u8, hash_name));
         }
 
-        pub fn resolveCSS(
-            this: anytype,
-            path: Fs.Path,
-            url: string,
-            range: logger.Range,
-            kind: ImportKind,
-            comptime import_path_format: Options.BundleOptions.ImportPathFormat,
-            comptime resolve_only: bool,
-        ) !string {
-            const dir = path.name.dirWithTrailingSlash();
-
-            switch (kind) {
-                .at => {
-                    var resolve_result = try this.resolver.resolve(dir, url, .at);
-                    if (resolve_only or resolve_result.is_external) {
-                        return resolve_result.path_pair.primary.text;
-                    }
+        if (this.fs.fs.needToCloseFiles() and fd == null) {
+            file.close();
+        }
 
-                    var import_record = ImportRecord{ .range = range, .path = resolve_result.path_pair.primary, .kind = kind };
+        return hash_name;
+    }
+
+    pub fn resolveCSS(
+        this: anytype,
+        path: Fs.Path,
+        url: string,
+        range: logger.Range,
+        kind: ImportKind,
+        comptime import_path_format: Options.BundleOptions.ImportPathFormat,
+        comptime resolve_only: bool,
+    ) !string {
+        const dir = path.name.dirWithTrailingSlash();
+
+        switch (kind) {
+            .at => {
+                var resolve_result = try this.resolver.resolve(dir, url, .at);
+                if (resolve_only or resolve_result.is_external) {
+                    return resolve_result.path_pair.primary.text;
+                }
 
-                    const loader = this.options.loaders.get(resolve_result.path_pair.primary.name.ext) orelse .file;
+                var import_record = ImportRecord{ .range = range, .path = resolve_result.path_pair.primary, .kind = kind };
 
-                    this.processImportRecord(loader, dir, &resolve_result, &import_record, import_path_format) catch unreachable;
-                    return import_record.path.text;
-                },
-                .at_conditional => {
-                    var resolve_result = try this.resolver.resolve(dir, url, .at_conditional);
-                    if (resolve_only or resolve_result.is_external) {
-                        return resolve_result.path_pair.primary.text;
-                    }
+                const loader = this.options.loaders.get(resolve_result.path_pair.primary.name.ext) orelse .file;
 
-                    var import_record = ImportRecord{ .range = range, .path = resolve_result.path_pair.primary, .kind = kind };
-                    const loader = this.options.loaders.get(resolve_result.path_pair.primary.name.ext) orelse .file;
-
-                    this.processImportRecord(loader, dir, &resolve_result, &import_record, import_path_format) catch unreachable;
-                    return import_record.path.text;
-                },
-                .url => {
-                    var resolve_result = try this.resolver.resolve(dir, url, .url);
-                    if (resolve_only or resolve_result.is_external) {
-                        return resolve_result.path_pair.primary.text;
-                    }
+                this.processImportRecord(loader, dir, &resolve_result, &import_record, import_path_format) catch unreachable;
+                return import_record.path.text;
+            },
+            .at_conditional => {
+                var resolve_result = try this.resolver.resolve(dir, url, .at_conditional);
+                if (resolve_only or resolve_result.is_external) {
+                    return resolve_result.path_pair.primary.text;
+                }
 
-                    var import_record = ImportRecord{ .range = range, .path = resolve_result.path_pair.primary, .kind = kind };
-                    const loader = this.options.loaders.get(resolve_result.path_pair.primary.name.ext) orelse .file;
+                var import_record = ImportRecord{ .range = range, .path = resolve_result.path_pair.primary, .kind = kind };
+                const loader = this.options.loaders.get(resolve_result.path_pair.primary.name.ext) orelse .file;
 
-                    this.processImportRecord(loader, dir, &resolve_result, &import_record, import_path_format) catch unreachable;
-                    return import_record.path.text;
-                },
-                else => unreachable,
-            }
-            unreachable;
-        }
+                this.processImportRecord(loader, dir, &resolve_result, &import_record, import_path_format) catch unreachable;
+                return import_record.path.text;
+            },
+            .url => {
+                var resolve_result = try this.resolver.resolve(dir, url, .url);
+                if (resolve_only or resolve_result.is_external) {
+                    return resolve_result.path_pair.primary.text;
+                }
 
-        pub inline fn nodeModuleBundleImportPath(this: *const ThisLinker) string {
-            if (this.options.platform == .bun) return "/node_modules.server.bun";
+                var import_record = ImportRecord{ .range = range, .path = resolve_result.path_pair.primary, .kind = kind };
+                const loader = this.options.loaders.get(resolve_result.path_pair.primary.name.ext) orelse .file;
 
-            return if (this.options.node_modules_bundle_url.len > 0)
-                this.options.node_modules_bundle_url
-            else
-                this.options.node_modules_bundle.?.bundle.import_from_name;
+                this.processImportRecord(loader, dir, &resolve_result, &import_record, import_path_format) catch unreachable;
+                return import_record.path.text;
+            },
+            else => unreachable,
         }
-
-        // pub const Scratch = struct {
-        //     threadlocal var externals: std.ArrayList(u32) = undefined;
-        //     threadlocal var has_externals: std.ArrayList(u32) = undefined;
-        //     pub fn externals() {
-
-        //     }
-        // };
-        // This modifies the Ast in-place!
-        // But more importantly, this does the following:
-        // - Wrap CommonJS files
-        threadlocal var require_part: js_ast.Part = undefined;
-        threadlocal var require_part_stmts: [1]js_ast.Stmt = undefined;
-        threadlocal var require_part_import_statement: js_ast.S.Import = undefined;
-        threadlocal var require_part_import_clauses: [1]js_ast.ClauseItem = undefined;
-        const require_alias: string = "__require";
-        pub fn link(
-            linker: *ThisLinker,
-            file_path: Fs.Path,
-            result: *_bundler.ParseResult,
-            comptime import_path_format: Options.BundleOptions.ImportPathFormat,
-            comptime ignore_runtime: bool,
-        ) !void {
-            var needs_runtime = result.ast.uses_exports_ref or result.ast.uses_module_ref or result.ast.runtime_imports.hasAny();
-            const source_dir = if (file_path.is_symlink and file_path.pretty.len > 0 and import_path_format == .absolute_url and linker.options.platform != .bun)
-                Fs.PathName.init(file_path.pretty).dirWithTrailingSlash()
-            else
-                file_path.sourceDir();
-            var externals = std.ArrayList(u32).init(linker.allocator);
-            var needs_bundle = false;
-            var first_bundled_index: ?u32 = null;
-            var had_resolve_errors = false;
-            var needs_require = false;
-
-            // Step 1. Resolve imports & requires
-            switch (result.loader) {
-                .jsx, .js, .ts, .tsx => {
-                    for (result.ast.import_records) |*import_record, _record_index| {
-                        if (import_record.is_unused) continue;
-
-                        const record_index = @truncate(u32, _record_index);
-                        if (comptime !ignore_runtime) {
-                            if (strings.eqlComptime(import_record.path.text, Runtime.Imports.Name)) {
-                                // runtime is included in the bundle, so we don't need to dynamically import it
-                                if (linker.options.node_modules_bundle != null) {
-                                    import_record.path.text = linker.nodeModuleBundleImportPath();
-                                    result.ast.runtime_import_record_id = record_index;
-                                } else {
-                                    import_record.path = try linker.generateImportPath(
-                                        source_dir,
-                                        linker.runtime_source_path,
-                                        Runtime.version(),
-                                        false,
-                                        "bun",
-                                        import_path_format,
-                                    );
-                                    result.ast.runtime_import_record_id = record_index;
-                                    result.ast.needs_runtime = true;
-                                }
-                                continue;
+        unreachable;
+    }
+
+    pub inline fn nodeModuleBundleImportPath(this: *const ThisLinker) string {
+        if (this.options.platform == .bun) return "/node_modules.server.bun";
+
+        return if (this.options.node_modules_bundle_url.len > 0)
+            this.options.node_modules_bundle_url
+        else
+            this.options.node_modules_bundle.?.bundle.import_from_name;
+    }
+
+    // pub const Scratch = struct {
+    //     threadlocal var externals: std.ArrayList(u32) = undefined;
+    //     threadlocal var has_externals: std.ArrayList(u32) = undefined;
+    //     pub fn externals() {
+
+    //     }
+    // };
+    // This modifies the Ast in-place!
+    // But more importantly, this does the following:
+    // - Wrap CommonJS files
+    threadlocal var require_part: js_ast.Part = undefined;
+    threadlocal var require_part_stmts: [1]js_ast.Stmt = undefined;
+    threadlocal var require_part_import_statement: js_ast.S.Import = undefined;
+    threadlocal var require_part_import_clauses: [1]js_ast.ClauseItem = undefined;
+    const require_alias: string = "__require";
+    pub fn link(
+        linker: *ThisLinker,
+        file_path: Fs.Path,
+        result: *_bundler.ParseResult,
+        comptime import_path_format: Options.BundleOptions.ImportPathFormat,
+        comptime ignore_runtime: bool,
+    ) !void {
+        var needs_runtime = result.ast.uses_exports_ref or result.ast.uses_module_ref or result.ast.runtime_imports.hasAny();
+        const source_dir = if (file_path.is_symlink and file_path.pretty.len > 0 and import_path_format == .absolute_url and linker.options.platform != .bun)
+            Fs.PathName.init(file_path.pretty).dirWithTrailingSlash()
+        else
+            file_path.sourceDir();
+        var externals = std.ArrayList(u32).init(linker.allocator);
+        var needs_bundle = false;
+        var first_bundled_index: ?u32 = null;
+        var had_resolve_errors = false;
+        var needs_require = false;
+
+        // Step 1. Resolve imports & requires
+        switch (result.loader) {
+            .jsx, .js, .ts, .tsx => {
+                for (result.ast.import_records) |*import_record, _record_index| {
+                    if (import_record.is_unused) continue;
+
+                    const record_index = @truncate(u32, _record_index);
+                    if (comptime !ignore_runtime) {
+                        if (strings.eqlComptime(import_record.path.text, Runtime.Imports.Name)) {
+                            // runtime is included in the bundle, so we don't need to dynamically import it
+                            if (linker.options.node_modules_bundle != null) {
+                                import_record.path.text = linker.nodeModuleBundleImportPath();
+                                result.ast.runtime_import_record_id = record_index;
+                            } else {
+                                import_record.path = try linker.generateImportPath(
+                                    source_dir,
+                                    linker.runtime_source_path,
+                                    Runtime.version(),
+                                    false,
+                                    "bun",
+                                    import_path_format,
+                                );
+                                result.ast.runtime_import_record_id = record_index;
+                                result.ast.needs_runtime = true;
                             }
+                            continue;
                         }
+                    }
 
-                        if (linker.resolver.resolve(source_dir, import_record.path.text, import_record.kind)) |*_resolved_import| {
-                            const resolved_import: *const Resolver.Result = _resolved_import;
-                            if (resolved_import.is_external) {
-                                externals.append(record_index) catch unreachable;
-                                continue;
-                            }
+                    if (linker.resolver.resolve(source_dir, import_record.path.text, import_record.kind)) |*_resolved_import| {
+                        const resolved_import: *const Resolver.Result = _resolved_import;
+                        if (resolved_import.is_external) {
+                            externals.append(record_index) catch unreachable;
+                            continue;
+                        }
 
-                            const path = resolved_import.pathConst() orelse {
-                                import_record.path.is_disabled = true;
-                                continue;
-                            };
-
-                            const loader = linker.options.loader(path.name.ext);
-                            if (loader.isJavaScriptLikeOrJSON()) {
-                                bundled: {
-                                    if (linker.options.node_modules_bundle) |node_modules_bundle| {
-                                        const package_json = resolved_import.package_json orelse break :bundled;
-                                        const package_base_dir = package_json.source.path.sourceDir();
-                                        if (node_modules_bundle.getPackageIDByHash(package_json.hash)) |pkg_id| {
-                                            const package = node_modules_bundle.bundle.packages[pkg_id];
-
-                                            if (comptime isDebug) {
-                                                std.debug.assert(strings.eql(node_modules_bundle.str(package.name), package_json.name));
-                                                std.debug.assert(strings.eql(node_modules_bundle.str(package.version), package_json.version));
-                                            }
-
-                                            const package_relative_path = linker.fs.relative(
-                                                package_base_dir,
-                                                if (!strings.eqlComptime(path.namespace, "node")) path.pretty else path.text,
-                                            );
+                        const path = resolved_import.pathConst() orelse {
+                            import_record.path.is_disabled = true;
+                            continue;
+                        };
+
+                        const loader = linker.options.loader(path.name.ext);
+                        if (loader.isJavaScriptLikeOrJSON()) {
+                            bundled: {
+                                if (linker.options.node_modules_bundle) |node_modules_bundle| {
+                                    const package_json = resolved_import.package_json orelse break :bundled;
+                                    const package_base_dir = package_json.source.path.sourceDir();
+                                    if (node_modules_bundle.getPackageIDByHash(package_json.hash)) |pkg_id| {
+                                        const package = node_modules_bundle.bundle.packages[pkg_id];
+
+                                        if (comptime isDebug) {
+                                            std.debug.assert(strings.eql(node_modules_bundle.str(package.name), package_json.name));
+                                            std.debug.assert(strings.eql(node_modules_bundle.str(package.version), package_json.version));
+                                        }
+
+                                        const package_relative_path = linker.fs.relative(
+                                            package_base_dir,
+                                            if (!strings.eqlComptime(path.namespace, "node")) path.pretty else path.text,
+                                        );
 
-                                            const found_module = node_modules_bundle.findModuleInPackage(&package, package_relative_path) orelse {
-                                                // linker.log.addErrorFmt(
-                                                //     null,
-                                                //     logger.Loc.Empty,
-                                                //     linker.allocator,
-                                                //     "New dependency import: \"{s}/{s}\"\nPlease run `bun bun` to update the .bun.",
-                                                //     .{
-                                                //         package_json.name,
-                                                //         package_relative_path,
-                                                //     },
-                                                // ) catch {};
-                                                break :bundled;
-                                            };
-
-                                            if (comptime isDebug) {
-                                                const module_path = node_modules_bundle.str(found_module.path);
-                                                std.debug.assert(
-                                                    strings.eql(
-                                                        module_path,
-                                                        package_relative_path,
-                                                    ),
-                                                );
-                                            }
-
-                                            import_record.is_bundled = true;
-                                            import_record.path.text = linker.nodeModuleBundleImportPath();
-                                            import_record.module_id = found_module.id;
-                                            needs_bundle = true;
-                                            continue;
+                                        const found_module = node_modules_bundle.findModuleInPackage(&package, package_relative_path) orelse {
+                                            // linker.log.addErrorFmt(
+                                            //     null,
+                                            //     logger.Loc.Empty,
+                                            //     linker.allocator,
+                                            //     "New dependency import: \"{s}/{s}\"\nPlease run `bun bun` to update the .bun.",
+                                            //     .{
+                                            //         package_json.name,
+                                            //         package_relative_path,
+                                            //     },
+                                            // ) catch {};
+                                            break :bundled;
+                                        };
+
+                                        if (comptime isDebug) {
+                                            const module_path = node_modules_bundle.str(found_module.path);
+                                            std.debug.assert(
+                                                strings.eql(
+                                                    module_path,
+                                                    package_relative_path,
+                                                ),
+                                            );
                                         }
+
+                                        import_record.is_bundled = true;
+                                        import_record.path.text = linker.nodeModuleBundleImportPath();
+                                        import_record.module_id = found_module.id;
+                                        needs_bundle = true;
+                                        continue;
                                     }
                                 }
                             }
+                        }
 
-                            linker.processImportRecord(
-                                loader,
-
-                                // Include trailing slash
-                                source_dir,
-                                resolved_import,
-                                import_record,
-                                import_path_format,
-                            ) catch continue;
-
-                            // If we're importing a CommonJS module as ESM
-                            // We need to do the following transform:
-                            //      import React from 'react';
-                            //      =>
-                            //      import {_require} from 'RUNTIME_IMPORTS';
-                            //      import * as react_module from 'react';
-                            //      var React = _require(react_module).default;
-                            // UNLESS it's a namespace import
-                            // If it's a namespace import, assume it's safe.
-                            // We can do this in the printer instead of creating a bunch of AST nodes here.
-                            // But we need to at least tell the printer that this needs to happen.
-                            if (result.ast.exports_kind != .cjs and
-                                (import_record.kind == .require or
-                                (import_record.kind == .stmt and resolved_import.shouldAssumeCommonJS(import_record))))
-                            {
-                                import_record.wrap_with_to_module = true;
-                                import_record.module_id = @truncate(u32, std.hash.Wyhash.hash(0, path.pretty));
+                        linker.processImportRecord(
+                            loader,
 
-                                result.ast.needs_runtime = true;
-                                needs_require = true;
-                            } else if (result.ast.exports_kind == .cjs) {
-                                import_record.module_id = @truncate(u32, std.hash.Wyhash.hash(0, path.pretty));
-                            }
-                        } else |err| {
-                            had_resolve_errors = true;
-
-                            switch (err) {
-                                error.ModuleNotFound => {
-                                    if (import_record.path.text.len > 0 and Resolver.isPackagePath(import_record.path.text)) {
-                                        if (linker.options.platform.isWebLike() and Options.ExternalModules.isNodeBuiltin(import_record.path.text)) {
-                                            try linker.log.addResolveError(
-                                                &result.source,
-                                                import_record.range,
-                                                linker.allocator,
-                                                "Could not resolve: \"{s}\". Try setting --platform=\"node\" (after bun build exists)",
-                                                .{import_record.path.text},
-                                                import_record.kind,
-                                            );
-                                            continue;
-                                        } else {
-                                            try linker.log.addResolveError(
-                                                &result.source,
-                                                import_record.range,
-                                                linker.allocator,
-                                                "Could not resolve: \"{s}\". Maybe you need to \"npm install\" (or yarn/pnpm)?",
-                                                .{import_record.path.text},
-                                                import_record.kind,
-                                            );
-                                            continue;
-                                        }
+                            // Include trailing slash
+                            source_dir,
+                            resolved_import,
+                            import_record,
+                            import_path_format,
+                        ) catch continue;
+
+                        // If we're importing a CommonJS module as ESM
+                        // We need to do the following transform:
+                        //      import React from 'react';
+                        //      =>
+                        //      import {_require} from 'RUNTIME_IMPORTS';
+                        //      import * as react_module from 'react';
+                        //      var React = _require(react_module).default;
+                        // UNLESS it's a namespace import
+                        // If it's a namespace import, assume it's safe.
+                        // We can do this in the printer instead of creating a bunch of AST nodes here.
+                        // But we need to at least tell the printer that this needs to happen.
+                        if (result.ast.exports_kind != .cjs and
+                            (import_record.kind == .require or
+                            (import_record.kind == .stmt and resolved_import.shouldAssumeCommonJS(import_record))))
+                        {
+                            import_record.wrap_with_to_module = true;
+                            import_record.module_id = @truncate(u32, std.hash.Wyhash.hash(0, path.pretty));
+
+                            result.ast.needs_runtime = true;
+                            needs_require = true;
+                        } else if (result.ast.exports_kind == .cjs) {
+                            import_record.module_id = @truncate(u32, std.hash.Wyhash.hash(0, path.pretty));
+                        }
+                    } else |err| {
+                        had_resolve_errors = true;
+
+                        switch (err) {
+                            error.ModuleNotFound => {
+                                if (import_record.path.text.len > 0 and Resolver.isPackagePath(import_record.path.text)) {
+                                    if (linker.options.platform.isWebLike() and Options.ExternalModules.isNodeBuiltin(import_record.path.text)) {
+                                        try linker.log.addResolveError(
+                                            &result.source,
+                                            import_record.range,
+                                            linker.allocator,
+                                            "Could not resolve: \"{s}\". Try setting --platform=\"node\" (after bun build exists)",
+                                            .{import_record.path.text},
+                                            import_record.kind,
+                                        );
+                                        continue;
                                     } else {
                                         try linker.log.addResolveError(
                                             &result.source,
                                             import_record.range,
                                             linker.allocator,
-                                            "Could not resolve: \"{s}\"",
-                                            .{
-                                                import_record.path.text,
-                                            },
+                                            "Could not resolve: \"{s}\". Maybe you need to \"npm install\" (or yarn/pnpm)?",
+                                            .{import_record.path.text},
                                             import_record.kind,
                                         );
                                         continue;
                                     }
-                                },
-                                else => {
+                                } else {
                                     try linker.log.addResolveError(
                                         &result.source,
                                         import_record.range,
                                         linker.allocator,
-                                        "{s} resolving \"{s}\"",
+                                        "Could not resolve: \"{s}\"",
                                         .{
-                                            @errorName(err),
                                             import_record.path.text,
                                         },
                                         import_record.kind,
                                     );
                                     continue;
-                                },
-                            }
+                                }
+                            },
+                            else => {
+                                try linker.log.addResolveError(
+                                    &result.source,
+                                    import_record.range,
+                                    linker.allocator,
+                                    "{s} resolving \"{s}\"",
+                                    .{
+                                        @errorName(err),
+                                        import_record.path.text,
+                                    },
+                                    import_record.kind,
+                                );
+                                continue;
+                            },
                         }
                     }
-                },
-                else => {},
-            }
-            if (had_resolve_errors) return error.ResolveError;
-            result.ast.externals = externals.toOwnedSlice();
-
-            if (result.ast.needs_runtime and result.ast.runtime_import_record_id == null) {
-                var import_records = try linker.allocator.alloc(ImportRecord, result.ast.import_records.len + 1);
-                std.mem.copy(ImportRecord, import_records, result.ast.import_records);
-
-                import_records[import_records.len - 1] = ImportRecord{
-                    .kind = .stmt,
-                    .path = if (linker.options.node_modules_bundle != null)
-                        Fs.Path.init(linker.nodeModuleBundleImportPath())
-                    else
-                        try linker.generateImportPath(
-                            source_dir,
-                            linker.runtime_source_path,
-                            Runtime.version(),
-                            false,
-                            "bun",
-                            import_path_format,
-                        ),
-                    .range = logger.Range{ .loc = logger.Loc{ .start = 0 }, .len = 0 },
-                };
-                result.ast.runtime_import_record_id = @truncate(u32, import_records.len - 1);
-                result.ast.import_records = import_records;
-            }
+                }
+            },
+            else => {},
+        }
+        if (had_resolve_errors) return error.ResolveError;
+        result.ast.externals = externals.toOwnedSlice();
+
+        if (result.ast.needs_runtime and result.ast.runtime_import_record_id == null) {
+            var import_records = try linker.allocator.alloc(ImportRecord, result.ast.import_records.len + 1);
+            std.mem.copy(ImportRecord, import_records, result.ast.import_records);
+
+            import_records[import_records.len - 1] = ImportRecord{
+                .kind = .stmt,
+                .path = if (linker.options.node_modules_bundle != null)
+                    Fs.Path.init(linker.nodeModuleBundleImportPath())
+                else
+                    try linker.generateImportPath(
+                        source_dir,
+                        linker.runtime_source_path,
+                        Runtime.version(),
+                        false,
+                        "bun",
+                        import_path_format,
+                    ),
+                .range = logger.Range{ .loc = logger.Loc{ .start = 0 }, .len = 0 },
+            };
+            result.ast.runtime_import_record_id = @truncate(u32, import_records.len - 1);
+            result.ast.import_records = import_records;
+        }
 
-            // We _assume_ you're importing ESM.
-            // But, that assumption can be wrong without parsing code of the imports.
-            // That's where in here, we inject
-            // > import {require} from 'bun:runtime';
-            // Since they definitely aren't using require, we don't have to worry about the symbol being renamed.
-            if (needs_require and !result.ast.uses_require_ref) {
-                result.ast.uses_require_ref = true;
-                require_part_import_clauses[0] = js_ast.ClauseItem{
-                    .alias = require_alias,
-                    .original_name = "",
-                    .alias_loc = logger.Loc.Empty,
-                    .name = js_ast.LocRef{
-                        .loc = logger.Loc.Empty,
-                        .ref = result.ast.require_ref,
-                    },
-                };
-
-                require_part_import_statement = js_ast.S.Import{
-                    .namespace_ref = Ref.None,
-                    .items = std.mem.span(&require_part_import_clauses),
-                    .import_record_index = result.ast.runtime_import_record_id.?,
-                };
-                require_part_stmts[0] = js_ast.Stmt{
-                    .data = .{ .s_import = &require_part_import_statement },
+        // We _assume_ you're importing ESM.
+        // But, that assumption can be wrong without parsing code of the imports.
+        // That's where in here, we inject
+        // > import {require} from 'bun:runtime';
+        // Since they definitely aren't using require, we don't have to worry about the symbol being renamed.
+        if (needs_require and !result.ast.uses_require_ref) {
+            result.ast.uses_require_ref = true;
+            require_part_import_clauses[0] = js_ast.ClauseItem{
+                .alias = require_alias,
+                .original_name = "",
+                .alias_loc = logger.Loc.Empty,
+                .name = js_ast.LocRef{
                     .loc = logger.Loc.Empty,
-                };
-                result.ast.prepend_part = js_ast.Part{ .stmts = std.mem.span(&require_part_stmts) };
-            }
+                    .ref = result.ast.require_ref,
+                },
+            };
 
-            // This is a bad idea
-            // I don't think it's safe to do this
-            const ImportStatementSorter = struct {
-                import_records: []ImportRecord,
-                pub fn lessThan(ctx: @This(), lhs: js_ast.Stmt, rhs: js_ast.Stmt) bool {
-                    switch (lhs.data) {
-                        .s_import => |li| {
-                            switch (rhs.data) {
-                                .s_import => |ri| {
-                                    const a = ctx.import_records[li.import_record_index];
-                                    const b = ctx.import_records[ri.import_record_index];
-                                    if (a.is_bundled and !b.is_bundled) {
-                                        return false;
-                                    } else {
-                                        return true;
-                                    }
-                                },
-                                else => {
+            require_part_import_statement = js_ast.S.Import{
+                .namespace_ref = Ref.None,
+                .items = std.mem.span(&require_part_import_clauses),
+                .import_record_index = result.ast.runtime_import_record_id.?,
+            };
+            require_part_stmts[0] = js_ast.Stmt{
+                .data = .{ .s_import = &require_part_import_statement },
+                .loc = logger.Loc.Empty,
+            };
+            result.ast.prepend_part = js_ast.Part{ .stmts = std.mem.span(&require_part_stmts) };
+        }
+
+        // This is a bad idea
+        // I don't think it's safe to do this
+        const ImportStatementSorter = struct {
+            import_records: []ImportRecord,
+            pub fn lessThan(ctx: @This(), lhs: js_ast.Stmt, rhs: js_ast.Stmt) bool {
+                switch (lhs.data) {
+                    .s_import => |li| {
+                        switch (rhs.data) {
+                            .s_import => |ri| {
+                                const a = ctx.import_records[li.import_record_index];
+                                const b = ctx.import_records[ri.import_record_index];
+                                if (a.is_bundled and !b.is_bundled) {
+                                    return false;
+                                } else {
                                     return true;
-                                },
-                            }
-                        },
-                        else => {
-                            switch (rhs.data) {
-                                .s_import => |ri| {
-                                    const a = ctx.import_records[ri.import_record_index];
-                                    if (!a.is_bundled) {
-                                        return false;
-                                    } else {
-                                        return true;
-                                    }
-                                },
-                                else => {
+                                }
+                            },
+                            else => {
+                                return true;
+                            },
+                        }
+                    },
+                    else => {
+                        switch (rhs.data) {
+                            .s_import => |ri| {
+                                const a = ctx.import_records[ri.import_record_index];
+                                if (!a.is_bundled) {
+                                    return false;
+                                } else {
                                     return true;
-                                },
-                            }
-                        },
-                    }
+                                }
+                            },
+                            else => {
+                                return true;
+                            },
+                        }
+                    },
                 }
-            };
+            }
+        };
 
-            // std.sort.sort(comptime T: type, items: []T, context: anytype, comptime lessThan: fn(context:@TypeOf(context), lhs:T, rhs:T)bool)
+        // std.sort.sort(comptime T: type, items: []T, context: anytype, comptime lessThan: fn(context:@TypeOf(context), lhs:T, rhs:T)bool)
 
-            // Change the import order so that any bundled imports appear last
-            // This is to make it so the bundle (which should be quite large) is least likely to block rendering
-            // if (needs_bundle) {
-            //     const sorter = ImportStatementSorter{ .import_records = result.ast.import_records };
-            //     for (result.ast.parts) |*part, i| {
-            //         std.sort.sort(js_ast.Stmt, part.stmts, sorter, ImportStatementSorter.lessThan);
-            //     }
-            // }
-        }
+        // Change the import order so that any bundled imports appear last
+        // This is to make it so the bundle (which should be quite large) is least likely to block rendering
+        // if (needs_bundle) {
+        //     const sorter = ImportStatementSorter{ .import_records = result.ast.import_records };
+        //     for (result.ast.parts) |*part, i| {
+        //         std.sort.sort(js_ast.Stmt, part.stmts, sorter, ImportStatementSorter.lessThan);
+        //     }
+        // }
+    }
+
+    const ImportPathsList = allocators.BSSStringList(512, 128);
+    pub var relative_paths_list: *ImportPathsList = undefined;
+
+    pub fn generateImportPath(
+        linker: *ThisLinker,
+        source_dir: string,
+        source_path: string,
+        package_version: ?string,
+        use_hashed_name: bool,
+        namespace: string,
+        comptime import_path_format: Options.BundleOptions.ImportPathFormat,
+    ) !Fs.Path {
+        switch (import_path_format) {
+            .absolute_path => {
+                if (strings.eqlComptime(namespace, "node")) {
+                    return Fs.Path.initWithNamespace(source_path, "node");
+                }
 
-        const ImportPathsList = allocators.BSSStringList(512, 128);
-        pub var relative_paths_list: *ImportPathsList = undefined;
-
-        pub fn generateImportPath(
-            linker: *ThisLinker,
-            source_dir: string,
-            source_path: string,
-            package_version: ?string,
-            use_hashed_name: bool,
-            namespace: string,
-            comptime import_path_format: Options.BundleOptions.ImportPathFormat,
-        ) !Fs.Path {
-            switch (import_path_format) {
-                .absolute_path => {
-                    if (strings.eqlComptime(namespace, "node")) {
-                        return Fs.Path.initWithNamespace(source_path, "node");
-                    }
+                var relative_name = linker.fs.relative(source_dir, source_path);
+
+                return Fs.Path.initWithPretty(source_path, relative_name);
+            },
+            .relative => {
+                var relative_name = linker.fs.relative(source_dir, source_path);
+
+                var pretty: string = undefined;
+                if (use_hashed_name) {
+                    var basepath = Fs.Path.init(source_path);
+                    const basename = try linker.getHashedFilename(basepath, null);
+                    var dir = basepath.name.dirWithTrailingSlash();
+                    var _pretty = try linker.allocator.alloc(u8, dir.len + basename.len + basepath.name.ext.len);
+                    std.mem.copy(u8, _pretty, dir);
+                    var remaining_pretty = _pretty[dir.len..];
+                    std.mem.copy(u8, remaining_pretty, basename);
+                    remaining_pretty = remaining_pretty[basename.len..];
+                    std.mem.copy(u8, remaining_pretty, basepath.name.ext);
+                    pretty = _pretty;
+                    relative_name = try linker.allocator.dupe(u8, relative_name);
+                } else {
+                    pretty = try linker.allocator.dupe(u8, relative_name);
+                    relative_name = pretty;
+                }
 
-                    var relative_name = linker.fs.relative(source_dir, source_path);
+                return Fs.Path.initWithPretty(pretty, relative_name);
+            },
+            .relative_nodejs => {
+                var relative_name = linker.fs.relative(source_dir, source_path);
+                var pretty: string = undefined;
+                if (use_hashed_name) {
+                    var basepath = Fs.Path.init(source_path);
+                    const basename = try linker.getHashedFilename(basepath, null);
+                    var dir = basepath.name.dirWithTrailingSlash();
+                    var _pretty = try linker.allocator.alloc(u8, dir.len + basename.len + basepath.name.ext.len);
+                    std.mem.copy(u8, _pretty, dir);
+                    var remaining_pretty = _pretty[dir.len..];
+                    std.mem.copy(u8, remaining_pretty, basename);
+                    remaining_pretty = remaining_pretty[basename.len..];
+                    std.mem.copy(u8, remaining_pretty, basepath.name.ext);
+                    pretty = _pretty;
+                    relative_name = try linker.allocator.dupe(u8, relative_name);
+                } else {
+                    pretty = try linker.allocator.dupe(u8, relative_name);
+                    relative_name = pretty;
+                }
 
-                    return Fs.Path.initWithPretty(source_path, relative_name);
-                },
-                .relative => {
-                    var relative_name = linker.fs.relative(source_dir, source_path);
+                var pathname = Fs.PathName.init(pretty);
+                var path = Fs.Path.initWithPretty(pretty, relative_name);
+                path.text = path.text[0 .. path.text.len - path.name.ext.len];
+                return path;
+            },
+
+            .absolute_url => {
+                if (strings.eqlComptime(namespace, "node")) {
+                    if (comptime isDebug) std.debug.assert(strings.eqlComptime(source_path[0..5], "node:"));
+
+                    return Fs.Path.init(try std.fmt.allocPrint(
+                        linker.allocator,
+                        // assumption: already starts with "node:"
+                        "{s}/{s}",
+                        .{
+                            linker.options.origin.origin,
+                            source_path,
+                        },
+                    ));
+                } else {
+                    var absolute_pathname = Fs.PathName.init(source_path);
 
-                    var pretty: string = undefined;
-                    if (use_hashed_name) {
-                        var basepath = Fs.Path.init(source_path);
-                        const basename = try linker.getHashedFilename(basepath, null);
-                        var dir = basepath.name.dirWithTrailingSlash();
-                        var _pretty = try linker.allocator.alloc(u8, dir.len + basename.len + basepath.name.ext.len);
-                        std.mem.copy(u8, _pretty, dir);
-                        var remaining_pretty = _pretty[dir.len..];
-                        std.mem.copy(u8, remaining_pretty, basename);
-                        remaining_pretty = remaining_pretty[basename.len..];
-                        std.mem.copy(u8, remaining_pretty, basepath.name.ext);
-                        pretty = _pretty;
-                        relative_name = try linker.allocator.dupe(u8, relative_name);
-                    } else {
-                        pretty = try linker.allocator.dupe(u8, relative_name);
-                        relative_name = pretty;
+                    if (!linker.options.preserve_extensions) {
+                        if (linker.options.out_extensions.get(absolute_pathname.ext)) |ext| {
+                            absolute_pathname.ext = ext;
+                        }
                     }
 
-                    return Fs.Path.initWithPretty(pretty, relative_name);
-                },
-                .relative_nodejs => {
-                    var relative_name = linker.fs.relative(source_dir, source_path);
-                    var pretty: string = undefined;
-                    if (use_hashed_name) {
-                        var basepath = Fs.Path.init(source_path);
-                        const basename = try linker.getHashedFilename(basepath, null);
-                        var dir = basepath.name.dirWithTrailingSlash();
-                        var _pretty = try linker.allocator.alloc(u8, dir.len + basename.len + basepath.name.ext.len);
-                        std.mem.copy(u8, _pretty, dir);
-                        var remaining_pretty = _pretty[dir.len..];
-                        std.mem.copy(u8, remaining_pretty, basename);
-                        remaining_pretty = remaining_pretty[basename.len..];
-                        std.mem.copy(u8, remaining_pretty, basepath.name.ext);
-                        pretty = _pretty;
-                        relative_name = try linker.allocator.dupe(u8, relative_name);
-                    } else {
-                        pretty = try linker.allocator.dupe(u8, relative_name);
-                        relative_name = pretty;
+                    var base = linker.fs.relativeTo(source_path);
+                    if (strings.lastIndexOfChar(base, '.')) |dot| {
+                        base = base[0..dot];
                     }
 
-                    var pathname = Fs.PathName.init(pretty);
-                    var path = Fs.Path.initWithPretty(pretty, relative_name);
-                    path.text = path.text[0 .. path.text.len - path.name.ext.len];
-                    return path;
-                },
-
-                .absolute_url => {
-                    if (strings.eqlComptime(namespace, "node")) {
-                        if (comptime isDebug) std.debug.assert(strings.eqlComptime(source_path[0..5], "node:"));
-
-                        return Fs.Path.init(try std.fmt.allocPrint(
-                            linker.allocator,
-                            // assumption: already starts with "node:"
-                            "{s}/{s}",
-                            .{
-                                linker.options.origin.origin,
-                                source_path,
-                            },
-                        ));
-                    } else {
-                        var absolute_pathname = Fs.PathName.init(source_path);
-
-                        if (!linker.options.preserve_extensions) {
-                            if (linker.options.out_extensions.get(absolute_pathname.ext)) |ext| {
-                                absolute_pathname.ext = ext;
-                            }
-                        }
-
-                        var base = linker.fs.relativeTo(source_path);
-                        if (strings.lastIndexOfChar(base, '.')) |dot| {
-                            base = base[0..dot];
-                        }
-
-                        var dirname = std.fs.path.dirname(base) orelse "";
-
-                        var basename = std.fs.path.basename(base);
+                    var dirname = std.fs.path.dirname(base) orelse "";
 
-                        if (use_hashed_name) {
-                            var basepath = Fs.Path.init(source_path);
-                            basename = try linker.getHashedFilename(basepath, null);
-                        }
+                    var basename = std.fs.path.basename(base);
 
-                        return Fs.Path.init(try linker.options.origin.joinAlloc(
-                            linker.allocator,
-                            linker.options.routes.asset_prefix_path,
-                            dirname,
-                            basename,
-                            absolute_pathname.ext,
-                            source_path,
-                        ));
+                    if (use_hashed_name) {
+                        var basepath = Fs.Path.init(source_path);
+                        basename = try linker.getHashedFilename(basepath, null);
                     }
-                },
 
-                else => unreachable,
-            }
-        }
+                    return Fs.Path.init(try linker.options.origin.joinAlloc(
+                        linker.allocator,
+                        linker.options.routes.asset_prefix_path,
+                        dirname,
+                        basename,
+                        absolute_pathname.ext,
+                        source_path,
+                    ));
+                }
+            },
 
-        pub fn processImportRecord(
-            linker: *ThisLinker,
-            loader: Options.Loader,
-            source_dir: string,
-            resolve_result: *const Resolver.Result,
-            import_record: *ImportRecord,
-            comptime import_path_format: Options.BundleOptions.ImportPathFormat,
-        ) !void {
-            linker.import_counter += 1;
-            // lazy means:
-            // Run the resolver
-            // Don't parse/print automatically.
-            if (linker.options.resolve_mode != .lazy) {
-                _ = try linker.enqueueResolveResult(resolve_result);
-            }
-            const path = resolve_result.pathConst() orelse unreachable;
-
-            import_record.path = try linker.generateImportPath(
-                source_dir,
-                if (path.is_symlink and import_path_format == .absolute_url and linker.options.platform != .bun) path.pretty else path.text,
-                if (resolve_result.package_json) |package_json| package_json.version else "",
-                BundlerType.isCacheEnabled and loader == .file,
-                path.namespace,
-                import_path_format,
-            );
-
-            switch (loader) {
-                .css => {
-                    if (linker.onImportCSS) |callback| {
-                        callback(resolve_result, import_record, source_dir);
-                    }
-                    // This saves us a less reliable string check
-                    import_record.print_mode = .css;
-                },
-                .file => {
-                    import_record.print_mode = .import_path;
-                },
-                else => {},
-            }
+            else => unreachable,
         }
+    }
+
+    pub fn processImportRecord(
+        linker: *ThisLinker,
+        loader: Options.Loader,
+        source_dir: string,
+        resolve_result: *const Resolver.Result,
+        import_record: *ImportRecord,
+        comptime import_path_format: Options.BundleOptions.ImportPathFormat,
+    ) !void {
+        linker.import_counter += 1;
+        // lazy means:
+        // Run the resolver
+        // Don't parse/print automatically.
+        if (linker.options.resolve_mode != .lazy) {
+            _ = try linker.enqueueResolveResult(resolve_result);
+        }
+        const path = resolve_result.pathConst() orelse unreachable;
+
+        import_record.path = try linker.generateImportPath(
+            source_dir,
+            if (path.is_symlink and import_path_format == .absolute_url and linker.options.platform != .bun) path.pretty else path.text,
+            if (resolve_result.package_json) |package_json| package_json.version else "",
+            Bundler.isCacheEnabled and loader == .file,
+            path.namespace,
+            import_path_format,
+        );
+
+        switch (loader) {
+            .css => {
+                if (linker.onImportCSS) |callback| {
+                    callback(resolve_result, import_record, source_dir);
+                }
+                // This saves us a less reliable string check
+                import_record.print_mode = .css;
+            },
+            .file => {
+                import_record.print_mode = .import_path;
+            },
+            else => {},
+        }
+    }
 
-        pub fn resolveResultHashKey(linker: *ThisLinker, resolve_result: *const Resolver.Result) u64 {
-            const path = resolve_result.pathConst() orelse unreachable;
-            var hash_key = path.text;
-
-            // Shorter hash key is faster to hash
-            if (strings.startsWith(path.text, linker.fs.top_level_dir)) {
-                hash_key = path.text[linker.fs.top_level_dir.len..];
-            }
+    pub fn resolveResultHashKey(linker: *ThisLinker, resolve_result: *const Resolver.Result) u64 {
+        const path = resolve_result.pathConst() orelse unreachable;
+        var hash_key = path.text;
 
-            return std.hash.Wyhash.hash(0, hash_key);
+        // Shorter hash key is faster to hash
+        if (strings.startsWith(path.text, linker.fs.top_level_dir)) {
+            hash_key = path.text[linker.fs.top_level_dir.len..];
         }
 
-        pub fn enqueueResolveResult(linker: *ThisLinker, resolve_result: *const Resolver.Result) !bool {
-            const hash_key = linker.resolveResultHashKey(resolve_result);
+        return std.hash.Wyhash.hash(0, hash_key);
+    }
 
-            const get_or_put_entry = try linker.resolve_results.getOrPut(hash_key);
+    pub fn enqueueResolveResult(linker: *ThisLinker, resolve_result: *const Resolver.Result) !bool {
+        const hash_key = linker.resolveResultHashKey(resolve_result);
 
-            if (!get_or_put_entry.found_existing) {
-                try linker.resolve_queue.writeItem(resolve_result.*);
-            }
+        const get_or_put_entry = try linker.resolve_results.getOrPut(hash_key);
 
-            return !get_or_put_entry.found_existing;
+        if (!get_or_put_entry.found_existing) {
+            try linker.resolve_queue.writeItem(resolve_result.*);
         }
-    };
-}
 
-pub const Linker = NewLinker(_bundler.Bundler);
-pub const ServeLinker = NewLinker(_bundler.ServeBundler);
+        return !get_or_put_entry.found_existing;
+    }
+};
diff --git a/src/resolver/resolver.zig b/src/resolver/resolver.zig
index 1eeed401d..a40cc0f1c 100644
--- a/src/resolver/resolver.zig
+++ b/src/resolver/resolver.zig
@@ -10,7 +10,7 @@ const TSConfigJSON = @import("./tsconfig_json.zig").TSConfigJSON;
 const PackageJSON = @import("./package_json.zig").PackageJSON;
 const ESModule = @import("./package_json.zig").ESModule;
 const BrowserMap = @import("./package_json.zig").BrowserMap;
-
+const CacheSet = cache.Set;
 usingnamespace @import("./data_url.zig");
 pub const DirInfo = @import("./dir_info.zig");
 const HTTPWatcher = @import("../http.zig").Watcher;
@@ -316,169 +316,140 @@ var resolver_Mutex_loaded: bool = false;
 // TODO:
 // - Fix "browser" field mapping
 // - Consider removing the string list abstraction?
-pub fn NewResolver(cache_files: bool) type {
-    const CacheSet = if (cache_files) cache.Cache.Set else cache.ServeCache.Set;
-
-    return struct {
-        const ThisResolver = @This();
-        opts: options.BundleOptions,
-        fs: *Fs.FileSystem,
-        log: *logger.Log,
+pub const Resolver = struct {
+    const ThisResolver = @This();
+    opts: options.BundleOptions,
+    fs: *Fs.FileSystem,
+    log: *logger.Log,
+    allocator: *std.mem.Allocator,
+    node_module_bundle: ?*NodeModuleBundle,
+    extension_order: []const string = undefined,
+
+    debug_logs: ?DebugLogs = null,
+    elapsed: i128 = 0, // tracing
+
+    onStartWatchingDirectory: ?fn (*HTTPWatcher, dir_path: string, dir_fd: StoredFileDescriptorType) void = null,
+    onStartWatchingDirectoryCtx: ?*HTTPWatcher = null,
+
+    caches: CacheSet,
+
+    // These are sets that represent various conditions for the "exports" field
+    // in package.json.
+    // esm_conditions_default: std.StringHashMap(bool),
+    // esm_conditions_import: std.StringHashMap(bool),
+    // esm_conditions_require: std.StringHashMap(bool),
+
+    // A special filtered import order for CSS "@import" imports.
+    //
+    // The "resolve extensions" setting determines the order of implicit
+    // extensions to try when resolving imports with the extension omitted.
+    // Sometimes people create a JavaScript/TypeScript file and a CSS file with
+    // the same name when they create a component. At a high level, users expect
+    // implicit extensions to resolve to the JS file when being imported from JS
+    // and to resolve to the CSS file when being imported from CSS.
+    //
+    // Different bundlers handle this in different ways. Parcel handles this by
+    // having the resolver prefer the same extension as the importing file in
+    // front of the configured "resolve extensions" order. Webpack's "css-loader"
+    // plugin just explicitly configures a special "resolve extensions" order
+    // consisting of only ".css" for CSS files.
+    //
+    // It's unclear what behavior is best here. What we currently do is to create
+    // a special filtered version of the configured "resolve extensions" order
+    // for CSS files that filters out any extension that has been explicitly
+    // configured with a non-CSS loader. This still gives users control over the
+    // order but avoids the scenario where we match an import in a CSS file to a
+    // JavaScript-related file. It's probably not perfect with plugins in the
+    // picture but it's better than some alternatives and probably pretty good.
+    // atImportExtensionOrder []string
+
+    // This mutex serves two purposes. First of all, it guards access to "dirCache"
+    // which is potentially mutated during path resolution. But this mutex is also
+    // necessary for performance. The "React admin" benchmark mysteriously runs
+    // twice as fast when this mutex is locked around the whole resolve operation
+    // instead of around individual accesses to "dirCache". For some reason,
+    // reducing parallelism in the resolver helps the rest of the bundler go
+    // faster. I'm not sure why this is but please don't change this unless you
+    // do a lot of testing with various benchmarks and there aren't any regressions.
+    mutex: *Mutex,
+
+    // This cache maps a directory path to information about that directory and
+    // all parent directories
+    dir_cache: *DirInfo.HashMap,
+
+    pub fn init1(
         allocator: *std.mem.Allocator,
-        node_module_bundle: ?*NodeModuleBundle,
-        extension_order: []const string = undefined,
-
-        debug_logs: ?DebugLogs = null,
-        elapsed: i128 = 0, // tracing
-
-        onStartWatchingDirectory: ?fn (*HTTPWatcher, dir_path: string, dir_fd: StoredFileDescriptorType) void = null,
-        onStartWatchingDirectoryCtx: ?*HTTPWatcher = null,
-
-        caches: CacheSet,
-
-        // These are sets that represent various conditions for the "exports" field
-        // in package.json.
-        // esm_conditions_default: std.StringHashMap(bool),
-        // esm_conditions_import: std.StringHashMap(bool),
-        // esm_conditions_require: std.StringHashMap(bool),
-
-        // A special filtered import order for CSS "@import" imports.
-        //
-        // The "resolve extensions" setting determines the order of implicit
-        // extensions to try when resolving imports with the extension omitted.
-        // Sometimes people create a JavaScript/TypeScript file and a CSS file with
-        // the same name when they create a component. At a high level, users expect
-        // implicit extensions to resolve to the JS file when being imported from JS
-        // and to resolve to the CSS file when being imported from CSS.
-        //
-        // Different bundlers handle this in different ways. Parcel handles this by
-        // having the resolver prefer the same extension as the importing file in
-        // front of the configured "resolve extensions" order. Webpack's "css-loader"
-        // plugin just explicitly configures a special "resolve extensions" order
-        // consisting of only ".css" for CSS files.
-        //
-        // It's unclear what behavior is best here. What we currently do is to create
-        // a special filtered version of the configured "resolve extensions" order
-        // for CSS files that filters out any extension that has been explicitly
-        // configured with a non-CSS loader. This still gives users control over the
-        // order but avoids the scenario where we match an import in a CSS file to a
-        // JavaScript-related file. It's probably not perfect with plugins in the
-        // picture but it's better than some alternatives and probably pretty good.
-        // atImportExtensionOrder []string
-
-        // This mutex serves two purposes. First of all, it guards access to "dirCache"
-        // which is potentially mutated during path resolution. But this mutex is also
-        // necessary for performance. The "React admin" benchmark mysteriously runs
-        // twice as fast when this mutex is locked around the whole resolve operation
-        // instead of around individual accesses to "dirCache". For some reason,
-        // reducing parallelism in the resolver helps the rest of the bundler go
-        // faster. I'm not sure why this is but please don't change this unless you
-        // do a lot of testing with various benchmarks and there aren't any regressions.
-        mutex: *Mutex,
-
-        // This cache maps a directory path to information about that directory and
-        // all parent directories
-        dir_cache: *DirInfo.HashMap,
-
-        pub fn init1(
-            allocator: *std.mem.Allocator,
-            log: *logger.Log,
-            _fs: *Fs.FileSystem,
-            opts: options.BundleOptions,
-        ) ThisResolver {
-            if (!resolver_Mutex_loaded) {
-                resolver_Mutex = Mutex.init();
-                resolver_Mutex_loaded = true;
-            }
-
-            return ThisResolver{
-                .allocator = allocator,
-                .dir_cache = DirInfo.HashMap.init(allocator),
-                .mutex = &resolver_Mutex,
-                .caches = CacheSet.init(allocator),
-                .opts = opts,
-                .fs = _fs,
-                .node_module_bundle = opts.node_modules_bundle,
-                .log = log,
-                .extension_order = opts.extension_order,
-            };
+        log: *logger.Log,
+        _fs: *Fs.FileSystem,
+        opts: options.BundleOptions,
+    ) ThisResolver {
+        if (!resolver_Mutex_loaded) {
+            resolver_Mutex = Mutex.init();
+            resolver_Mutex_loaded = true;
         }
 
-        pub fn isExternalPattern(r: *ThisResolver, import_path: string) bool {
-            for (r.opts.external.patterns) |pattern| {
-                if (import_path.len >= pattern.prefix.len + pattern.suffix.len and (strings.startsWith(
-                    import_path,
-                    pattern.prefix,
-                ) and strings.endsWith(
-                    import_path,
-                    pattern.suffix,
-                ))) {
-                    return true;
-                }
+        return ThisResolver{
+            .allocator = allocator,
+            .dir_cache = DirInfo.HashMap.init(allocator),
+            .mutex = &resolver_Mutex,
+            .caches = CacheSet.init(allocator),
+            .opts = opts,
+            .fs = _fs,
+            .node_module_bundle = opts.node_modules_bundle,
+            .log = log,
+            .extension_order = opts.extension_order,
+        };
+    }
+
+    pub fn isExternalPattern(r: *ThisResolver, import_path: string) bool {
+        for (r.opts.external.patterns) |pattern| {
+            if (import_path.len >= pattern.prefix.len + pattern.suffix.len and (strings.startsWith(
+                import_path,
+                pattern.prefix,
+            ) and strings.endsWith(
+                import_path,
+                pattern.suffix,
+            ))) {
+                return true;
             }
-            return false;
         }
+        return false;
+    }
 
-        pub fn flushDebugLogs(r: *ThisResolver, flush_mode: DebugLogs.FlushMode) !void {
-            if (r.debug_logs) |*debug| {
-                if (flush_mode == DebugLogs.FlushMode.fail) {
-                    try r.log.addRangeDebugWithNotes(null, logger.Range{ .loc = logger.Loc{} }, debug.what, debug.notes.toOwnedSlice());
-                } else if (@enumToInt(r.log.level) <= @enumToInt(logger.Log.Level.verbose)) {
-                    try r.log.addVerboseWithNotes(null, logger.Loc.Empty, debug.what, debug.notes.toOwnedSlice());
-                }
+    pub fn flushDebugLogs(r: *ThisResolver, flush_mode: DebugLogs.FlushMode) !void {
+        if (r.debug_logs) |*debug| {
+            if (flush_mode == DebugLogs.FlushMode.fail) {
+                try r.log.addRangeDebugWithNotes(null, logger.Range{ .loc = logger.Loc{} }, debug.what, debug.notes.toOwnedSlice());
+            } else if (@enumToInt(r.log.level) <= @enumToInt(logger.Log.Level.verbose)) {
+                try r.log.addVerboseWithNotes(null, logger.Loc.Empty, debug.what, debug.notes.toOwnedSlice());
             }
         }
-        var tracing_start: i128 = if (FeatureFlags.tracing) 0 else undefined;
-
-        pub const bunFrameworkPackagePrefix = "bun-framework-";
-        pub fn resolveFramework(
-            r: *ThisResolver,
-            package: string,
-            pair: *PackageJSON.FrameworkRouterPair,
-            comptime preference: PackageJSON.LoadFramework,
-            comptime load_defines: bool,
-        ) !void {
-
-            // We want to enable developers to integrate frameworks without waiting on official support.
-            // But, we still want the command to do the actual framework integration to be succint
-            // This lets users type "--use next" instead of "--use bun-framework-next"
-            // If they're using a local file path, we skip this.
-            if (isPackagePath(package)) {
-                var prefixed_package_buf: [512]u8 = undefined;
-                // Prevent the extra lookup if the package is already prefixed, i.e. avoid "bun-framework-next-bun-framework-next"
-                if (strings.startsWith(package, bunFrameworkPackagePrefix) or package.len + bunFrameworkPackagePrefix.len >= prefixed_package_buf.len) {
-                    return r._resolveFramework(package, pair, preference, load_defines) catch |err| {
-                        switch (err) {
-                            error.ModuleNotFound => {
-                                Output.prettyErrorln("<r><red>ResolveError<r> can't find framework: <b>\"{s}\"<r>.\n\nMaybe it's not installed? Try running this:\n\n   <b>npm install -D {s}<r>\n   <b>bun bun --use {s}<r>", .{ package, package, package });
-                                Output.flush();
-                                std.os.exit(1);
-                            },
-                            else => {
-                                return err;
-                            },
-                        }
-                    };
-                }
-
-                prefixed_package_buf[0..bunFrameworkPackagePrefix.len].* = bunFrameworkPackagePrefix.*;
-                std.mem.copy(u8, prefixed_package_buf[bunFrameworkPackagePrefix.len..], package);
-                const prefixed_name = prefixed_package_buf[0 .. bunFrameworkPackagePrefix.len + package.len];
-                return r._resolveFramework(prefixed_name, pair, preference, load_defines) catch |err| {
+    }
+    var tracing_start: i128 = if (FeatureFlags.tracing) 0 else undefined;
+
+    pub const bunFrameworkPackagePrefix = "bun-framework-";
+    pub fn resolveFramework(
+        r: *ThisResolver,
+        package: string,
+        pair: *PackageJSON.FrameworkRouterPair,
+        comptime preference: PackageJSON.LoadFramework,
+        comptime load_defines: bool,
+    ) !void {
+
+        // We want to enable developers to integrate frameworks without waiting on official support.
+        // But, we still want the command to do the actual framework integration to be succint
+        // This lets users type "--use next" instead of "--use bun-framework-next"
+        // If they're using a local file path, we skip this.
+        if (isPackagePath(package)) {
+            var prefixed_package_buf: [512]u8 = undefined;
+            // Prevent the extra lookup if the package is already prefixed, i.e. avoid "bun-framework-next-bun-framework-next"
+            if (strings.startsWith(package, bunFrameworkPackagePrefix) or package.len + bunFrameworkPackagePrefix.len >= prefixed_package_buf.len) {
+                return r._resolveFramework(package, pair, preference, load_defines) catch |err| {
                     switch (err) {
                         error.ModuleNotFound => {
-                            return r._resolveFramework(package, pair, preference, load_defines) catch |err2| {
-                                switch (err2) {
-                                    error.ModuleNotFound => {
-                                        Output.prettyErrorln("<r><red>ResolveError<r> can't find framework: <b>\"{s}\"<r>.\n\nMaybe it's not installed? Try running this:\n\n   <b>npm install -D {s}\n   <b>bun bun --use {s}<r>", .{ package, prefixed_name, package });
-                                        Output.flush();
-                                        std.os.exit(1);
-                                    },
-                                    else => {
-                                        return err;
-                                    },
-                                }
-                            };
+                            Output.prettyErrorln("<r><red>ResolveError<r> can't find framework: <b>\"{s}\"<r>.\n\nMaybe it's not installed? Try running this:\n\n   <b>npm install -D {s}<r>\n   <b>bun bun --use {s}<r>", .{ package, package, package });
+                            Output.flush();
+                            std.os.exit(1);
                         },
                         else => {
                             return err;
@@ -487,13 +458,24 @@ pub fn NewResolver(cache_files: bool) type {
                 };
             }
 
-            return r._resolveFramework(package, pair, preference, load_defines) catch |err| {
+            prefixed_package_buf[0..bunFrameworkPackagePrefix.len].* = bunFrameworkPackagePrefix.*;
+            std.mem.copy(u8, prefixed_package_buf[bunFrameworkPackagePrefix.len..], package);
+            const prefixed_name = prefixed_package_buf[0 .. bunFrameworkPackagePrefix.len + package.len];
+            return r._resolveFramework(prefixed_name, pair, preference, load_defines) catch |err| {
                 switch (err) {
                     error.ModuleNotFound => {
-                        Output.prettyError("<r><red>ResolveError<r> can't find local framework: <b>\"{s}\"<r>.", .{package});
-
-                        Output.flush();
-                        std.os.exit(1);
+                        return r._resolveFramework(package, pair, preference, load_defines) catch |err2| {
+                            switch (err2) {
+                                error.ModuleNotFound => {
+                                    Output.prettyErrorln("<r><red>ResolveError<r> can't find framework: <b>\"{s}\"<r>.\n\nMaybe it's not installed? Try running this:\n\n   <b>npm install -D {s}\n   <b>bun bun --use {s}<r>", .{ package, prefixed_name, package });
+                                    Output.flush();
+                                    std.os.exit(1);
+                                },
+                                else => {
+                                    return err;
+                                },
+                            }
+                        };
                     },
                     else => {
                         return err;
@@ -502,2079 +484,2077 @@ pub fn NewResolver(cache_files: bool) type {
             };
         }
 
-        fn _resolveFramework(
-            r: *ThisResolver,
-            package: string,
-            pair: *PackageJSON.FrameworkRouterPair,
-            comptime preference: PackageJSON.LoadFramework,
-            comptime load_defines: bool,
-        ) !void {
+        return r._resolveFramework(package, pair, preference, load_defines) catch |err| {
+            switch (err) {
+                error.ModuleNotFound => {
+                    Output.prettyError("<r><red>ResolveError<r> can't find local framework: <b>\"{s}\"<r>.", .{package});
 
-            // TODO: make this only parse package.json once
-            var result = try r.resolve(r.fs.top_level_dir, package, .internal);
-            // support passing a package.json or path to a package
-            const pkg: *const PackageJSON = result.package_json orelse r.packageJSONForResolvedNodeModuleWithIgnoreMissingName(&result, true) orelse return error.MissingPackageJSON;
+                    Output.flush();
+                    std.os.exit(1);
+                },
+                else => {
+                    return err;
+                },
+            }
+        };
+    }
 
-            const json = (try r.caches.json.parseJSON(r.log, pkg.source, r.allocator)) orelse return error.JSONParseError;
+    fn _resolveFramework(
+        r: *ThisResolver,
+        package: string,
+        pair: *PackageJSON.FrameworkRouterPair,
+        comptime preference: PackageJSON.LoadFramework,
+        comptime load_defines: bool,
+    ) !void {
 
-            pkg.loadFrameworkWithPreference(pair, json, r.allocator, load_defines, preference);
-            const dir = pkg.source.path.sourceDir();
+        // TODO: make this only parse package.json once
+        var result = try r.resolve(r.fs.top_level_dir, package, .internal);
+        // support passing a package.json or path to a package
+        const pkg: *const PackageJSON = result.package_json orelse r.packageJSONForResolvedNodeModuleWithIgnoreMissingName(&result, true) orelse return error.MissingPackageJSON;
 
-            var buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
+        const json = (try r.caches.json.parseJSON(r.log, pkg.source, r.allocator)) orelse return error.JSONParseError;
 
-            pair.framework.resolved_dir = pkg.source.path.sourceDir();
+        pkg.loadFrameworkWithPreference(pair, json, r.allocator, load_defines, preference);
+        const dir = pkg.source.path.sourceDir();
 
-            if (pair.framework.client.isEnabled()) {
-                var parts = [_]string{ dir, pair.framework.client.path };
-                const abs = r.fs.abs(&parts);
-                pair.framework.client.path = try r.allocator.dupe(u8, abs);
-                pair.framework.resolved = true;
-            }
+        var buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
 
-            if (pair.framework.server.isEnabled()) {
-                var parts = [_]string{ dir, pair.framework.server.path };
-                const abs = r.fs.abs(&parts);
-                pair.framework.server.path = try r.allocator.dupe(u8, abs);
-                pair.framework.resolved = true;
-            }
+        pair.framework.resolved_dir = pkg.source.path.sourceDir();
 
-            if (pair.framework.fallback.isEnabled()) {
-                var parts = [_]string{ dir, pair.framework.fallback.path };
-                const abs = r.fs.abs(&parts);
-                pair.framework.fallback.path = try r.allocator.dupe(u8, abs);
-                pair.framework.resolved = true;
-            }
+        if (pair.framework.client.isEnabled()) {
+            var parts = [_]string{ dir, pair.framework.client.path };
+            const abs = r.fs.abs(&parts);
+            pair.framework.client.path = try r.allocator.dupe(u8, abs);
+            pair.framework.resolved = true;
+        }
 
-            if (pair.loaded_routes) {
-                const chosen_dir: string = brk: {
-                    if (pair.router.possible_dirs.len > 0) {
-                        for (pair.router.possible_dirs) |route_dir| {
-                            var parts = [_]string{ r.fs.top_level_dir, std.fs.path.sep_str, route_dir };
-                            const abs = r.fs.join(&parts);
-                            // must end in trailing slash
-                            break :brk (std.os.realpath(abs, &buf) catch continue);
-                        }
-                        return error.MissingRouteDir;
-                    } else {
-                        var parts = [_]string{ r.fs.top_level_dir, std.fs.path.sep_str, pair.router.dir };
+        if (pair.framework.server.isEnabled()) {
+            var parts = [_]string{ dir, pair.framework.server.path };
+            const abs = r.fs.abs(&parts);
+            pair.framework.server.path = try r.allocator.dupe(u8, abs);
+            pair.framework.resolved = true;
+        }
+
+        if (pair.framework.fallback.isEnabled()) {
+            var parts = [_]string{ dir, pair.framework.fallback.path };
+            const abs = r.fs.abs(&parts);
+            pair.framework.fallback.path = try r.allocator.dupe(u8, abs);
+            pair.framework.resolved = true;
+        }
+
+        if (pair.loaded_routes) {
+            const chosen_dir: string = brk: {
+                if (pair.router.possible_dirs.len > 0) {
+                    for (pair.router.possible_dirs) |route_dir| {
+                        var parts = [_]string{ r.fs.top_level_dir, std.fs.path.sep_str, route_dir };
                         const abs = r.fs.join(&parts);
                         // must end in trailing slash
-                        break :brk std.os.realpath(abs, &buf) catch return error.MissingRouteDir;
+                        break :brk (std.os.realpath(abs, &buf) catch continue);
                     }
-                };
+                    return error.MissingRouteDir;
+                } else {
+                    var parts = [_]string{ r.fs.top_level_dir, std.fs.path.sep_str, pair.router.dir };
+                    const abs = r.fs.join(&parts);
+                    // must end in trailing slash
+                    break :brk std.os.realpath(abs, &buf) catch return error.MissingRouteDir;
+                }
+            };
 
-                var out = try r.allocator.alloc(u8, chosen_dir.len + 1);
-                std.mem.copy(u8, out, chosen_dir);
-                out[out.len - 1] = '/';
-                pair.router.dir = out;
-                pair.router.routes_enabled = true;
-            }
+            var out = try r.allocator.alloc(u8, chosen_dir.len + 1);
+            std.mem.copy(u8, out, chosen_dir);
+            out[out.len - 1] = '/';
+            pair.router.dir = out;
+            pair.router.routes_enabled = true;
         }
+    }
 
-        pub fn resolve(r: *ThisResolver, source_dir: string, import_path: string, kind: ast.ImportKind) !Result {
-            r.extension_order = if (kind.isFromCSS()) std.mem.span(&options.BundleOptions.Defaults.CSSExtensionOrder) else r.opts.extension_order;
+    pub fn resolve(r: *ThisResolver, source_dir: string, import_path: string, kind: ast.ImportKind) !Result {
+        r.extension_order = if (kind.isFromCSS()) std.mem.span(&options.BundleOptions.Defaults.CSSExtensionOrder) else r.opts.extension_order;
 
+        if (FeatureFlags.tracing) {
+            tracing_start = std.time.nanoTimestamp();
+        }
+        defer {
             if (FeatureFlags.tracing) {
-                tracing_start = std.time.nanoTimestamp();
+                r.elapsed += std.time.nanoTimestamp() - tracing_start;
             }
-            defer {
-                if (FeatureFlags.tracing) {
-                    r.elapsed += std.time.nanoTimestamp() - tracing_start;
-                }
+        }
+        if (r.log.level == .verbose) {
+            if (r.debug_logs != null) {
+                r.debug_logs.?.deinit();
             }
-            if (r.log.level == .verbose) {
-                if (r.debug_logs != null) {
-                    r.debug_logs.?.deinit();
-                }
 
-                r.debug_logs = try DebugLogs.init(r.allocator);
-            }
+            r.debug_logs = try DebugLogs.init(r.allocator);
+        }
 
-            if (import_path.len == 0) return error.ModuleNotFound;
+        if (import_path.len == 0) return error.ModuleNotFound;
 
-            // Certain types of URLs default to being external for convenience
-            if (r.isExternalPattern(import_path) or
-                // "fill: url(#filter);"
-                (kind.isFromCSS() and strings.startsWith(import_path, "#")) or
+        // Certain types of URLs default to being external for convenience
+        if (r.isExternalPattern(import_path) or
+            // "fill: url(#filter);"
+            (kind.isFromCSS() and strings.startsWith(import_path, "#")) or
 
-                // "background: url(http://example.com/images/image.png);"
-                strings.startsWith(import_path, "http://") or
+            // "background: url(http://example.com/images/image.png);"
+            strings.startsWith(import_path, "http://") or
 
-                // "background: url(https://example.com/images/image.png);"
-                strings.startsWith(import_path, "https://") or
+            // "background: url(https://example.com/images/image.png);"
+            strings.startsWith(import_path, "https://") or
 
-                // "background: url(//example.com/images/image.png);"
-                strings.startsWith(import_path, "//"))
-            {
-                if (r.debug_logs) |*debug| {
-                    try debug.addNote("Marking this path as implicitly external");
-                }
-                r.flushDebugLogs(.success) catch {};
-                return Result{
-                    .import_kind = kind,
-                    .path_pair = PathPair{
-                        .primary = Path.init(import_path),
-                    },
-                    .is_external = true,
-                    .module_type = .esm,
-                };
+            // "background: url(//example.com/images/image.png);"
+            strings.startsWith(import_path, "//"))
+        {
+            if (r.debug_logs) |*debug| {
+                try debug.addNote("Marking this path as implicitly external");
             }
+            r.flushDebugLogs(.success) catch {};
+            return Result{
+                .import_kind = kind,
+                .path_pair = PathPair{
+                    .primary = Path.init(import_path),
+                },
+                .is_external = true,
+                .module_type = .esm,
+            };
+        }
 
-            if (DataURL.parse(import_path)) |_data_url| {
-                const data_url: DataURL = _data_url;
-                // "import 'data:text/javascript,console.log(123)';"
-                // "@import 'data:text/css,body{background:white}';"
-                if (data_url.decode_mime_type() != .Unsupported) {
-                    if (r.debug_logs) |*debug| {
-                        debug.addNote("Putting this path in the \"dataurl\" namespace") catch {};
-                    }
-                    r.flushDebugLogs(.success) catch {};
-                    return Result{ .path_pair = PathPair{ .primary = Path.initWithNamespace(import_path, "dataurl") } };
-                }
-
-                // "background: url(data:image/png;base64,iVBORw0KGgo=);"
+        if (DataURL.parse(import_path)) |_data_url| {
+            const data_url: DataURL = _data_url;
+            // "import 'data:text/javascript,console.log(123)';"
+            // "@import 'data:text/css,body{background:white}';"
+            if (data_url.decode_mime_type() != .Unsupported) {
                 if (r.debug_logs) |*debug| {
-                    debug.addNote("Marking this \"dataurl\" as external") catch {};
+                    debug.addNote("Putting this path in the \"dataurl\" namespace") catch {};
                 }
                 r.flushDebugLogs(.success) catch {};
-                return Result{
-                    .path_pair = PathPair{ .primary = Path.initWithNamespace(import_path, "dataurl") },
-                    .is_external = true,
-                };
+                return Result{ .path_pair = PathPair{ .primary = Path.initWithNamespace(import_path, "dataurl") } };
             }
 
-            // Fail now if there is no directory to resolve in. This can happen for
-            // virtual modules (e.g. stdin) if a resolve directory is not specified.
-            if (source_dir.len == 0) {
-                if (r.debug_logs) |*debug| {
-                    debug.addNote("Cannot resolve this path without a directory") catch {};
-                }
-                r.flushDebugLogs(.fail) catch {};
-                return error.MissingResolveDir;
+            // "background: url(data:image/png;base64,iVBORw0KGgo=);"
+            if (r.debug_logs) |*debug| {
+                debug.addNote("Marking this \"dataurl\" as external") catch {};
             }
-
-            // r.mutex.lock();
-            // defer r.mutex.unlock();
-            errdefer (r.flushDebugLogs(.fail) catch {});
-            var result = (try r.resolveWithoutSymlinks(source_dir, import_path, kind)) orelse {
-                r.flushDebugLogs(.fail) catch {};
-                return error.ModuleNotFound;
+            r.flushDebugLogs(.success) catch {};
+            return Result{
+                .path_pair = PathPair{ .primary = Path.initWithNamespace(import_path, "dataurl") },
+                .is_external = true,
             };
+        }
 
-            if (!strings.eqlComptime(result.path_pair.primary.namespace, "node"))
-                try r.finalizeResult(&result);
-
-            r.flushDebugLogs(.success) catch {};
-            result.import_kind = kind;
-            return result;
+        // Fail now if there is no directory to resolve in. This can happen for
+        // virtual modules (e.g. stdin) if a resolve directory is not specified.
+        if (source_dir.len == 0) {
+            if (r.debug_logs) |*debug| {
+                debug.addNote("Cannot resolve this path without a directory") catch {};
+            }
+            r.flushDebugLogs(.fail) catch {};
+            return error.MissingResolveDir;
         }
 
-        pub fn finalizeResult(r: *ThisResolver, result: *Result) !void {
-            if (result.is_external) return;
+        // r.mutex.lock();
+        // defer r.mutex.unlock();
+        errdefer (r.flushDebugLogs(.fail) catch {});
+        var result = (try r.resolveWithoutSymlinks(source_dir, import_path, kind)) orelse {
+            r.flushDebugLogs(.fail) catch {};
+            return error.ModuleNotFound;
+        };
 
-            var iter = result.path_pair.iter();
-            while (iter.next()) |path| {
-                var dir: *DirInfo = (r.readDirInfo(path.name.dir) catch continue) orelse continue;
-                result.package_json = result.package_json orelse dir.enclosing_package_json;
+        if (!strings.eqlComptime(result.path_pair.primary.namespace, "node"))
+            try r.finalizeResult(&result);
 
-                if (dir.getEntries()) |entries| {
-                    if (entries.get(path.name.filename)) |query| {
-                        const symlink_path = query.entry.symlink(&r.fs.fs);
-                        if (symlink_path.len > 0) {
-                            path.setRealpath(symlink_path);
-                            if (result.file_fd == 0) result.file_fd = query.entry.cache.fd;
+        r.flushDebugLogs(.success) catch {};
+        result.import_kind = kind;
+        return result;
+    }
 
-                            if (r.debug_logs) |*debug| {
-                                debug.addNoteFmt("Resolved symlink \"{s}\" to \"{s}\"", .{ path.text, symlink_path }) catch {};
-                            }
-                        } else if (dir.abs_real_path.len > 0) {
-                            var parts = [_]string{ dir.abs_real_path, query.entry.base() };
-                            var buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
+    pub fn finalizeResult(r: *ThisResolver, result: *Result) !void {
+        if (result.is_external) return;
 
-                            var out = r.fs.absBuf(&parts, &buf);
+        var iter = result.path_pair.iter();
+        while (iter.next()) |path| {
+            var dir: *DirInfo = (r.readDirInfo(path.name.dir) catch continue) orelse continue;
+            result.package_json = result.package_json orelse dir.enclosing_package_json;
 
-                            if (query.entry.cache.fd == 0) {
-                                buf[out.len] = 0;
-                                const span = buf[0..out.len :0];
-                                var file = try std.fs.openFileAbsoluteZ(span, .{ .read = true });
+            if (dir.getEntries()) |entries| {
+                if (entries.get(path.name.filename)) |query| {
+                    const symlink_path = query.entry.symlink(&r.fs.fs);
+                    if (symlink_path.len > 0) {
+                        path.setRealpath(symlink_path);
+                        if (result.file_fd == 0) result.file_fd = query.entry.cache.fd;
 
-                                if (comptime !FeatureFlags.store_file_descriptors) {
-                                    out = try std.os.getFdPath(query.entry.cache.fd, &buf);
-                                    file.close();
-                                } else {
-                                    query.entry.cache.fd = file.handle;
-                                    Fs.FileSystem.setMaxFd(file.handle);
-                                }
-                            }
+                        if (r.debug_logs) |*debug| {
+                            debug.addNoteFmt("Resolved symlink \"{s}\" to \"{s}\"", .{ path.text, symlink_path }) catch {};
+                        }
+                    } else if (dir.abs_real_path.len > 0) {
+                        var parts = [_]string{ dir.abs_real_path, query.entry.base() };
+                        var buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
 
-                            defer {
-                                if (r.fs.fs.needToCloseFiles()) {
-                                    if (query.entry.cache.fd != 0) {
-                                        var file = std.fs.File{ .handle = query.entry.cache.fd };
-                                        file.close();
-                                        query.entry.cache.fd = 0;
-                                    }
-                                }
-                            }
+                        var out = r.fs.absBuf(&parts, &buf);
 
-                            if (comptime FeatureFlags.store_file_descriptors) {
+                        if (query.entry.cache.fd == 0) {
+                            buf[out.len] = 0;
+                            const span = buf[0..out.len :0];
+                            var file = try std.fs.openFileAbsoluteZ(span, .{ .read = true });
+
+                            if (comptime !FeatureFlags.store_file_descriptors) {
                                 out = try std.os.getFdPath(query.entry.cache.fd, &buf);
+                                file.close();
+                            } else {
+                                query.entry.cache.fd = file.handle;
+                                Fs.FileSystem.setMaxFd(file.handle);
                             }
+                        }
 
-                            const symlink = try Fs.FileSystem.FilenameStore.instance.append(@TypeOf(out), out);
-                            if (r.debug_logs) |*debug| {
-                                debug.addNoteFmt("Resolved symlink \"{s}\" to \"{s}\"", .{ symlink, path.text }) catch {};
+                        defer {
+                            if (r.fs.fs.needToCloseFiles()) {
+                                if (query.entry.cache.fd != 0) {
+                                    var file = std.fs.File{ .handle = query.entry.cache.fd };
+                                    file.close();
+                                    query.entry.cache.fd = 0;
+                                }
                             }
-                            query.entry.cache.symlink = PathString.init(symlink);
-                            if (result.file_fd == 0) result.file_fd = query.entry.cache.fd;
+                        }
+
+                        if (comptime FeatureFlags.store_file_descriptors) {
+                            out = try std.os.getFdPath(query.entry.cache.fd, &buf);
+                        }
 
-                            path.setRealpath(symlink);
+                        const symlink = try Fs.FileSystem.FilenameStore.instance.append(@TypeOf(out), out);
+                        if (r.debug_logs) |*debug| {
+                            debug.addNoteFmt("Resolved symlink \"{s}\" to \"{s}\"", .{ symlink, path.text }) catch {};
                         }
+                        query.entry.cache.symlink = PathString.init(symlink);
+                        if (result.file_fd == 0) result.file_fd = query.entry.cache.fd;
+
+                        path.setRealpath(symlink);
                     }
                 }
             }
-
-            if (result.package_json) |package_json| {
-                result.module_type = switch (package_json.module_type) {
-                    .esm, .cjs => package_json.module_type,
-                    .unknown => result.module_type,
-                };
-            }
         }
 
-        pub fn resolveWithoutSymlinks(r: *ThisResolver, source_dir: string, import_path: string, kind: ast.ImportKind) !?Result {
-
-            // This implements the module resolution algorithm from node.js, which is
-            // described here: https://nodejs.org/api/modules.html#modules_all_together
-            var result: Result = Result{ .path_pair = PathPair{ .primary = Path.empty } };
+        if (result.package_json) |package_json| {
+            result.module_type = switch (package_json.module_type) {
+                .esm, .cjs => package_json.module_type,
+                .unknown => result.module_type,
+            };
+        }
+    }
 
-            // Return early if this is already an absolute path. In addition to asking
-            // the file system whether this is an absolute path, we also explicitly check
-            // whether it starts with a "/" and consider that an absolute path too. This
-            // is because relative paths can technically start with a "/" on Windows
-            // because it's not an absolute path on Windows. Then people might write code
-            // with imports that start with a "/" that works fine on Windows only to
-            // experience unexpected build failures later on other operating systems.
-            // Treating these paths as absolute paths on all platforms means Windows
-            // users will not be able to accidentally make use of these paths.
-            if (strings.startsWith(import_path, "/") or std.fs.path.isAbsolutePosix(import_path)) {
-                if (r.debug_logs) |*debug| {
-                    debug.addNoteFmt("The import \"{s}\" is being treated as an absolute path", .{import_path}) catch {};
-                }
+    pub fn resolveWithoutSymlinks(r: *ThisResolver, source_dir: string, import_path: string, kind: ast.ImportKind) !?Result {
+
+        // This implements the module resolution algorithm from node.js, which is
+        // described here: https://nodejs.org/api/modules.html#modules_all_together
+        var result: Result = Result{ .path_pair = PathPair{ .primary = Path.empty } };
+
+        // Return early if this is already an absolute path. In addition to asking
+        // the file system whether this is an absolute path, we also explicitly check
+        // whether it starts with a "/" and consider that an absolute path too. This
+        // is because relative paths can technically start with a "/" on Windows
+        // because it's not an absolute path on Windows. Then people might write code
+        // with imports that start with a "/" that works fine on Windows only to
+        // experience unexpected build failures later on other operating systems.
+        // Treating these paths as absolute paths on all platforms means Windows
+        // users will not be able to accidentally make use of these paths.
+        if (strings.startsWith(import_path, "/") or std.fs.path.isAbsolutePosix(import_path)) {
+            if (r.debug_logs) |*debug| {
+                debug.addNoteFmt("The import \"{s}\" is being treated as an absolute path", .{import_path}) catch {};
+            }
 
-                // First, check path overrides from the nearest enclosing TypeScript "tsconfig.json" file
-                if ((r.dirInfoCached(source_dir) catch null)) |_dir_info| {
-                    const dir_info: *DirInfo = _dir_info;
-                    if (dir_info.enclosing_tsconfig_json) |tsconfig| {
-                        if (tsconfig.paths.count() > 0) {
-                            if (r.matchTSConfigPaths(tsconfig, import_path, kind)) |res| {
+            // First, check path overrides from the nearest enclosing TypeScript "tsconfig.json" file
+            if ((r.dirInfoCached(source_dir) catch null)) |_dir_info| {
+                const dir_info: *DirInfo = _dir_info;
+                if (dir_info.enclosing_tsconfig_json) |tsconfig| {
+                    if (tsconfig.paths.count() > 0) {
+                        if (r.matchTSConfigPaths(tsconfig, import_path, kind)) |res| {
 
-                                // We don't set the directory fd here because it might remap an entirely different directory
-                                return Result{
-                                    .path_pair = res.path_pair,
-                                    .diff_case = res.diff_case,
-                                    .package_json = res.package_json,
-                                    .dirname_fd = res.dirname_fd,
-                                    .file_fd = res.file_fd,
-                                };
-                            }
+                            // We don't set the directory fd here because it might remap an entirely different directory
+                            return Result{
+                                .path_pair = res.path_pair,
+                                .diff_case = res.diff_case,
+                                .package_json = res.package_json,
+                                .dirname_fd = res.dirname_fd,
+                                .file_fd = res.file_fd,
+                            };
                         }
                     }
                 }
+            }
 
-                if (r.opts.external.abs_paths.count() > 0 and r.opts.external.abs_paths.contains(import_path)) {
-                    // If the string literal in the source text is an absolute path and has
-                    // been marked as an external module, mark it as *not* an absolute path.
-                    // That way we preserve the literal text in the output and don't generate
-                    // a relative path from the output directory to that path.
-                    if (r.debug_logs) |*debug| {
-                        debug.addNoteFmt("The path \"{s}\" is marked as external by the user", .{import_path}) catch {};
-                    }
-
-                    return Result{
-                        .path_pair = .{ .primary = Path.init(import_path) },
-                        .is_external = true,
-                    };
-                }
-
-                // Run node's resolution rules (e.g. adding ".js")
-                if (r.loadAsFileOrDirectory(import_path, kind)) |entry| {
-                    return Result{
-                        .dirname_fd = entry.dirname_fd,
-                        .path_pair = entry.path_pair,
-                        .diff_case = entry.diff_case,
-                        .package_json = entry.package_json,
-                        .file_fd = entry.file_fd,
-                    };
+            if (r.opts.external.abs_paths.count() > 0 and r.opts.external.abs_paths.contains(import_path)) {
+                // If the string literal in the source text is an absolute path and has
+                // been marked as an external module, mark it as *not* an absolute path.
+                // That way we preserve the literal text in the output and don't generate
+                // a relative path from the output directory to that path.
+                if (r.debug_logs) |*debug| {
+                    debug.addNoteFmt("The path \"{s}\" is marked as external by the user", .{import_path}) catch {};
                 }
 
-                return null;
+                return Result{
+                    .path_pair = .{ .primary = Path.init(import_path) },
+                    .is_external = true,
+                };
             }
 
-            // Check both relative and package paths for CSS URL tokens, with relative
-            // paths taking precedence over package paths to match Webpack behavior.
-            const is_package_path = isPackagePath(import_path);
-            var check_relative = !is_package_path or kind == .url;
-            var check_package = is_package_path;
+            // Run node's resolution rules (e.g. adding ".js")
+            if (r.loadAsFileOrDirectory(import_path, kind)) |entry| {
+                return Result{
+                    .dirname_fd = entry.dirname_fd,
+                    .path_pair = entry.path_pair,
+                    .diff_case = entry.diff_case,
+                    .package_json = entry.package_json,
+                    .file_fd = entry.file_fd,
+                };
+            }
 
-            if (check_relative) {
-                const parts = [_]string{ source_dir, import_path };
-                const abs_path = r.fs.absBuf(&parts, &relative_abs_path_buf);
-
-                if (r.opts.external.abs_paths.count() > 0 and r.opts.external.abs_paths.contains(abs_path)) {
-                    // If the string literal in the source text is an absolute path and has
-                    // been marked as an external module, mark it as *not* an absolute path.
-                    // That way we preserve the literal text in the output and don't generate
-                    // a relative path from the output directory to that path.
-                    if (r.debug_logs) |*debug| {
-                        debug.addNoteFmt("The path \"{s}\" is marked as external by the user", .{abs_path}) catch {};
-                    }
+            return null;
+        }
 
-                    return Result{
-                        .path_pair = .{ .primary = Path.init(r.fs.dirname_store.append(@TypeOf(abs_path), abs_path) catch unreachable) },
-                        .is_external = true,
-                    };
+        // Check both relative and package paths for CSS URL tokens, with relative
+        // paths taking precedence over package paths to match Webpack behavior.
+        const is_package_path = isPackagePath(import_path);
+        var check_relative = !is_package_path or kind == .url;
+        var check_package = is_package_path;
+
+        if (check_relative) {
+            const parts = [_]string{ source_dir, import_path };
+            const abs_path = r.fs.absBuf(&parts, &relative_abs_path_buf);
+
+            if (r.opts.external.abs_paths.count() > 0 and r.opts.external.abs_paths.contains(abs_path)) {
+                // If the string literal in the source text is an absolute path and has
+                // been marked as an external module, mark it as *not* an absolute path.
+                // That way we preserve the literal text in the output and don't generate
+                // a relative path from the output directory to that path.
+                if (r.debug_logs) |*debug| {
+                    debug.addNoteFmt("The path \"{s}\" is marked as external by the user", .{abs_path}) catch {};
                 }
 
-                // Check the "browser" map
-                if (r.dirInfoCached(std.fs.path.dirname(abs_path) orelse unreachable) catch null) |_import_dir_info| {
-                    if (_import_dir_info.getEnclosingBrowserScope()) |import_dir_info| {
-                        const pkg = import_dir_info.package_json.?;
-                        if (r.checkBrowserMap(
-                            import_dir_info,
-                            abs_path,
-                            .AbsolutePath,
-                        )) |remap| {
+                return Result{
+                    .path_pair = .{ .primary = Path.init(r.fs.dirname_store.append(@TypeOf(abs_path), abs_path) catch unreachable) },
+                    .is_external = true,
+                };
+            }
 
-                            // Is the path disabled?
-                            if (remap.len == 0) {
-                                var _path = Path.init(r.fs.dirname_store.append(string, abs_path) catch unreachable);
-                                _path.is_disabled = true;
-                                return Result{
-                                    .path_pair = PathPair{
-                                        .primary = _path,
-                                    },
-                                };
-                            }
+            // Check the "browser" map
+            if (r.dirInfoCached(std.fs.path.dirname(abs_path) orelse unreachable) catch null) |_import_dir_info| {
+                if (_import_dir_info.getEnclosingBrowserScope()) |import_dir_info| {
+                    const pkg = import_dir_info.package_json.?;
+                    if (r.checkBrowserMap(
+                        import_dir_info,
+                        abs_path,
+                        .AbsolutePath,
+                    )) |remap| {
 
-                            if (r.resolveWithoutRemapping(import_dir_info, remap, kind)) |_result| {
-                                result = Result{
-                                    .path_pair = _result.path_pair,
-                                    .diff_case = _result.diff_case,
-                                    .module_type = pkg.module_type,
-                                    .dirname_fd = _result.dirname_fd,
-                                    .package_json = pkg,
-                                };
-                                check_relative = false;
-                                check_package = false;
-                            }
+                        // Is the path disabled?
+                        if (remap.len == 0) {
+                            var _path = Path.init(r.fs.dirname_store.append(string, abs_path) catch unreachable);
+                            _path.is_disabled = true;
+                            return Result{
+                                .path_pair = PathPair{
+                                    .primary = _path,
+                                },
+                            };
+                        }
+
+                        if (r.resolveWithoutRemapping(import_dir_info, remap, kind)) |_result| {
+                            result = Result{
+                                .path_pair = _result.path_pair,
+                                .diff_case = _result.diff_case,
+                                .module_type = pkg.module_type,
+                                .dirname_fd = _result.dirname_fd,
+                                .package_json = pkg,
+                            };
+                            check_relative = false;
+                            check_package = false;
                         }
                     }
                 }
+            }
 
-                if (check_relative) {
-                    if (r.loadAsFileOrDirectory(abs_path, kind)) |res| {
-                        check_package = false;
-                        result = Result{
-                            .path_pair = res.path_pair,
-                            .diff_case = res.diff_case,
-                            .dirname_fd = res.dirname_fd,
-                            .package_json = res.package_json,
-                        };
-                    } else if (!check_package) {
-                        return null;
-                    }
+            if (check_relative) {
+                if (r.loadAsFileOrDirectory(abs_path, kind)) |res| {
+                    check_package = false;
+                    result = Result{
+                        .path_pair = res.path_pair,
+                        .diff_case = res.diff_case,
+                        .dirname_fd = res.dirname_fd,
+                        .package_json = res.package_json,
+                    };
+                } else if (!check_package) {
+                    return null;
                 }
             }
+        }
 
-            if (check_package) {
-                if (r.opts.polyfill_node_globals) {
-                    var import_path_without_node_prefix = import_path;
-                    const had_node_prefix = import_path_without_node_prefix.len > "node:".len and
-                        strings.eqlComptime(import_path_without_node_prefix[0.."node:".len], "node:");
-
-                    import_path_without_node_prefix = if (had_node_prefix)
-                        import_path_without_node_prefix["node:".len..]
-                    else
-                        import_path_without_node_prefix;
-
-                    if (NodeFallbackModules.Map.get(import_path_without_node_prefix)) |*fallback_module| {
-                        result.path_pair.primary = fallback_module.path;
-                        result.module_type = .cjs;
-                        result.package_json = @intToPtr(*PackageJSON, @ptrToInt(fallback_module.package_json));
-                        result.is_from_node_modules = true;
-                        return result;
-                        // "node:*
-                        // "fs"
-                        // "fs/*"
-                        // These are disabled!
-                    } else if (had_node_prefix or
-                        (import_path_without_node_prefix.len >= 2 and strings.eqlComptimeIgnoreLen(import_path_without_node_prefix[0..2], "fs") and
-                        (import_path_without_node_prefix.len == 2 or
-                        import_path_without_node_prefix[3] == '/')))
-                    {
-                        result.path_pair.primary.namespace = "node";
-                        result.path_pair.primary.text = import_path_without_node_prefix;
-                        result.path_pair.primary.name = Fs.PathName.init(import_path_without_node_prefix);
-                        result.module_type = .cjs;
-                        result.path_pair.primary.is_disabled = true;
-                        result.is_from_node_modules = true;
-                        return result;
-                    }
+        if (check_package) {
+            if (r.opts.polyfill_node_globals) {
+                var import_path_without_node_prefix = import_path;
+                const had_node_prefix = import_path_without_node_prefix.len > "node:".len and
+                    strings.eqlComptime(import_path_without_node_prefix[0.."node:".len], "node:");
+
+                import_path_without_node_prefix = if (had_node_prefix)
+                    import_path_without_node_prefix["node:".len..]
+                else
+                    import_path_without_node_prefix;
+
+                if (NodeFallbackModules.Map.get(import_path_without_node_prefix)) |*fallback_module| {
+                    result.path_pair.primary = fallback_module.path;
+                    result.module_type = .cjs;
+                    result.package_json = @intToPtr(*PackageJSON, @ptrToInt(fallback_module.package_json));
+                    result.is_from_node_modules = true;
+                    return result;
+                    // "node:*
+                    // "fs"
+                    // "fs/*"
+                    // These are disabled!
+                } else if (had_node_prefix or
+                    (import_path_without_node_prefix.len >= 2 and strings.eqlComptimeIgnoreLen(import_path_without_node_prefix[0..2], "fs") and
+                    (import_path_without_node_prefix.len == 2 or
+                    import_path_without_node_prefix[3] == '/')))
+                {
+                    result.path_pair.primary.namespace = "node";
+                    result.path_pair.primary.text = import_path_without_node_prefix;
+                    result.path_pair.primary.name = Fs.PathName.init(import_path_without_node_prefix);
+                    result.module_type = .cjs;
+                    result.path_pair.primary.is_disabled = true;
+                    result.is_from_node_modules = true;
+                    return result;
                 }
+            }
 
-                // Check for external packages first
-                if (r.opts.external.node_modules.count() > 0) {
-                    var query = import_path;
-                    while (true) {
-                        if (r.opts.external.node_modules.contains(query)) {
-                            if (r.debug_logs) |*debug| {
-                                debug.addNoteFmt("The path \"{s}\" was marked as external by the user", .{query}) catch {};
-                            }
-                            return Result{
-                                .path_pair = .{ .primary = Path.init(query) },
-                                .is_external = true,
-                            };
+            // Check for external packages first
+            if (r.opts.external.node_modules.count() > 0) {
+                var query = import_path;
+                while (true) {
+                    if (r.opts.external.node_modules.contains(query)) {
+                        if (r.debug_logs) |*debug| {
+                            debug.addNoteFmt("The path \"{s}\" was marked as external by the user", .{query}) catch {};
                         }
-
-                        // If the module "foo" has been marked as external, we also want to treat
-                        // paths into that module such as "foo/bar" as external too.
-                        var slash = strings.lastIndexOfChar(query, '/') orelse break;
-                        query = query[0..slash];
+                        return Result{
+                            .path_pair = .{ .primary = Path.init(query) },
+                            .is_external = true,
+                        };
                     }
+
+                    // If the module "foo" has been marked as external, we also want to treat
+                    // paths into that module such as "foo/bar" as external too.
+                    var slash = strings.lastIndexOfChar(query, '/') orelse break;
+                    query = query[0..slash];
                 }
+            }
 
-                const source_dir_info = (r.dirInfoCached(source_dir) catch null) orelse return null;
+            const source_dir_info = (r.dirInfoCached(source_dir) catch null) orelse return null;
 
-                // Support remapping one package path to another via the "browser" field
-                if (source_dir_info.getEnclosingBrowserScope()) |browser_scope| {
-                    if (browser_scope.package_json) |package_json| {
-                        if (r.checkBrowserMap(
-                            browser_scope,
-                            import_path,
-                            .PackagePath,
-                        )) |remapped| {
-                            if (remapped.len == 0) {
-                                // "browser": {"module": false}
-                                if (r.loadNodeModules(import_path, kind, source_dir_info)) |node_module| {
-                                    var pair = node_module.path_pair;
-                                    pair.primary.is_disabled = true;
-                                    if (pair.secondary != null) {
-                                        pair.secondary.?.is_disabled = true;
-                                    }
-                                    return Result{
-                                        .path_pair = pair,
-                                        .dirname_fd = node_module.dirname_fd,
-                                        .diff_case = node_module.diff_case,
-                                        .package_json = package_json,
-                                    };
+            // Support remapping one package path to another via the "browser" field
+            if (source_dir_info.getEnclosingBrowserScope()) |browser_scope| {
+                if (browser_scope.package_json) |package_json| {
+                    if (r.checkBrowserMap(
+                        browser_scope,
+                        import_path,
+                        .PackagePath,
+                    )) |remapped| {
+                        if (remapped.len == 0) {
+                            // "browser": {"module": false}
+                            if (r.loadNodeModules(import_path, kind, source_dir_info)) |node_module| {
+                                var pair = node_module.path_pair;
+                                pair.primary.is_disabled = true;
+                                if (pair.secondary != null) {
+                                    pair.secondary.?.is_disabled = true;
                                 }
-                            } else {
-                                var primary = Path.init(import_path);
-                                primary.is_disabled = true;
                                 return Result{
-                                    .path_pair = PathPair{ .primary = primary },
-                                    // this might not be null? i think it is
-                                    .diff_case = null,
+                                    .path_pair = pair,
+                                    .dirname_fd = node_module.dirname_fd,
+                                    .diff_case = node_module.diff_case,
+                                    .package_json = package_json,
                                 };
                             }
+                        } else {
+                            var primary = Path.init(import_path);
+                            primary.is_disabled = true;
+                            return Result{
+                                .path_pair = PathPair{ .primary = primary },
+                                // this might not be null? i think it is
+                                .diff_case = null,
+                            };
                         }
                     }
                 }
+            }
 
-                if (r.resolveWithoutRemapping(source_dir_info, import_path, kind)) |res| {
-                    result.path_pair = res.path_pair;
-                    result.dirname_fd = res.dirname_fd;
-                    result.file_fd = res.file_fd;
-                    result.package_json = res.package_json;
-                    result.diff_case = res.diff_case;
-                    result.is_from_node_modules = result.is_from_node_modules or res.is_node_module;
+            if (r.resolveWithoutRemapping(source_dir_info, import_path, kind)) |res| {
+                result.path_pair = res.path_pair;
+                result.dirname_fd = res.dirname_fd;
+                result.file_fd = res.file_fd;
+                result.package_json = res.package_json;
+                result.diff_case = res.diff_case;
+                result.is_from_node_modules = result.is_from_node_modules or res.is_node_module;
 
-                    if (res.path_pair.primary.is_disabled and res.path_pair.secondary == null) {
-                        return result;
-                    }
+                if (res.path_pair.primary.is_disabled and res.path_pair.secondary == null) {
+                    return result;
+                }
 
-                    if (res.package_json) |pkg| {
-                        var base_dir_info = res.dir_info orelse (r.readDirInfo(res.path_pair.primary.name.dir) catch null) orelse return result;
-                        if (base_dir_info.getEnclosingBrowserScope()) |browser_scope| {
-                            if (r.checkBrowserMap(
-                                browser_scope,
-                                res.path_pair.primary.text,
-                                .AbsolutePath,
-                            )) |remap| {
-                                if (remap.len == 0) {
-                                    result.path_pair.primary.is_disabled = true;
-                                    result.path_pair.primary = Fs.Path.initWithNamespace(remap, "file");
-                                } else {
-                                    if (r.resolveWithoutRemapping(base_dir_info, remap, kind)) |remapped| {
-                                        result.path_pair = remapped.path_pair;
-                                        result.dirname_fd = remapped.dirname_fd;
-                                        result.file_fd = remapped.file_fd;
-                                        result.package_json = remapped.package_json;
-                                        result.diff_case = remapped.diff_case;
-                                        result.is_from_node_modules = result.is_from_node_modules or remapped.is_node_module;
-                                        return result;
-                                    }
+                if (res.package_json) |pkg| {
+                    var base_dir_info = res.dir_info orelse (r.readDirInfo(res.path_pair.primary.name.dir) catch null) orelse return result;
+                    if (base_dir_info.getEnclosingBrowserScope()) |browser_scope| {
+                        if (r.checkBrowserMap(
+                            browser_scope,
+                            res.path_pair.primary.text,
+                            .AbsolutePath,
+                        )) |remap| {
+                            if (remap.len == 0) {
+                                result.path_pair.primary.is_disabled = true;
+                                result.path_pair.primary = Fs.Path.initWithNamespace(remap, "file");
+                            } else {
+                                if (r.resolveWithoutRemapping(base_dir_info, remap, kind)) |remapped| {
+                                    result.path_pair = remapped.path_pair;
+                                    result.dirname_fd = remapped.dirname_fd;
+                                    result.file_fd = remapped.file_fd;
+                                    result.package_json = remapped.package_json;
+                                    result.diff_case = remapped.diff_case;
+                                    result.is_from_node_modules = result.is_from_node_modules or remapped.is_node_module;
+                                    return result;
                                 }
                             }
                         }
                     }
-
-                    return result;
-                } else {
-                    // Note: node's "self references" are not currently supported
-                    return null;
                 }
-            }
 
-            return result;
+                return result;
+            } else {
+                // Note: node's "self references" are not currently supported
+                return null;
+            }
         }
 
-        pub fn packageJSONForResolvedNodeModule(
-            r: *ThisResolver,
-            result: *const Result,
-        ) ?*const PackageJSON {
-            return @call(.{ .modifier = .always_inline }, packageJSONForResolvedNodeModuleWithIgnoreMissingName, .{ r, result, true });
-        }
+        return result;
+    }
 
-        // This is a fallback, hopefully not called often. It should be relatively quick because everything should be in the cache.
-        fn packageJSONForResolvedNodeModuleWithIgnoreMissingName(
-            r: *ThisResolver,
-            result: *const Result,
-            comptime ignore_missing_name: bool,
-        ) ?*const PackageJSON {
-            var dir_info = (r.dirInfoCached(result.path_pair.primary.name.dir) catch null) orelse return null;
-            while (true) {
-                if (dir_info.package_json) |pkg| {
-                    // if it doesn't have a name, assume it's something just for adjusting the main fields (react-bootstrap does this)
-                    // In that case, we really would like the top-level package that you download from NPM
-                    // so we ignore any unnamed packages
-                    if (comptime !ignore_missing_name) {
-                        if (pkg.name.len > 0) {
-                            return pkg;
-                        }
-                    } else {
+    pub fn packageJSONForResolvedNodeModule(
+        r: *ThisResolver,
+        result: *const Result,
+    ) ?*const PackageJSON {
+        return @call(.{ .modifier = .always_inline }, packageJSONForResolvedNodeModuleWithIgnoreMissingName, .{ r, result, true });
+    }
+
+    // This is a fallback, hopefully not called often. It should be relatively quick because everything should be in the cache.
+    fn packageJSONForResolvedNodeModuleWithIgnoreMissingName(
+        r: *ThisResolver,
+        result: *const Result,
+        comptime ignore_missing_name: bool,
+    ) ?*const PackageJSON {
+        var dir_info = (r.dirInfoCached(result.path_pair.primary.name.dir) catch null) orelse return null;
+        while (true) {
+            if (dir_info.package_json) |pkg| {
+                // if it doesn't have a name, assume it's something just for adjusting the main fields (react-bootstrap does this)
+                // In that case, we really would like the top-level package that you download from NPM
+                // so we ignore any unnamed packages
+                if (comptime !ignore_missing_name) {
+                    if (pkg.name.len > 0) {
                         return pkg;
                     }
+                } else {
+                    return pkg;
                 }
-
-                dir_info = dir_info.getParent() orelse return null;
             }
 
-            unreachable;
+            dir_info = dir_info.getParent() orelse return null;
         }
-        const node_module_root_string = std.fs.path.sep_str ++ "node_modules" ++ std.fs.path.sep_str;
-
-        pub fn rootNodeModulePackageJSON(
-            r: *ThisResolver,
-            result: *const Result,
-        ) ?RootPathPair {
-            const path = (result.pathConst() orelse return null);
-            var absolute = path.text;
-            // /foo/node_modules/@babel/standalone/index.js
-            //     ^------------^
-            var end = strings.lastIndexOf(absolute, node_module_root_string) orelse brk: {
-                // try non-symlinked version
-                if (path.pretty.len != absolute.len) {
-                    absolute = path.pretty;
-                    break :brk strings.lastIndexOf(absolute, node_module_root_string);
-                }
 
-                break :brk null;
-            } orelse return null;
-            end += node_module_root_string.len;
-
-            const is_scoped_package = absolute[end] == '@';
+        unreachable;
+    }
+    const node_module_root_string = std.fs.path.sep_str ++ "node_modules" ++ std.fs.path.sep_str;
+
+    pub fn rootNodeModulePackageJSON(
+        r: *ThisResolver,
+        result: *const Result,
+    ) ?RootPathPair {
+        const path = (result.pathConst() orelse return null);
+        var absolute = path.text;
+        // /foo/node_modules/@babel/standalone/index.js
+        //     ^------------^
+        var end = strings.lastIndexOf(absolute, node_module_root_string) orelse brk: {
+            // try non-symlinked version
+            if (path.pretty.len != absolute.len) {
+                absolute = path.pretty;
+                break :brk strings.lastIndexOf(absolute, node_module_root_string);
+            }
+
+            break :brk null;
+        } orelse return null;
+        end += node_module_root_string.len;
+
+        const is_scoped_package = absolute[end] == '@';
+        end += strings.indexOfChar(absolute[end..], std.fs.path.sep) orelse return null;
+
+        // /foo/node_modules/@babel/standalone/index.js
+        //                   ^
+        if (is_scoped_package) {
+            end += 1;
             end += strings.indexOfChar(absolute[end..], std.fs.path.sep) orelse return null;
+        }
 
-            // /foo/node_modules/@babel/standalone/index.js
-            //                   ^
-            if (is_scoped_package) {
-                end += 1;
-                end += strings.indexOfChar(absolute[end..], std.fs.path.sep) orelse return null;
-            }
-
-            end += 1;
+        end += 1;
 
-            // /foo/node_modules/@babel/standalone/index.js
-            //                                    ^
-            const slice = absolute[0..end];
-
-            // Try to avoid the hash table lookup whenever possible
-            // That can cause filesystem lookups in parent directories and it requires a lock
-            if (result.package_json) |pkg| {
-                if (strings.eql(slice, pkg.source.path.name.dirWithTrailingSlash())) {
-                    return RootPathPair{
-                        .package_json = pkg,
-                        .base_path = slice,
-                    };
-                }
-            }
+        // /foo/node_modules/@babel/standalone/index.js
+        //                                    ^
+        const slice = absolute[0..end];
 
-            {
-                var dir_info = (r.dirInfoCached(slice) catch null) orelse return null;
+        // Try to avoid the hash table lookup whenever possible
+        // That can cause filesystem lookups in parent directories and it requires a lock
+        if (result.package_json) |pkg| {
+            if (strings.eql(slice, pkg.source.path.name.dirWithTrailingSlash())) {
                 return RootPathPair{
+                    .package_json = pkg,
                     .base_path = slice,
-                    .package_json = dir_info.package_json.?,
                 };
             }
         }
 
-        threadlocal var esm_subpath_buf: [512]u8 = undefined;
-        threadlocal var esm_absolute_package_path: [std.fs.MAX_PATH_BYTES]u8 = undefined;
-        threadlocal var esm_absolute_package_path_joined: [std.fs.MAX_PATH_BYTES]u8 = undefined;
-        pub fn loadNodeModules(r: *ThisResolver, import_path: string, kind: ast.ImportKind, _dir_info: *DirInfo) ?MatchResult {
-            var dir_info = _dir_info;
+        {
+            var dir_info = (r.dirInfoCached(slice) catch null) orelse return null;
+            return RootPathPair{
+                .base_path = slice,
+                .package_json = dir_info.package_json.?,
+            };
+        }
+    }
+
+    threadlocal var esm_subpath_buf: [512]u8 = undefined;
+    threadlocal var esm_absolute_package_path: [std.fs.MAX_PATH_BYTES]u8 = undefined;
+    threadlocal var esm_absolute_package_path_joined: [std.fs.MAX_PATH_BYTES]u8 = undefined;
+    pub fn loadNodeModules(r: *ThisResolver, import_path: string, kind: ast.ImportKind, _dir_info: *DirInfo) ?MatchResult {
+        var dir_info = _dir_info;
+        if (r.debug_logs) |*debug| {
+            debug.addNoteFmt("Searching for {s} in \"node_modules\" directories starting from \"{s}\"", .{ import_path, dir_info.abs_path }) catch {};
+            debug.increaseIndent() catch {};
+        }
+
+        defer {
             if (r.debug_logs) |*debug| {
-                debug.addNoteFmt("Searching for {s} in \"node_modules\" directories starting from \"{s}\"", .{ import_path, dir_info.abs_path }) catch {};
-                debug.increaseIndent() catch {};
+                debug.decreaseIndent() catch {};
             }
+        }
 
-            defer {
-                if (r.debug_logs) |*debug| {
-                    debug.decreaseIndent() catch {};
+        // First, check path overrides from the nearest enclosing TypeScript "tsconfig.json" file
+
+        if (dir_info.enclosing_tsconfig_json) |tsconfig| {
+            // Try path substitutions first
+            if (tsconfig.paths.count() > 0) {
+                if (r.matchTSConfigPaths(tsconfig, import_path, kind)) |res| {
+                    return res;
                 }
             }
 
-            // First, check path overrides from the nearest enclosing TypeScript "tsconfig.json" file
+            // Try looking up the path relative to the base URL
+            if (tsconfig.hasBaseURL()) {
+                const base = tsconfig.base_url;
+                const paths = [_]string{ base, import_path };
+                const abs = r.fs.absBuf(&paths, &load_as_file_or_directory_via_tsconfig_base_path);
 
-            if (dir_info.enclosing_tsconfig_json) |tsconfig| {
-                // Try path substitutions first
-                if (tsconfig.paths.count() > 0) {
-                    if (r.matchTSConfigPaths(tsconfig, import_path, kind)) |res| {
-                        return res;
-                    }
+                if (r.loadAsFileOrDirectory(abs, kind)) |res| {
+                    return res;
                 }
+                // r.allocator.free(abs);
+            }
+        }
 
-                // Try looking up the path relative to the base URL
-                if (tsconfig.hasBaseURL()) {
-                    const base = tsconfig.base_url;
-                    const paths = [_]string{ base, import_path };
-                    const abs = r.fs.absBuf(&paths, &load_as_file_or_directory_via_tsconfig_base_path);
+        const esm_ = ESModule.Package.parse(import_path, &esm_subpath_buf);
 
-                    if (r.loadAsFileOrDirectory(abs, kind)) |res| {
-                        return res;
-                    }
-                    // r.allocator.free(abs);
+        // Then check for the package in any enclosing "node_modules" directories
+        while (true) {
+            // Skip directories that are themselves called "node_modules", since we
+            // don't ever want to search for "node_modules/node_modules"
+            if (dir_info.has_node_modules) {
+                var _paths = [_]string{ dir_info.abs_path, "node_modules", import_path };
+                const abs_path = r.fs.absBuf(&_paths, &node_modules_check_buf);
+                if (r.debug_logs) |*debug| {
+                    debug.addNoteFmt("Checking for a package in the directory \"{s}\"", .{abs_path}) catch {};
                 }
-            }
 
-            const esm_ = ESModule.Package.parse(import_path, &esm_subpath_buf);
-
-            // Then check for the package in any enclosing "node_modules" directories
-            while (true) {
-                // Skip directories that are themselves called "node_modules", since we
-                // don't ever want to search for "node_modules/node_modules"
-                if (dir_info.has_node_modules) {
-                    var _paths = [_]string{ dir_info.abs_path, "node_modules", import_path };
-                    const abs_path = r.fs.absBuf(&_paths, &node_modules_check_buf);
-                    if (r.debug_logs) |*debug| {
-                        debug.addNoteFmt("Checking for a package in the directory \"{s}\"", .{abs_path}) catch {};
-                    }
+                if (esm_) |esm| {
+                    const abs_package_path = brk: {
+                        var parts = [_]string{ dir_info.abs_path, "node_modules", esm.name };
+                        break :brk r.fs.absBuf(&parts, &esm_absolute_package_path);
+                    };
 
-                    if (esm_) |esm| {
-                        const abs_package_path = brk: {
-                            var parts = [_]string{ dir_info.abs_path, "node_modules", esm.name };
-                            break :brk r.fs.absBuf(&parts, &esm_absolute_package_path);
-                        };
+                    if (r.dirInfoCached(abs_package_path) catch null) |pkg_dir_info| {
+                        if (pkg_dir_info.package_json) |package_json| {
+                            if (package_json.exports) |exports_map| {
 
-                        if (r.dirInfoCached(abs_package_path) catch null) |pkg_dir_info| {
-                            if (pkg_dir_info.package_json) |package_json| {
-                                if (package_json.exports) |exports_map| {
+                                // The condition set is determined by the kind of import
 
-                                    // The condition set is determined by the kind of import
+                                const esmodule = ESModule{
+                                    .conditions = switch (kind) {
+                                        ast.ImportKind.stmt, ast.ImportKind.dynamic => r.opts.conditions.import,
+                                        ast.ImportKind.require, ast.ImportKind.require_resolve => r.opts.conditions.require,
+                                        else => r.opts.conditions.default,
+                                    },
+                                    .allocator = r.allocator,
+                                    .debug_logs = if (r.debug_logs) |*debug| debug else null,
+                                };
 
-                                    const esmodule = ESModule{
-                                        .conditions = switch (kind) {
-                                            ast.ImportKind.stmt, ast.ImportKind.dynamic => r.opts.conditions.import,
-                                            ast.ImportKind.require, ast.ImportKind.require_resolve => r.opts.conditions.require,
-                                            else => r.opts.conditions.default,
-                                        },
-                                        .allocator = r.allocator,
-                                        .debug_logs = if (r.debug_logs) |*debug| debug else null,
+                                // Resolve against the path "/", then join it with the absolute
+                                // directory path. This is done because ESM package resolution uses
+                                // URLs while our path resolution uses file system paths. We don't
+                                // want problems due to Windows paths, which are very unlike URL
+                                // paths. We also want to avoid any "%" characters in the absolute
+                                // directory path accidentally being interpreted as URL escapes.
+                                var esm_resolution = esmodule.resolve("/", esm.subpath, exports_map.root);
+
+                                if ((esm_resolution.status == .Inexact or esm_resolution.status == .Exact) and strings.startsWith(esm_resolution.path, "/")) {
+                                    const abs_esm_path: string = brk: {
+                                        var parts = [_]string{
+                                            abs_package_path,
+                                            esm_resolution.path[1..],
+                                        };
+                                        break :brk r.fs.absBuf(&parts, &esm_absolute_package_path_joined);
                                     };
 
-                                    // Resolve against the path "/", then join it with the absolute
-                                    // directory path. This is done because ESM package resolution uses
-                                    // URLs while our path resolution uses file system paths. We don't
-                                    // want problems due to Windows paths, which are very unlike URL
-                                    // paths. We also want to avoid any "%" characters in the absolute
-                                    // directory path accidentally being interpreted as URL escapes.
-                                    var esm_resolution = esmodule.resolve("/", esm.subpath, exports_map.root);
-
-                                    if ((esm_resolution.status == .Inexact or esm_resolution.status == .Exact) and strings.startsWith(esm_resolution.path, "/")) {
-                                        const abs_esm_path: string = brk: {
-                                            var parts = [_]string{
-                                                abs_package_path,
-                                                esm_resolution.path[1..],
+                                    switch (esm_resolution.status) {
+                                        .Exact => {
+                                            const resolved_dir_info = (r.dirInfoCached(std.fs.path.dirname(abs_esm_path).?) catch null) orelse {
+                                                esm_resolution.status = .ModuleNotFound;
+                                                return null;
+                                            };
+                                            const entries = resolved_dir_info.getEntries() orelse {
+                                                esm_resolution.status = .ModuleNotFound;
+                                                return null;
+                                            };
+                                            const entry_query = entries.get(std.fs.path.basename(abs_esm_path)) orelse {
+                                                esm_resolution.status = .ModuleNotFound;
+                                                return null;
                                             };
-                                            break :brk r.fs.absBuf(&parts, &esm_absolute_package_path_joined);
-                                        };
 
-                                        switch (esm_resolution.status) {
-                                            .Exact => {
-                                                const resolved_dir_info = (r.dirInfoCached(std.fs.path.dirname(abs_esm_path).?) catch null) orelse {
-                                                    esm_resolution.status = .ModuleNotFound;
-                                                    return null;
-                                                };
-                                                const entries = resolved_dir_info.getEntries() orelse {
-                                                    esm_resolution.status = .ModuleNotFound;
-                                                    return null;
-                                                };
-                                                const entry_query = entries.get(std.fs.path.basename(abs_esm_path)) orelse {
-                                                    esm_resolution.status = .ModuleNotFound;
-                                                    return null;
-                                                };
-
-                                                if (entry_query.entry.kind(&r.fs.fs) == .dir) {
-                                                    esm_resolution.status = .UnsupportedDirectoryImport;
-                                                    return null;
-                                                }
+                                            if (entry_query.entry.kind(&r.fs.fs) == .dir) {
+                                                esm_resolution.status = .UnsupportedDirectoryImport;
+                                                return null;
+                                            }
 
-                                                const absolute_out_path = brk: {
-                                                    if (entry_query.entry.abs_path.isEmpty()) {
-                                                        entry_query.entry.abs_path =
-                                                            PathString.init(r.fs.dirname_store.append(@TypeOf(abs_esm_path), abs_esm_path) catch unreachable);
-                                                    }
-                                                    break :brk entry_query.entry.abs_path.slice();
-                                                };
-
-                                                return MatchResult{
-                                                    .path_pair = PathPair{
-                                                        .primary = Path.initWithNamespace(absolute_out_path, "file"),
-                                                    },
-                                                    .dirname_fd = entries.fd,
-                                                    .file_fd = entry_query.entry.cache.fd,
-                                                    .dir_info = resolved_dir_info,
-                                                    .diff_case = entry_query.diff_case,
-                                                    .is_node_module = true,
-                                                    .package_json = resolved_dir_info.package_json orelse package_json,
-                                                };
-                                            },
-                                            .Inexact => {
-                                                // If this was resolved against an expansion key ending in a "/"
-                                                // instead of a "*", we need to try CommonJS-style implicit
-                                                // extension and/or directory detection.
-                                                if (r.loadAsFileOrDirectory(abs_esm_path, kind)) |*res| {
-                                                    res.is_node_module = true;
-                                                    res.package_json = res.package_json orelse package_json;
-                                                    return res.*;
+                                            const absolute_out_path = brk: {
+                                                if (entry_query.entry.abs_path.isEmpty()) {
+                                                    entry_query.entry.abs_path =
+                                                        PathString.init(r.fs.dirname_store.append(@TypeOf(abs_esm_path), abs_esm_path) catch unreachable);
                                                 }
-                                                esm_resolution.status = .ModuleNotFound;
-                                                return null;
-                                            },
-                                            else => unreachable,
-                                        }
+                                                break :brk entry_query.entry.abs_path.slice();
+                                            };
+
+                                            return MatchResult{
+                                                .path_pair = PathPair{
+                                                    .primary = Path.initWithNamespace(absolute_out_path, "file"),
+                                                },
+                                                .dirname_fd = entries.fd,
+                                                .file_fd = entry_query.entry.cache.fd,
+                                                .dir_info = resolved_dir_info,
+                                                .diff_case = entry_query.diff_case,
+                                                .is_node_module = true,
+                                                .package_json = resolved_dir_info.package_json orelse package_json,
+                                            };
+                                        },
+                                        .Inexact => {
+                                            // If this was resolved against an expansion key ending in a "/"
+                                            // instead of a "*", we need to try CommonJS-style implicit
+                                            // extension and/or directory detection.
+                                            if (r.loadAsFileOrDirectory(abs_esm_path, kind)) |*res| {
+                                                res.is_node_module = true;
+                                                res.package_json = res.package_json orelse package_json;
+                                                return res.*;
+                                            }
+                                            esm_resolution.status = .ModuleNotFound;
+                                            return null;
+                                        },
+                                        else => unreachable,
                                     }
                                 }
                             }
                         }
                     }
-
-                    if (r.loadAsFileOrDirectory(abs_path, kind)) |res| {
-                        return res;
-                    }
-                    // r.allocator.free(abs_path);
                 }
 
-                dir_info = dir_info.getParent() orelse break;
+                if (r.loadAsFileOrDirectory(abs_path, kind)) |res| {
+                    return res;
+                }
+                // r.allocator.free(abs_path);
             }
 
-            // Mostly to cut scope, we don't resolve `NODE_PATH` environment variable.
-            // But also: https://github.com/nodejs/node/issues/38128#issuecomment-814969356
-
-            return null;
+            dir_info = dir_info.getParent() orelse break;
         }
 
-        pub fn resolveWithoutRemapping(r: *ThisResolver, source_dir_info: *DirInfo, import_path: string, kind: ast.ImportKind) ?MatchResult {
-            if (isPackagePath(import_path)) {
-                return r.loadNodeModules(import_path, kind, source_dir_info);
-            } else {
-                const paths = [_]string{ source_dir_info.abs_path, import_path };
-                var resolved = r.fs.absBuf(&paths, &resolve_without_remapping_buf);
-                return r.loadAsFileOrDirectory(resolved, kind);
-            }
-        }
-
-        pub fn parseTSConfig(
-            r: *ThisResolver,
-            file: string,
-            dirname_fd: StoredFileDescriptorType,
-        ) !?*TSConfigJSON {
-            const entry = try r.caches.fs.readFile(
-                r.fs,
-                file,
-                dirname_fd,
-                false,
-                null,
-            );
-            const key_path = Path.init(file);
-
-            const source = logger.Source.initPathString(key_path.text, entry.contents);
-            const file_dir = source.path.sourceDir();
+        // Mostly to cut scope, we don't resolve `NODE_PATH` environment variable.
+        // But also: https://github.com/nodejs/node/issues/38128#issuecomment-814969356
 
-            var result = (try TSConfigJSON.parse(r.allocator, r.log, source, @TypeOf(r.caches.json), &r.caches.json)) orelse return null;
+        return null;
+    }
 
-            if (result.hasBaseURL()) {
-                // this might leak
-                if (!std.fs.path.isAbsolute(result.base_url)) {
-                    const paths = [_]string{ file_dir, result.base_url };
-                    result.base_url = r.fs.dirname_store.append(string, r.fs.absBuf(&paths, &tsconfig_base_url_buf)) catch unreachable;
-                }
-            }
+    pub fn resolveWithoutRemapping(r: *ThisResolver, source_dir_info: *DirInfo, import_path: string, kind: ast.ImportKind) ?MatchResult {
+        if (isPackagePath(import_path)) {
+            return r.loadNodeModules(import_path, kind, source_dir_info);
+        } else {
+            const paths = [_]string{ source_dir_info.abs_path, import_path };
+            var resolved = r.fs.absBuf(&paths, &resolve_without_remapping_buf);
+            return r.loadAsFileOrDirectory(resolved, kind);
+        }
+    }
 
-            if (result.paths.count() > 0 and (result.base_url_for_paths.len == 0 or !std.fs.path.isAbsolute(result.base_url_for_paths))) {
-                // this might leak
+    pub fn parseTSConfig(
+        r: *ThisResolver,
+        file: string,
+        dirname_fd: StoredFileDescriptorType,
+    ) !?*TSConfigJSON {
+        const entry = try r.caches.fs.readFile(
+            r.fs,
+            file,
+            dirname_fd,
+            false,
+            null,
+        );
+        const key_path = Path.init(file);
+
+        const source = logger.Source.initPathString(key_path.text, entry.contents);
+        const file_dir = source.path.sourceDir();
+
+        var result = (try TSConfigJSON.parse(r.allocator, r.log, source, @TypeOf(r.caches.json), &r.caches.json)) orelse return null;
+
+        if (result.hasBaseURL()) {
+            // this might leak
+            if (!std.fs.path.isAbsolute(result.base_url)) {
                 const paths = [_]string{ file_dir, result.base_url };
-                result.base_url_for_paths = r.fs.dirname_store.append(string, r.fs.absBuf(&paths, &tsconfig_base_url_buf)) catch unreachable;
+                result.base_url = r.fs.dirname_store.append(string, r.fs.absBuf(&paths, &tsconfig_base_url_buf)) catch unreachable;
             }
-
-            return result;
         }
 
-        // TODO:
-        pub fn prettyPath(r: *ThisResolver, path: Path) string {
-            return path.text;
+        if (result.paths.count() > 0 and (result.base_url_for_paths.len == 0 or !std.fs.path.isAbsolute(result.base_url_for_paths))) {
+            // this might leak
+            const paths = [_]string{ file_dir, result.base_url };
+            result.base_url_for_paths = r.fs.dirname_store.append(string, r.fs.absBuf(&paths, &tsconfig_base_url_buf)) catch unreachable;
         }
 
-        pub fn parsePackageJSON(r: *ThisResolver, file: string, dirname_fd: StoredFileDescriptorType) !?*PackageJSON {
-            if (!cache_files or r.opts.node_modules_bundle != null) {
-                const pkg = PackageJSON.parse(ThisResolver, r, file, dirname_fd, true) orelse return null;
-                var _pkg = try r.allocator.create(PackageJSON);
-                _pkg.* = pkg;
-                return _pkg;
-            } else {
-                const pkg = PackageJSON.parse(ThisResolver, r, file, dirname_fd, false) orelse return null;
-                var _pkg = try r.allocator.create(PackageJSON);
-                _pkg.* = pkg;
-                return _pkg;
-            }
-        }
+        return result;
+    }
 
-        fn dirInfoCached(
-            r: *ThisResolver,
-            path: string,
-        ) !?*DirInfo {
-            return try r.dirInfoCachedMaybeLog(path, true, true);
-        }
+    // TODO:
+    pub fn prettyPath(r: *ThisResolver, path: Path) string {
+        return path.text;
+    }
 
-        pub fn readDirInfo(
-            r: *ThisResolver,
-            path: string,
-        ) !?*DirInfo {
-            return try r.dirInfoCachedMaybeLog(path, false, true);
-        }
+    pub fn parsePackageJSON(r: *ThisResolver, file: string, dirname_fd: StoredFileDescriptorType) !?*PackageJSON {
+        const pkg = PackageJSON.parse(ThisResolver, r, file, dirname_fd, true) orelse return null;
+        var _pkg = try r.allocator.create(PackageJSON);
+        _pkg.* = pkg;
+        return _pkg;
+    }
 
-        pub fn readDirInfoIgnoreError(
-            r: *ThisResolver,
-            path: string,
-        ) ?*const DirInfo {
-            return r.dirInfoCachedMaybeLog(path, false, true) catch null;
-        }
+    fn dirInfoCached(
+        r: *ThisResolver,
+        path: string,
+    ) !?*DirInfo {
+        return try r.dirInfoCachedMaybeLog(path, true, true);
+    }
 
-        pub inline fn readDirInfoCacheOnly(
-            r: *ThisResolver,
-            path: string,
-        ) ?*DirInfo {
-            return r.dir_cache.get(path);
-        }
+    pub fn readDirInfo(
+        r: *ThisResolver,
+        path: string,
+    ) !?*DirInfo {
+        return try r.dirInfoCachedMaybeLog(path, false, true);
+    }
+
+    pub fn readDirInfoIgnoreError(
+        r: *ThisResolver,
+        path: string,
+    ) ?*const DirInfo {
+        return r.dirInfoCachedMaybeLog(path, false, true) catch null;
+    }
 
-        inline fn dirInfoCachedMaybeLog(r: *ThisResolver, __path: string, comptime enable_logging: bool, comptime follow_symlinks: bool) !?*DirInfo {
-            r.mutex.lock();
-            defer r.mutex.unlock();
-            var _path = __path;
-            if (strings.eqlComptime(_path, "./") or strings.eqlComptime(_path, "."))
-                _path = r.fs.top_level_dir;
+    pub inline fn readDirInfoCacheOnly(
+        r: *ThisResolver,
+        path: string,
+    ) ?*DirInfo {
+        return r.dir_cache.get(path);
+    }
 
-            const top_result = try r.dir_cache.getOrPut(_path);
-            if (top_result.status != .unknown) {
-                return r.dir_cache.atIndex(top_result.index);
-            }
+    inline fn dirInfoCachedMaybeLog(r: *ThisResolver, __path: string, comptime enable_logging: bool, comptime follow_symlinks: bool) !?*DirInfo {
+        r.mutex.lock();
+        defer r.mutex.unlock();
+        var _path = __path;
+        if (strings.eqlComptime(_path, "./") or strings.eqlComptime(_path, "."))
+            _path = r.fs.top_level_dir;
 
-            var i: i32 = 1;
-            std.mem.copy(u8, &dir_info_uncached_path_buf, _path);
-            var path = dir_info_uncached_path_buf[0.._path.len];
+        const top_result = try r.dir_cache.getOrPut(_path);
+        if (top_result.status != .unknown) {
+            return r.dir_cache.atIndex(top_result.index);
+        }
+
+        var i: i32 = 1;
+        std.mem.copy(u8, &dir_info_uncached_path_buf, _path);
+        var path = dir_info_uncached_path_buf[0.._path.len];
 
-            _dir_entry_paths_to_resolve[0] = (DirEntryResolveQueueItem{ .result = top_result, .unsafe_path = path, .safe_path = "" });
-            var top = Dirname.dirname(path);
+        _dir_entry_paths_to_resolve[0] = (DirEntryResolveQueueItem{ .result = top_result, .unsafe_path = path, .safe_path = "" });
+        var top = Dirname.dirname(path);
 
-            var top_parent: allocators.Result = allocators.Result{
-                .index = allocators.NotFound,
-                .hash = 0,
-                .status = .not_found,
+        var top_parent: allocators.Result = allocators.Result{
+            .index = allocators.NotFound,
+            .hash = 0,
+            .status = .not_found,
+        };
+        const root_path = if (comptime isWindows)
+            std.fs.path.diskDesignator(path)
+        else
+            // we cannot just use "/"
+            // we will write to the buffer past the ptr len so it must be a non-const buffer
+            path[0..1];
+        var rfs: *Fs.FileSystem.RealFS = &r.fs.fs;
+
+        rfs.entries_mutex.lock();
+        defer rfs.entries_mutex.unlock();
+
+        while (!strings.eql(top, root_path)) : (top = Dirname.dirname(top)) {
+            var result = try r.dir_cache.getOrPut(top);
+            if (result.status != .unknown) {
+                top_parent = result;
+                break;
+            }
+            _dir_entry_paths_to_resolve[@intCast(usize, i)] = DirEntryResolveQueueItem{
+                .unsafe_path = top,
+                .result = result,
+                .fd = 0,
             };
-            const root_path = if (comptime isWindows)
-                std.fs.path.diskDesignator(path)
-            else
-                // we cannot just use "/"
-                // we will write to the buffer past the ptr len so it must be a non-const buffer
-                path[0..1];
-            var rfs: *Fs.FileSystem.RealFS = &r.fs.fs;
-
-            rfs.entries_mutex.lock();
-            defer rfs.entries_mutex.unlock();
-
-            while (!strings.eql(top, root_path)) : (top = Dirname.dirname(top)) {
-                var result = try r.dir_cache.getOrPut(top);
-                if (result.status != .unknown) {
-                    top_parent = result;
-                    break;
-                }
+
+            if (rfs.entries.get(top)) |top_entry| {
+                _dir_entry_paths_to_resolve[@intCast(usize, i)].safe_path = top_entry.entries.dir;
+                _dir_entry_paths_to_resolve[@intCast(usize, i)].fd = top_entry.entries.fd;
+            }
+            i += 1;
+        }
+
+        if (strings.eql(top, root_path)) {
+            var result = try r.dir_cache.getOrPut(root_path);
+            if (result.status != .unknown) {
+                top_parent = result;
+            } else {
                 _dir_entry_paths_to_resolve[@intCast(usize, i)] = DirEntryResolveQueueItem{
-                    .unsafe_path = top,
+                    .unsafe_path = root_path,
                     .result = result,
                     .fd = 0,
                 };
-
                 if (rfs.entries.get(top)) |top_entry| {
                     _dir_entry_paths_to_resolve[@intCast(usize, i)].safe_path = top_entry.entries.dir;
                     _dir_entry_paths_to_resolve[@intCast(usize, i)].fd = top_entry.entries.fd;
                 }
-                i += 1;
-            }
-
-            if (strings.eql(top, root_path)) {
-                var result = try r.dir_cache.getOrPut(root_path);
-                if (result.status != .unknown) {
-                    top_parent = result;
-                } else {
-                    _dir_entry_paths_to_resolve[@intCast(usize, i)] = DirEntryResolveQueueItem{
-                        .unsafe_path = root_path,
-                        .result = result,
-                        .fd = 0,
-                    };
-                    if (rfs.entries.get(top)) |top_entry| {
-                        _dir_entry_paths_to_resolve[@intCast(usize, i)].safe_path = top_entry.entries.dir;
-                        _dir_entry_paths_to_resolve[@intCast(usize, i)].fd = top_entry.entries.fd;
-                    }
 
-                    i += 1;
-                }
+                i += 1;
             }
+        }
 
-            var queue_slice: []DirEntryResolveQueueItem = _dir_entry_paths_to_resolve[0..@intCast(usize, i)];
-            std.debug.assert(queue_slice.len > 0);
-            var open_dir_count: usize = 0;
+        var queue_slice: []DirEntryResolveQueueItem = _dir_entry_paths_to_resolve[0..@intCast(usize, i)];
+        std.debug.assert(queue_slice.len > 0);
+        var open_dir_count: usize = 0;
 
-            // When this function halts, any item not processed means it's not found.
-            defer {
+        // When this function halts, any item not processed means it's not found.
+        defer {
 
-                // Anything
-                if (open_dir_count > 0 and r.fs.fs.needToCloseFiles()) {
-                    var open_dirs: []std.fs.Dir = _open_dirs[0..open_dir_count];
-                    for (open_dirs) |*open_dir| {
-                        open_dir.close();
-                    }
+            // Anything
+            if (open_dir_count > 0 and r.fs.fs.needToCloseFiles()) {
+                var open_dirs: []std.fs.Dir = _open_dirs[0..open_dir_count];
+                for (open_dirs) |*open_dir| {
+                    open_dir.close();
                 }
             }
+        }
 
-            // We want to walk in a straight line from the topmost directory to the desired directory
-            // For each directory we visit, we get the entries, but not traverse into child directories
-            // (unless those child directores are in the queue)
-            // We go top-down instead of bottom-up to increase odds of reusing previously open file handles
-            // "/home/jarred/Code/node_modules/react/cjs/react.development.js"
-            //       ^
-            // If we start there, we will traverse all of /home/jarred, including e.g. /home/jarred/Downloads
-            // which is completely irrelevant.
-
-            // After much experimentation...
-            // - fts_open is not the fastest way to read directories. fts actually just uses readdir!!
-            // - remember
-            var _safe_path: ?string = null;
-
-            // Start at the top.
-            while (queue_slice.len > 0) {
-                var queue_top = queue_slice[queue_slice.len - 1];
-                defer top_parent = queue_top.result;
-                queue_slice.len -= 1;
-
-                var _open_dir: anyerror!std.fs.Dir = undefined;
-                if (queue_top.fd == 0) {
-
-                    // This saves us N copies of .toPosixPath
-                    // which was likely the perf gain from resolving directories relative to the parent directory, anyway.
-                    const prev_char = path.ptr[queue_top.unsafe_path.len];
-                    path.ptr[queue_top.unsafe_path.len] = 0;
-                    defer path.ptr[queue_top.unsafe_path.len] = prev_char;
-                    var sentinel = path.ptr[0..queue_top.unsafe_path.len :0];
-                    _open_dir = std.fs.openDirAbsoluteZ(
-                        sentinel,
-                        .{
-                            .iterate = true,
-                            .no_follow = !follow_symlinks,
-                        },
-                    );
-                    // }
-                }
+        // We want to walk in a straight line from the topmost directory to the desired directory
+        // For each directory we visit, we get the entries, but not traverse into child directories
+        // (unless those child directores are in the queue)
+        // We go top-down instead of bottom-up to increase odds of reusing previously open file handles
+        // "/home/jarred/Code/node_modules/react/cjs/react.development.js"
+        //       ^
+        // If we start there, we will traverse all of /home/jarred, including e.g. /home/jarred/Downloads
+        // which is completely irrelevant.
+
+        // After much experimentation...
+        // - fts_open is not the fastest way to read directories. fts actually just uses readdir!!
+        // - remember
+        var _safe_path: ?string = null;
+
+        // Start at the top.
+        while (queue_slice.len > 0) {
+            var queue_top = queue_slice[queue_slice.len - 1];
+            defer top_parent = queue_top.result;
+            queue_slice.len -= 1;
+
+            var _open_dir: anyerror!std.fs.Dir = undefined;
+            if (queue_top.fd == 0) {
+
+                // This saves us N copies of .toPosixPath
+                // which was likely the perf gain from resolving directories relative to the parent directory, anyway.
+                const prev_char = path.ptr[queue_top.unsafe_path.len];
+                path.ptr[queue_top.unsafe_path.len] = 0;
+                defer path.ptr[queue_top.unsafe_path.len] = prev_char;
+                var sentinel = path.ptr[0..queue_top.unsafe_path.len :0];
+                _open_dir = std.fs.openDirAbsoluteZ(
+                    sentinel,
+                    .{
+                        .iterate = true,
+                        .no_follow = !follow_symlinks,
+                    },
+                );
+                // }
+            }
 
-                const open_dir = if (queue_top.fd != 0) std.fs.Dir{ .fd = queue_top.fd } else (_open_dir catch |err| {
-                    switch (err) {
-                        error.EACCESS => {},
-
-                        // Ignore "ENOTDIR" here so that calling "ReadDirectory" on a file behaves
-                        // as if there is nothing there at all instead of causing an error due to
-                        // the directory actually being a file. This is a workaround for situations
-                        // where people try to import from a path containing a file as a parent
-                        // directory. The "pnpm" package manager generates a faulty "NODE_PATH"
-                        // list which contains such paths and treating them as missing means we just
-                        // ignore them during path resolution.
-                        error.ENOENT,
-                        error.ENOTDIR,
-                        error.IsDir,
-                        error.NotDir,
-                        error.FileNotFound,
-                        => {
-                            return null;
-                        },
+            const open_dir = if (queue_top.fd != 0) std.fs.Dir{ .fd = queue_top.fd } else (_open_dir catch |err| {
+                switch (err) {
+                    error.EACCESS => {},
+
+                    // Ignore "ENOTDIR" here so that calling "ReadDirectory" on a file behaves
+                    // as if there is nothing there at all instead of causing an error due to
+                    // the directory actually being a file. This is a workaround for situations
+                    // where people try to import from a path containing a file as a parent
+                    // directory. The "pnpm" package manager generates a faulty "NODE_PATH"
+                    // list which contains such paths and treating them as missing means we just
+                    // ignore them during path resolution.
+                    error.ENOENT,
+                    error.ENOTDIR,
+                    error.IsDir,
+                    error.NotDir,
+                    error.FileNotFound,
+                    => {
+                        return null;
+                    },
 
-                        else => {
-                            var cached_dir_entry_result = rfs.entries.getOrPut(queue_top.unsafe_path) catch unreachable;
-                            r.dir_cache.markNotFound(queue_top.result);
-                            rfs.entries.markNotFound(cached_dir_entry_result);
-                            if (comptime enable_logging) {
-                                const pretty = r.prettyPath(Path.init(queue_top.unsafe_path));
-
-                                r.log.addErrorFmt(
-                                    null,
-                                    logger.Loc{},
-                                    r.allocator,
-                                    "Cannot read directory \"{s}\": {s}",
-                                    .{
-                                        pretty,
-                                        @errorName(err),
-                                    },
-                                ) catch {};
-                            }
-                        },
-                    }
+                    else => {
+                        var cached_dir_entry_result = rfs.entries.getOrPut(queue_top.unsafe_path) catch unreachable;
+                        r.dir_cache.markNotFound(queue_top.result);
+                        rfs.entries.markNotFound(cached_dir_entry_result);
+                        if (comptime enable_logging) {
+                            const pretty = r.prettyPath(Path.init(queue_top.unsafe_path));
+
+                            r.log.addErrorFmt(
+                                null,
+                                logger.Loc{},
+                                r.allocator,
+                                "Cannot read directory \"{s}\": {s}",
+                                .{
+                                    pretty,
+                                    @errorName(err),
+                                },
+                            ) catch {};
+                        }
+                    },
+                }
 
-                    return null;
-                });
+                return null;
+            });
 
-                if (queue_top.fd == 0) {
-                    Fs.FileSystem.setMaxFd(open_dir.fd);
-                    // these objects mostly just wrap the file descriptor, so it's fine to keep it.
-                    _open_dirs[open_dir_count] = open_dir;
-                    open_dir_count += 1;
-                }
+            if (queue_top.fd == 0) {
+                Fs.FileSystem.setMaxFd(open_dir.fd);
+                // these objects mostly just wrap the file descriptor, so it's fine to keep it.
+                _open_dirs[open_dir_count] = open_dir;
+                open_dir_count += 1;
+            }
 
-                const dir_path = if (queue_top.safe_path.len > 0) queue_top.safe_path else brk: {
+            const dir_path = if (queue_top.safe_path.len > 0) queue_top.safe_path else brk: {
 
-                    // ensure trailing slash
-                    if (_safe_path == null) {
-                        // Now that we've opened the topmost directory successfully, it's reasonable to store the slice.
-                        if (path[path.len - 1] != std.fs.path.sep) {
-                            var parts = [_]string{ path, std.fs.path.sep_str };
-                            _safe_path = try r.fs.dirname_store.append(@TypeOf(parts), parts);
-                        } else {
-                            _safe_path = try r.fs.dirname_store.append(string, path);
-                        }
+                // ensure trailing slash
+                if (_safe_path == null) {
+                    // Now that we've opened the topmost directory successfully, it's reasonable to store the slice.
+                    if (path[path.len - 1] != std.fs.path.sep) {
+                        var parts = [_]string{ path, std.fs.path.sep_str };
+                        _safe_path = try r.fs.dirname_store.append(@TypeOf(parts), parts);
+                    } else {
+                        _safe_path = try r.fs.dirname_store.append(string, path);
                     }
+                }
 
-                    const safe_path = _safe_path.?;
+                const safe_path = _safe_path.?;
 
-                    var dir_path_i = std.mem.indexOf(u8, safe_path, queue_top.unsafe_path) orelse unreachable;
-                    var end = dir_path_i +
-                        queue_top.unsafe_path.len;
+                var dir_path_i = std.mem.indexOf(u8, safe_path, queue_top.unsafe_path) orelse unreachable;
+                var end = dir_path_i +
+                    queue_top.unsafe_path.len;
 
-                    // Directories must always end in a trailing slash or else various bugs can occur.
-                    // This covers "what happens when the trailing"
-                    end += @intCast(usize, @boolToInt(safe_path.len > end and end > 0 and safe_path[end - 1] != std.fs.path.sep and safe_path[end] == std.fs.path.sep));
-                    break :brk safe_path[dir_path_i..end];
-                };
+                // Directories must always end in a trailing slash or else various bugs can occur.
+                // This covers "what happens when the trailing"
+                end += @intCast(usize, @boolToInt(safe_path.len > end and end > 0 and safe_path[end - 1] != std.fs.path.sep and safe_path[end] == std.fs.path.sep));
+                break :brk safe_path[dir_path_i..end];
+            };
 
-                var cached_dir_entry_result = rfs.entries.getOrPut(dir_path) catch unreachable;
+            var cached_dir_entry_result = rfs.entries.getOrPut(dir_path) catch unreachable;
 
-                var dir_entries_option: *Fs.FileSystem.RealFS.EntriesOption = undefined;
-                var needs_iter: bool = true;
+            var dir_entries_option: *Fs.FileSystem.RealFS.EntriesOption = undefined;
+            var needs_iter: bool = true;
 
-                if (rfs.entries.atIndex(cached_dir_entry_result.index)) |cached_entry| {
-                    if (cached_entry.* == .entries) {
-                        dir_entries_option = cached_entry;
-                        needs_iter = false;
-                    }
+            if (rfs.entries.atIndex(cached_dir_entry_result.index)) |cached_entry| {
+                if (cached_entry.* == .entries) {
+                    dir_entries_option = cached_entry;
+                    needs_iter = false;
                 }
+            }
 
-                if (needs_iter) {
-                    dir_entries_option = try rfs.entries.put(&cached_dir_entry_result, .{
-                        .entries = Fs.FileSystem.DirEntry.init(dir_path, r.fs.allocator),
-                    });
+            if (needs_iter) {
+                dir_entries_option = try rfs.entries.put(&cached_dir_entry_result, .{
+                    .entries = Fs.FileSystem.DirEntry.init(dir_path, r.fs.allocator),
+                });
 
-                    if (FeatureFlags.store_file_descriptors) {
-                        Fs.FileSystem.setMaxFd(open_dir.fd);
-                        dir_entries_option.entries.fd = open_dir.fd;
-                    }
-                    var dir_iterator = open_dir.iterate();
-                    while (try dir_iterator.next()) |_value| {
-                        dir_entries_option.entries.addEntry(_value) catch unreachable;
-                    }
+                if (FeatureFlags.store_file_descriptors) {
+                    Fs.FileSystem.setMaxFd(open_dir.fd);
+                    dir_entries_option.entries.fd = open_dir.fd;
                 }
-
-                // We must initialize it as empty so that the result index is correct.
-                // This is important so that browser_scope has a valid index.
-                var dir_info_ptr = try r.dir_cache.put(&queue_top.result, DirInfo{});
-
-                try r.dirInfoUncached(
-                    dir_info_ptr,
-                    dir_path,
-                    dir_entries_option,
-                    queue_top.result,
-                    cached_dir_entry_result.index,
-                    r.dir_cache.atIndex(top_parent.index),
-                    top_parent.index,
-                    open_dir.fd,
-                );
-
-                if (queue_slice.len == 0) {
-                    return dir_info_ptr;
-
-                    // Is the directory we're searching for actually a file?
-                } else if (queue_slice.len == 1) {
-                    // const next_in_queue = queue_slice[0];
-                    // const next_basename = std.fs.path.basename(next_in_queue.unsafe_path);
-                    // if (dir_info_ptr.getEntries()) |entries| {
-                    //     if (entries.get(next_basename) != null) {
-                    //         return null;
-                    //     }
-                    // }
+                var dir_iterator = open_dir.iterate();
+                while (try dir_iterator.next()) |_value| {
+                    dir_entries_option.entries.addEntry(_value) catch unreachable;
                 }
             }
 
-            unreachable;
-        }
+            // We must initialize it as empty so that the result index is correct.
+            // This is important so that browser_scope has a valid index.
+            var dir_info_ptr = try r.dir_cache.put(&queue_top.result, DirInfo{});
 
-        // This closely follows the behavior of "tryLoadModuleUsingPaths()" in the
-        // official TypeScript compiler
-        pub fn matchTSConfigPaths(r: *ThisResolver, tsconfig: *const TSConfigJSON, path: string, kind: ast.ImportKind) ?MatchResult {
-            if (r.debug_logs) |*debug| {
-                debug.addNoteFmt("Matching \"{s}\" against \"paths\" in \"{s}\"", .{ path, tsconfig.abs_path }) catch unreachable;
-            }
+            try r.dirInfoUncached(
+                dir_info_ptr,
+                dir_path,
+                dir_entries_option,
+                queue_top.result,
+                cached_dir_entry_result.index,
+                r.dir_cache.atIndex(top_parent.index),
+                top_parent.index,
+                open_dir.fd,
+            );
 
-            var abs_base_url = tsconfig.base_url_for_paths;
+            if (queue_slice.len == 0) {
+                return dir_info_ptr;
 
-            // The explicit base URL should take precedence over the implicit base URL
-            // if present. This matters when a tsconfig.json file overrides "baseUrl"
-            // from another extended tsconfig.json file but doesn't override "paths".
-            if (tsconfig.hasBaseURL()) {
-                abs_base_url = tsconfig.base_url;
+                // Is the directory we're searching for actually a file?
+            } else if (queue_slice.len == 1) {
+                // const next_in_queue = queue_slice[0];
+                // const next_basename = std.fs.path.basename(next_in_queue.unsafe_path);
+                // if (dir_info_ptr.getEntries()) |entries| {
+                //     if (entries.get(next_basename) != null) {
+                //         return null;
+                //     }
+                // }
             }
+        }
 
-            if (r.debug_logs) |*debug| {
-                debug.addNoteFmt("Using \"{s}\" as \"baseURL\"", .{abs_base_url}) catch unreachable;
-            }
+        unreachable;
+    }
 
-            // Check for exact matches first
-            {
-                var iter = tsconfig.paths.iterator();
-                while (iter.next()) |entry| {
-                    const key = entry.key_ptr.*;
-
-                    if (strings.eql(key, path)) {
-                        for (entry.value_ptr.*) |original_path| {
-                            var absolute_original_path = original_path;
-                            var was_alloc = false;
-
-                            if (!std.fs.path.isAbsolute(absolute_original_path)) {
-                                const parts = [_]string{ abs_base_url, original_path };
-                                absolute_original_path = r.fs.absBuf(&parts, &tsconfig_path_abs_buf);
-                            }
+    // This closely follows the behavior of "tryLoadModuleUsingPaths()" in the
+    // official TypeScript compiler
+    pub fn matchTSConfigPaths(r: *ThisResolver, tsconfig: *const TSConfigJSON, path: string, kind: ast.ImportKind) ?MatchResult {
+        if (r.debug_logs) |*debug| {
+            debug.addNoteFmt("Matching \"{s}\" against \"paths\" in \"{s}\"", .{ path, tsconfig.abs_path }) catch unreachable;
+        }
 
-                            if (r.loadAsFileOrDirectory(absolute_original_path, kind)) |res| {
-                                return res;
-                            }
-                        }
-                    }
-                }
-            }
+        var abs_base_url = tsconfig.base_url_for_paths;
 
-            const TSConfigMatch = struct {
-                prefix: string,
-                suffix: string,
-                original_paths: []string,
-            };
+        // The explicit base URL should take precedence over the implicit base URL
+        // if present. This matters when a tsconfig.json file overrides "baseUrl"
+        // from another extended tsconfig.json file but doesn't override "paths".
+        if (tsconfig.hasBaseURL()) {
+            abs_base_url = tsconfig.base_url;
+        }
 
-            var longest_match: TSConfigMatch = undefined;
-            var longest_match_prefix_length: i32 = -1;
-            var longest_match_suffix_length: i32 = -1;
+        if (r.debug_logs) |*debug| {
+            debug.addNoteFmt("Using \"{s}\" as \"baseURL\"", .{abs_base_url}) catch unreachable;
+        }
 
+        // Check for exact matches first
+        {
             var iter = tsconfig.paths.iterator();
             while (iter.next()) |entry| {
                 const key = entry.key_ptr.*;
-                const original_paths = entry.value_ptr.*;
-
-                if (strings.indexOfChar(key, '*')) |star| {
-                    const prefix = key[0 .. star - 1];
-                    const suffix = key[star + 1 ..];
-
-                    // Find the match with the longest prefix. If two matches have the same
-                    // prefix length, pick the one with the longest suffix. This second edge
-                    // case isn't handled by the TypeScript compiler, but we handle it
-                    // because we want the output to always be deterministic
-                    if (strings.startsWith(path, prefix) and
-                        strings.endsWith(path, suffix) and
-                        (prefix.len >= longest_match_prefix_length and
-                        suffix.len > longest_match_suffix_length))
-                    {
-                        longest_match_prefix_length = @intCast(i32, prefix.len);
-                        longest_match_suffix_length = @intCast(i32, suffix.len);
-                        longest_match = TSConfigMatch{ .prefix = prefix, .suffix = suffix, .original_paths = original_paths };
+
+                if (strings.eql(key, path)) {
+                    for (entry.value_ptr.*) |original_path| {
+                        var absolute_original_path = original_path;
+                        var was_alloc = false;
+
+                        if (!std.fs.path.isAbsolute(absolute_original_path)) {
+                            const parts = [_]string{ abs_base_url, original_path };
+                            absolute_original_path = r.fs.absBuf(&parts, &tsconfig_path_abs_buf);
+                        }
+
+                        if (r.loadAsFileOrDirectory(absolute_original_path, kind)) |res| {
+                            return res;
+                        }
                     }
                 }
             }
+        }
 
-            // If there is at least one match, only consider the one with the longest
-            // prefix. This matches the behavior of the TypeScript compiler.
-            if (longest_match_prefix_length > -1) {
-                if (r.debug_logs) |*debug| {
-                    debug.addNoteFmt("Found a fuzzy match for \"{s}*{s}\" in \"paths\"", .{ longest_match.prefix, longest_match.suffix }) catch unreachable;
+        const TSConfigMatch = struct {
+            prefix: string,
+            suffix: string,
+            original_paths: []string,
+        };
+
+        var longest_match: TSConfigMatch = undefined;
+        var longest_match_prefix_length: i32 = -1;
+        var longest_match_suffix_length: i32 = -1;
+
+        var iter = tsconfig.paths.iterator();
+        while (iter.next()) |entry| {
+            const key = entry.key_ptr.*;
+            const original_paths = entry.value_ptr.*;
+
+            if (strings.indexOfChar(key, '*')) |star| {
+                const prefix = key[0 .. star - 1];
+                const suffix = key[star + 1 ..];
+
+                // Find the match with the longest prefix. If two matches have the same
+                // prefix length, pick the one with the longest suffix. This second edge
+                // case isn't handled by the TypeScript compiler, but we handle it
+                // because we want the output to always be deterministic
+                if (strings.startsWith(path, prefix) and
+                    strings.endsWith(path, suffix) and
+                    (prefix.len >= longest_match_prefix_length and
+                    suffix.len > longest_match_suffix_length))
+                {
+                    longest_match_prefix_length = @intCast(i32, prefix.len);
+                    longest_match_suffix_length = @intCast(i32, suffix.len);
+                    longest_match = TSConfigMatch{ .prefix = prefix, .suffix = suffix, .original_paths = original_paths };
                 }
+            }
+        }
+
+        // If there is at least one match, only consider the one with the longest
+        // prefix. This matches the behavior of the TypeScript compiler.
+        if (longest_match_prefix_length > -1) {
+            if (r.debug_logs) |*debug| {
+                debug.addNoteFmt("Found a fuzzy match for \"{s}*{s}\" in \"paths\"", .{ longest_match.prefix, longest_match.suffix }) catch unreachable;
+            }
 
-                for (longest_match.original_paths) |original_path| {
-                    // Swap out the "*" in the original path for whatever the "*" matched
-                    const matched_text = path[longest_match.prefix.len .. path.len - longest_match.suffix.len];
+            for (longest_match.original_paths) |original_path| {
+                // Swap out the "*" in the original path for whatever the "*" matched
+                const matched_text = path[longest_match.prefix.len .. path.len - longest_match.suffix.len];
 
-                    const total_length = std.mem.indexOfScalar(u8, original_path, '*') orelse unreachable;
-                    var prefix_parts = [_]string{ abs_base_url, original_path[0..total_length] };
+                const total_length = std.mem.indexOfScalar(u8, original_path, '*') orelse unreachable;
+                var prefix_parts = [_]string{ abs_base_url, original_path[0..total_length] };
 
-                    // 1. Normalize the base path
-                    // so that "/Users/foo/project/", "../components/*" => "/Users/foo/components/""
-                    var prefix = r.fs.absBuf(&prefix_parts, &TemporaryBuffer.TSConfigMatchFullBuf2);
+                // 1. Normalize the base path
+                // so that "/Users/foo/project/", "../components/*" => "/Users/foo/components/""
+                var prefix = r.fs.absBuf(&prefix_parts, &TemporaryBuffer.TSConfigMatchFullBuf2);
 
-                    // 2. Join the new base path with the matched result
-                    // so that "/Users/foo/components/", "/foo/bar" => /Users/foo/components/foo/bar
-                    var parts = [_]string{ prefix, std.mem.trimLeft(u8, matched_text, "/"), std.mem.trimLeft(u8, longest_match.suffix, "/") };
-                    var absolute_original_path = r.fs.absBuf(
-                        &parts,
-                        &TemporaryBuffer.TSConfigMatchFullBuf,
-                    );
+                // 2. Join the new base path with the matched result
+                // so that "/Users/foo/components/", "/foo/bar" => /Users/foo/components/foo/bar
+                var parts = [_]string{ prefix, std.mem.trimLeft(u8, matched_text, "/"), std.mem.trimLeft(u8, longest_match.suffix, "/") };
+                var absolute_original_path = r.fs.absBuf(
+                    &parts,
+                    &TemporaryBuffer.TSConfigMatchFullBuf,
+                );
 
-                    if (r.loadAsFileOrDirectory(absolute_original_path, kind)) |res| {
-                        return res;
-                    }
+                if (r.loadAsFileOrDirectory(absolute_original_path, kind)) |res| {
+                    return res;
                 }
             }
-
-            return null;
         }
 
-        const BrowserMapPath = struct {
-            remapped: string = "",
-            cleaned: string = "",
-            input_path: string = "",
-            extension_order: []const string,
-            map: BrowserMap,
-
-            pub threadlocal var abs_to_rel_buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
-
-            pub const Kind = enum { PackagePath, AbsolutePath };
-
-            pub fn checkPath(
-                this: *BrowserMapPath,
-                path_to_check: string,
-            ) bool {
-                const map = this.map;
+        return null;
+    }
 
-                const cleaned = this.cleaned;
-                // Check for equality
-                if (this.map.get(path_to_check)) |result| {
-                    this.remapped = result;
-                    this.input_path = path_to_check;
+    const BrowserMapPath = struct {
+        remapped: string = "",
+        cleaned: string = "",
+        input_path: string = "",
+        extension_order: []const string,
+        map: BrowserMap,
+
+        pub threadlocal var abs_to_rel_buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
+
+        pub const Kind = enum { PackagePath, AbsolutePath };
+
+        pub fn checkPath(
+            this: *BrowserMapPath,
+            path_to_check: string,
+        ) bool {
+            const map = this.map;
+
+            const cleaned = this.cleaned;
+            // Check for equality
+            if (this.map.get(path_to_check)) |result| {
+                this.remapped = result;
+                this.input_path = path_to_check;
+                return true;
+            }
+
+            std.mem.copy(u8, &TemporaryBuffer.ExtensionPathBuf, cleaned);
+
+            // If that failed, try adding implicit extensions
+            for (this.extension_order) |ext| {
+                std.mem.copy(u8, TemporaryBuffer.ExtensionPathBuf[cleaned.len .. cleaned.len + ext.len], ext);
+                const new_path = TemporaryBuffer.ExtensionPathBuf[0 .. cleaned.len + ext.len];
+                // if (r.debug_logs) |*debug| {
+                //     debug.addNoteFmt("Checking for \"{s}\" ", .{new_path}) catch {};
+                // }
+                if (map.get(new_path)) |_remapped| {
+                    this.remapped = _remapped;
+                    this.cleaned = new_path;
+                    this.input_path = new_path;
                     return true;
                 }
+            }
 
-                std.mem.copy(u8, &TemporaryBuffer.ExtensionPathBuf, cleaned);
-
-                // If that failed, try adding implicit extensions
-                for (this.extension_order) |ext| {
-                    std.mem.copy(u8, TemporaryBuffer.ExtensionPathBuf[cleaned.len .. cleaned.len + ext.len], ext);
-                    const new_path = TemporaryBuffer.ExtensionPathBuf[0 .. cleaned.len + ext.len];
-                    // if (r.debug_logs) |*debug| {
-                    //     debug.addNoteFmt("Checking for \"{s}\" ", .{new_path}) catch {};
-                    // }
-                    if (map.get(new_path)) |_remapped| {
-                        this.remapped = _remapped;
-                        this.cleaned = new_path;
-                        this.input_path = new_path;
-                        return true;
-                    }
-                }
+            // If that failed, try assuming this is a directory and looking for an "index" file
 
-                // If that failed, try assuming this is a directory and looking for an "index" file
+            var index_path: string = "";
+            {
+                var parts = [_]string{ std.mem.trimRight(u8, path_to_check, std.fs.path.sep_str), std.fs.path.sep_str ++ "index" };
+                index_path = ResolvePath.joinStringBuf(&tsconfig_base_url_buf, &parts, .auto);
+            }
 
-                var index_path: string = "";
-                {
-                    var parts = [_]string{ std.mem.trimRight(u8, path_to_check, std.fs.path.sep_str), std.fs.path.sep_str ++ "index" };
-                    index_path = ResolvePath.joinStringBuf(&tsconfig_base_url_buf, &parts, .auto);
-                }
+            if (map.get(index_path)) |_remapped| {
+                this.remapped = _remapped;
+                this.input_path = index_path;
+                return true;
+            }
+
+            std.mem.copy(u8, &TemporaryBuffer.ExtensionPathBuf, index_path);
 
-                if (map.get(index_path)) |_remapped| {
+            for (this.extension_order) |ext| {
+                std.mem.copy(u8, TemporaryBuffer.ExtensionPathBuf[index_path.len .. index_path.len + ext.len], ext);
+                const new_path = TemporaryBuffer.ExtensionPathBuf[0 .. index_path.len + ext.len];
+                // if (r.debug_logs) |*debug| {
+                //     debug.addNoteFmt("Checking for \"{s}\" ", .{new_path}) catch {};
+                // }
+                if (map.get(new_path)) |_remapped| {
                     this.remapped = _remapped;
-                    this.input_path = index_path;
+                    this.cleaned = new_path;
+                    this.input_path = new_path;
                     return true;
                 }
-
-                std.mem.copy(u8, &TemporaryBuffer.ExtensionPathBuf, index_path);
-
-                for (this.extension_order) |ext| {
-                    std.mem.copy(u8, TemporaryBuffer.ExtensionPathBuf[index_path.len .. index_path.len + ext.len], ext);
-                    const new_path = TemporaryBuffer.ExtensionPathBuf[0 .. index_path.len + ext.len];
-                    // if (r.debug_logs) |*debug| {
-                    //     debug.addNoteFmt("Checking for \"{s}\" ", .{new_path}) catch {};
-                    // }
-                    if (map.get(new_path)) |_remapped| {
-                        this.remapped = _remapped;
-                        this.cleaned = new_path;
-                        this.input_path = new_path;
-                        return true;
-                    }
-                }
-
-                return false;
             }
-        };
-
-        pub fn checkBrowserMap(
-            r: *ThisResolver,
-            dir_info: *const DirInfo,
-            input_path_: string,
-            comptime kind: BrowserMapPath.Kind,
-        ) ?string {
-            const package_json = dir_info.package_json orelse return null;
-            const browser_map = package_json.browser_map;
 
-            if (browser_map.count() == 0) return null;
+            return false;
+        }
+    };
 
-            var input_path = input_path_;
+    pub fn checkBrowserMap(
+        r: *ThisResolver,
+        dir_info: *const DirInfo,
+        input_path_: string,
+        comptime kind: BrowserMapPath.Kind,
+    ) ?string {
+        const package_json = dir_info.package_json orelse return null;
+        const browser_map = package_json.browser_map;
 
-            if (comptime kind == .AbsolutePath) {
-                const abs_path = dir_info.abs_path;
-                // Turn absolute paths into paths relative to the "browser" map location
-                if (!strings.startsWith(input_path, abs_path)) {
-                    return null;
-                }
+        if (browser_map.count() == 0) return null;
 
-                input_path = input_path[abs_path.len..];
-            }
+        var input_path = input_path_;
 
-            if (input_path.len == 0 or (input_path.len == 1 and (input_path[0] == '.' or input_path[0] == std.fs.path.sep))) {
-                // No bundler supports remapping ".", so we don't either
+        if (comptime kind == .AbsolutePath) {
+            const abs_path = dir_info.abs_path;
+            // Turn absolute paths into paths relative to the "browser" map location
+            if (!strings.startsWith(input_path, abs_path)) {
                 return null;
             }
 
-            // Normalize the path so we can compare against it without getting confused by "./"
-            var cleaned = r.fs.normalizeBuf(&check_browser_map_buf, input_path);
+            input_path = input_path[abs_path.len..];
+        }
 
-            if (cleaned.len == 1 and cleaned[0] == '.') {
-                // No bundler supports remapping ".", so we don't either
-                return null;
-            }
+        if (input_path.len == 0 or (input_path.len == 1 and (input_path[0] == '.' or input_path[0] == std.fs.path.sep))) {
+            // No bundler supports remapping ".", so we don't either
+            return null;
+        }
 
-            var checker = BrowserMapPath{
-                .remapped = "",
-                .cleaned = cleaned,
-                .input_path = input_path,
-                .extension_order = r.extension_order,
-                .map = package_json.browser_map,
-            };
+        // Normalize the path so we can compare against it without getting confused by "./"
+        var cleaned = r.fs.normalizeBuf(&check_browser_map_buf, input_path);
 
-            if (checker.checkPath(input_path)) {
-                return checker.remapped;
-            }
+        if (cleaned.len == 1 and cleaned[0] == '.') {
+            // No bundler supports remapping ".", so we don't either
+            return null;
+        }
+
+        var checker = BrowserMapPath{
+            .remapped = "",
+            .cleaned = cleaned,
+            .input_path = input_path,
+            .extension_order = r.extension_order,
+            .map = package_json.browser_map,
+        };
 
-            // First try the import path as a package path
-            if (isPackagePath(checker.input_path)) {
-                switch (comptime kind) {
-                    .AbsolutePath => {
+        if (checker.checkPath(input_path)) {
+            return checker.remapped;
+        }
+
+        // First try the import path as a package path
+        if (isPackagePath(checker.input_path)) {
+            switch (comptime kind) {
+                .AbsolutePath => {
+                    BrowserMapPath.abs_to_rel_buf[0..2].* = "./".*;
+                    std.mem.copy(u8, BrowserMapPath.abs_to_rel_buf[2..], checker.input_path);
+                    if (checker.checkPath(BrowserMapPath.abs_to_rel_buf[0 .. checker.input_path.len + 2])) {
+                        return checker.remapped;
+                    }
+                },
+                .PackagePath => {
+                    // Browserify allows a browser map entry of "./pkg" to override a package
+                    // path of "require('pkg')". This is weird, and arguably a bug. But we
+                    // replicate this bug for compatibility. However, Browserify only allows
+                    // this within the same package. It does not allow such an entry in a
+                    // parent package to override this in a child package. So this behavior
+                    // is disallowed if there is a "node_modules" folder in between the child
+                    // package and the parent package.
+                    const isInSamePackage = brk: {
+                        const parent = dir_info.getParent() orelse break :brk true;
+                        break :brk !parent.is_node_modules;
+                    };
+
+                    if (isInSamePackage) {
                         BrowserMapPath.abs_to_rel_buf[0..2].* = "./".*;
                         std.mem.copy(u8, BrowserMapPath.abs_to_rel_buf[2..], checker.input_path);
+
                         if (checker.checkPath(BrowserMapPath.abs_to_rel_buf[0 .. checker.input_path.len + 2])) {
                             return checker.remapped;
                         }
-                    },
-                    .PackagePath => {
-                        // Browserify allows a browser map entry of "./pkg" to override a package
-                        // path of "require('pkg')". This is weird, and arguably a bug. But we
-                        // replicate this bug for compatibility. However, Browserify only allows
-                        // this within the same package. It does not allow such an entry in a
-                        // parent package to override this in a child package. So this behavior
-                        // is disallowed if there is a "node_modules" folder in between the child
-                        // package and the parent package.
-                        const isInSamePackage = brk: {
-                            const parent = dir_info.getParent() orelse break :brk true;
-                            break :brk !parent.is_node_modules;
-                        };
-
-                        if (isInSamePackage) {
-                            BrowserMapPath.abs_to_rel_buf[0..2].* = "./".*;
-                            std.mem.copy(u8, BrowserMapPath.abs_to_rel_buf[2..], checker.input_path);
-
-                            if (checker.checkPath(BrowserMapPath.abs_to_rel_buf[0 .. checker.input_path.len + 2])) {
-                                return checker.remapped;
-                            }
-                        }
-                    },
-                }
+                    }
+                },
             }
+        }
 
-            return null;
+        return null;
+    }
+
+    pub fn loadFromMainField(r: *ThisResolver, path: string, dir_info: *DirInfo, _field_rel_path: string, field: string, extension_order: []const string) ?MatchResult {
+        var field_rel_path = _field_rel_path;
+        // Is this a directory?
+        if (r.debug_logs) |*debug| {
+            debug.addNoteFmt("Found main field \"{s}\" with path \"{s}\"", .{ field, field_rel_path }) catch {};
+            debug.increaseIndent() catch {};
         }
 
-        pub fn loadFromMainField(r: *ThisResolver, path: string, dir_info: *DirInfo, _field_rel_path: string, field: string, extension_order: []const string) ?MatchResult {
-            var field_rel_path = _field_rel_path;
-            // Is this a directory?
+        defer {
             if (r.debug_logs) |*debug| {
-                debug.addNoteFmt("Found main field \"{s}\" with path \"{s}\"", .{ field, field_rel_path }) catch {};
-                debug.increaseIndent() catch {};
-            }
-
-            defer {
-                if (r.debug_logs) |*debug| {
-                    debug.decreaseIndent() catch {};
-                }
+                debug.decreaseIndent() catch {};
             }
+        }
 
-            // Potentially remap using the "browser" field
-            if (dir_info.getEnclosingBrowserScope()) |browser_scope| {
-                if (browser_scope.package_json) |browser_json| {
-                    if (r.checkBrowserMap(
-                        browser_scope,
-                        field_rel_path,
-                        .AbsolutePath,
-                    )) |remap| {
-                        // Is the path disabled?
-                        if (remap.len == 0) {
-                            const paths = [_]string{ path, field_rel_path };
-                            const new_path = r.fs.absAlloc(r.allocator, &paths) catch unreachable;
-                            var _path = Path.init(new_path);
-                            _path.is_disabled = true;
-                            return MatchResult{
-                                .path_pair = PathPair{
-                                    .primary = _path,
-                                },
-                                .package_json = browser_json,
-                            };
-                        }
-
-                        field_rel_path = remap;
+        // Potentially remap using the "browser" field
+        if (dir_info.getEnclosingBrowserScope()) |browser_scope| {
+            if (browser_scope.package_json) |browser_json| {
+                if (r.checkBrowserMap(
+                    browser_scope,
+                    field_rel_path,
+                    .AbsolutePath,
+                )) |remap| {
+                    // Is the path disabled?
+                    if (remap.len == 0) {
+                        const paths = [_]string{ path, field_rel_path };
+                        const new_path = r.fs.absAlloc(r.allocator, &paths) catch unreachable;
+                        var _path = Path.init(new_path);
+                        _path.is_disabled = true;
+                        return MatchResult{
+                            .path_pair = PathPair{
+                                .primary = _path,
+                            },
+                            .package_json = browser_json,
+                        };
                     }
-                }
-            }
-            const _paths = [_]string{ path, field_rel_path };
-            const field_abs_path = r.fs.absBuf(&_paths, &field_abs_path_buf);
 
-            // Is this a file?
-            if (r.loadAsFile(field_abs_path, extension_order)) |result| {
-                if (dir_info.package_json) |package_json| {
-                    return MatchResult{
-                        .path_pair = PathPair{ .primary = Fs.Path.init(result.path) },
-                        .package_json = package_json,
-                        .dirname_fd = result.dirname_fd,
-                    };
+                    field_rel_path = remap;
                 }
+            }
+        }
+        const _paths = [_]string{ path, field_rel_path };
+        const field_abs_path = r.fs.absBuf(&_paths, &field_abs_path_buf);
 
+        // Is this a file?
+        if (r.loadAsFile(field_abs_path, extension_order)) |result| {
+            if (dir_info.package_json) |package_json| {
                 return MatchResult{
                     .path_pair = PathPair{ .primary = Fs.Path.init(result.path) },
+                    .package_json = package_json,
                     .dirname_fd = result.dirname_fd,
-                    .diff_case = result.diff_case,
                 };
             }
 
-            // Is it a directory with an index?
-            const field_dir_info = (r.dirInfoCached(field_abs_path) catch null) orelse {
-                return null;
-            };
-
-            return r.loadAsIndexWithBrowserRemapping(field_dir_info, field_abs_path, extension_order) orelse {
-                return null;
+            return MatchResult{
+                .path_pair = PathPair{ .primary = Fs.Path.init(result.path) },
+                .dirname_fd = result.dirname_fd,
+                .diff_case = result.diff_case,
             };
         }
 
-        pub fn loadAsIndex(r: *ThisResolver, dir_info: *DirInfo, path: string, extension_order: []const string) ?MatchResult {
-            var rfs = &r.fs.fs;
-            // Try the "index" file with extensions
-            for (extension_order) |ext| {
-                var base = TemporaryBuffer.ExtensionPathBuf[0 .. "index".len + ext.len];
-                base[0.."index".len].* = "index".*;
-                std.mem.copy(u8, base["index".len..base.len], ext);
-
-                if (dir_info.getEntries()) |entries| {
-                    if (entries.get(base)) |lookup| {
-                        if (lookup.entry.kind(rfs) == .file) {
-                            const out_buf = brk: {
-                                if (lookup.entry.abs_path.isEmpty()) {
-                                    const parts = [_]string{ path, base };
-                                    const out_buf_ = r.fs.absBuf(&parts, &index_buf);
-                                    lookup.entry.abs_path =
-                                        PathString.init(r.fs.dirname_store.append(@TypeOf(out_buf_), out_buf_) catch unreachable);
-                                }
-                                break :brk lookup.entry.abs_path.slice();
-                            };
+        // Is it a directory with an index?
+        const field_dir_info = (r.dirInfoCached(field_abs_path) catch null) orelse {
+            return null;
+        };
 
-                            if (r.debug_logs) |*debug| {
-                                debug.addNoteFmt("Found file: \"{s}\"", .{out_buf}) catch unreachable;
-                            }
+        return r.loadAsIndexWithBrowserRemapping(field_dir_info, field_abs_path, extension_order) orelse {
+            return null;
+        };
+    }
 
-                            if (dir_info.package_json) |package_json| {
-                                return MatchResult{
-                                    .path_pair = .{ .primary = Path.init(out_buf) },
-                                    .diff_case = lookup.diff_case,
-                                    .package_json = package_json,
-                                    .dirname_fd = dir_info.getFileDescriptor(),
-                                };
+    pub fn loadAsIndex(r: *ThisResolver, dir_info: *DirInfo, path: string, extension_order: []const string) ?MatchResult {
+        var rfs = &r.fs.fs;
+        // Try the "index" file with extensions
+        for (extension_order) |ext| {
+            var base = TemporaryBuffer.ExtensionPathBuf[0 .. "index".len + ext.len];
+            base[0.."index".len].* = "index".*;
+            std.mem.copy(u8, base["index".len..base.len], ext);
+
+            if (dir_info.getEntries()) |entries| {
+                if (entries.get(base)) |lookup| {
+                    if (lookup.entry.kind(rfs) == .file) {
+                        const out_buf = brk: {
+                            if (lookup.entry.abs_path.isEmpty()) {
+                                const parts = [_]string{ path, base };
+                                const out_buf_ = r.fs.absBuf(&parts, &index_buf);
+                                lookup.entry.abs_path =
+                                    PathString.init(r.fs.dirname_store.append(@TypeOf(out_buf_), out_buf_) catch unreachable);
                             }
+                            break :brk lookup.entry.abs_path.slice();
+                        };
+
+                        if (r.debug_logs) |*debug| {
+                            debug.addNoteFmt("Found file: \"{s}\"", .{out_buf}) catch unreachable;
+                        }
 
+                        if (dir_info.package_json) |package_json| {
                             return MatchResult{
                                 .path_pair = .{ .primary = Path.init(out_buf) },
                                 .diff_case = lookup.diff_case,
-
+                                .package_json = package_json,
                                 .dirname_fd = dir_info.getFileDescriptor(),
                             };
                         }
-                    }
-                }
 
-                if (r.debug_logs) |*debug| {
-                    debug.addNoteFmt("Failed to find file: \"{s}/{s}\"", .{ path, base }) catch unreachable;
+                        return MatchResult{
+                            .path_pair = .{ .primary = Path.init(out_buf) },
+                            .diff_case = lookup.diff_case,
+
+                            .dirname_fd = dir_info.getFileDescriptor(),
+                        };
+                    }
                 }
             }
 
-            return null;
-        }
-
-        pub fn loadAsIndexWithBrowserRemapping(r: *ThisResolver, dir_info: *DirInfo, path_: string, extension_order: []const string) ?MatchResult {
-            // In order for our path handling logic to be correct, it must end with a trailing slash.
-            var path = path_;
-            if (!strings.endsWithChar(path_, std.fs.path.sep)) {
-                std.mem.copy(u8, &remap_path_trailing_slash, path);
-                remap_path_trailing_slash[path.len] = std.fs.path.sep;
-                remap_path_trailing_slash[path.len + 1] = 0;
-                path = remap_path_trailing_slash[0 .. path.len + 1];
+            if (r.debug_logs) |*debug| {
+                debug.addNoteFmt("Failed to find file: \"{s}/{s}\"", .{ path, base }) catch unreachable;
             }
+        }
 
-            if (dir_info.getEnclosingBrowserScope()) |browser_scope| {
-                const field_rel_path = comptime "index";
+        return null;
+    }
 
-                if (browser_scope.package_json) |browser_json| {
-                    if (r.checkBrowserMap(
-                        browser_scope,
-                        field_rel_path,
-                        .AbsolutePath,
-                    )) |remap| {
+    pub fn loadAsIndexWithBrowserRemapping(r: *ThisResolver, dir_info: *DirInfo, path_: string, extension_order: []const string) ?MatchResult {
+        // In order for our path handling logic to be correct, it must end with a trailing slash.
+        var path = path_;
+        if (!strings.endsWithChar(path_, std.fs.path.sep)) {
+            std.mem.copy(u8, &remap_path_trailing_slash, path);
+            remap_path_trailing_slash[path.len] = std.fs.path.sep;
+            remap_path_trailing_slash[path.len + 1] = 0;
+            path = remap_path_trailing_slash[0 .. path.len + 1];
+        }
 
-                        // Is the path disabled?
-                        if (remap.len == 0) {
-                            const paths = [_]string{ path, field_rel_path };
-                            const new_path = r.fs.absBuf(&paths, &remap_path_buf);
-                            var _path = Path.init(new_path);
-                            _path.is_disabled = true;
-                            return MatchResult{
-                                .path_pair = PathPair{
-                                    .primary = _path,
-                                },
-                                .package_json = browser_json,
-                            };
-                        }
+        if (dir_info.getEnclosingBrowserScope()) |browser_scope| {
+            const field_rel_path = comptime "index";
+
+            if (browser_scope.package_json) |browser_json| {
+                if (r.checkBrowserMap(
+                    browser_scope,
+                    field_rel_path,
+                    .AbsolutePath,
+                )) |remap| {
+
+                    // Is the path disabled?
+                    if (remap.len == 0) {
+                        const paths = [_]string{ path, field_rel_path };
+                        const new_path = r.fs.absBuf(&paths, &remap_path_buf);
+                        var _path = Path.init(new_path);
+                        _path.is_disabled = true;
+                        return MatchResult{
+                            .path_pair = PathPair{
+                                .primary = _path,
+                            },
+                            .package_json = browser_json,
+                        };
+                    }
 
-                        const new_paths = [_]string{ path, remap };
-                        const remapped_abs = r.fs.absBuf(&new_paths, &remap_path_buf);
+                    const new_paths = [_]string{ path, remap };
+                    const remapped_abs = r.fs.absBuf(&new_paths, &remap_path_buf);
 
-                        // Is this a file
-                        if (r.loadAsFile(remapped_abs, extension_order)) |file_result| {
-                            return MatchResult{ .dirname_fd = file_result.dirname_fd, .path_pair = .{ .primary = Path.init(file_result.path) }, .diff_case = file_result.diff_case };
-                        }
+                    // Is this a file
+                    if (r.loadAsFile(remapped_abs, extension_order)) |file_result| {
+                        return MatchResult{ .dirname_fd = file_result.dirname_fd, .path_pair = .{ .primary = Path.init(file_result.path) }, .diff_case = file_result.diff_case };
+                    }
 
-                        // Is it a directory with an index?
-                        if (r.dirInfoCached(remapped_abs) catch null) |new_dir| {
-                            if (r.loadAsIndex(new_dir, remapped_abs, extension_order)) |absolute| {
-                                return absolute;
-                            }
+                    // Is it a directory with an index?
+                    if (r.dirInfoCached(remapped_abs) catch null) |new_dir| {
+                        if (r.loadAsIndex(new_dir, remapped_abs, extension_order)) |absolute| {
+                            return absolute;
                         }
-
-                        return null;
                     }
+
+                    return null;
                 }
             }
+        }
 
-            return r.loadAsIndex(dir_info, path_, extension_order);
-        }
-
-        pub fn loadAsFileOrDirectory(r: *ThisResolver, path: string, kind: ast.ImportKind) ?MatchResult {
-            const extension_order = r.extension_order;
-
-            // Is this a file?
-            if (r.loadAsFile(path, extension_order)) |file| {
-                // ServeBundler cares about the package.json
-                if (!cache_files) {
-                    // Determine the package folder by looking at the last node_modules/ folder in the path
-                    if (strings.lastIndexOf(file.path, "node_modules" ++ std.fs.path.sep_str)) |last_node_modules_folder| {
-                        const node_modules_folder_offset = last_node_modules_folder + ("node_modules" ++ std.fs.path.sep_str).len;
-                        // Determine the package name by looking at the next separator
-                        if (strings.indexOfChar(file.path[node_modules_folder_offset..], std.fs.path.sep)) |package_name_length| {
-                            if ((r.dirInfoCached(file.path[0 .. node_modules_folder_offset + package_name_length]) catch null)) |package_dir_info| {
-                                if (package_dir_info.package_json) |package_json| {
-                                    return MatchResult{
-                                        .path_pair = .{ .primary = Path.init(file.path) },
-                                        .diff_case = file.diff_case,
-                                        .dirname_fd = file.dirname_fd,
-                                        .package_json = package_json,
-                                        .file_fd = file.file_fd,
-                                    };
-                                }
-                            }
+        return r.loadAsIndex(dir_info, path_, extension_order);
+    }
+
+    pub fn loadAsFileOrDirectory(r: *ThisResolver, path: string, kind: ast.ImportKind) ?MatchResult {
+        const extension_order = r.extension_order;
+
+        // Is this a file?
+        if (r.loadAsFile(path, extension_order)) |file| {
+
+            // Determine the package folder by looking at the last node_modules/ folder in the path
+            if (strings.lastIndexOf(file.path, "node_modules" ++ std.fs.path.sep_str)) |last_node_modules_folder| {
+                const node_modules_folder_offset = last_node_modules_folder + ("node_modules" ++ std.fs.path.sep_str).len;
+                // Determine the package name by looking at the next separator
+                if (strings.indexOfChar(file.path[node_modules_folder_offset..], std.fs.path.sep)) |package_name_length| {
+                    if ((r.dirInfoCached(file.path[0 .. node_modules_folder_offset + package_name_length]) catch null)) |package_dir_info| {
+                        if (package_dir_info.package_json) |package_json| {
+                            return MatchResult{
+                                .path_pair = .{ .primary = Path.init(file.path) },
+                                .diff_case = file.diff_case,
+                                .dirname_fd = file.dirname_fd,
+                                .package_json = package_json,
+                                .file_fd = file.file_fd,
+                            };
                         }
                     }
                 }
-
-                return MatchResult{
-                    .path_pair = .{ .primary = Path.init(file.path) },
-                    .diff_case = file.diff_case,
-                    .dirname_fd = file.dirname_fd,
-                    .file_fd = file.file_fd,
-                };
             }
 
-            // Is this a directory?
+            return MatchResult{
+                .path_pair = .{ .primary = Path.init(file.path) },
+                .diff_case = file.diff_case,
+                .dirname_fd = file.dirname_fd,
+                .file_fd = file.file_fd,
+            };
+        }
+
+        // Is this a directory?
+        if (r.debug_logs) |*debug| {
+            debug.addNoteFmt("Attempting to load \"{s}\" as a directory", .{path}) catch {};
+            debug.increaseIndent() catch {};
+        }
+
+        defer {
             if (r.debug_logs) |*debug| {
-                debug.addNoteFmt("Attempting to load \"{s}\" as a directory", .{path}) catch {};
-                debug.increaseIndent() catch {};
+                debug.decreaseIndent() catch {};
             }
+        }
+
+        const dir_info = (r.dirInfoCached(path) catch |err| {
+            if (comptime isDebug) Output.prettyErrorln("err: {s} reading {s}", .{ @errorName(err), path });
+            return null;
+        }) orelse return null;
+        var package_json: ?*PackageJSON = null;
+
+        // Try using the main field(s) from "package.json"
+        if (dir_info.package_json) |pkg_json| {
+            package_json = pkg_json;
+            if (pkg_json.main_fields.count() > 0) {
+                const main_field_values = pkg_json.main_fields;
+                const main_field_keys = r.opts.main_fields;
+                // TODO: check this works right. Not sure this will really work.
+                const auto_main = r.opts.main_fields.ptr == options.Platform.DefaultMainFields.get(r.opts.platform).ptr;
 
-            defer {
                 if (r.debug_logs) |*debug| {
-                    debug.decreaseIndent() catch {};
+                    debug.addNoteFmt("Searching for main fields in \"{s}\"", .{pkg_json.source.path.text}) catch {};
                 }
-            }
 
-            const dir_info = (r.dirInfoCached(path) catch |err| {
-                if (comptime isDebug) Output.prettyErrorln("err: {s} reading {s}", .{ @errorName(err), path });
-                return null;
-            }) orelse return null;
-            var package_json: ?*PackageJSON = null;
-
-            // Try using the main field(s) from "package.json"
-            if (dir_info.package_json) |pkg_json| {
-                package_json = pkg_json;
-                if (pkg_json.main_fields.count() > 0) {
-                    const main_field_values = pkg_json.main_fields;
-                    const main_field_keys = r.opts.main_fields;
-                    // TODO: check this works right. Not sure this will really work.
-                    const auto_main = r.opts.main_fields.ptr == options.Platform.DefaultMainFields.get(r.opts.platform).ptr;
+                for (main_field_keys) |key| {
+                    const field_rel_path = (main_field_values.get(key)) orelse {
+                        if (r.debug_logs) |*debug| {
+                            debug.addNoteFmt("Did not find main field \"{s}\"", .{key}) catch {};
+                        }
+                        continue;
+                    };
 
-                    if (r.debug_logs) |*debug| {
-                        debug.addNoteFmt("Searching for main fields in \"{s}\"", .{pkg_json.source.path.text}) catch {};
-                    }
+                    var _result = r.loadFromMainField(path, dir_info, field_rel_path, key, extension_order) orelse continue;
 
-                    for (main_field_keys) |key| {
-                        const field_rel_path = (main_field_values.get(key)) orelse {
-                            if (r.debug_logs) |*debug| {
-                                debug.addNoteFmt("Did not find main field \"{s}\"", .{key}) catch {};
-                            }
-                            continue;
-                        };
+                    // If the user did not manually configure a "main" field order, then
+                    // use a special per-module automatic algorithm to decide whether to
+                    // use "module" or "main" based on whether the package is imported
+                    // using "import" or "require".
+                    if (auto_main and strings.eqlComptime(key, "module")) {
+                        var absolute_result: ?MatchResult = null;
 
-                        var _result = r.loadFromMainField(path, dir_info, field_rel_path, key, extension_order) orelse continue;
+                        if (main_field_values.get("main")) |main_rel_path| {
+                            if (main_rel_path.len > 0) {
+                                absolute_result = r.loadFromMainField(path, dir_info, main_rel_path, "main", extension_order);
+                            }
+                        } else {
+                            // Some packages have a "module" field without a "main" field but
+                            // still have an implicit "index.js" file. In that case, treat that
+                            // as the value for "main".
+                            absolute_result = r.loadAsIndexWithBrowserRemapping(dir_info, path, extension_order);
+                        }
 
-                        // If the user did not manually configure a "main" field order, then
-                        // use a special per-module automatic algorithm to decide whether to
-                        // use "module" or "main" based on whether the package is imported
-                        // using "import" or "require".
-                        if (auto_main and strings.eqlComptime(key, "module")) {
-                            var absolute_result: ?MatchResult = null;
+                        if (absolute_result) |auto_main_result| {
+                            // If both the "main" and "module" fields exist, use "main" if the
+                            // path is for "require" and "module" if the path is for "import".
+                            // If we're using "module", return enough information to be able to
+                            // fall back to "main" later if something ended up using "require()"
+                            // with this same path. The goal of this code is to avoid having
+                            // both the "module" file and the "main" file in the bundle at the
+                            // same time.
+                            if (kind != ast.ImportKind.require) {
+                                if (r.debug_logs) |*debug| {
+                                    debug.addNoteFmt("Resolved to \"{s}\" using the \"module\" field in \"{s}\"", .{ auto_main_result.path_pair.primary.text, pkg_json.source.key_path.text }) catch {};
 
-                            if (main_field_values.get("main")) |main_rel_path| {
-                                if (main_rel_path.len > 0) {
-                                    absolute_result = r.loadFromMainField(path, dir_info, main_rel_path, "main", extension_order);
+                                    debug.addNoteFmt("The fallback path in case of \"require\" is {s}", .{auto_main_result.path_pair.primary.text}) catch {};
                                 }
-                            } else {
-                                // Some packages have a "module" field without a "main" field but
-                                // still have an implicit "index.js" file. In that case, treat that
-                                // as the value for "main".
-                                absolute_result = r.loadAsIndexWithBrowserRemapping(dir_info, path, extension_order);
-                            }
-
-                            if (absolute_result) |auto_main_result| {
-                                // If both the "main" and "module" fields exist, use "main" if the
-                                // path is for "require" and "module" if the path is for "import".
-                                // If we're using "module", return enough information to be able to
-                                // fall back to "main" later if something ended up using "require()"
-                                // with this same path. The goal of this code is to avoid having
-                                // both the "module" file and the "main" file in the bundle at the
-                                // same time.
-                                if (kind != ast.ImportKind.require) {
-                                    if (r.debug_logs) |*debug| {
-                                        debug.addNoteFmt("Resolved to \"{s}\" using the \"module\" field in \"{s}\"", .{ auto_main_result.path_pair.primary.text, pkg_json.source.key_path.text }) catch {};
-
-                                        debug.addNoteFmt("The fallback path in case of \"require\" is {s}", .{auto_main_result.path_pair.primary.text}) catch {};
-                                    }
 
-                                    return MatchResult{
-                                        .path_pair = .{
-                                            .primary = _result.path_pair.primary,
-                                            .secondary = auto_main_result.path_pair.primary,
-                                        },
-                                        .diff_case = _result.diff_case,
-                                        .dirname_fd = _result.dirname_fd,
-                                        .package_json = package_json,
-                                        .file_fd = auto_main_result.file_fd,
-                                    };
-                                } else {
-                                    if (r.debug_logs) |*debug| {
-                                        debug.addNoteFmt("Resolved to \"{s}\" using the \"{s}\" field in \"{s}\"", .{
-                                            auto_main_result.path_pair.primary.text,
-                                            key,
-                                            pkg_json.source.key_path.text,
-                                        }) catch {};
-                                    }
-                                    var _auto_main_result = auto_main_result;
-                                    _auto_main_result.package_json = package_json;
-                                    return _auto_main_result;
+                                return MatchResult{
+                                    .path_pair = .{
+                                        .primary = _result.path_pair.primary,
+                                        .secondary = auto_main_result.path_pair.primary,
+                                    },
+                                    .diff_case = _result.diff_case,
+                                    .dirname_fd = _result.dirname_fd,
+                                    .package_json = package_json,
+                                    .file_fd = auto_main_result.file_fd,
+                                };
+                            } else {
+                                if (r.debug_logs) |*debug| {
+                                    debug.addNoteFmt("Resolved to \"{s}\" using the \"{s}\" field in \"{s}\"", .{
+                                        auto_main_result.path_pair.primary.text,
+                                        key,
+                                        pkg_json.source.key_path.text,
+                                    }) catch {};
                                 }
+                                var _auto_main_result = auto_main_result;
+                                _auto_main_result.package_json = package_json;
+                                return _auto_main_result;
                             }
                         }
-
-                        _result.package_json = _result.package_json orelse package_json;
-                        return _result;
                     }
+
+                    _result.package_json = _result.package_json orelse package_json;
+                    return _result;
                 }
             }
+        }
+
+        // Look for an "index" file with known extensions
+        if (r.loadAsIndexWithBrowserRemapping(dir_info, path, extension_order)) |*res| {
+            res.package_json = res.package_json orelse package_json;
+            return res.*;
+        }
+
+        return null;
+    }
+
+    pub fn loadAsFile(r: *ThisResolver, path: string, extension_order: []const string) ?LoadResult {
+        var rfs: *Fs.FileSystem.RealFS = &r.fs.fs;
 
-            // Look for an "index" file with known extensions
-            if (r.loadAsIndexWithBrowserRemapping(dir_info, path, extension_order)) |*res| {
-                res.package_json = res.package_json orelse package_json;
-                return res.*;
+        if (r.debug_logs) |*debug| {
+            debug.addNoteFmt("Attempting to load \"{s}\" as a file", .{path}) catch {};
+            debug.increaseIndent() catch {};
+        }
+        defer {
+            if (r.debug_logs) |*debug| {
+                debug.decreaseIndent() catch {};
             }
+        }
 
+        const dir_path = Dirname.dirname(path);
+
+        const dir_entry: *Fs.FileSystem.RealFS.EntriesOption = rfs.readDirectory(
+            dir_path,
+            null,
+        ) catch {
+            return null;
+        };
+
+        if (@as(Fs.FileSystem.RealFS.EntriesOption.Tag, dir_entry.*) == .err) {
+            if (dir_entry.err.original_err != error.ENOENT) {
+                r.log.addErrorFmt(
+                    null,
+                    logger.Loc.Empty,
+                    r.allocator,
+                    "Cannot read directory \"{s}\": {s}",
+                    .{
+                        r.prettyPath(Path.init(dir_path)),
+                        @errorName(dir_entry.err.original_err),
+                    },
+                ) catch {};
+            }
             return null;
         }
 
-        pub fn loadAsFile(r: *ThisResolver, path: string, extension_order: []const string) ?LoadResult {
-            var rfs: *Fs.FileSystem.RealFS = &r.fs.fs;
+        const entries = dir_entry.entries;
 
-            if (r.debug_logs) |*debug| {
-                debug.addNoteFmt("Attempting to load \"{s}\" as a file", .{path}) catch {};
-                debug.increaseIndent() catch {};
-            }
-            defer {
+        const base = std.fs.path.basename(path);
+
+        // Try the plain path without any extensions
+        if (r.debug_logs) |*debug| {
+            debug.addNoteFmt("Checking for file \"{s}\" ", .{base}) catch {};
+        }
+
+        if (entries.get(base)) |query| {
+            if (query.entry.kind(rfs) == .file) {
                 if (r.debug_logs) |*debug| {
-                    debug.decreaseIndent() catch {};
+                    debug.addNoteFmt("Found file \"{s}\" ", .{base}) catch {};
                 }
-            }
 
-            const dir_path = Dirname.dirname(path);
+                const abs_path = brk: {
+                    if (query.entry.abs_path.isEmpty()) {
+                        const abs_path_parts = [_]string{ query.entry.dir, query.entry.base() };
+                        query.entry.abs_path = PathString.init(r.fs.dirname_store.append(string, r.fs.absBuf(&abs_path_parts, &load_as_file_buf)) catch unreachable);
+                    }
 
-            const dir_entry: *Fs.FileSystem.RealFS.EntriesOption = rfs.readDirectory(
-                dir_path,
-                null,
-            ) catch {
-                return null;
-            };
+                    break :brk query.entry.abs_path.slice();
+                };
 
-            if (@as(Fs.FileSystem.RealFS.EntriesOption.Tag, dir_entry.*) == .err) {
-                if (dir_entry.err.original_err != error.ENOENT) {
-                    r.log.addErrorFmt(
-                        null,
-                        logger.Loc.Empty,
-                        r.allocator,
-                        "Cannot read directory \"{s}\": {s}",
-                        .{
-                            r.prettyPath(Path.init(dir_path)),
-                            @errorName(dir_entry.err.original_err),
-                        },
-                    ) catch {};
-                }
-                return null;
+                return LoadResult{
+                    .path = abs_path,
+                    .diff_case = query.diff_case,
+                    .dirname_fd = entries.fd,
+                    .file_fd = query.entry.cache.fd,
+                };
             }
+        }
 
-            const entries = dir_entry.entries;
-
-            const base = std.fs.path.basename(path);
+        // Try the path with extensions
+        std.mem.copy(u8, &load_as_file_buf, path);
+        for (r.extension_order) |ext| {
+            var buffer = load_as_file_buf[0 .. path.len + ext.len];
+            std.mem.copy(u8, buffer[path.len..buffer.len], ext);
+            const file_name = buffer[path.len - base.len .. buffer.len];
 
-            // Try the plain path without any extensions
             if (r.debug_logs) |*debug| {
-                debug.addNoteFmt("Checking for file \"{s}\" ", .{base}) catch {};
+                debug.addNoteFmt("Checking for file \"{s}\" ", .{buffer}) catch {};
             }
 
-            if (entries.get(base)) |query| {
+            if (entries.get(file_name)) |query| {
                 if (query.entry.kind(rfs) == .file) {
                     if (r.debug_logs) |*debug| {
-                        debug.addNoteFmt("Found file \"{s}\" ", .{base}) catch {};
+                        debug.addNoteFmt("Found file \"{s}\" ", .{buffer}) catch {};
                     }
 
-                    const abs_path = brk: {
-                        if (query.entry.abs_path.isEmpty()) {
-                            const abs_path_parts = [_]string{ query.entry.dir, query.entry.base() };
-                            query.entry.abs_path = PathString.init(r.fs.dirname_store.append(string, r.fs.absBuf(&abs_path_parts, &load_as_file_buf)) catch unreachable);
-                        }
-
-                        break :brk query.entry.abs_path.slice();
-                    };
-
+                    // now that we've found it, we allocate it.
                     return LoadResult{
-                        .path = abs_path,
+                        .path = brk: {
+                            query.entry.abs_path = if (query.entry.abs_path.isEmpty())
+                                PathString.init(r.fs.dirname_store.append(@TypeOf(buffer), buffer) catch unreachable)
+                            else
+                                query.entry.abs_path;
+
+                            break :brk query.entry.abs_path.slice();
+                        },
                         .diff_case = query.diff_case,
                         .dirname_fd = entries.fd,
                         .file_fd = query.entry.cache.fd,
                     };
                 }
             }
+        }
 
-            // Try the path with extensions
-            std.mem.copy(u8, &load_as_file_buf, path);
-            for (r.extension_order) |ext| {
-                var buffer = load_as_file_buf[0 .. path.len + ext.len];
-                std.mem.copy(u8, buffer[path.len..buffer.len], ext);
-                const file_name = buffer[path.len - base.len .. buffer.len];
+        // TypeScript-specific behavior: if the extension is ".js" or ".jsx", try
+        // replacing it with ".ts" or ".tsx". At the time of writing this specific
+        // behavior comes from the function "loadModuleFromFile()" in the file
+        // "moduleNameThisResolver.ts" in the TypeScript compiler source code. It
+        // contains this comment:
+        //
+        //   If that didn't work, try stripping a ".js" or ".jsx" extension and
+        //   replacing it with a TypeScript one; e.g. "./foo.js" can be matched
+        //   by "./foo.ts" or "./foo.d.ts"
+        //
+        // We don't care about ".d.ts" files because we can't do anything with
+        // those, so we ignore that part of the behavior.
+        //
+        // See the discussion here for more historical context:
+        // https://github.com/microsoft/TypeScript/issues/4595
+        if (strings.lastIndexOfChar(base, '.')) |last_dot| {
+            const ext = base[last_dot..base.len];
+            if (strings.eqlComptime(ext, ".js") or strings.eqlComptime(ext, ".jsx")) {
+                const segment = base[0..last_dot];
+                var tail = load_as_file_buf[path.len - base.len ..];
+                std.mem.copy(u8, tail, segment);
+
+                const exts = comptime [_]string{ ".ts", ".tsx" };
+
+                inline for (exts) |ext_to_replace| {
+                    var buffer = tail[0 .. segment.len + ext_to_replace.len];
+                    std.mem.copy(u8, buffer[segment.len..buffer.len], ext_to_replace);
+
+                    if (entries.get(buffer)) |query| {
+                        if (query.entry.kind(rfs) == .file) {
+                            if (r.debug_logs) |*debug| {
+                                debug.addNoteFmt("Rewrote to \"{s}\" ", .{buffer}) catch {};
+                            }
 
-                if (r.debug_logs) |*debug| {
-                    debug.addNoteFmt("Checking for file \"{s}\" ", .{buffer}) catch {};
-                }
+                            return LoadResult{
+                                .path = brk: {
+                                    if (query.entry.abs_path.isEmpty()) {
+                                        // Should already have a trailing slash so we shouldn't need to worry.
+                                        var parts = [_]string{ query.entry.dir, buffer };
+                                        query.entry.abs_path = PathString.init(r.fs.filename_store.append(@TypeOf(parts), parts) catch unreachable);
+                                    }
 
-                if (entries.get(file_name)) |query| {
-                    if (query.entry.kind(rfs) == .file) {
-                        if (r.debug_logs) |*debug| {
-                            debug.addNoteFmt("Found file \"{s}\" ", .{buffer}) catch {};
+                                    break :brk query.entry.abs_path.slice();
+                                },
+                                .diff_case = query.diff_case,
+                                .dirname_fd = entries.fd,
+                                .file_fd = query.entry.cache.fd,
+                            };
                         }
-
-                        // now that we've found it, we allocate it.
-                        return LoadResult{
-                            .path = brk: {
-                                query.entry.abs_path = if (query.entry.abs_path.isEmpty())
-                                    PathString.init(r.fs.dirname_store.append(@TypeOf(buffer), buffer) catch unreachable)
-                                else
-                                    query.entry.abs_path;
-
-                                break :brk query.entry.abs_path.slice();
-                            },
-                            .diff_case = query.diff_case,
-                            .dirname_fd = entries.fd,
-                            .file_fd = query.entry.cache.fd,
-                        };
                     }
-                }
-            }
-
-            // TypeScript-specific behavior: if the extension is ".js" or ".jsx", try
-            // replacing it with ".ts" or ".tsx". At the time of writing this specific
-            // behavior comes from the function "loadModuleFromFile()" in the file
-            // "moduleNameThisResolver.ts" in the TypeScript compiler source code. It
-            // contains this comment:
-            //
-            //   If that didn't work, try stripping a ".js" or ".jsx" extension and
-            //   replacing it with a TypeScript one; e.g. "./foo.js" can be matched
-            //   by "./foo.ts" or "./foo.d.ts"
-            //
-            // We don't care about ".d.ts" files because we can't do anything with
-            // those, so we ignore that part of the behavior.
-            //
-            // See the discussion here for more historical context:
-            // https://github.com/microsoft/TypeScript/issues/4595
-            if (strings.lastIndexOfChar(base, '.')) |last_dot| {
-                const ext = base[last_dot..base.len];
-                if (strings.eqlComptime(ext, ".js") or strings.eqlComptime(ext, ".jsx")) {
-                    const segment = base[0..last_dot];
-                    var tail = load_as_file_buf[path.len - base.len ..];
-                    std.mem.copy(u8, tail, segment);
-
-                    const exts = comptime [_]string{ ".ts", ".tsx" };
-
-                    inline for (exts) |ext_to_replace| {
-                        var buffer = tail[0 .. segment.len + ext_to_replace.len];
-                        std.mem.copy(u8, buffer[segment.len..buffer.len], ext_to_replace);
-
-                        if (entries.get(buffer)) |query| {
-                            if (query.entry.kind(rfs) == .file) {
-                                if (r.debug_logs) |*debug| {
-                                    debug.addNoteFmt("Rewrote to \"{s}\" ", .{buffer}) catch {};
-                                }
-
-                                return LoadResult{
-                                    .path = brk: {
-                                        if (query.entry.abs_path.isEmpty()) {
-                                            // Should already have a trailing slash so we shouldn't need to worry.
-                                            var parts = [_]string{ query.entry.dir, buffer };
-                                            query.entry.abs_path = PathString.init(r.fs.filename_store.append(@TypeOf(parts), parts) catch unreachable);
-                                        }
-
-                                        break :brk query.entry.abs_path.slice();
-                                    },
-                                    .diff_case = query.diff_case,
-                                    .dirname_fd = entries.fd,
-                                    .file_fd = query.entry.cache.fd,
-                                };
-                            }
-                        }
-                        if (r.debug_logs) |*debug| {
-                            debug.addNoteFmt("Failed to rewrite \"{s}\" ", .{base}) catch {};
-                        }
+                    if (r.debug_logs) |*debug| {
+                        debug.addNoteFmt("Failed to rewrite \"{s}\" ", .{base}) catch {};
                     }
                 }
             }
+        }
 
-            if (r.debug_logs) |*debug| {
-                debug.addNoteFmt("Failed to find \"{s}\" ", .{path}) catch {};
-            }
+        if (r.debug_logs) |*debug| {
+            debug.addNoteFmt("Failed to find \"{s}\" ", .{path}) catch {};
+        }
 
-            if (comptime FeatureFlags.watch_directories) {
-                // For existent directories which don't find a match
-                // Start watching it automatically,
-                // onStartWatchingDirectory fn decides whether to actually watch.
-                if (r.onStartWatchingDirectoryCtx) |ctx| {
-                    r.onStartWatchingDirectory.?(ctx, entries.dir, entries.fd);
-                }
+        if (comptime FeatureFlags.watch_directories) {
+            // For existent directories which don't find a match
+            // Start watching it automatically,
+            // onStartWatchingDirectory fn decides whether to actually watch.
+            if (r.onStartWatchingDirectoryCtx) |ctx| {
+                r.onStartWatchingDirectory.?(ctx, entries.dir, entries.fd);
             }
-            return null;
         }
+        return null;
+    }
 
-        fn dirInfoUncached(
-            r: *ThisResolver,
-            info: *DirInfo,
-            path: string,
-            _entries: *Fs.FileSystem.RealFS.EntriesOption,
-            _result: allocators.Result,
-            dir_entry_index: allocators.IndexType,
-            parent: ?*DirInfo,
-            parent_index: allocators.IndexType,
-            fd: FileDescriptorType,
-        ) anyerror!void {
-            var result = _result;
-
-            var rfs: *Fs.FileSystem.RealFS = &r.fs.fs;
-            var entries = _entries.entries;
-
-            info.* = DirInfo{
-                .abs_path = path,
-                // .abs_real_path = path,
-                .parent = parent_index,
-                .entries = dir_entry_index,
-            };
+    fn dirInfoUncached(
+        r: *ThisResolver,
+        info: *DirInfo,
+        path: string,
+        _entries: *Fs.FileSystem.RealFS.EntriesOption,
+        _result: allocators.Result,
+        dir_entry_index: allocators.IndexType,
+        parent: ?*DirInfo,
+        parent_index: allocators.IndexType,
+        fd: FileDescriptorType,
+    ) anyerror!void {
+        var result = _result;
+
+        var rfs: *Fs.FileSystem.RealFS = &r.fs.fs;
+        var entries = _entries.entries;
+
+        info.* = DirInfo{
+            .abs_path = path,
+            // .abs_real_path = path,
+            .parent = parent_index,
+            .entries = dir_entry_index,
+        };
 
-            // A "node_modules" directory isn't allowed to directly contain another "node_modules" directory
-            var base = std.fs.path.basename(path);
+        // A "node_modules" directory isn't allowed to directly contain another "node_modules" directory
+        var base = std.fs.path.basename(path);
 
-            // base must
-            if (base.len > 1 and base[base.len - 1] == std.fs.path.sep) base = base[0 .. base.len - 1];
+        // base must
+        if (base.len > 1 and base[base.len - 1] == std.fs.path.sep) base = base[0 .. base.len - 1];
 
-            info.is_node_modules = strings.eqlComptime(base, "node_modules");
+        info.is_node_modules = strings.eqlComptime(base, "node_modules");
 
-            // if (entries != null) {
-            if (!info.is_node_modules) {
-                if (entries.getComptimeQuery("node_modules")) |entry| {
-                    info.has_node_modules = (entry.entry.kind(rfs)) == .dir;
-                }
+        // if (entries != null) {
+        if (!info.is_node_modules) {
+            if (entries.getComptimeQuery("node_modules")) |entry| {
+                info.has_node_modules = (entry.entry.kind(rfs)) == .dir;
             }
-            // }
+        }
+        // }
 
-            if (parent != null) {
+        if (parent != null) {
 
-                // Propagate the browser scope into child directories
-                info.enclosing_browser_scope = parent.?.enclosing_browser_scope;
-                info.package_json_for_browser_field = parent.?.package_json_for_browser_field;
-                info.enclosing_tsconfig_json = parent.?.enclosing_tsconfig_json;
-                info.enclosing_package_json = parent.?.package_json orelse parent.?.enclosing_package_json;
+            // Propagate the browser scope into child directories
+            info.enclosing_browser_scope = parent.?.enclosing_browser_scope;
+            info.package_json_for_browser_field = parent.?.package_json_for_browser_field;
+            info.enclosing_tsconfig_json = parent.?.enclosing_tsconfig_json;
+            info.enclosing_package_json = parent.?.package_json orelse parent.?.enclosing_package_json;
 
-                // Make sure "absRealPath" is the real path of the directory (resolving any symlinks)
-                if (!r.opts.preserve_symlinks) {
-                    if (parent.?.getEntries()) |parent_entries| {
-                        if (parent_entries.get(base)) |lookup| {
-                            if (entries.fd != 0 and lookup.entry.cache.fd == 0) lookup.entry.cache.fd = entries.fd;
-                            const entry = lookup.entry;
+            // Make sure "absRealPath" is the real path of the directory (resolving any symlinks)
+            if (!r.opts.preserve_symlinks) {
+                if (parent.?.getEntries()) |parent_entries| {
+                    if (parent_entries.get(base)) |lookup| {
+                        if (entries.fd != 0 and lookup.entry.cache.fd == 0) lookup.entry.cache.fd = entries.fd;
+                        const entry = lookup.entry;
 
-                            var symlink = entry.symlink(rfs);
-                            if (symlink.len > 0) {
-                                if (r.debug_logs) |*logs| {
-                                    try logs.addNote(std.fmt.allocPrint(r.allocator, "Resolved symlink \"{s}\" to \"{s}\"", .{ path, symlink }) catch unreachable);
-                                }
-                                info.abs_real_path = symlink;
-                            } else if (parent.?.abs_real_path.len > 0) {
-                                // this might leak a little i'm not sure
-                                const parts = [_]string{ parent.?.abs_real_path, base };
-                                symlink = r.fs.dirname_store.append(string, r.fs.absBuf(&parts, &dir_info_uncached_filename_buf)) catch unreachable;
-
-                                if (r.debug_logs) |*logs| {
-                                    try logs.addNote(std.fmt.allocPrint(r.allocator, "Resolved symlink \"{s}\" to \"{s}\"", .{ path, symlink }) catch unreachable);
-                                }
-                                lookup.entry.cache.symlink = PathString.init(symlink);
-                                info.abs_real_path = symlink;
+                        var symlink = entry.symlink(rfs);
+                        if (symlink.len > 0) {
+                            if (r.debug_logs) |*logs| {
+                                try logs.addNote(std.fmt.allocPrint(r.allocator, "Resolved symlink \"{s}\" to \"{s}\"", .{ path, symlink }) catch unreachable);
+                            }
+                            info.abs_real_path = symlink;
+                        } else if (parent.?.abs_real_path.len > 0) {
+                            // this might leak a little i'm not sure
+                            const parts = [_]string{ parent.?.abs_real_path, base };
+                            symlink = r.fs.dirname_store.append(string, r.fs.absBuf(&parts, &dir_info_uncached_filename_buf)) catch unreachable;
+
+                            if (r.debug_logs) |*logs| {
+                                try logs.addNote(std.fmt.allocPrint(r.allocator, "Resolved symlink \"{s}\" to \"{s}\"", .{ path, symlink }) catch unreachable);
                             }
+                            lookup.entry.cache.symlink = PathString.init(symlink);
+                            info.abs_real_path = symlink;
                         }
                     }
                 }
             }
+        }
 
-            // Record if this directory has a package.json file
-            if (entries.getComptimeQuery("package.json")) |lookup| {
-                const entry = lookup.entry;
-                if (entry.kind(rfs) == .file) {
-                    info.package_json = r.parsePackageJSON(path, if (FeatureFlags.store_file_descriptors) fd else 0) catch null;
+        // Record if this directory has a package.json file
+        if (entries.getComptimeQuery("package.json")) |lookup| {
+            const entry = lookup.entry;
+            if (entry.kind(rfs) == .file) {
+                info.package_json = r.parsePackageJSON(path, if (FeatureFlags.store_file_descriptors) fd else 0) catch null;
 
-                    if (info.package_json) |pkg| {
-                        if (pkg.browser_map.count() > 0) {
-                            info.enclosing_browser_scope = result.index;
-                            info.package_json_for_browser_field = pkg;
-                        }
-                        info.enclosing_package_json = pkg;
+                if (info.package_json) |pkg| {
+                    if (pkg.browser_map.count() > 0) {
+                        info.enclosing_browser_scope = result.index;
+                        info.package_json_for_browser_field = pkg;
+                    }
+                    info.enclosing_package_json = pkg;
 
-                        if (r.debug_logs) |*logs| {
-                            logs.addNoteFmt("Resolved package.json in \"{s}\"", .{
-                                path,
-                            }) catch unreachable;
-                        }
+                    if (r.debug_logs) |*logs| {
+                        logs.addNoteFmt("Resolved package.json in \"{s}\"", .{
+                            path,
+                        }) catch unreachable;
                     }
                 }
             }
+        }
 
-            // Record if this directory has a tsconfig.json or jsconfig.json file
-            {
-                var tsconfig_path: ?string = null;
-                if (r.opts.tsconfig_override == null) {
-                    if (entries.getComptimeQuery("tsconfig.json")) |lookup| {
+        // Record if this directory has a tsconfig.json or jsconfig.json file
+        {
+            var tsconfig_path: ?string = null;
+            if (r.opts.tsconfig_override == null) {
+                if (entries.getComptimeQuery("tsconfig.json")) |lookup| {
+                    const entry = lookup.entry;
+                    if (entry.kind(rfs) == .file) {
+                        const parts = [_]string{ path, "tsconfig.json" };
+
+                        tsconfig_path = r.fs.absBuf(&parts, &dir_info_uncached_filename_buf);
+                    }
+                }
+                if (tsconfig_path == null) {
+                    if (entries.getComptimeQuery("jsconfig.json")) |lookup| {
                         const entry = lookup.entry;
                         if (entry.kind(rfs) == .file) {
-                            const parts = [_]string{ path, "tsconfig.json" };
-
+                            const parts = [_]string{ path, "jsconfig.json" };
                             tsconfig_path = r.fs.absBuf(&parts, &dir_info_uncached_filename_buf);
                         }
                     }
-                    if (tsconfig_path == null) {
-                        if (entries.getComptimeQuery("jsconfig.json")) |lookup| {
-                            const entry = lookup.entry;
-                            if (entry.kind(rfs) == .file) {
-                                const parts = [_]string{ path, "jsconfig.json" };
-                                tsconfig_path = r.fs.absBuf(&parts, &dir_info_uncached_filename_buf);
-                            }
-                        }
-                    }
-                } else if (parent == null) {
-                    tsconfig_path = r.opts.tsconfig_override.?;
                 }
+            } else if (parent == null) {
+                tsconfig_path = r.opts.tsconfig_override.?;
+            }
 
-                if (tsconfig_path) |tsconfigpath| {
-                    info.tsconfig_json = r.parseTSConfig(
-                        tsconfigpath,
-                        if (FeatureFlags.store_file_descriptors) fd else 0,
-                    ) catch |err| brk: {
-                        const pretty = r.prettyPath(Path.init(tsconfigpath));
-
-                        if (err == error.ENOENT) {
-                            r.log.addErrorFmt(null, logger.Loc.Empty, r.allocator, "Cannot find tsconfig file \"{s}\"", .{pretty}) catch unreachable;
-                        } else if (err != error.ParseErrorAlreadyLogged and err != error.IsDir) {
-                            r.log.addErrorFmt(null, logger.Loc.Empty, r.allocator, "Cannot read file \"{s}\": {s}", .{ pretty, @errorName(err) }) catch unreachable;
-                        }
-                        break :brk null;
-                    };
-                    info.enclosing_tsconfig_json = info.tsconfig_json;
-                }
+            if (tsconfig_path) |tsconfigpath| {
+                info.tsconfig_json = r.parseTSConfig(
+                    tsconfigpath,
+                    if (FeatureFlags.store_file_descriptors) fd else 0,
+                ) catch |err| brk: {
+                    const pretty = r.prettyPath(Path.init(tsconfigpath));
+
+                    if (err == error.ENOENT) {
+                        r.log.addErrorFmt(null, logger.Loc.Empty, r.allocator, "Cannot find tsconfig file \"{s}\"", .{pretty}) catch unreachable;
+                    } else if (err != error.ParseErrorAlreadyLogged and err != error.IsDir) {
+                        r.log.addErrorFmt(null, logger.Loc.Empty, r.allocator, "Cannot read file \"{s}\": {s}", .{ pretty, @errorName(err) }) catch unreachable;
+                    }
+                    break :brk null;
+                };
+                info.enclosing_tsconfig_json = info.tsconfig_json;
             }
         }
-    };
-}
-
-pub const Resolver = NewResolver(
-    true,
-);
-pub const ResolverUncached = NewResolver(
-    false,
-);
+    }
+};
 
 pub const Dirname = struct {
     pub fn dirname(path: string) string {