Bun gets a new bundler (#2312)

* alright now just gotta try running it

* fix a gajillion compiler errors

* even more code

* okay i fixed more errors

* wip

* Update launch.json

* Update string_builder.zig

* `fast_debug_build_mode` makes debug build 2x faster

* Update bundle_v2.zig

* more code!

* It bundles!

* Rename `Bun.Transpiler` to `Bun.Bundler`

* `import()` expressions almost work

* wip attempt to get import() expr to work

* Bundle namespace imports

* Attempt to fix the issue with import() unsuccessfully

* consider current working directory when resolving relative paths (#2313)

* consider current working directory when resolving relative paths

fixes #2298

* comment test

---------

Co-authored-by: Jarred Sumner <709451+Jarred-Sumner@users.noreply.github.com>

* support `expect().toThrow(/pattern/)` (#2314)

- fix time-zone-dependent test failure

* fix missing `Blob` error messages on Linux (#2315)

* fix & clean up tests (#2318)

- skip flaky tests when running as `root`
- use `expect().toThrow()`
- clean up temporary files after tests

* feat(tty): add some `tty.WriteStream` methods to `process.{stdout, stderr}` (#2320)

* feat(stdio): add some `tty.WriteStream` methods

* chore(builtins): add process builtin gen'd code

* Fix docker install command

* `bun test` on macOS in GitHub Actions (#2322)

* Fixes #2323

* throw invalid parameter errors in `crypto.scryptSync` (#2331)

* throw invalid parameter errors

* remove comptime, add empty buffer function

* remove error_name comptime

* Add reference documentation for bun:test (#2327)

* Reorganize tests (#2332)

* Fix html-rewriter.test.js

* fix the wrong thing being incremented in hmr example (#2334)

* Add more test harness

* Improve Benchmarking page, small fixes (#2339)

* Improve benchmarking page

* WIP

* Add typescript instructions to hot

* Document preload in Plugins. Fix loader in plugin types.

* Fix typo

* Fix links

* run prettier

* Document openInEditor

* improve `Buffer` compatibility with Node.js (#2341)

* improve `Buffer` compatibility with Node.js

* use `memmove()`
allow `encoding` to be `undefined`

* run `bun test` after macOS builds (#2343)

* "binary" is an alias of "latin1"

Fixes https://github.com/oven-sh/bun/issues/2110

* More spec compliant `Blob.prototype.type` (#2340)

* Make `Blob.prototype. type` more spec compliant

* Add a few more checks for isNumber()

* Fix `make headers`

* Safer JSValue.isString()

* More tests for blob.slice

* Make `Blob.prototype.type` more spec compliant

* Add isASCII check

* Fix types

* Fix failing type test

* Update blob.zig

* Update blob.zig

* Fix .eql check on empty values

---------

Co-authored-by: Jarred Sumner <709451+Jarred-Sumner@users.noreply.github.com>

* Fix bug in test runner

* Support `import()` expressions

* Implement `require()`

* clean up bit_set.zig slightly

* Move some things around

* misc cleanup

* Cleanup some things

* Fix a lot of stuff

* Fix `module.exports.fn = fn;` in ESM entry point

* Fix crash due when printing file

* Fix issue with class names

* Fix issue with `export default identifier`

* Update js_parser.zig

* optimization: inline single-property object acceses and arrays

* Fix undefined memory in renamed symbols list

* Handle call target

* wip

* Inline it

* Fix undefined memory issue when reclaiming blocks in ast

* Halt linking on any parse errors

* alias

* Rename `enable_bundling` to `enable_legacy_bundling`

* Workaround anonymous struct literal zig bug

* Use slower approach (without bitset) because it doesn't break after 8 symbols

* Fix incorrectly-renaming statically defined symbols

* Handle more edgecases in our bit_set fork

* Reduce number of allocations for `define`

* Do not rename unbound symbols

* Clean up dot defines a little more

* Make the generated names prettier

* Workaround runtime symbol missing issue

* Fail the build on errors

* Support export * from

* Support `--outfile`

* partially fix renaming

* fanicer symbol renaming impl

* misc, extremely revertible cleanup

* Fix up some bugs with symbol renaming

* formatting

* Update launch.json

* Parse `__PURE__` comments

* clean up simd code for pure comments

* changes to merge

* workaround runtime issue

* Fix issue with `export * as` not propagating correctly

* Make all top-level declarations `var` when bundling

* Fix missing prefix

* Fix assigning to stack copy

* Fix missing runtime symbol

* Fix bug with namespace exports

* Dramatically reduce allocations

* Update launch.json

* Add missing flags

* Update js_parser.zig

* small cleanup

* Make the export name better

* Fix unnecessary `var foo = foo`

* Implement CommonJS -> ESM conversion

* Implement module redirects

* Port esbuild bundler tests for new bundler (#2380)

* started porting esbuild tests

* clean up test names and api before moving on

* port tests using a program i wrote

* replace todo generated comment

* fix generated tests not including some files

* work on tests

* [github web editor] add define, external, inject, minifySyntax, minifyWhitespace options.

* get most of the todo comments out of the way, but expectBundled does not handle most of the cases

* continue working on esbuild tests

* use test.skip for unsupported tests

* Fixups for test runner

* Hoist imports & exports

* Fix test

* Hoist classes

* bundler test refining, 51/835

* Fix runtime require

* bundler test refining, 81/835

* bundler test refining, 93/835

* Make the test work in any timezone

* feat(expect): update toBeInstanceOf (#2396)

* feat: update instanceof binding

* fix: according to PR comments

* Rename `expectObjectTypeCount` to `expectMaxObjectTypeCount`

* Fix socket tests with connection errors (#2403)

* release pending activity with connection error handler

* unref poll_ref

* remove trailing comma

* Organize Dockerfiles for official status

* Remove test Dockerfile

* Remove old Docker workflow

* Feat(test): add toMatch (#2404)

* Fix various fetch/response/request tests (#2416)

* fix most fetch tests, skip a few

* fastGet, toValueGC, and invalid init

* bigint unreachable, range error, log process as process

* remove extra fetch_headers

* remove js_type parameter, check isObject()

* throw invalid mime type error, use enum literal

* switch back to promise rejection

* RangeError pascal case

* Fix several bugs (#2418)

* utf16 codepoint with replacement character

* Fix test failure with `TextEncoder("ascii')`

* Add missing type

* Fix Response.prototype.bodyUsed and Request.prototype.bodyUsed

* Fix bug with scrypt error not clearing

* Update server.zig

* oopsie

* :nail_care:

* docs: Use correct url in the 'Issues' link in README header (#2420)

* Fix crash when rendering error page and the server or network is slow

* [fetch] Make the default body value `null` when unspecified

This is better aligned with the fetch spec

* Make node-net tests less flaky

* [node:net] Fix issue with `listen` callback firing before it's listening

* Always clear timers in node test harness

* Fix out of bounds access

Repro'd in Buffer tests

* Update UWS

cc @cirospaciari

* Make this test more thorough

* Hanging abort test

* 0 length body is a null stream

* Several bug fixes (#2427)

* Fix test

* Fix segfault when unexpected type is passed in `expect().toThrow`

* Fix issues with request constructor

* Don't bother cloning headers when its empty

* woops

* more tests

* fix incorrect test

* Make the fetch error messages better

* Update response.zig

* Fix test that failed on macOS

* Fix test

* Remove extra hash table lookups

* Support running dummy registry directly

cc @alexlamsl

* Update test

* Update test

* fixup

* Workaround crash in test runner

* Fixup test

* Fixup test

* Update os.test.js

---------

Co-authored-by: Jarred Sumner <709451+Jarred-Sumner@users.noreply.github.com>

* Remove usages of port numbers in tests

* Set -O2 and -fno-rtti

* Remove -g

* Prevent undefined memory access

* [bun test] Implement `--rerun-each` flag to run each test N times

* Reduce number of module scopes created

* add some extra abort checks into streams (#2430)

* add some checks to avoid UAF

* avoid multiple calls to finalize if endFromJS is called more than once

* fix no-op comment

* mark as requested_end on abort

* remove requested_end from abort

* remove unnecessary check (#2432)

* Fix bug with scoped aliased dependencies in bun install on macOS

* remove `addLog`, remove `--prominent-compile-errors`

* Finish the upgrade

* Optional chaining flag

* Implement same_target_becomes_destructuring optimization

* bundler test refining, 109/835

* Reset bindings

* Support multiple entry points

* Implement `--entry-names` flag

* Use a tempdir with a better name

* prettier

* Log file name

* Update js_parser.zig

* Mark all bun builtins as external

* Make resolve errors actually errors

* Update bundler_default.test.ts

* Fix `await import(foo)`

* WIP react server components

* Do more stuff at runtime

* :scissors:

* Support automatic JSX imports

* Use a module cache for now

* Update tsconfig.base.json

* Fix ThisOutsideFunctionNotRenamed

* woopsie

* moar cpu

* clamp it

* fixup

* Add a bunch of assertions

* Bun uses automatic runtime by default

* Parse Import Attributes

* Add a note about Valgrind

* Update developing.md

* Fix up code splitting for React Server Components

* Implement client component manifest

* Fix crash with --react-server-components and no client components

* Backport https://github.com/ziglang/zig/commit/4d31e3c917a05541394c544708f0047cfb53331a

* Update launch.json

* Fix for latest zig

* Workaround bug with ?[]const string

Occasionally saw alignment errors in this code

Workaround https://github.com/ziglang/zig/issues/15085

related: https://github.com/ziglang/zig/pull/15089

* switch to regular slice

* Avoid initializing named_imports and named_exports as undefined

* Reduce usages of `undefined`

* Add more assertions

* --watch wip

* Update javascript.zig

* Possibly fix the race condition

* Faster `do`

* bump allocator

* Reduce the size of `Symbol` slightly

* Alphabetically sort runtime import symbols, for determinism

* Prepare for code splitting

* handle overlapping stdout

* pure

* clean up some things

* Fix bug with `$$typeof`

* Address CommonJS -> ESM hoisting bug

* Support `"use server"` in manifest

* Implement `"use server"`

* Fix importing bun builtins when bundling

* Make `commonjs_to_esm` a feature flag, fix some splitting bugs

* :scissors:

* fixme remove this

* Fix crash in longestCommonPath

* Chunking! Just need to do import paths now.

* Import paths work...now trying to figure out how to make runtime symbols work

* add workaround

* Replace `bun bun` with `bun build`

* Fix crash with dual package hazard

* Fix many CommonJS <> ESM interop bugs

* Support package.json `"sideEffects"`

also skip loading unnecessary package.json data in `bun run`

* add a not good --watch implementation

* bundler test refining, 140/831

* remove accidentally committed file

* do not return status code 1 on successful bundles

* bundler test refining, 159/830

* pass exit code to exitOrWatch

* clean up help menu

-remove two spaces to line up bun build
-moved all <r> tags to the end of the text they are colorizing
-moved other colors to the start of the text they colorize
-removed unneeded <r> tags, keeping only one at the start of the block

* importstar is fully ported

* wip

* you can run code in this branch now

* Disable this transform

* organize and document bundler tests

* Fix double import

* Fix sloppy mode function declarations

* Disable our CommonJS transform for now

* add `assertNotPresent` to make splitting cases easier

* Bump!

* Update bun.d.ts

* use import.meta.require in runtime code

* Disable this again

* Fix dirname

* Fix ESM -> CJS wrapper

* :nail_care:

---------

Co-authored-by: Jarred Sumner <709451+Jarred-Sumner@users.noreply.github.com>
Co-authored-by: Alex Lam S.L <alexlamsl@gmail.com>
Co-authored-by: Derrick Farris <mr.dcfarris@gmail.com>
Co-authored-by: Ashcon Partovi <ashcon@partovi.net>
Co-authored-by: Dylan Conway <35280289+dylan-conway@users.noreply.github.com>
Co-authored-by: pfg <pfg@pfg.pw>
Co-authored-by: Colin McDonnell <colinmcd94@gmail.com>
Co-authored-by: dave caruso <me@paperdave.net>
Co-authored-by: zhiyuan <32867472+zhiyuang@users.noreply.github.com>
Co-authored-by: Dylan Conway <dylan.conway567@gmail.com>
Co-authored-by: Kamil Ogórek <kamil.ogorek@gmail.com>
Co-authored-by: Ciro Spaciari <ciro.spaciari@gmail.com>

6 files changed, 378 insertions, 17 deletions

diff --git a/src/bun.js/api/transpiler.classes.ts b/src/bun.js/api/JSBundler.classes.ts
index f016a1844..5eeed30f0 100644
--- a/src/bun.js/api/transpiler.classes.ts
+++ b/src/bun.js/api/JSBundler.classes.ts
@@ -27,14 +27,24 @@ export default [
         length: 2,
       },
     },
-    custom: {
-      onLoadPlugins: {
-        extraHeaderIncludes: ["BunPlugin.h"],
-        impl: "JSTranspiler+BunPlugin-impl.h",
-        type: `WTF::Vector<std::unique_ptr<BunPlugin::OnLoad>>`,
+  }),
+
+  define({
+    name: "Bundler",
+    construct: true,
+    finalize: true,
+    hasPendingActivity: true,
+    configurable: false,
+    klass: {},
+    JSType: "0b11101110",
+    proto: {
+      handle: {
+        fn: "handleRequest",
+        length: 2,
       },
-      onResolvePlugins: {
-        type: `WTF::Vector<std::unique_ptr<BunPlugin::OnResolve>>`,
+      write: {
+        fn: "write",
+        length: 1,
       },
     },
   }),
diff --git a/src/bun.js/api/JSBundler.zig b/src/bun.js/api/JSBundler.zig
new file mode 100644
index 000000000..e8ce7a0e5
--- /dev/null
+++ b/src/bun.js/api/JSBundler.zig
@@ -0,0 +1,332 @@
+const std = @import("std");
+const Api = @import("../../api/schema.zig").Api;
+const http = @import("../../http.zig");
+const JavaScript = @import("../javascript.zig");
+const QueryStringMap = @import("../../url.zig").QueryStringMap;
+const CombinedScanner = @import("../../url.zig").CombinedScanner;
+const bun = @import("bun");
+const string = bun.string;
+const JSC = bun.JSC;
+const js = JSC.C;
+const WebCore = @import("../webcore/response.zig");
+const Bundler = bun.bundler;
+const options = @import("../../options.zig");
+const VirtualMachine = JavaScript.VirtualMachine;
+const ScriptSrcStream = std.io.FixedBufferStream([]u8);
+const ZigString = JSC.ZigString;
+const Fs = @import("../../fs.zig");
+const Base = @import("../base.zig");
+const getAllocator = Base.getAllocator;
+const JSObject = JSC.JSObject;
+const JSError = Base.JSError;
+const JSValue = bun.JSC.JSValue;
+const JSGlobalObject = JSC.JSGlobalObject;
+const strings = bun.strings;
+const NewClass = Base.NewClass;
+const To = Base.To;
+const Request = WebCore.Request;
+
+const FetchEvent = WebCore.FetchEvent;
+const MacroMap = @import("../../resolver/package_json.zig").MacroMap;
+const TSConfigJSON = @import("../../resolver/tsconfig_json.zig").TSConfigJSON;
+const PackageJSON = @import("../../resolver/package_json.zig").PackageJSON;
+const logger = bun.logger;
+const Loader = options.Loader;
+const Platform = options.Platform;
+const JSAst = bun.JSAst;
+const JSParser = bun.js_parser;
+const JSPrinter = bun.js_printer;
+const ScanPassResult = JSParser.ScanPassResult;
+const Mimalloc = @import("../../mimalloc_arena.zig");
+const Runtime = @import("../../runtime.zig").Runtime;
+const JSLexer = bun.js_lexer;
+const Expr = JSAst.Expr;
+
+pub const JSBundler = struct {
+    heap: Mimalloc.Arena,
+    allocator: std.mem.Allocator,
+    configs: Config.List = .{},
+    has_pending_activity: std.atomic.Atomic(bool) = std.atomic.Atomic(bool).init(true),
+
+    pub usingnamespace JSC.Codegen.JSBundler;
+
+    const OwnedString = bun.MutableString;
+
+    pub const Config = struct {
+        target: options.Platform = options.Platform.browser,
+        entry_points: std.BufSet = std.BufSet.init(bun.default_allocator),
+        hot: bool = false,
+        define: std.BufMap = std.BufMap.init(bun.default_allocator),
+        dir: OwnedString = OwnedString.initEmpty(bun.default_allocator),
+        serve: Serve = .{},
+        jsx: options.JSX.Pragma = .{},
+        code_splitting: bool = false,
+        minify: Minify = .{},
+        server_components: ServerComponents = ServerComponents{},
+        plugins: PluginDeclaration.List = .{},
+
+        names: Names = .{},
+        label: OwnedString = OwnedString.initEmpty(bun.default_allocator),
+
+        pub const List = bun.StringArrayHashMapUnmanaged(Config);
+
+        ///
+        /// { name: "", setup: (build) {} }
+        pub const PluginDeclaration = struct {
+            name: OwnedString = OwnedString.initEmpty(bun.default_allocator),
+            setup: JSC.Strong = .{},
+
+            pub const List = std.ArrayListUnmanaged(PluginDeclaration);
+
+            pub fn deinit(this: *PluginDeclaration) void {
+                this.name.deinit();
+                this.setup.deinit();
+            }
+        };
+
+        pub fn fromJS(globalThis: *JSC.JSGlobalObject, config: JSC.JSValue, allocator: std.mem.Allocator) !Config {
+            var this = Config{
+                .entry_points = std.BufSet.init(allocator),
+                .define = std.BufMap.init(allocator),
+                .dir = OwnedString.initEmpty(allocator),
+                .label = OwnedString.initEmpty(allocator),
+                .names = .{
+                    .owned_entry_point = OwnedString.initEmpty(allocator),
+                    .owned_chunk = OwnedString.initEmpty(allocator),
+                },
+            };
+            errdefer this.deinit(allocator);
+
+            if (try config.getOptionalEnum(globalThis, "target", options.Platform)) |target| {
+                this.target = target;
+            }
+
+            if (try config.getOptional(globalThis, "hot", bool)) |hot| {
+                this.hot = hot;
+            }
+
+            if (try config.getOptional(globalThis, "splitting", bool)) |hot| {
+                this.code_splitting = hot;
+            }
+
+            if (try config.getOptional(globalThis, "minifyWhitespace", bool)) |hot| {
+                this.minify.whitespace = hot;
+            }
+
+            if (try config.getArray(globalThis, "entrypoints")) |entry_points| {
+                var iter = entry_points.arrayIterator(globalThis);
+                while (iter.next()) |entry_point| {
+                    var slice = entry_point.toSliceOrNull(globalThis, allocator) orelse {
+                        globalThis.throwInvalidArguments("Expected entrypoints to be an array of strings", .{});
+                        return error.JSException;
+                    };
+                    defer slice.deinit();
+                    try this.entry_points.insert(slice.slice());
+                }
+            } else {
+                globalThis.throwInvalidArguments("Expected entrypoints to be an array of strings", .{});
+                return error.JSException;
+            }
+
+            if (try config.getOptional(globalThis, "name", ZigString.Slice)) |slice| {
+                defer slice.deinit();
+                this.label.appendSliceExact(slice.slice()) catch unreachable;
+            }
+
+            if (try config.getOptional(globalThis, "dir", ZigString.Slice)) |slice| {
+                defer slice.deinit();
+                this.dir.appendSliceExact(slice.slice()) catch unreachable;
+            } else {
+                this.dir.appendSliceExact(globalThis.bunVM().bundler.fs.top_level_dir) catch unreachable;
+            }
+
+            if (try config.getOptional(globalThis, "entryNames", ZigString.Slice)) |slice| {
+                defer slice.deinit();
+                this.names.owned_entry_point.appendSliceExact(slice.slice()) catch unreachable;
+                this.names.entry_point.data = this.names.owned_entry_point.list.items;
+            }
+
+            if (try config.getOptional(globalThis, "chunkNames", ZigString.Slice)) |slice| {
+                defer slice.deinit();
+                this.names.owned_chunk.appendSliceExact(slice.slice()) catch unreachable;
+                this.names.chunk.data = this.names.owned_chunk.list.items;
+            }
+
+            if (try config.getArray(globalThis, "plugins")) |array| {
+                var iter = array.arrayIterator(globalThis);
+                while (iter.next()) |plugin| {
+                    var decl = PluginDeclaration{
+                        .name = OwnedString.initEmpty(allocator),
+                        .setup = .{},
+                    };
+                    errdefer decl.deinit();
+
+                    if (plugin.getObject(globalThis, "SECRET_SERVER_COMPONENTS_INTERNALS")) |internals| {
+                        if (try internals.get(globalThis, "router")) |router_value| {
+                            if (router_value.as(JSC.API.FileSystemRouter) != null) {
+                                this.server_components.router.set(globalThis, router_value);
+                            } else {
+                                globalThis.throwInvalidArguments("Expected router to be a Bun.FileSystemRouter", .{});
+                                return error.JSError;
+                            }
+                        }
+
+                        const directive_object = (try internals.getObject(globalThis, "directive")) orelse {
+                            globalThis.throwInvalidArguments("Expected directive to be an object", .{});
+                            return error.JSError;
+                        };
+
+                        if (try directive_object.getArray(globalThis, "client")) |client_names_array| {
+                            var array_iter = client_names_array.arrayIterator(globalThis);
+                            while (array_iter.next()) |client_name| {
+                                var slice = client_name.toSliceOrNull(globalThis, allocator) orelse {
+                                    globalThis.throwInvalidArguments("Expected directive.client to be an array of strings", .{});
+                                    return error.JSException;
+                                };
+                                defer slice.deinit();
+                                try this.server_components.client.append(allocator, OwnedString.initCopy(allocator, slice.slice()) catch unreachable);
+                            }
+                        } else {
+                            globalThis.throwInvalidArguments("Expected directive.client to be an array of strings", .{});
+                            return error.JSException;
+                        }
+
+                        if (try directive_object.getArray(globalThis, "server")) |server_names_array| {
+                            var array_iter = server_names_array.arrayIterator(globalThis);
+                            while (array_iter.next()) |server_name| {
+                                var slice = server_name.toSliceOrNull(globalThis, allocator) orelse {
+                                    globalThis.throwInvalidArguments("Expected directive.server to be an array of strings", .{});
+                                    return error.JSException;
+                                };
+                                defer slice.deinit();
+                                try this.server_components.server.append(allocator, OwnedString.initCopy(allocator, slice.slice()) catch unreachable);
+                            }
+                        } else {
+                            globalThis.throwInvalidArguments("Expected directive.server to be an array of strings", .{});
+                            return error.JSException;
+                        }
+                    }
+
+                    if (try plugin.getOptional(globalThis, "name", ZigString.Slice)) |slice| {
+                        defer slice.deinit();
+                        decl.name.appendSliceExact(slice.slice()) catch unreachable;
+                    }
+
+                    if (try plugin.getFunction(globalThis, "setup", JSC.JSValue)) |setup| {
+                        decl.setup.set(globalThis, setup);
+                    } else {
+                        globalThis.throwInvalidArguments("Expected plugin to have a setup() function", .{});
+                        return error.JSError;
+                    }
+
+                    try this.plugins.append(allocator, decl);
+                }
+            }
+
+            return config;
+        }
+
+        pub const Names = struct {
+            owned_entry_point: OwnedString = OwnedString.initEmpty(bun.default_allocator),
+            entry_point: options.PathTemplate = options.PathTemplate.file,
+            owned_chunk: OwnedString = OwnedString.initEmpty(bun.default_allocator),
+            chunk: options.PathTemplate = options.PathTemplate.chunk,
+
+            pub fn deinit(self: *Names) void {
+                self.owned_entry_point.deinit();
+                self.owned_chunk.deinit();
+            }
+        };
+
+        pub const ServerComponents = struct {
+            router: JSC.Strong = .{},
+            client: std.ArrayListUnmanaged(OwnedString) = .{},
+            server: std.ArrayListUnmanaged(OwnedString) = .{},
+
+            pub fn deinit(self: *ServerComponents, allocator: std.mem.Allocator) void {
+                self.router.deinit();
+                self.client.clearAndFree(allocator);
+                self.server.clearAndFree(allocator);
+            }
+        };
+
+        pub const Minify = struct {
+            whitespace: bool = false,
+        };
+
+        pub const Serve = struct {
+            handler_path: OwnedString = OwnedString.initEmpty(bun.default_allocator),
+            prefix: OwnedString = OwnedString.initEmpty(bun.default_allocator),
+
+            pub fn deinit(self: *Serve, allocator: std.mem.Allocator) void {
+                _ = allocator;
+                self.handler_path.deinit();
+                self.prefix.deinit();
+            }
+        };
+
+        pub fn deinit(self: *Config, allocator: std.mem.Allocator) void {
+            self.entry_points.deinit();
+            self.define.deinit();
+            self.dir.deinit();
+            self.serve.deinit(allocator);
+            self.plugins.deinit();
+            self.server_components.deinit(allocator);
+            self.names.deinit();
+            self.label.deinit();
+        }
+    };
+
+    pub fn constructor(
+        globalThis: *JSC.JSGlobalObject,
+        callframe: *JSC.CallFrame,
+    ) callconv(.C) ?*JSBundler {
+        var temp = std.heap.ArenaAllocator.init(getAllocator(globalThis));
+        const arguments = callframe.arguments(3);
+        var args = JSC.Node.ArgumentsSlice.init(
+            globalThis.bunVM(),
+            arguments.ptr[0..arguments.len],
+        );
+        _ = args;
+
+        defer temp.deinit();
+
+        return null;
+    }
+
+    pub fn handleRequest(
+        this: *JSBundler,
+        globalThis: *JSC.JSGlobalObject,
+        callframe: *JSC.CallFrame,
+    ) callconv(.C) JSValue {
+        _ = callframe;
+        _ = globalThis;
+        _ = this;
+
+        return .zero;
+    }
+
+    pub fn write(
+        this: *JSBundler,
+        globalThis: *JSC.JSGlobalObject,
+        callframe: *JSC.CallFrame,
+    ) callconv(.C) JSValue {
+        _ = callframe;
+        _ = globalThis;
+        _ = this;
+
+        return .zero;
+    }
+
+    pub fn hasPendingActivity(this: *JSBundler) callconv(.C) bool {
+        @fence(.Acquire);
+        return this.has_pending_activity.load(.Acquire);
+    }
+
+    pub fn finalize(
+        this: *JSBundler,
+    ) callconv(.C) void {
+        this.heap.deinit();
+        JSC.VirtualMachine.get().allocator.destroy(this);
+    }
+};
diff --git a/src/bun.js/api/transpiler.zig b/src/bun.js/api/JSTranspiler.zig
index 8562a3204..465ab0ad4 100644
--- a/src/bun.js/api/transpiler.zig
+++ b/src/bun.js/api/JSTranspiler.zig
@@ -6,7 +6,7 @@ const QueryStringMap = @import("../../url.zig").QueryStringMap;
 const CombinedScanner = @import("../../url.zig").CombinedScanner;
 const bun = @import("bun");
 const string = bun.string;
-const JSC = @import("bun").JSC;
+const JSC = bun.JSC;
 const js = JSC.C;
 const WebCore = @import("../webcore/response.zig");
 const Bundler = bun.bundler;
@@ -19,9 +19,9 @@ const Base = @import("../base.zig");
 const getAllocator = Base.getAllocator;
 const JSObject = JSC.JSObject;
 const JSError = Base.JSError;
-const JSValue = JSC.JSValue;
+const JSValue = bun.JSC.JSValue;
 const JSGlobalObject = JSC.JSGlobalObject;
-const strings = @import("bun").strings;
+const strings = bun.strings;
 const NewClass = Base.NewClass;
 const To = Base.To;
 const Request = WebCore.Request;
@@ -30,7 +30,7 @@ const FetchEvent = WebCore.FetchEvent;
 const MacroMap = @import("../../resolver/package_json.zig").MacroMap;
 const TSConfigJSON = @import("../../resolver/tsconfig_json.zig").TSConfigJSON;
 const PackageJSON = @import("../../resolver/package_json.zig").PackageJSON;
-const logger = @import("bun").logger;
+const logger = bun.logger;
 const Loader = options.Loader;
 const Platform = options.Platform;
 const JSAst = bun.JSAst;
@@ -838,7 +838,7 @@ fn getParseResult(this: *Transpiler, allocator: std.mem.Allocator, code: []const
 
     // necessary because we don't run the linker
     if (parse_result) |*res| {
-        for (res.ast.import_records) |*import| {
+        for (res.ast.import_records.slice()) |*import| {
             if (import.kind.isCommonJS()) {
                 import.do_commonjs_transform_in_printer = true;
                 import.module_id = @truncate(u32, std.hash.Wyhash.hash(0, import.path.pretty));
@@ -923,7 +923,7 @@ pub fn scan(
     const imports_label = JSC.ZigString.static("imports");
     const named_imports_value = namedImportsToJS(
         globalThis,
-        parse_result.ast.import_records,
+        parse_result.ast.import_records.slice(),
         exception,
     );
     if (exception.* != null) {
diff --git a/src/bun.js/api/bun.zig b/src/bun.js/api/bun.zig
index 5dc3abcf9..7c6473727 100644
--- a/src/bun.js/api/bun.zig
+++ b/src/bun.js/api/bun.zig
@@ -71,7 +71,8 @@ const VM = @import("bun").JSC.VM;
 const JSFunction = @import("bun").JSC.JSFunction;
 const Config = @import("../config.zig");
 const URL = @import("../../url.zig").URL;
-const Transpiler = @import("./transpiler.zig");
+const Transpiler = bun.JSC.API.JSTranspiler;
+const JSBundler = bun.JSC.API.JSBundler;
 const VirtualMachine = JSC.VirtualMachine;
 const IOTask = JSC.IOTask;
 const zlib = @import("../../zlib.zig");
@@ -1319,6 +1320,9 @@ pub const Class = NewClass(
         .Transpiler = .{
             .get = getTranspilerConstructor,
         },
+        .Bundler = .{
+            .get = getBundlerConstructor,
+        },
         .hash = .{
             .get = getHashObject,
         },
@@ -2339,6 +2343,16 @@ pub fn mmapFile(
     }.x, @intToPtr(?*anyopaque, map.len), exception);
 }
 
+pub fn getBundlerConstructor(
+    _: void,
+    ctx: js.JSContextRef,
+    _: js.JSValueRef,
+    _: js.JSStringRef,
+    _: js.ExceptionRef,
+) js.JSValueRef {
+    return JSC.API.JSBundler.getConstructor(ctx).asObjectRef();
+}
+
 pub fn getTranspilerConstructor(
     _: void,
     ctx: js.JSContextRef,
@@ -2346,7 +2360,7 @@ pub fn getTranspilerConstructor(
     _: js.JSStringRef,
     _: js.ExceptionRef,
 ) js.JSValueRef {
-    return JSC.API.Bun.Transpiler.getConstructor(ctx).asObjectRef();
+    return JSC.API.JSTranspiler.getConstructor(ctx).asObjectRef();
 }
 
 pub fn getFileSystemRouter(
diff --git a/src/bun.js/api/ffi.zig b/src/bun.js/api/ffi.zig
index 89192dc85..6e2ad4242 100644
--- a/src/bun.js/api/ffi.zig
+++ b/src/bun.js/api/ffi.zig
@@ -71,7 +71,6 @@ const VM = @import("bun").JSC.VM;
 const JSFunction = @import("bun").JSC.JSFunction;
 const Config = @import("../config.zig");
 const URL = @import("../../url.zig").URL;
-const Transpiler = @import("./transpiler.zig");
 const VirtualMachine = JSC.VirtualMachine;
 const IOTask = JSC.IOTask;
 const ComptimeStringMap = @import("../../comptime_string_map.zig").ComptimeStringMap;
diff --git a/src/bun.js/api/server.zig b/src/bun.js/api/server.zig
index 11237844a..bc83a021b 100644
--- a/src/bun.js/api/server.zig
+++ b/src/bun.js/api/server.zig
@@ -70,7 +70,6 @@ const VM = @import("bun").JSC.VM;
 const JSFunction = @import("bun").JSC.JSFunction;
 const Config = @import("../config.zig");
 const URL = @import("../../url.zig").URL;
-const Transpiler = @import("./transpiler.zig");
 const VirtualMachine = JSC.VirtualMachine;
 const IOTask = JSC.IOTask;
 const is_bindgen = JSC.is_bindgen;
@@ -5173,4 +5172,11 @@ pub const SSLServer = NewServer(true, false);
 pub const DebugServer = NewServer(false, true);
 pub const DebugSSLServer = NewServer(true, true);
 
+pub const AnyServer = union(enum) {
+    Server: *Server,
+    SSLServer: *SSLServer,
+    DebugServer: *DebugServer,
+    DebugSSLServer: *DebugSSLServer,
+};
+
 const welcome_page_html_gz = @embedFile("welcome-page.html.gz");