alright thats the rename

Former-commit-id: 0faf61249e76382dfb1aa8721249474eae920753

43 files changed, 2401 insertions, 1964 deletions

diff --git a/.gitignore b/.gitignore
index 70e083c4b..cc43103a1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -37,7 +37,7 @@ out.*
 out
 .parcel-cache
 esbuilddir
-*.jsb
+*.bun
 parceldist
 esbuilddir
 outdir/
@@ -47,4 +47,5 @@ txt.js
 .idea
 .vscode/cpp*
 
-node_modules_*
\ No newline at end of file
+node_modules_*
+*.jsb
\ No newline at end of file
diff --git a/.vscode/launch.json b/.vscode/launch.json
index dced9e0df..193a2c7f3 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -31,6 +31,18 @@
     {
       "type": "lldb",
       "request": "launch",
+      "name": "Discord",
+      "program": "${workspaceFolder}/build/debug/macos-x86_64/bun",
+      "args": [
+        "discord"
+        // "--origin=https://localhost:9000/"
+      ],
+      "cwd": "${workspaceFolder}",
+      "console": "internalConsole"
+    },
+    {
+      "type": "lldb",
+      "request": "launch",
       "name": "Eval",
       "program": "${workspaceFolder}/build/debug/macos-x86_64/spjs",
       "args": [
@@ -99,7 +111,7 @@
     {
       "type": "lldb",
       "request": "launch",
-      "name": "Demo .jsb",
+      "name": "Demo .bun",
       "program": "${workspaceFolder}/build/debug/macos-x86_64/bun",
       "args": [
         "./src/index.tsx",
@@ -113,11 +125,11 @@
     {
       "type": "lldb",
       "request": "launch",
-      "name": "Demo Build .jsb",
+      "name": "Demo Build .bun",
       "program": "${workspaceFolder}/build/debug/macos-x86_64/bun",
       "args": [
         "--origin=http://localhost:9000/",
-        "--new-jsb",
+        "--new-bun",
         "--use=ipwipwipwip-next-donotuse",
         "--platform=browser"
       ],
@@ -136,9 +148,9 @@
     {
       "type": "lldb",
       "request": "launch",
-      "name": "Demo Print .jsb",
+      "name": "Demo Print .bun",
       "program": "${workspaceFolder}/build/debug/macos-x86_64/bun",
-      "args": ["./node_modules.jsb"],
+      "args": ["./node_modules.bun"],
       "cwd": "${workspaceFolder}/demos/simple-react",
       "console": "internalConsole"
     },
diff --git a/buglogs/aug10.md b/buglogs/aug10.md
index 1ea87f2ce..6f69b3830 100644
--- a/buglogs/aug10.md
+++ b/buglogs/aug10.md
@@ -2,7 +2,7 @@
 ModuleNotFound on resolving "object-assign" from "/Users/jarred/Code/bun/demos/css-stress-test/node_modules/react-dom/cjs/"
 ```
 
-Happens with `--platform=browser` when importing react while building the .jsb
+Happens with `--platform=browser` when importing react while building the .bun
 
 `object-assign` doesn't have a `main` field set. That's not a bug; this should work.
 
diff --git a/demos/css-stress-test/nexty/client.development.tsx b/demos/css-stress-test/bun-framework-next/client.development.tsx
index b83d78e01..d046751b2 100644
--- a/demos/css-stress-test/nexty/client.development.tsx
+++ b/demos/css-stress-test/bun-framework-next/client.development.tsx
@@ -187,6 +187,7 @@ let CachedComponent: React.ComponentType;
 
 function _boot(EntryPointNamespace) {
   const PageComponent = EntryPointNamespace.default;
+  
   ReactDOM.hydrate(
     <Container fn={(error) => <div>{JSON.stringify(error)}</div>}>
       <App Component={PageComponent} pageProps={data.props}></App>
diff --git a/demos/css-stress-test/bun-framework-next/index.js b/demos/css-stress-test/bun-framework-next/index.js
new file mode 100644
index 000000000..10adb5205
--- /dev/null
+++ b/demos/css-stress-test/bun-framework-next/index.js
@@ -0,0 +1 @@
+console.log("HI");
diff --git a/demos/css-stress-test/nexty/next-server.tsx b/demos/css-stress-test/bun-framework-next/next-server.tsx
index e69de29bb..e69de29bb 100644
--- a/demos/css-stress-test/nexty/next-server.tsx
+++ b/demos/css-stress-test/bun-framework-next/next-server.tsx
diff --git a/demos/css-stress-test/nexty/package.json b/demos/css-stress-test/bun-framework-next/package.json
index 2399517b7..8fbe38baf 100644
--- a/demos/css-stress-test/nexty/package.json
+++ b/demos/css-stress-test/bun-framework-next/package.json
@@ -1,6 +1,6 @@
 {
-  "name": "wipwipwipwip-next-donotuse",
-  "version": "4.0.0",
+  "name": "bun-framework-next",
+  "version": "0.0.0-0",
   "description": "",
   "main": "package.json",
   "framework": {
diff --git a/demos/css-stress-test/nexty/page-loader.ts b/demos/css-stress-test/bun-framework-next/page-loader.ts
index fdc6f5f28..fdc6f5f28 100644
--- a/demos/css-stress-test/nexty/page-loader.ts
+++ b/demos/css-stress-test/bun-framework-next/page-loader.ts
diff --git a/demos/css-stress-test/nexty/render.tsx b/demos/css-stress-test/bun-framework-next/render.tsx
index e69de29bb..e69de29bb 100644
--- a/demos/css-stress-test/nexty/render.tsx
+++ b/demos/css-stress-test/bun-framework-next/render.tsx
diff --git a/demos/css-stress-test/nexty/renderDocument.tsx b/demos/css-stress-test/bun-framework-next/renderDocument.tsx
index 9fd2e8e07..9fd2e8e07 100644
--- a/demos/css-stress-test/nexty/renderDocument.tsx
+++ b/demos/css-stress-test/bun-framework-next/renderDocument.tsx
diff --git a/demos/css-stress-test/nexty/route-loader.ts b/demos/css-stress-test/bun-framework-next/route-loader.ts
index e69de29bb..e69de29bb 100644
--- a/demos/css-stress-test/nexty/route-loader.ts
+++ b/demos/css-stress-test/bun-framework-next/route-loader.ts
diff --git a/demos/css-stress-test/nexty/server.development.tsx b/demos/css-stress-test/bun-framework-next/server.development.tsx
index 1f0eaee50..1f0eaee50 100644
--- a/demos/css-stress-test/nexty/server.development.tsx
+++ b/demos/css-stress-test/bun-framework-next/server.development.tsx
diff --git a/demos/css-stress-test/nexty/server.production.tsx b/demos/css-stress-test/bun-framework-next/server.production.tsx
index e69de29bb..e69de29bb 100644
--- a/demos/css-stress-test/nexty/server.production.tsx
+++ b/demos/css-stress-test/bun-framework-next/server.production.tsx
diff --git a/demos/css-stress-test/nexty/tsconfig.json b/demos/css-stress-test/bun-framework-next/tsconfig.json
index 679268d71..679268d71 100644
--- a/demos/css-stress-test/nexty/tsconfig.json
+++ b/demos/css-stress-test/bun-framework-next/tsconfig.json
diff --git a/demos/css-stress-test/nexty/index.js b/demos/css-stress-test/nexty/index.js
deleted file mode 100644
index e69de29bb..000000000
--- a/demos/css-stress-test/nexty/index.js
+++ /dev/null
diff --git a/src/allocators.zig b/src/allocators.zig
index 125611956..9a18049dc 100644
--- a/src/allocators.zig
+++ b/src/allocators.zig
@@ -239,7 +239,7 @@ const Mutex = @import("./sync.zig").Mutex;
 /// Stores an initial count in .bss section of the object file
 /// Overflows to heap when count is exceeded.
 pub fn BSSStringList(comptime _count: usize, comptime _item_length: usize) type {
-    // I experimented with string interning here and it was around...maybe 1% when generating a .jsb?
+    // I experimented with string interning here and it was around...maybe 1% when generating a .bun?
     // I tried:
     // - arraybacked list
     // - hashmap list
diff --git a/src/api/schema.d.ts b/src/api/schema.d.ts
index 021f20c3b..39ba7fa82 100644
--- a/src/api/schema.d.ts
+++ b/src/api/schema.d.ts
@@ -1,4 +1,4 @@
-import type {ByteBuffer} from "peechy";
+import type { ByteBuffer } from "peechy";
 
 type byte = number;
 type float = number;
@@ -12,515 +12,661 @@ type int32 = number;
 type float32 = number;
 type uint16 = number;
 type uint32 = number;
-  export enum Loader {
-    jsx = 1,
-    js = 2,
-    ts = 3,
-    tsx = 4,
-    css = 5,
-    file = 6,
-    json = 7
-  }
-  export const LoaderKeys = {
-    1: "jsx",
-    jsx: "jsx",
-    2: "js",
-    js: "js",
-    3: "ts",
-    ts: "ts",
-    4: "tsx",
-    tsx: "tsx",
-    5: "css",
-    css: "css",
-    6: "file",
-    file: "file",
-    7: "json",
-    json: "json"
-  }
-  export enum ResolveMode {
-    disable = 1,
-    lazy = 2,
-    dev = 3,
-    bundle = 4
-  }
-  export const ResolveModeKeys = {
-    1: "disable",
-    disable: "disable",
-    2: "lazy",
-    lazy: "lazy",
-    3: "dev",
-    dev: "dev",
-    4: "bundle",
-    bundle: "bundle"
-  }
-  export enum Platform {
-    browser = 1,
-    node = 2,
-    bun = 3
-  }
-  export const PlatformKeys = {
-    1: "browser",
-    browser: "browser",
-    2: "node",
-    node: "node",
-    3: "bun",
-    bun: "bun"
-  }
-  export enum JSXRuntime {
-    automatic = 1,
-    classic = 2
-  }
-  export const JSXRuntimeKeys = {
-    1: "automatic",
-    automatic: "automatic",
-    2: "classic",
-    classic: "classic"
-  }
-  export enum ScanDependencyMode {
-    app = 1,
-    all = 2
-  }
-  export const ScanDependencyModeKeys = {
-    1: "app",
-    app: "app",
-    2: "all",
-    all: "all"
-  }
-  export enum ModuleImportType {
-    import = 1,
-    require = 2
-  }
-  export const ModuleImportTypeKeys = {
-    1: "import",
-    import: "import",
-    2: "require",
-    require: "require"
-  }
-  export enum DotEnvBehavior {
-    disable = 1,
-    prefix = 2,
-    load_all = 3
-  }
-  export const DotEnvBehaviorKeys = {
-    1: "disable",
-    disable: "disable",
-    2: "prefix",
-    prefix: "prefix",
-    3: "load_all",
-    load_all: "load_all"
-  }
-  export enum TransformResponseStatus {
-    success = 1,
-    fail = 2
-  }
-  export const TransformResponseStatusKeys = {
-    1: "success",
-    success: "success",
-    2: "fail",
-    fail: "fail"
-  }
-  export enum MessageKind {
-    err = 1,
-    warn = 2,
-    note = 3,
-    debug = 4
-  }
-  export const MessageKindKeys = {
-    1: "err",
-    err: "err",
-    2: "warn",
-    warn: "warn",
-    3: "note",
-    note: "note",
-    4: "debug",
-    debug: "debug"
-  }
-  export enum Reloader {
-    disable = 1,
-    live = 2,
-    fast_refresh = 3
-  }
-  export const ReloaderKeys = {
-    1: "disable",
-    disable: "disable",
-    2: "live",
-    live: "live",
-    3: "fast_refresh",
-    fast_refresh: "fast_refresh"
-  }
-  export enum WebsocketMessageKind {
-    welcome = 1,
-    file_change_notification = 2,
-    build_success = 3,
-    build_fail = 4,
-    manifest_success = 5,
-    manifest_fail = 6
-  }
-  export const WebsocketMessageKindKeys = {
-    1: "welcome",
-    welcome: "welcome",
-    2: "file_change_notification",
-    file_change_notification: "file_change_notification",
-    3: "build_success",
-    build_success: "build_success",
-    4: "build_fail",
-    build_fail: "build_fail",
-    5: "manifest_success",
-    manifest_success: "manifest_success",
-    6: "manifest_fail",
-    manifest_fail: "manifest_fail"
-  }
-  export enum WebsocketCommandKind {
-    build = 1,
-    manifest = 2
-  }
-  export const WebsocketCommandKindKeys = {
-    1: "build",
-    build: "build",
-    2: "manifest",
-    manifest: "manifest"
-  }
-  export interface JSX {
-    factory: string;
-    runtime: JSXRuntime;
-    fragment: string;
-    development: boolean;
-    import_source: string;
-    react_fast_refresh: boolean;
-  }
-
-  export interface StringPointer {
-    offset: uint32;
-    length: uint32;
-  }
-
-  export interface JavascriptBundledModule {
-    path: StringPointer;
-    code: StringPointer;
-    package_id: uint32;
-    id: uint32;
-    path_extname_length: byte;
-  }
-
-  export interface JavascriptBundledPackage {
-    name: StringPointer;
-    version: StringPointer;
-    hash: uint32;
-    modules_offset: uint32;
-    modules_length: uint32;
-  }
-
-  export interface JavascriptBundle {
-    modules: JavascriptBundledModule[];
-    packages: JavascriptBundledPackage[];
-    etag: Uint8Array;
-    generated_at: uint32;
-    app_package_json_dependencies_hash: Uint8Array;
-    import_from_name: Uint8Array;
-    manifest_string: Uint8Array;
-  }
-
-  export interface JavascriptBundleContainer {
-    bundle_format_version?: uint32;
-    bundle?: JavascriptBundle;
-    framework?: LoadedFramework;
-    routes?: LoadedRouteConfig;
-    code_length?: uint32;
-  }
-
-  export interface ModuleImportRecord {
-    kind: ModuleImportType;
-    path: string;
-    dynamic: boolean;
-  }
-
-  export interface Module {
-    path: string;
-    imports: ModuleImportRecord[];
-  }
-
-  export interface StringMap {
-    keys: string[];
-    values: string[];
-  }
-
-  export interface LoaderMap {
-    extensions: string[];
-    loaders: Loader[];
-  }
-
-  export interface EnvConfig {
-    prefix?: string;
-    defaults?: StringMap;
-  }
-
-  export interface LoadedEnvConfig {
-    dotenv: DotEnvBehavior;
-    defaults: StringMap;
-    prefix: string;
-  }
-
-  export interface FrameworkConfig {
-    package?: string;
-    client?: string;
-    server?: string;
-    development?: boolean;
-    client_env?: EnvConfig;
-    server_env?: EnvConfig;
-  }
-
-  export interface LoadedFramework {
-    entry_point: string;
-    package: string;
-    development: boolean;
-    client: boolean;
-    env: LoadedEnvConfig;
-  }
-
-  export interface LoadedRouteConfig {
-    dir: string;
-    extensions: string[];
-    static_dir: string;
-    asset_prefix: string;
-  }
-
-  export interface RouteConfig {
-    dir?: string[];
-    extensions?: string[];
-    static_dir?: string;
-    asset_prefix?: string;
-  }
-
-  export interface TransformOptions {
-    jsx?: JSX;
-    tsconfig_override?: string;
-    resolve?: ResolveMode;
-    origin?: string;
-    absolute_working_dir?: string;
-    define?: StringMap;
-    preserve_symlinks?: boolean;
-    entry_points?: string[];
-    write?: boolean;
-    inject?: string[];
-    output_dir?: string;
-    external?: string[];
-    loaders?: LoaderMap;
-    main_fields?: string[];
-    platform?: Platform;
-    serve?: boolean;
-    extension_order?: string[];
-    only_scan_dependencies?: ScanDependencyMode;
-    generate_node_module_bundle?: boolean;
-    node_modules_bundle_path?: string;
-    node_modules_bundle_path_server?: string;
-    framework?: FrameworkConfig;
-    router?: RouteConfig;
-  }
-
-  export interface FileHandle {
-    path: string;
-    size: uint;
-    fd: uint;
-  }
-
-  export interface Transform {
-    handle?: FileHandle;
-    path?: string;
-    contents?: Uint8Array;
-    loader?: Loader;
-    options?: TransformOptions;
-  }
-
-  export interface OutputFile {
-    data: Uint8Array;
-    path: string;
-  }
-
-  export interface TransformResponse {
-    status: TransformResponseStatus;
-    files: OutputFile[];
-    errors: Message[];
-  }
-
-  export interface Location {
-    file: string;
-    namespace: string;
-    line: int32;
-    column: int32;
-    line_text: string;
-    suggestion: string;
-    offset: uint;
-  }
-
-  export interface MessageData {
-    text?: string;
-    location?: Location;
-  }
-
-  export interface Message {
-    kind: MessageKind;
-    data: MessageData;
-    notes: MessageData[];
-  }
-
-  export interface Log {
-    warnings: uint32;
-    errors: uint32;
-    msgs: Message[];
-  }
-
-  export interface WebsocketMessage {
-    timestamp: uint32;
-    kind: WebsocketMessageKind;
-  }
-
-  export interface WebsocketMessageWelcome {
-    epoch: uint32;
-    javascriptReloader: Reloader;
-  }
-
-  export interface WebsocketMessageFileChangeNotification {
-    id: uint32;
-    loader: Loader;
-  }
-
-  export interface WebsocketCommand {
-    kind: WebsocketCommandKind;
-    timestamp: uint32;
-  }
-
-  export interface WebsocketCommandBuild {
-    id: uint32;
-  }
-
-  export interface WebsocketCommandManifest {
-    id: uint32;
-  }
-
-  export interface WebsocketMessageBuildSuccess {
-    id: uint32;
-    from_timestamp: uint32;
-    loader: Loader;
-    module_path: string;
-    blob_length: uint32;
-  }
-
-  export interface WebsocketMessageBuildFailure {
-    id: uint32;
-    from_timestamp: uint32;
-    loader: Loader;
-    module_path: string;
-    log: Log;
-  }
-
-  export interface DependencyManifest {
-    ids: Uint32Array;
-  }
-
-  export interface FileList {
-    ptrs: StringPointer[];
-    files: string;
-  }
-
-  export interface WebsocketMessageResolveIDs {
-    id: Uint32Array;
-    list: FileList;
-  }
-
-  export interface WebsocketCommandResolveIDs {
-    ptrs: StringPointer[];
-    files: string;
-  }
-
-  export interface WebsocketMessageManifestSuccess {
-    id: uint32;
-    module_path: string;
-    loader: Loader;
-    manifest: DependencyManifest;
-  }
-
-  export interface WebsocketMessageManifestFailure {
-    id: uint32;
-    from_timestamp: uint32;
-    loader: Loader;
-    log: Log;
-  }
-
-  export declare function  encodeJSX(message: JSX, bb: ByteBuffer): void;
-  export declare function decodeJSX(buffer: ByteBuffer): JSX;
-  export declare function  encodeStringPointer(message: StringPointer, bb: ByteBuffer): void;
-  export declare function decodeStringPointer(buffer: ByteBuffer): StringPointer;
-  export declare function  encodeJavascriptBundledModule(message: JavascriptBundledModule, bb: ByteBuffer): void;
-  export declare function decodeJavascriptBundledModule(buffer: ByteBuffer): JavascriptBundledModule;
-  export declare function  encodeJavascriptBundledPackage(message: JavascriptBundledPackage, bb: ByteBuffer): void;
-  export declare function decodeJavascriptBundledPackage(buffer: ByteBuffer): JavascriptBundledPackage;
-  export declare function  encodeJavascriptBundle(message: JavascriptBundle, bb: ByteBuffer): void;
-  export declare function decodeJavascriptBundle(buffer: ByteBuffer): JavascriptBundle;
-  export declare function  encodeJavascriptBundleContainer(message: JavascriptBundleContainer, bb: ByteBuffer): void;
-  export declare function decodeJavascriptBundleContainer(buffer: ByteBuffer): JavascriptBundleContainer;
-  export declare function  encodeModuleImportRecord(message: ModuleImportRecord, bb: ByteBuffer): void;
-  export declare function decodeModuleImportRecord(buffer: ByteBuffer): ModuleImportRecord;
-  export declare function  encodeModule(message: Module, bb: ByteBuffer): void;
-  export declare function decodeModule(buffer: ByteBuffer): Module;
-  export declare function  encodeStringMap(message: StringMap, bb: ByteBuffer): void;
-  export declare function decodeStringMap(buffer: ByteBuffer): StringMap;
-  export declare function  encodeLoaderMap(message: LoaderMap, bb: ByteBuffer): void;
-  export declare function decodeLoaderMap(buffer: ByteBuffer): LoaderMap;
-  export declare function  encodeEnvConfig(message: EnvConfig, bb: ByteBuffer): void;
-  export declare function decodeEnvConfig(buffer: ByteBuffer): EnvConfig;
-  export declare function  encodeLoadedEnvConfig(message: LoadedEnvConfig, bb: ByteBuffer): void;
-  export declare function decodeLoadedEnvConfig(buffer: ByteBuffer): LoadedEnvConfig;
-  export declare function  encodeFrameworkConfig(message: FrameworkConfig, bb: ByteBuffer): void;
-  export declare function decodeFrameworkConfig(buffer: ByteBuffer): FrameworkConfig;
-  export declare function  encodeLoadedFramework(message: LoadedFramework, bb: ByteBuffer): void;
-  export declare function decodeLoadedFramework(buffer: ByteBuffer): LoadedFramework;
-  export declare function  encodeLoadedRouteConfig(message: LoadedRouteConfig, bb: ByteBuffer): void;
-  export declare function decodeLoadedRouteConfig(buffer: ByteBuffer): LoadedRouteConfig;
-  export declare function  encodeRouteConfig(message: RouteConfig, bb: ByteBuffer): void;
-  export declare function decodeRouteConfig(buffer: ByteBuffer): RouteConfig;
-  export declare function  encodeTransformOptions(message: TransformOptions, bb: ByteBuffer): void;
-  export declare function decodeTransformOptions(buffer: ByteBuffer): TransformOptions;
-  export declare function  encodeFileHandle(message: FileHandle, bb: ByteBuffer): void;
-  export declare function decodeFileHandle(buffer: ByteBuffer): FileHandle;
-  export declare function  encodeTransform(message: Transform, bb: ByteBuffer): void;
-  export declare function decodeTransform(buffer: ByteBuffer): Transform;
-  export declare function  encodeOutputFile(message: OutputFile, bb: ByteBuffer): void;
-  export declare function decodeOutputFile(buffer: ByteBuffer): OutputFile;
-  export declare function  encodeTransformResponse(message: TransformResponse, bb: ByteBuffer): void;
-  export declare function decodeTransformResponse(buffer: ByteBuffer): TransformResponse;
-  export declare function  encodeLocation(message: Location, bb: ByteBuffer): void;
-  export declare function decodeLocation(buffer: ByteBuffer): Location;
-  export declare function  encodeMessageData(message: MessageData, bb: ByteBuffer): void;
-  export declare function decodeMessageData(buffer: ByteBuffer): MessageData;
-  export declare function  encodeMessage(message: Message, bb: ByteBuffer): void;
-  export declare function decodeMessage(buffer: ByteBuffer): Message;
-  export declare function  encodeLog(message: Log, bb: ByteBuffer): void;
-  export declare function decodeLog(buffer: ByteBuffer): Log;
-  export declare function  encodeWebsocketMessage(message: WebsocketMessage, bb: ByteBuffer): void;
-  export declare function decodeWebsocketMessage(buffer: ByteBuffer): WebsocketMessage;
-  export declare function  encodeWebsocketMessageWelcome(message: WebsocketMessageWelcome, bb: ByteBuffer): void;
-  export declare function decodeWebsocketMessageWelcome(buffer: ByteBuffer): WebsocketMessageWelcome;
-  export declare function  encodeWebsocketMessageFileChangeNotification(message: WebsocketMessageFileChangeNotification, bb: ByteBuffer): void;
-  export declare function decodeWebsocketMessageFileChangeNotification(buffer: ByteBuffer): WebsocketMessageFileChangeNotification;
-  export declare function  encodeWebsocketCommand(message: WebsocketCommand, bb: ByteBuffer): void;
-  export declare function decodeWebsocketCommand(buffer: ByteBuffer): WebsocketCommand;
-  export declare function  encodeWebsocketCommandBuild(message: WebsocketCommandBuild, bb: ByteBuffer): void;
-  export declare function decodeWebsocketCommandBuild(buffer: ByteBuffer): WebsocketCommandBuild;
-  export declare function  encodeWebsocketCommandManifest(message: WebsocketCommandManifest, bb: ByteBuffer): void;
-  export declare function decodeWebsocketCommandManifest(buffer: ByteBuffer): WebsocketCommandManifest;
-  export declare function  encodeWebsocketMessageBuildSuccess(message: WebsocketMessageBuildSuccess, bb: ByteBuffer): void;
-  export declare function decodeWebsocketMessageBuildSuccess(buffer: ByteBuffer): WebsocketMessageBuildSuccess;
-  export declare function  encodeWebsocketMessageBuildFailure(message: WebsocketMessageBuildFailure, bb: ByteBuffer): void;
-  export declare function decodeWebsocketMessageBuildFailure(buffer: ByteBuffer): WebsocketMessageBuildFailure;
-  export declare function  encodeDependencyManifest(message: DependencyManifest, bb: ByteBuffer): void;
-  export declare function decodeDependencyManifest(buffer: ByteBuffer): DependencyManifest;
-  export declare function  encodeFileList(message: FileList, bb: ByteBuffer): void;
-  export declare function decodeFileList(buffer: ByteBuffer): FileList;
-  export declare function  encodeWebsocketMessageResolveIDs(message: WebsocketMessageResolveIDs, bb: ByteBuffer): void;
-  export declare function decodeWebsocketMessageResolveIDs(buffer: ByteBuffer): WebsocketMessageResolveIDs;
-  export declare function  encodeWebsocketCommandResolveIDs(message: WebsocketCommandResolveIDs, bb: ByteBuffer): void;
-  export declare function decodeWebsocketCommandResolveIDs(buffer: ByteBuffer): WebsocketCommandResolveIDs;
-  export declare function  encodeWebsocketMessageManifestSuccess(message: WebsocketMessageManifestSuccess, bb: ByteBuffer): void;
-  export declare function decodeWebsocketMessageManifestSuccess(buffer: ByteBuffer): WebsocketMessageManifestSuccess;
-  export declare function  encodeWebsocketMessageManifestFailure(message: WebsocketMessageManifestFailure, bb: ByteBuffer): void;
-  export declare function decodeWebsocketMessageManifestFailure(buffer: ByteBuffer): WebsocketMessageManifestFailure;
+export enum Loader {
+  jsx = 1,
+  js = 2,
+  ts = 3,
+  tsx = 4,
+  css = 5,
+  file = 6,
+  json = 7,
+}
+export const LoaderKeys = {
+  1: "jsx",
+  jsx: "jsx",
+  2: "js",
+  js: "js",
+  3: "ts",
+  ts: "ts",
+  4: "tsx",
+  tsx: "tsx",
+  5: "css",
+  css: "css",
+  6: "file",
+  file: "file",
+  7: "json",
+  json: "json",
+};
+export enum ResolveMode {
+  disable = 1,
+  lazy = 2,
+  dev = 3,
+  bundle = 4,
+}
+export const ResolveModeKeys = {
+  1: "disable",
+  disable: "disable",
+  2: "lazy",
+  lazy: "lazy",
+  3: "dev",
+  dev: "dev",
+  4: "bundle",
+  bundle: "bundle",
+};
+export enum Platform {
+  browser = 1,
+  node = 2,
+  bun = 3,
+}
+export const PlatformKeys = {
+  1: "browser",
+  browser: "browser",
+  2: "node",
+  node: "node",
+  3: "bun",
+  bun: "bun",
+};
+export enum JSXRuntime {
+  automatic = 1,
+  classic = 2,
+}
+export const JSXRuntimeKeys = {
+  1: "automatic",
+  automatic: "automatic",
+  2: "classic",
+  classic: "classic",
+};
+export enum ScanDependencyMode {
+  app = 1,
+  all = 2,
+}
+export const ScanDependencyModeKeys = {
+  1: "app",
+  app: "app",
+  2: "all",
+  all: "all",
+};
+export enum ModuleImportType {
+  import = 1,
+  require = 2,
+}
+export const ModuleImportTypeKeys = {
+  1: "import",
+  import: "import",
+  2: "require",
+  require: "require",
+};
+export enum DotEnvBehavior {
+  disable = 1,
+  prefix = 2,
+  load_all = 3,
+}
+export const DotEnvBehaviorKeys = {
+  1: "disable",
+  disable: "disable",
+  2: "prefix",
+  prefix: "prefix",
+  3: "load_all",
+  load_all: "load_all",
+};
+export enum TransformResponseStatus {
+  success = 1,
+  fail = 2,
+}
+export const TransformResponseStatusKeys = {
+  1: "success",
+  success: "success",
+  2: "fail",
+  fail: "fail",
+};
+export enum MessageKind {
+  err = 1,
+  warn = 2,
+  note = 3,
+  debug = 4,
+}
+export const MessageKindKeys = {
+  1: "err",
+  err: "err",
+  2: "warn",
+  warn: "warn",
+  3: "note",
+  note: "note",
+  4: "debug",
+  debug: "debug",
+};
+export enum Reloader {
+  disable = 1,
+  live = 2,
+  fast_refresh = 3,
+}
+export const ReloaderKeys = {
+  1: "disable",
+  disable: "disable",
+  2: "live",
+  live: "live",
+  3: "fast_refresh",
+  fast_refresh: "fast_refresh",
+};
+export enum WebsocketMessageKind {
+  welcome = 1,
+  file_change_notification = 2,
+  build_success = 3,
+  build_fail = 4,
+  manifest_success = 5,
+  manifest_fail = 6,
+}
+export const WebsocketMessageKindKeys = {
+  1: "welcome",
+  welcome: "welcome",
+  2: "file_change_notification",
+  file_change_notification: "file_change_notification",
+  3: "build_success",
+  build_success: "build_success",
+  4: "build_fail",
+  build_fail: "build_fail",
+  5: "manifest_success",
+  manifest_success: "manifest_success",
+  6: "manifest_fail",
+  manifest_fail: "manifest_fail",
+};
+export enum WebsocketCommandKind {
+  build = 1,
+  manifest = 2,
+}
+export const WebsocketCommandKindKeys = {
+  1: "build",
+  build: "build",
+  2: "manifest",
+  manifest: "manifest",
+};
+export interface JSX {
+  factory: string;
+  runtime: JSXRuntime;
+  fragment: string;
+  development: boolean;
+  import_source: string;
+  react_fast_refresh: boolean;
+}
+
+export interface StringPointer {
+  offset: uint32;
+  length: uint32;
+}
+
+export interface JavascriptBundledModule {
+  path: StringPointer;
+  code: StringPointer;
+  package_id: uint32;
+  id: uint32;
+  path_extname_length: byte;
+}
+
+export interface JavascriptBundledPackage {
+  name: StringPointer;
+  version: StringPointer;
+  hash: uint32;
+  modules_offset: uint32;
+  modules_length: uint32;
+}
+
+export interface JavascriptBundle {
+  modules: JavascriptBundledModule[];
+  packages: JavascriptBundledPackage[];
+  etag: Uint8Array;
+  generated_at: uint32;
+  app_package_json_dependencies_hash: Uint8Array;
+  import_from_name: Uint8Array;
+  manifest_string: Uint8Array;
+}
+
+export interface JavascriptBundleContainer {
+  bundle_format_version?: uint32;
+  bundle?: JavascriptBundle;
+  framework?: LoadedFramework;
+  routes?: LoadedRouteConfig;
+  code_length?: uint32;
+}
+
+export interface ModuleImportRecord {
+  kind: ModuleImportType;
+  path: string;
+  dynamic: boolean;
+}
+
+export interface Module {
+  path: string;
+  imports: ModuleImportRecord[];
+}
+
+export interface StringMap {
+  keys: string[];
+  values: string[];
+}
+
+export interface LoaderMap {
+  extensions: string[];
+  loaders: Loader[];
+}
+
+export interface EnvConfig {
+  prefix?: string;
+  defaults?: StringMap;
+}
+
+export interface LoadedEnvConfig {
+  dotenv: DotEnvBehavior;
+  defaults: StringMap;
+  prefix: string;
+}
+
+export interface FrameworkConfig {
+  package?: string;
+  client?: string;
+  server?: string;
+  development?: boolean;
+  client_env?: EnvConfig;
+  server_env?: EnvConfig;
+}
+
+export interface LoadedFramework {
+  entry_point: string;
+  package: string;
+  development: boolean;
+  client: boolean;
+  env: LoadedEnvConfig;
+}
+
+export interface LoadedRouteConfig {
+  dir: string;
+  extensions: string[];
+  static_dir: string;
+  asset_prefix: string;
+}
+
+export interface RouteConfig {
+  dir?: string[];
+  extensions?: string[];
+  static_dir?: string;
+  asset_prefix?: string;
+}
+
+export interface TransformOptions {
+  jsx?: JSX;
+  tsconfig_override?: string;
+  resolve?: ResolveMode;
+  origin?: string;
+  absolute_working_dir?: string;
+  define?: StringMap;
+  preserve_symlinks?: boolean;
+  entry_points?: string[];
+  write?: boolean;
+  inject?: string[];
+  output_dir?: string;
+  external?: string[];
+  loaders?: LoaderMap;
+  main_fields?: string[];
+  platform?: Platform;
+  serve?: boolean;
+  extension_order?: string[];
+  generate_node_module_bundle?: boolean;
+  node_modules_bundle_path?: string;
+  node_modules_bundle_path_server?: string;
+  framework?: FrameworkConfig;
+  router?: RouteConfig;
+}
+
+export interface FileHandle {
+  path: string;
+  size: uint;
+  fd: uint;
+}
+
+export interface Transform {
+  handle?: FileHandle;
+  path?: string;
+  contents?: Uint8Array;
+  loader?: Loader;
+  options?: TransformOptions;
+}
+
+export interface OutputFile {
+  data: Uint8Array;
+  path: string;
+}
+
+export interface TransformResponse {
+  status: TransformResponseStatus;
+  files: OutputFile[];
+  errors: Message[];
+}
+
+export interface Location {
+  file: string;
+  namespace: string;
+  line: int32;
+  column: int32;
+  line_text: string;
+  suggestion: string;
+  offset: uint;
+}
+
+export interface MessageData {
+  text?: string;
+  location?: Location;
+}
+
+export interface Message {
+  kind: MessageKind;
+  data: MessageData;
+  notes: MessageData[];
+}
+
+export interface Log {
+  warnings: uint32;
+  errors: uint32;
+  msgs: Message[];
+}
+
+export interface WebsocketMessage {
+  timestamp: uint32;
+  kind: WebsocketMessageKind;
+}
+
+export interface WebsocketMessageWelcome {
+  epoch: uint32;
+  javascriptReloader: Reloader;
+}
+
+export interface WebsocketMessageFileChangeNotification {
+  id: uint32;
+  loader: Loader;
+}
+
+export interface WebsocketCommand {
+  kind: WebsocketCommandKind;
+  timestamp: uint32;
+}
+
+export interface WebsocketCommandBuild {
+  id: uint32;
+}
+
+export interface WebsocketCommandManifest {
+  id: uint32;
+}
+
+export interface WebsocketMessageBuildSuccess {
+  id: uint32;
+  from_timestamp: uint32;
+  loader: Loader;
+  module_path: string;
+  blob_length: uint32;
+}
+
+export interface WebsocketMessageBuildFailure {
+  id: uint32;
+  from_timestamp: uint32;
+  loader: Loader;
+  module_path: string;
+  log: Log;
+}
+
+export interface DependencyManifest {
+  ids: Uint32Array;
+}
+
+export interface FileList {
+  ptrs: StringPointer[];
+  files: string;
+}
+
+export interface WebsocketMessageResolveIDs {
+  id: Uint32Array;
+  list: FileList;
+}
+
+export interface WebsocketCommandResolveIDs {
+  ptrs: StringPointer[];
+  files: string;
+}
+
+export interface WebsocketMessageManifestSuccess {
+  id: uint32;
+  module_path: string;
+  loader: Loader;
+  manifest: DependencyManifest;
+}
+
+export interface WebsocketMessageManifestFailure {
+  id: uint32;
+  from_timestamp: uint32;
+  loader: Loader;
+  log: Log;
+}
+
+export declare function encodeJSX(message: JSX, bb: ByteBuffer): void;
+export declare function decodeJSX(buffer: ByteBuffer): JSX;
+export declare function encodeStringPointer(
+  message: StringPointer,
+  bb: ByteBuffer
+): void;
+export declare function decodeStringPointer(buffer: ByteBuffer): StringPointer;
+export declare function encodeJavascriptBundledModule(
+  message: JavascriptBundledModule,
+  bb: ByteBuffer
+): void;
+export declare function decodeJavascriptBundledModule(
+  buffer: ByteBuffer
+): JavascriptBundledModule;
+export declare function encodeJavascriptBundledPackage(
+  message: JavascriptBundledPackage,
+  bb: ByteBuffer
+): void;
+export declare function decodeJavascriptBundledPackage(
+  buffer: ByteBuffer
+): JavascriptBundledPackage;
+export declare function encodeJavascriptBundle(
+  message: JavascriptBundle,
+  bb: ByteBuffer
+): void;
+export declare function decodeJavascriptBundle(
+  buffer: ByteBuffer
+): JavascriptBundle;
+export declare function encodeJavascriptBundleContainer(
+  message: JavascriptBundleContainer,
+  bb: ByteBuffer
+): void;
+export declare function decodeJavascriptBundleContainer(
+  buffer: ByteBuffer
+): JavascriptBundleContainer;
+export declare function encodeModuleImportRecord(
+  message: ModuleImportRecord,
+  bb: ByteBuffer
+): void;
+export declare function decodeModuleImportRecord(
+  buffer: ByteBuffer
+): ModuleImportRecord;
+export declare function encodeModule(message: Module, bb: ByteBuffer): void;
+export declare function decodeModule(buffer: ByteBuffer): Module;
+export declare function encodeStringMap(
+  message: StringMap,
+  bb: ByteBuffer
+): void;
+export declare function decodeStringMap(buffer: ByteBuffer): StringMap;
+export declare function encodeLoaderMap(
+  message: LoaderMap,
+  bb: ByteBuffer
+): void;
+export declare function decodeLoaderMap(buffer: ByteBuffer): LoaderMap;
+export declare function encodeEnvConfig(
+  message: EnvConfig,
+  bb: ByteBuffer
+): void;
+export declare function decodeEnvConfig(buffer: ByteBuffer): EnvConfig;
+export declare function encodeLoadedEnvConfig(
+  message: LoadedEnvConfig,
+  bb: ByteBuffer
+): void;
+export declare function decodeLoadedEnvConfig(
+  buffer: ByteBuffer
+): LoadedEnvConfig;
+export declare function encodeFrameworkConfig(
+  message: FrameworkConfig,
+  bb: ByteBuffer
+): void;
+export declare function decodeFrameworkConfig(
+  buffer: ByteBuffer
+): FrameworkConfig;
+export declare function encodeLoadedFramework(
+  message: LoadedFramework,
+  bb: ByteBuffer
+): void;
+export declare function decodeLoadedFramework(
+  buffer: ByteBuffer
+): LoadedFramework;
+export declare function encodeLoadedRouteConfig(
+  message: LoadedRouteConfig,
+  bb: ByteBuffer
+): void;
+export declare function decodeLoadedRouteConfig(
+  buffer: ByteBuffer
+): LoadedRouteConfig;
+export declare function encodeRouteConfig(
+  message: RouteConfig,
+  bb: ByteBuffer
+): void;
+export declare function decodeRouteConfig(buffer: ByteBuffer): RouteConfig;
+export declare function encodeTransformOptions(
+  message: TransformOptions,
+  bb: ByteBuffer
+): void;
+export declare function decodeTransformOptions(
+  buffer: ByteBuffer
+): TransformOptions;
+export declare function encodeFileHandle(
+  message: FileHandle,
+  bb: ByteBuffer
+): void;
+export declare function decodeFileHandle(buffer: ByteBuffer): FileHandle;
+export declare function encodeTransform(
+  message: Transform,
+  bb: ByteBuffer
+): void;
+export declare function decodeTransform(buffer: ByteBuffer): Transform;
+export declare function encodeOutputFile(
+  message: OutputFile,
+  bb: ByteBuffer
+): void;
+export declare function decodeOutputFile(buffer: ByteBuffer): OutputFile;
+export declare function encodeTransformResponse(
+  message: TransformResponse,
+  bb: ByteBuffer
+): void;
+export declare function decodeTransformResponse(
+  buffer: ByteBuffer
+): TransformResponse;
+export declare function encodeLocation(message: Location, bb: ByteBuffer): void;
+export declare function decodeLocation(buffer: ByteBuffer): Location;
+export declare function encodeMessageData(
+  message: MessageData,
+  bb: ByteBuffer
+): void;
+export declare function decodeMessageData(buffer: ByteBuffer): MessageData;
+export declare function encodeMessage(message: Message, bb: ByteBuffer): void;
+export declare function decodeMessage(buffer: ByteBuffer): Message;
+export declare function encodeLog(message: Log, bb: ByteBuffer): void;
+export declare function decodeLog(buffer: ByteBuffer): Log;
+export declare function encodeWebsocketMessage(
+  message: WebsocketMessage,
+  bb: ByteBuffer
+): void;
+export declare function decodeWebsocketMessage(
+  buffer: ByteBuffer
+): WebsocketMessage;
+export declare function encodeWebsocketMessageWelcome(
+  message: WebsocketMessageWelcome,
+  bb: ByteBuffer
+): void;
+export declare function decodeWebsocketMessageWelcome(
+  buffer: ByteBuffer
+): WebsocketMessageWelcome;
+export declare function encodeWebsocketMessageFileChangeNotification(
+  message: WebsocketMessageFileChangeNotification,
+  bb: ByteBuffer
+): void;
+export declare function decodeWebsocketMessageFileChangeNotification(
+  buffer: ByteBuffer
+): WebsocketMessageFileChangeNotification;
+export declare function encodeWebsocketCommand(
+  message: WebsocketCommand,
+  bb: ByteBuffer
+): void;
+export declare function decodeWebsocketCommand(
+  buffer: ByteBuffer
+): WebsocketCommand;
+export declare function encodeWebsocketCommandBuild(
+  message: WebsocketCommandBuild,
+  bb: ByteBuffer
+): void;
+export declare function decodeWebsocketCommandBuild(
+  buffer: ByteBuffer
+): WebsocketCommandBuild;
+export declare function encodeWebsocketCommandManifest(
+  message: WebsocketCommandManifest,
+  bb: ByteBuffer
+): void;
+export declare function decodeWebsocketCommandManifest(
+  buffer: ByteBuffer
+): WebsocketCommandManifest;
+export declare function encodeWebsocketMessageBuildSuccess(
+  message: WebsocketMessageBuildSuccess,
+  bb: ByteBuffer
+): void;
+export declare function decodeWebsocketMessageBuildSuccess(
+  buffer: ByteBuffer
+): WebsocketMessageBuildSuccess;
+export declare function encodeWebsocketMessageBuildFailure(
+  message: WebsocketMessageBuildFailure,
+  bb: ByteBuffer
+): void;
+export declare function decodeWebsocketMessageBuildFailure(
+  buffer: ByteBuffer
+): WebsocketMessageBuildFailure;
+export declare function encodeDependencyManifest(
+  message: DependencyManifest,
+  bb: ByteBuffer
+): void;
+export declare function decodeDependencyManifest(
+  buffer: ByteBuffer
+): DependencyManifest;
+export declare function encodeFileList(message: FileList, bb: ByteBuffer): void;
+export declare function decodeFileList(buffer: ByteBuffer): FileList;
+export declare function encodeWebsocketMessageResolveIDs(
+  message: WebsocketMessageResolveIDs,
+  bb: ByteBuffer
+): void;
+export declare function decodeWebsocketMessageResolveIDs(
+  buffer: ByteBuffer
+): WebsocketMessageResolveIDs;
+export declare function encodeWebsocketCommandResolveIDs(
+  message: WebsocketCommandResolveIDs,
+  bb: ByteBuffer
+): void;
+export declare function decodeWebsocketCommandResolveIDs(
+  buffer: ByteBuffer
+): WebsocketCommandResolveIDs;
+export declare function encodeWebsocketMessageManifestSuccess(
+  message: WebsocketMessageManifestSuccess,
+  bb: ByteBuffer
+): void;
+export declare function decodeWebsocketMessageManifestSuccess(
+  buffer: ByteBuffer
+): WebsocketMessageManifestSuccess;
+export declare function encodeWebsocketMessageManifestFailure(
+  message: WebsocketMessageManifestFailure,
+  bb: ByteBuffer
+): void;
+export declare function decodeWebsocketMessageManifestFailure(
+  buffer: ByteBuffer
+): WebsocketMessageManifestFailure;
diff --git a/src/api/schema.js b/src/api/schema.js
index b5768117e..b27266160 100644
--- a/src/api/schema.js
+++ b/src/api/schema.js
@@ -1,82 +1,82 @@
 const Loader = {
-  "1": 1,
-  "2": 2,
-  "3": 3,
-  "4": 4,
-  "5": 5,
-  "6": 6,
-  "7": 7,
-  "jsx": 1,
-  "js": 2,
-  "ts": 3,
-  "tsx": 4,
-  "css": 5,
-  "file": 6,
-  "json": 7
+  1: 1,
+  2: 2,
+  3: 3,
+  4: 4,
+  5: 5,
+  6: 6,
+  7: 7,
+  jsx: 1,
+  js: 2,
+  ts: 3,
+  tsx: 4,
+  css: 5,
+  file: 6,
+  json: 7,
 };
 const LoaderKeys = {
-  "1": "jsx",
-  "2": "js",
-  "3": "ts",
-  "4": "tsx",
-  "5": "css",
-  "6": "file",
-  "7": "json",
-  "jsx": "jsx",
-  "js": "js",
-  "ts": "ts",
-  "tsx": "tsx",
-  "css": "css",
-  "file": "file",
-  "json": "json"
+  1: "jsx",
+  2: "js",
+  3: "ts",
+  4: "tsx",
+  5: "css",
+  6: "file",
+  7: "json",
+  jsx: "jsx",
+  js: "js",
+  ts: "ts",
+  tsx: "tsx",
+  css: "css",
+  file: "file",
+  json: "json",
 };
 const ResolveMode = {
-  "1": 1,
-  "2": 2,
-  "3": 3,
-  "4": 4,
-  "disable": 1,
-  "lazy": 2,
-  "dev": 3,
-  "bundle": 4
+  1: 1,
+  2: 2,
+  3: 3,
+  4: 4,
+  disable: 1,
+  lazy: 2,
+  dev: 3,
+  bundle: 4,
 };
 const ResolveModeKeys = {
-  "1": "disable",
-  "2": "lazy",
-  "3": "dev",
-  "4": "bundle",
-  "disable": "disable",
-  "lazy": "lazy",
-  "dev": "dev",
-  "bundle": "bundle"
+  1: "disable",
+  2: "lazy",
+  3: "dev",
+  4: "bundle",
+  disable: "disable",
+  lazy: "lazy",
+  dev: "dev",
+  bundle: "bundle",
 };
 const Platform = {
-  "1": 1,
-  "2": 2,
-  "3": 3,
-  "browser": 1,
-  "node": 2,
-  "bun": 3
+  1: 1,
+  2: 2,
+  3: 3,
+  browser: 1,
+  node: 2,
+  bun: 3,
 };
 const PlatformKeys = {
-  "1": "browser",
-  "2": "node",
-  "3": "bun",
-  "browser": "browser",
-  "node": "node",
-  "bun": "bun"
+  1: "browser",
+  2: "node",
+  3: "bun",
+  browser: "browser",
+  node: "node",
+  bun: "bun",
 };
 const JSXRuntime = {
-  "1": 1,
-  "2": 2,
-  "automatic": 1,
-  "classic": 2
+  1: 1,
+  2: 2,
+  automatic: 1,
+  classic: 2,
 };
 const JSXRuntimeKeys = {
-  "1": "automatic",
-  "2": "classic",
-  "automatic": "automatic",
-  "classic": "classic"
+  1: "automatic",
+  2: "classic",
+  automatic: "automatic",
+  classic: "classic",
 };
 
 function decodeJSX(bb) {
@@ -92,51 +92,52 @@ function decodeJSX(bb) {
 }
 
 function encodeJSX(message, bb) {
-
   var value = message["factory"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error("Missing required field \"factory\"");
+    throw new Error('Missing required field "factory"');
   }
 
   var value = message["runtime"];
   if (value != null) {
     var encoded = JSXRuntime[value];
-if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"JSXRuntime\"");
-bb.writeByte(encoded);
+    if (encoded === void 0)
+      throw new Error(
+        "Invalid value " + JSON.stringify(value) + ' for enum "JSXRuntime"'
+      );
+    bb.writeByte(encoded);
   } else {
-    throw new Error("Missing required field \"runtime\"");
+    throw new Error('Missing required field "runtime"');
   }
 
   var value = message["fragment"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error("Missing required field \"fragment\"");
+    throw new Error('Missing required field "fragment"');
   }
 
   var value = message["development"];
   if (value != null) {
     bb.writeByte(value);
   } else {
-    throw new Error("Missing required field \"development\"");
+    throw new Error('Missing required field "development"');
   }
 
   var value = message["import_source"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error("Missing required field \"import_source\"");
+    throw new Error('Missing required field "import_source"');
   }
 
   var value = message["react_fast_refresh"];
   if (value != null) {
     bb.writeByte(value);
   } else {
-    throw new Error("Missing required field \"react_fast_refresh\"");
+    throw new Error('Missing required field "react_fast_refresh"');
   }
-
 }
 
 function decodeStringPointer(bb) {
@@ -148,21 +149,19 @@ function decodeStringPointer(bb) {
 }
 
 function encodeStringPointer(message, bb) {
-
   var value = message["offset"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error("Missing required field \"offset\"");
+    throw new Error('Missing required field "offset"');
   }
 
   var value = message["length"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error("Missing required field \"length\"");
+    throw new Error('Missing required field "length"');
   }
-
 }
 
 function decodeJavascriptBundledModule(bb) {
@@ -177,42 +176,40 @@ function decodeJavascriptBundledModule(bb) {
 }
 
 function encodeJavascriptBundledModule(message, bb) {
-
   var value = message["path"];
   if (value != null) {
     encodeStringPointer(value, bb);
   } else {
-    throw new Error("Missing required field \"path\"");
+    throw new Error('Missing required field "path"');
   }
 
   var value = message["code"];
   if (value != null) {
     encodeStringPointer(value, bb);
   } else {
-    throw new Error("Missing required field \"code\"");
+    throw new Error('Missing required field "code"');
   }
 
   var value = message["package_id"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error("Missing required field \"package_id\"");
+    throw new Error('Missing required field "package_id"');
   }
 
   var value = message["id"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error("Missing required field \"id\"");
+    throw new Error('Missing required field "id"');
   }
 
   var value = message["path_extname_length"];
   if (value != null) {
     bb.writeByte(value);
   } else {
-    throw new Error("Missing required field \"path_extname_length\"");
+    throw new Error('Missing required field "path_extname_length"');
   }
-
 }
 
 function decodeJavascriptBundledPackage(bb) {
@@ -227,53 +224,53 @@ function decodeJavascriptBundledPackage(bb) {
 }
 
 function encodeJavascriptBundledPackage(message, bb) {
-
   var value = message["name"];
   if (value != null) {
     encodeStringPointer(value, bb);
   } else {
-    throw new Error("Missing required field \"name\"");
+    throw new Error('Missing required field "name"');
   }
 
   var value = message["version"];
   if (value != null) {
     encodeStringPointer(value, bb);
   } else {
-    throw new Error("Missing required field \"version\"");
+    throw new Error('Missing required field "version"');
   }
 
   var value = message["hash"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error("Missing required field \"hash\"");
+    throw new Error('Missing required field "hash"');
   }
 
   var value = message["modules_offset"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error("Missing required field \"modules_offset\"");
+    throw new Error('Missing required field "modules_offset"');
   }
 
   var value = message["modules_length"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error("Missing required field \"modules_length\"");
+    throw new Error('Missing required field "modules_length"');
   }
-
 }
 
 function decodeJavascriptBundle(bb) {
   var result = {};
 
   var length = bb.readVarUint();
-  var values = result["modules"] = Array(length);
-  for (var i = 0; i < length; i++) values[i] = decodeJavascriptBundledModule(bb);
+  var values = (result["modules"] = Array(length));
+  for (var i = 0; i < length; i++)
+    values[i] = decodeJavascriptBundledModule(bb);
   var length = bb.readVarUint();
-  var values = result["packages"] = Array(length);
-  for (var i = 0; i < length; i++) values[i] = decodeJavascriptBundledPackage(bb);
+  var values = (result["packages"] = Array(length));
+  for (var i = 0; i < length; i++)
+    values[i] = decodeJavascriptBundledPackage(bb);
   result["etag"] = bb.readByteArray();
   result["generated_at"] = bb.readUint32();
   result["app_package_json_dependencies_hash"] = bb.readByteArray();
@@ -283,66 +280,68 @@ function decodeJavascriptBundle(bb) {
 }
 
 function encodeJavascriptBundle(message, bb) {
-
   var value = message["modules"];
   if (value != null) {
-    var values = value, n = values.length;
+    var values = value,
+      n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       encodeJavascriptBundledModule(value, bb);
     }
   } else {
-    throw new Error("Missing required field \"modules\"");
+    throw new Error('Missing required field "modules"');
   }
 
   var value = message["packages"];
   if (value != null) {
-    var values = value, n = values.length;
+    var values = value,
+      n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       encodeJavascriptBundledPackage(value, bb);
     }
   } else {
-    throw new Error("Missing required field \"packages\"");
+    throw new Error('Missing required field "packages"');
   }
 
   var value = message["etag"];
   if (value != null) {
-   bb.writeByteArray(value);
+    bb.writeByteArray(value);
   } else {
-    throw new Error("Missing required field \"etag\"");
+    throw new Error('Missing required field "etag"');
   }
 
   var value = message["generated_at"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error("Missing required field \"generated_at\"");
+    throw new Error('Missing required field "generated_at"');
   }
 
   var value = message["app_package_json_dependencies_hash"];
   if (value != null) {
-   bb.writeByteArray(value);
+    bb.writeByteArray(value);
   } else {
-    throw new Error("Missing required field \"app_package_json_dependencies_hash\"");
+    throw new Error(
+      'Missing required field "app_package_json_dependencies_hash"'
+    );
   }
 
   var value = message["import_from_name"];
   if (value != null) {
-   bb.writeByteArray(value);
+    bb.writeByteArray(value);
   } else {
-    throw new Error("Missing required field \"import_from_name\"");
+    throw new Error('Missing required field "import_from_name"');
   }
 
   var value = message["manifest_string"];
   if (value != null) {
-   bb.writeByteArray(value);
+    bb.writeByteArray(value);
   } else {
-    throw new Error("Missing required field \"manifest_string\"");
+    throw new Error('Missing required field "manifest_string"');
   }
-
 }
 
 function decodeJavascriptBundleContainer(bb) {
@@ -350,37 +349,36 @@ function decodeJavascriptBundleContainer(bb) {
 
   while (true) {
     switch (bb.readByte()) {
-    case 0:
-      return result;
+      case 0:
+        return result;
 
-    case 1:
-      result["bundle_format_version"] = bb.readUint32();
-      break;
+      case 1:
+        result["bundle_format_version"] = bb.readUint32();
+        break;
 
-    case 2:
-      result["bundle"] = decodeJavascriptBundle(bb);
-      break;
+      case 2:
+        result["bundle"] = decodeJavascriptBundle(bb);
+        break;
 
-    case 3:
-      result["framework"] = decodeLoadedFramework(bb);
-      break;
+      case 3:
+        result["framework"] = decodeLoadedFramework(bb);
+        break;
 
-    case 4:
-      result["routes"] = decodeLoadedRouteConfig(bb);
-      break;
+      case 4:
+        result["routes"] = decodeLoadedRouteConfig(bb);
+        break;
 
-    case 5:
-      result["code_length"] = bb.readUint32();
-      break;
+      case 5:
+        result["code_length"] = bb.readUint32();
+        break;
 
-    default:
-      throw new Error("Attempted to parse invalid message");
+      default:
+        throw new Error("Attempted to parse invalid message");
     }
   }
 }
 
 function encodeJavascriptBundleContainer(message, bb) {
-
   var value = message["bundle_format_version"];
   if (value != null) {
     bb.writeByte(1);
@@ -411,31 +409,30 @@ function encodeJavascriptBundleContainer(message, bb) {
     bb.writeUint32(value);
   }
   bb.writeByte(0);
-
 }
 const ScanDependencyMode = {
-  "1": 1,
-  "2": 2,
-  "app": 1,
-  "all": 2
+  1: 1,
+  2: 2,
+  app: 1,
+  all: 2,
 };
 const ScanDependencyModeKeys = {
-  "1": "app",
-  "2": "all",
-  "app": "app",
-  "all": "all"
+  1: "app",
+  2: "all",
+  app: "app",
+  all: "all",
 };
 const ModuleImportType = {
-  "1": 1,
-  "2": 2,
-  "import": 1,
-  "require": 2
+  1: 1,
+  2: 2,
+  import: 1,
+  require: 2,
 };
 const ModuleImportTypeKeys = {
-  "1": "import",
-  "2": "require",
-  "import": "import",
-  "require": "require"
+  1: "import",
+  2: "require",
+  import: "import",
+  require: "require",
 };
 
 function decodeModuleImportRecord(bb) {
@@ -448,30 +445,33 @@ function decodeModuleImportRecord(bb) {
 }
 
 function encodeModuleImportRecord(message, bb) {
-
   var value = message["kind"];
   if (value != null) {
     var encoded = ModuleImportType[value];
-if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"ModuleImportType\"");
-bb.writeByte(encoded);
+    if (encoded === void 0)
+      throw new Error(
+        "Invalid value " +
+          JSON.stringify(value) +
+          ' for enum "ModuleImportType"'
+      );
+    bb.writeByte(encoded);
   } else {
-    throw new Error("Missing required field \"kind\"");
+    throw new Error('Missing required field "kind"');
   }
 
   var value = message["path"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error("Missing required field \"path\"");
+    throw new Error('Missing required field "path"');
   }
 
   var value = message["dynamic"];
   if (value != null) {
     bb.writeByte(value);
   } else {
-    throw new Error("Missing required field \"dynamic\"");
+    throw new Error('Missing required field "dynamic"');
   }
-
 }
 
 function decodeModule(bb) {
@@ -479,130 +479,132 @@ function decodeModule(bb) {
 
   result["path"] = bb.readString();
   var length = bb.readVarUint();
-  var values = result["imports"] = Array(length);
+  var values = (result["imports"] = Array(length));
   for (var i = 0; i < length; i++) values[i] = decodeModuleImportRecord(bb);
   return result;
 }
 
 function encodeModule(message, bb) {
-
   var value = message["path"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error("Missing required field \"path\"");
+    throw new Error('Missing required field "path"');
   }
 
   var value = message["imports"];
   if (value != null) {
-    var values = value, n = values.length;
+    var values = value,
+      n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       encodeModuleImportRecord(value, bb);
     }
   } else {
-    throw new Error("Missing required field \"imports\"");
+    throw new Error('Missing required field "imports"');
   }
-
 }
 
 function decodeStringMap(bb) {
   var result = {};
 
   var length = bb.readVarUint();
-  var values = result["keys"] = Array(length);
+  var values = (result["keys"] = Array(length));
   for (var i = 0; i < length; i++) values[i] = bb.readString();
   var length = bb.readVarUint();
-  var values = result["values"] = Array(length);
+  var values = (result["values"] = Array(length));
   for (var i = 0; i < length; i++) values[i] = bb.readString();
   return result;
 }
 
 function encodeStringMap(message, bb) {
-
   var value = message["keys"];
   if (value != null) {
-    var values = value, n = values.length;
+    var values = value,
+      n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       bb.writeString(value);
     }
   } else {
-    throw new Error("Missing required field \"keys\"");
+    throw new Error('Missing required field "keys"');
   }
 
   var value = message["values"];
   if (value != null) {
-    var values = value, n = values.length;
+    var values = value,
+      n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       bb.writeString(value);
     }
   } else {
-    throw new Error("Missing required field \"values\"");
+    throw new Error('Missing required field "values"');
   }
-
 }
 
 function decodeLoaderMap(bb) {
   var result = {};
 
   var length = bb.readVarUint();
-  var values = result["extensions"] = Array(length);
+  var values = (result["extensions"] = Array(length));
   for (var i = 0; i < length; i++) values[i] = bb.readString();
   var length = bb.readVarUint();
-  var values = result["loaders"] = Array(length);
+  var values = (result["loaders"] = Array(length));
   for (var i = 0; i < length; i++) values[i] = Loader[bb.readByte()];
   return result;
 }
 
 function encodeLoaderMap(message, bb) {
-
   var value = message["extensions"];
   if (value != null) {
-    var values = value, n = values.length;
+    var values = value,
+      n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       bb.writeString(value);
     }
   } else {
-    throw new Error("Missing required field \"extensions\"");
+    throw new Error('Missing required field "extensions"');
   }
 
   var value = message["loaders"];
   if (value != null) {
-    var values = value, n = values.length;
+    var values = value,
+      n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       var encoded = Loader[value];
-if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"Loader\"");
-bb.writeByte(encoded);
+      if (encoded === void 0)
+        throw new Error(
+          "Invalid value " + JSON.stringify(value) + ' for enum "Loader"'
+        );
+      bb.writeByte(encoded);
     }
   } else {
-    throw new Error("Missing required field \"loaders\"");
+    throw new Error('Missing required field "loaders"');
   }
-
 }
 const DotEnvBehavior = {
-  "1": 1,
-  "2": 2,
-  "3": 3,
-  "disable": 1,
-  "prefix": 2,
-  "load_all": 3
+  1: 1,
+  2: 2,
+  3: 3,
+  disable: 1,
+  prefix: 2,
+  load_all: 3,
 };
 const DotEnvBehaviorKeys = {
-  "1": "disable",
-  "2": "prefix",
-  "3": "load_all",
-  "disable": "disable",
-  "prefix": "prefix",
-  "load_all": "load_all"
+  1: "disable",
+  2: "prefix",
+  3: "load_all",
+  disable: "disable",
+  prefix: "prefix",
+  load_all: "load_all",
 };
 
 function decodeEnvConfig(bb) {
@@ -610,25 +612,24 @@ function decodeEnvConfig(bb) {
 
   while (true) {
     switch (bb.readByte()) {
-    case 0:
-      return result;
+      case 0:
+        return result;
 
-    case 1:
-      result["prefix"] = bb.readString();
-      break;
+      case 1:
+        result["prefix"] = bb.readString();
+        break;
 
-    case 2:
-      result["defaults"] = decodeStringMap(bb);
-      break;
+      case 2:
+        result["defaults"] = decodeStringMap(bb);
+        break;
 
-    default:
-      throw new Error("Attempted to parse invalid message");
+      default:
+        throw new Error("Attempted to parse invalid message");
     }
   }
 }
 
 function encodeEnvConfig(message, bb) {
-
   var value = message["prefix"];
   if (value != null) {
     bb.writeByte(1);
@@ -641,7 +642,6 @@ function encodeEnvConfig(message, bb) {
     encodeStringMap(value, bb);
   }
   bb.writeByte(0);
-
 }
 
 function decodeLoadedEnvConfig(bb) {
@@ -654,30 +654,31 @@ function decodeLoadedEnvConfig(bb) {
 }
 
 function encodeLoadedEnvConfig(message, bb) {
-
   var value = message["dotenv"];
   if (value != null) {
     var encoded = DotEnvBehavior[value];
-if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"DotEnvBehavior\"");
-bb.writeVarUint(encoded);
+    if (encoded === void 0)
+      throw new Error(
+        "Invalid value " + JSON.stringify(value) + ' for enum "DotEnvBehavior"'
+      );
+    bb.writeVarUint(encoded);
   } else {
-    throw new Error("Missing required field \"dotenv\"");
+    throw new Error('Missing required field "dotenv"');
   }
 
   var value = message["defaults"];
   if (value != null) {
     encodeStringMap(value, bb);
   } else {
-    throw new Error("Missing required field \"defaults\"");
+    throw new Error('Missing required field "defaults"');
   }
 
   var value = message["prefix"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error("Missing required field \"prefix\"");
+    throw new Error('Missing required field "prefix"');
   }
-
 }
 
 function decodeFrameworkConfig(bb) {
@@ -685,41 +686,40 @@ function decodeFrameworkConfig(bb) {
 
   while (true) {
     switch (bb.readByte()) {
-    case 0:
-      return result;
+      case 0:
+        return result;
 
-    case 1:
-      result["package"] = bb.readString();
-      break;
+      case 1:
+        result["package"] = bb.readString();
+        break;
 
-    case 2:
-      result["client"] = bb.readString();
-      break;
+      case 2:
+        result["client"] = bb.readString();
+        break;
 
-    case 3:
-      result["server"] = bb.readString();
-      break;
+      case 3:
+        result["server"] = bb.readString();
+        break;
 
-    case 4:
-      result["development"] = !!bb.readByte();
-      break;
+      case 4:
+        result["development"] = !!bb.readByte();
+        break;
 
-    case 5:
-      result["client_env"] = decodeEnvConfig(bb);
-      break;
+      case 5:
+        result["client_env"] = decodeEnvConfig(bb);
+        break;
 
-    case 6:
-      result["server_env"] = decodeEnvConfig(bb);
-      break;
+      case 6:
+        result["server_env"] = decodeEnvConfig(bb);
+        break;
 
-    default:
-      throw new Error("Attempted to parse invalid message");
+      default:
+        throw new Error("Attempted to parse invalid message");
     }
   }
 }
 
 function encodeFrameworkConfig(message, bb) {
-
   var value = message["package"];
   if (value != null) {
     bb.writeByte(1);
@@ -756,7 +756,6 @@ function encodeFrameworkConfig(message, bb) {
     encodeEnvConfig(value, bb);
   }
   bb.writeByte(0);
-
 }
 
 function decodeLoadedFramework(bb) {
@@ -771,42 +770,40 @@ function decodeLoadedFramework(bb) {
 }
 
 function encodeLoadedFramework(message, bb) {
-
   var value = message["entry_point"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error("Missing required field \"entry_point\"");
+    throw new Error('Missing required field "entry_point"');
   }
 
   var value = message["package"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error("Missing required field \"package\"");
+    throw new Error('Missing required field "package"');
   }
 
   var value = message["development"];
   if (value != null) {
     bb.writeByte(value);
   } else {
-    throw new Error("Missing required field \"development\"");
+    throw new Error('Missing required field "development"');
   }
 
   var value = message["client"];
   if (value != null) {
     bb.writeByte(value);
   } else {
-    throw new Error("Missing required field \"client\"");
+    throw new Error('Missing required field "client"');
   }
 
   var value = message["env"];
   if (value != null) {
     encodeLoadedEnvConfig(value, bb);
   } else {
-    throw new Error("Missing required field \"env\"");
+    throw new Error('Missing required field "env"');
   }
-
 }
 
 function decodeLoadedRouteConfig(bb) {
@@ -814,7 +811,7 @@ function decodeLoadedRouteConfig(bb) {
 
   result["dir"] = bb.readString();
   var length = bb.readVarUint();
-  var values = result["extensions"] = Array(length);
+  var values = (result["extensions"] = Array(length));
   for (var i = 0; i < length; i++) values[i] = bb.readString();
   result["static_dir"] = bb.readString();
   result["asset_prefix"] = bb.readString();
@@ -822,40 +819,39 @@ function decodeLoadedRouteConfig(bb) {
 }
 
 function encodeLoadedRouteConfig(message, bb) {
-
   var value = message["dir"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error("Missing required field \"dir\"");
+    throw new Error('Missing required field "dir"');
   }
 
   var value = message["extensions"];
   if (value != null) {
-    var values = value, n = values.length;
+    var values = value,
+      n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       bb.writeString(value);
     }
   } else {
-    throw new Error("Missing required field \"extensions\"");
+    throw new Error('Missing required field "extensions"');
   }
 
   var value = message["static_dir"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error("Missing required field \"static_dir\"");
+    throw new Error('Missing required field "static_dir"');
   }
 
   var value = message["asset_prefix"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error("Missing required field \"asset_prefix\"");
+    throw new Error('Missing required field "asset_prefix"');
   }
-
 }
 
 function decodeRouteConfig(bb) {
@@ -863,41 +859,41 @@ function decodeRouteConfig(bb) {
 
   while (true) {
     switch (bb.readByte()) {
-    case 0:
-      return result;
-
-    case 1:
-      var length = bb.readVarUint();
-      var values = result["dir"] = Array(length);
-      for (var i = 0; i < length; i++) values[i] = bb.readString();
-      break;
-
-    case 2:
-      var length = bb.readVarUint();
-      var values = result["extensions"] = Array(length);
-      for (var i = 0; i < length; i++) values[i] = bb.readString();
-      break;
-
-    case 3:
-      result["static_dir"] = bb.readString();
-      break;
-
-    case 4:
-      result["asset_prefix"] = bb.readString();
-      break;
-
-    default:
-      throw new Error("Attempted to parse invalid message");
+      case 0:
+        return result;
+
+      case 1:
+        var length = bb.readVarUint();
+        var values = (result["dir"] = Array(length));
+        for (var i = 0; i < length; i++) values[i] = bb.readString();
+        break;
+
+      case 2:
+        var length = bb.readVarUint();
+        var values = (result["extensions"] = Array(length));
+        for (var i = 0; i < length; i++) values[i] = bb.readString();
+        break;
+
+      case 3:
+        result["static_dir"] = bb.readString();
+        break;
+
+      case 4:
+        result["asset_prefix"] = bb.readString();
+        break;
+
+      default:
+        throw new Error("Attempted to parse invalid message");
     }
   }
 }
 
 function encodeRouteConfig(message, bb) {
-
   var value = message["dir"];
   if (value != null) {
     bb.writeByte(1);
-    var values = value, n = values.length;
+    var values = value,
+      n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
@@ -908,7 +904,8 @@ function encodeRouteConfig(message, bb) {
   var value = message["extensions"];
   if (value != null) {
     bb.writeByte(2);
-    var values = value, n = values.length;
+    var values = value,
+      n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
@@ -928,7 +925,6 @@ function encodeRouteConfig(message, bb) {
     bb.writeString(value);
   }
   bb.writeByte(0);
-
 }
 
 function decodeTransformOptions(bb) {
@@ -936,119 +932,114 @@ function decodeTransformOptions(bb) {
 
   while (true) {
     switch (bb.readByte()) {
-    case 0:
-      return result;
-
-    case 1:
-      result["jsx"] = decodeJSX(bb);
-      break;
-
-    case 2:
-      result["tsconfig_override"] = bb.readString();
-      break;
-
-    case 3:
-      result["resolve"] = ResolveMode[bb.readByte()];
-      break;
-
-    case 4:
-      result["origin"] = bb.readString();
-      break;
-
-    case 5:
-      result["absolute_working_dir"] = bb.readString();
-      break;
-
-    case 6:
-      result["define"] = decodeStringMap(bb);
-      break;
-
-    case 7:
-      result["preserve_symlinks"] = !!bb.readByte();
-      break;
-
-    case 8:
-      var length = bb.readVarUint();
-      var values = result["entry_points"] = Array(length);
-      for (var i = 0; i < length; i++) values[i] = bb.readString();
-      break;
-
-    case 9:
-      result["write"] = !!bb.readByte();
-      break;
-
-    case 10:
-      var length = bb.readVarUint();
-      var values = result["inject"] = Array(length);
-      for (var i = 0; i < length; i++) values[i] = bb.readString();
-      break;
-
-    case 11:
-      result["output_dir"] = bb.readString();
-      break;
-
-    case 12:
-      var length = bb.readVarUint();
-      var values = result["external"] = Array(length);
-      for (var i = 0; i < length; i++) values[i] = bb.readString();
-      break;
-
-    case 13:
-      result["loaders"] = decodeLoaderMap(bb);
-      break;
-
-    case 14:
-      var length = bb.readVarUint();
-      var values = result["main_fields"] = Array(length);
-      for (var i = 0; i < length; i++) values[i] = bb.readString();
-      break;
-
-    case 15:
-      result["platform"] = Platform[bb.readByte()];
-      break;
-
-    case 16:
-      result["serve"] = !!bb.readByte();
-      break;
-
-    case 17:
-      var length = bb.readVarUint();
-      var values = result["extension_order"] = Array(length);
-      for (var i = 0; i < length; i++) values[i] = bb.readString();
-      break;
-
-    case 18:
-      result["only_scan_dependencies"] = ScanDependencyMode[bb.readByte()];
-      break;
-
-    case 19:
-      result["generate_node_module_bundle"] = !!bb.readByte();
-      break;
-
-    case 20:
-      result["node_modules_bundle_path"] = bb.readString();
-      break;
-
-    case 21:
-      result["node_modules_bundle_path_server"] = bb.readString();
-      break;
-
-    case 22:
-      result["framework"] = decodeFrameworkConfig(bb);
-      break;
-
-    case 23:
-      result["router"] = decodeRouteConfig(bb);
-      break;
-
-    default:
-      throw new Error("Attempted to parse invalid message");
+      case 0:
+        return result;
+
+      case 1:
+        result["jsx"] = decodeJSX(bb);
+        break;
+
+      case 2:
+        result["tsconfig_override"] = bb.readString();
+        break;
+
+      case 3:
+        result["resolve"] = ResolveMode[bb.readByte()];
+        break;
+
+      case 4:
+        result["origin"] = bb.readString();
+        break;
+
+      case 5:
+        result["absolute_working_dir"] = bb.readString();
+        break;
+
+      case 6:
+        result["define"] = decodeStringMap(bb);
+        break;
+
+      case 7:
+        result["preserve_symlinks"] = !!bb.readByte();
+        break;
+
+      case 8:
+        var length = bb.readVarUint();
+        var values = (result["entry_points"] = Array(length));
+        for (var i = 0; i < length; i++) values[i] = bb.readString();
+        break;
+
+      case 9:
+        result["write"] = !!bb.readByte();
+        break;
+
+      case 10:
+        var length = bb.readVarUint();
+        var values = (result["inject"] = Array(length));
+        for (var i = 0; i < length; i++) values[i] = bb.readString();
+        break;
+
+      case 11:
+        result["output_dir"] = bb.readString();
+        break;
+
+      case 12:
+        var length = bb.readVarUint();
+        var values = (result["external"] = Array(length));
+        for (var i = 0; i < length; i++) values[i] = bb.readString();
+        break;
+
+      case 13:
+        result["loaders"] = decodeLoaderMap(bb);
+        break;
+
+      case 14:
+        var length = bb.readVarUint();
+        var values = (result["main_fields"] = Array(length));
+        for (var i = 0; i < length; i++) values[i] = bb.readString();
+        break;
+
+      case 15:
+        result["platform"] = Platform[bb.readByte()];
+        break;
+
+      case 16:
+        result["serve"] = !!bb.readByte();
+        break;
+
+      case 17:
+        var length = bb.readVarUint();
+        var values = (result["extension_order"] = Array(length));
+        for (var i = 0; i < length; i++) values[i] = bb.readString();
+        break;
+
+      case 18:
+        result["generate_node_module_bundle"] = !!bb.readByte();
+        break;
+
+      case 19:
+        result["node_modules_bundle_path"] = bb.readString();
+        break;
+
+      case 20:
+        result["node_modules_bundle_path_server"] = bb.readString();
+        break;
+
+      case 21:
+        result["framework"] = decodeFrameworkConfig(bb);
+        break;
+
+      case 22:
+        result["router"] = decodeRouteConfig(bb);
+        break;
+
+      default:
+        throw new Error("Attempted to parse invalid message");
     }
   }
 }
 
 function encodeTransformOptions(message, bb) {
-
   var value = message["jsx"];
   if (value != null) {
     bb.writeByte(1);
@@ -1065,8 +1056,11 @@ function encodeTransformOptions(message, bb) {
   if (value != null) {
     bb.writeByte(3);
     var encoded = ResolveMode[value];
-if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"ResolveMode\"");
-bb.writeByte(encoded);
+    if (encoded === void 0)
+      throw new Error(
+        "Invalid value " + JSON.stringify(value) + ' for enum "ResolveMode"'
+      );
+    bb.writeByte(encoded);
   }
 
   var value = message["origin"];
@@ -1096,7 +1090,8 @@ bb.writeByte(encoded);
   var value = message["entry_points"];
   if (value != null) {
     bb.writeByte(8);
-    var values = value, n = values.length;
+    var values = value,
+      n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
@@ -1113,7 +1108,8 @@ bb.writeByte(encoded);
   var value = message["inject"];
   if (value != null) {
     bb.writeByte(10);
-    var values = value, n = values.length;
+    var values = value,
+      n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
@@ -1130,7 +1126,8 @@ bb.writeByte(encoded);
   var value = message["external"];
   if (value != null) {
     bb.writeByte(12);
-    var values = value, n = values.length;
+    var values = value,
+      n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
@@ -1147,7 +1144,8 @@ bb.writeByte(encoded);
   var value = message["main_fields"];
   if (value != null) {
     bb.writeByte(14);
-    var values = value, n = values.length;
+    var values = value,
+      n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
@@ -1159,8 +1157,11 @@ bb.writeByte(encoded);
   if (value != null) {
     bb.writeByte(15);
     var encoded = Platform[value];
-if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"Platform\"");
-bb.writeByte(encoded);
+    if (encoded === void 0)
+      throw new Error(
+        "Invalid value " + JSON.stringify(value) + ' for enum "Platform"'
+      );
+    bb.writeByte(encoded);
   }
 
   var value = message["serve"];
@@ -1172,7 +1173,8 @@ bb.writeByte(encoded);
   var value = message["extension_order"];
   if (value != null) {
     bb.writeByte(17);
-    var values = value, n = values.length;
+    var values = value,
+      n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
@@ -1180,45 +1182,36 @@ bb.writeByte(encoded);
     }
   }
 
-  var value = message["only_scan_dependencies"];
-  if (value != null) {
-    bb.writeByte(18);
-    var encoded = ScanDependencyMode[value];
-if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"ScanDependencyMode\"");
-bb.writeByte(encoded);
-  }
-
   var value = message["generate_node_module_bundle"];
   if (value != null) {
-    bb.writeByte(19);
+    bb.writeByte(18);
     bb.writeByte(value);
   }
 
   var value = message["node_modules_bundle_path"];
   if (value != null) {
-    bb.writeByte(20);
+    bb.writeByte(19);
     bb.writeString(value);
   }
 
   var value = message["node_modules_bundle_path_server"];
   if (value != null) {
-    bb.writeByte(21);
+    bb.writeByte(20);
     bb.writeString(value);
   }
 
   var value = message["framework"];
   if (value != null) {
-    bb.writeByte(22);
+    bb.writeByte(21);
     encodeFrameworkConfig(value, bb);
   }
 
   var value = message["router"];
   if (value != null) {
-    bb.writeByte(23);
+    bb.writeByte(22);
     encodeRouteConfig(value, bb);
   }
   bb.writeByte(0);
-
 }
 
 function decodeFileHandle(bb) {
@@ -1231,28 +1224,26 @@ function decodeFileHandle(bb) {
 }
 
 function encodeFileHandle(message, bb) {
-
   var value = message["path"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error("Missing required field \"path\"");
+    throw new Error('Missing required field "path"');
   }
 
   var value = message["size"];
   if (value != null) {
     bb.writeVarUint(value);
   } else {
-    throw new Error("Missing required field \"size\"");
+    throw new Error('Missing required field "size"');
   }
 
   var value = message["fd"];
   if (value != null) {
     bb.writeVarUint(value);
   } else {
-    throw new Error("Missing required field \"fd\"");
+    throw new Error('Missing required field "fd"');
   }
-
 }
 
 function decodeTransform(bb) {
@@ -1260,37 +1251,36 @@ function decodeTransform(bb) {
 
   while (true) {
     switch (bb.readByte()) {
-    case 0:
-      return result;
+      case 0:
+        return result;
 
-    case 1:
-      result["handle"] = decodeFileHandle(bb);
-      break;
+      case 1:
+        result["handle"] = decodeFileHandle(bb);
+        break;
 
-    case 2:
-      result["path"] = bb.readString();
-      break;
+      case 2:
+        result["path"] = bb.readString();
+        break;
 
-    case 3:
-      result["contents"] = bb.readByteArray();
-      break;
+      case 3:
+        result["contents"] = bb.readByteArray();
+        break;
 
-    case 4:
-      result["loader"] = Loader[bb.readByte()];
-      break;
+      case 4:
+        result["loader"] = Loader[bb.readByte()];
+        break;
 
-    case 5:
-      result["options"] = decodeTransformOptions(bb);
-      break;
+      case 5:
+        result["options"] = decodeTransformOptions(bb);
+        break;
 
-    default:
-      throw new Error("Attempted to parse invalid message");
+      default:
+        throw new Error("Attempted to parse invalid message");
     }
   }
 }
 
 function encodeTransform(message, bb) {
-
   var value = message["handle"];
   if (value != null) {
     bb.writeByte(1);
@@ -1306,15 +1296,18 @@ function encodeTransform(message, bb) {
   var value = message["contents"];
   if (value != null) {
     bb.writeByte(3);
-   bb.writeByteArray(value);
+    bb.writeByteArray(value);
   }
 
   var value = message["loader"];
   if (value != null) {
     bb.writeByte(4);
     var encoded = Loader[value];
-if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"Loader\"");
-bb.writeByte(encoded);
+    if (encoded === void 0)
+      throw new Error(
+        "Invalid value " + JSON.stringify(value) + ' for enum "Loader"'
+      );
+    bb.writeByte(encoded);
   }
 
   var value = message["options"];
@@ -1323,19 +1316,18 @@ bb.writeByte(encoded);
     encodeTransformOptions(value, bb);
   }
   bb.writeByte(0);
-
 }
 const TransformResponseStatus = {
-  "1": 1,
-  "2": 2,
-  "success": 1,
-  "fail": 2
+  1: 1,
+  2: 2,
+  success: 1,
+  fail: 2,
 };
 const TransformResponseStatusKeys = {
-  "1": "success",
-  "2": "fail",
-  "success": "success",
-  "fail": "fail"
+  1: "success",
+  2: "fail",
+  success: "success",
+  fail: "fail",
 };
 
 function decodeOutputFile(bb) {
@@ -1347,21 +1339,19 @@ function decodeOutputFile(bb) {
 }
 
 function encodeOutputFile(message, bb) {
-
   var value = message["data"];
   if (value != null) {
-   bb.writeByteArray(value);
+    bb.writeByteArray(value);
   } else {
-    throw new Error("Missing required field \"data\"");
+    throw new Error('Missing required field "data"');
   }
 
   var value = message["path"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error("Missing required field \"path\"");
+    throw new Error('Missing required field "path"');
   }
-
 }
 
 function decodeTransformResponse(bb) {
@@ -1369,69 +1359,74 @@ function decodeTransformResponse(bb) {
 
   result["status"] = TransformResponseStatus[bb.readVarUint()];
   var length = bb.readVarUint();
-  var values = result["files"] = Array(length);
+  var values = (result["files"] = Array(length));
   for (var i = 0; i < length; i++) values[i] = decodeOutputFile(bb);
   var length = bb.readVarUint();
-  var values = result["errors"] = Array(length);
+  var values = (result["errors"] = Array(length));
   for (var i = 0; i < length; i++) values[i] = decodeMessage(bb);
   return result;
 }
 
 function encodeTransformResponse(message, bb) {
-
   var value = message["status"];
   if (value != null) {
     var encoded = TransformResponseStatus[value];
-if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"TransformResponseStatus\"");
-bb.writeVarUint(encoded);
+    if (encoded === void 0)
+      throw new Error(
+        "Invalid value " +
+          JSON.stringify(value) +
+          ' for enum "TransformResponseStatus"'
+      );
+    bb.writeVarUint(encoded);
   } else {
-    throw new Error("Missing required field \"status\"");
+    throw new Error('Missing required field "status"');
   }
 
   var value = message["files"];
   if (value != null) {
-    var values = value, n = values.length;
+    var values = value,
+      n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       encodeOutputFile(value, bb);
     }
   } else {
-    throw new Error("Missing required field \"files\"");
+    throw new Error('Missing required field "files"');
   }
 
   var value = message["errors"];
   if (value != null) {
-    var values = value, n = values.length;
+    var values = value,
+      n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       encodeMessage(value, bb);
     }
   } else {
-    throw new Error("Missing required field \"errors\"");
+    throw new Error('Missing required field "errors"');
   }
-
 }
 const MessageKind = {
-  "1": 1,
-  "2": 2,
-  "3": 3,
-  "4": 4,
-  "err": 1,
-  "warn": 2,
-  "note": 3,
-  "debug": 4
+  1: 1,
+  2: 2,
+  3: 3,
+  4: 4,
+  err: 1,
+  warn: 2,
+  note: 3,
+  debug: 4,
 };
 const MessageKindKeys = {
-  "1": "err",
-  "2": "warn",
-  "3": "note",
-  "4": "debug",
-  "err": "err",
-  "warn": "warn",
-  "note": "note",
-  "debug": "debug"
+  1: "err",
+  2: "warn",
+  3: "note",
+  4: "debug",
+  err: "err",
+  warn: "warn",
+  note: "note",
+  debug: "debug",
 };
 
 function decodeLocation(bb) {
@@ -1448,56 +1443,54 @@ function decodeLocation(bb) {
 }
 
 function encodeLocation(message, bb) {
-
   var value = message["file"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error("Missing required field \"file\"");
+    throw new Error('Missing required field "file"');
   }
 
   var value = message["namespace"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error("Missing required field \"namespace\"");
+    throw new Error('Missing required field "namespace"');
   }
 
   var value = message["line"];
   if (value != null) {
     bb.writeInt32(value);
   } else {
-    throw new Error("Missing required field \"line\"");
+    throw new Error('Missing required field "line"');
   }
 
   var value = message["column"];
   if (value != null) {
     bb.writeInt32(value);
   } else {
-    throw new Error("Missing required field \"column\"");
+    throw new Error('Missing required field "column"');
   }
 
   var value = message["line_text"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error("Missing required field \"line_text\"");
+    throw new Error('Missing required field "line_text"');
   }
 
   var value = message["suggestion"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error("Missing required field \"suggestion\"");
+    throw new Error('Missing required field "suggestion"');
   }
 
   var value = message["offset"];
   if (value != null) {
     bb.writeVarUint(value);
   } else {
-    throw new Error("Missing required field \"offset\"");
+    throw new Error('Missing required field "offset"');
   }
-
 }
 
 function decodeMessageData(bb) {
@@ -1505,25 +1498,24 @@ function decodeMessageData(bb) {
 
   while (true) {
     switch (bb.readByte()) {
-    case 0:
-      return result;
+      case 0:
+        return result;
 
-    case 1:
-      result["text"] = bb.readString();
-      break;
+      case 1:
+        result["text"] = bb.readString();
+        break;
 
-    case 2:
-      result["location"] = decodeLocation(bb);
-      break;
+      case 2:
+        result["location"] = decodeLocation(bb);
+        break;
 
-    default:
-      throw new Error("Attempted to parse invalid message");
+      default:
+        throw new Error("Attempted to parse invalid message");
     }
   }
 }
 
 function encodeMessageData(message, bb) {
-
   var value = message["text"];
   if (value != null) {
     bb.writeByte(1);
@@ -1536,7 +1528,6 @@ function encodeMessageData(message, bb) {
     encodeLocation(value, bb);
   }
   bb.writeByte(0);
-
 }
 
 function decodeMessage(bb) {
@@ -1545,41 +1536,43 @@ function decodeMessage(bb) {
   result["kind"] = MessageKind[bb.readVarUint()];
   result["data"] = decodeMessageData(bb);
   var length = bb.readVarUint();
-  var values = result["notes"] = Array(length);
+  var values = (result["notes"] = Array(length));
   for (var i = 0; i < length; i++) values[i] = decodeMessageData(bb);
   return result;
 }
 
 function encodeMessage(message, bb) {
-
   var value = message["kind"];
   if (value != null) {
     var encoded = MessageKind[value];
-if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"MessageKind\"");
-bb.writeVarUint(encoded);
+    if (encoded === void 0)
+      throw new Error(
+        "Invalid value " + JSON.stringify(value) + ' for enum "MessageKind"'
+      );
+    bb.writeVarUint(encoded);
   } else {
-    throw new Error("Missing required field \"kind\"");
+    throw new Error('Missing required field "kind"');
   }
 
   var value = message["data"];
   if (value != null) {
     encodeMessageData(value, bb);
   } else {
-    throw new Error("Missing required field \"data\"");
+    throw new Error('Missing required field "data"');
   }
 
   var value = message["notes"];
   if (value != null) {
-    var values = value, n = values.length;
+    var values = value,
+      n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       encodeMessageData(value, bb);
     }
   } else {
-    throw new Error("Missing required field \"notes\"");
+    throw new Error('Missing required field "notes"');
   }
-
 }
 
 function decodeLog(bb) {
@@ -1588,95 +1581,94 @@ function decodeLog(bb) {
   result["warnings"] = bb.readUint32();
   result["errors"] = bb.readUint32();
   var length = bb.readVarUint();
-  var values = result["msgs"] = Array(length);
+  var values = (result["msgs"] = Array(length));
   for (var i = 0; i < length; i++) values[i] = decodeMessage(bb);
   return result;
 }
 
 function encodeLog(message, bb) {
-
   var value = message["warnings"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error("Missing required field \"warnings\"");
+    throw new Error('Missing required field "warnings"');
   }
 
   var value = message["errors"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error("Missing required field \"errors\"");
+    throw new Error('Missing required field "errors"');
   }
 
   var value = message["msgs"];
   if (value != null) {
-    var values = value, n = values.length;
+    var values = value,
+      n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       encodeMessage(value, bb);
     }
   } else {
-    throw new Error("Missing required field \"msgs\"");
+    throw new Error('Missing required field "msgs"');
   }
-
 }
 const Reloader = {
-  "1": 1,
-  "2": 2,
-  "3": 3,
-  "disable": 1,
-  "live": 2,
-  "fast_refresh": 3
+  1: 1,
+  2: 2,
+  3: 3,
+  disable: 1,
+  live: 2,
+  fast_refresh: 3,
 };
 const ReloaderKeys = {
-  "1": "disable",
-  "2": "live",
-  "3": "fast_refresh",
-  "disable": "disable",
-  "live": "live",
-  "fast_refresh": "fast_refresh"
+  1: "disable",
+  2: "live",
+  3: "fast_refresh",
+  disable: "disable",
+  live: "live",
+  fast_refresh: "fast_refresh",
 };
 const WebsocketMessageKind = {
-  "1": 1,
-  "2": 2,
-  "3": 3,
-  "4": 4,
-  "5": 5,
-  "6": 6,
-  "welcome": 1,
-  "file_change_notification": 2,
-  "build_success": 3,
-  "build_fail": 4,
-  "manifest_success": 5,
-  "manifest_fail": 6
+  1: 1,
+  2: 2,
+  3: 3,
+  4: 4,
+  5: 5,
+  6: 6,
+  welcome: 1,
+  file_change_notification: 2,
+  build_success: 3,
+  build_fail: 4,
+  manifest_success: 5,
+  manifest_fail: 6,
 };
 const WebsocketMessageKindKeys = {
-  "1": "welcome",
-  "2": "file_change_notification",
-  "3": "build_success",
-  "4": "build_fail",
-  "5": "manifest_success",
-  "6": "manifest_fail",
-  "welcome": "welcome",
-  "file_change_notification": "file_change_notification",
-  "build_success": "build_success",
-  "build_fail": "build_fail",
-  "manifest_success": "manifest_success",
-  "manifest_fail": "manifest_fail"
+  1: "welcome",
+  2: "file_change_notification",
+  3: "build_success",
+  4: "build_fail",
+  5: "manifest_success",
+  6: "manifest_fail",
+  welcome: "welcome",
+  file_change_notification: "file_change_notification",
+  build_success: "build_success",
+  build_fail: "build_fail",
+  manifest_success: "manifest_success",
+  manifest_fail: "manifest_fail",
 };
 const WebsocketCommandKind = {
-  "1": 1,
-  "2": 2,
-  "build": 1,
-  "manifest": 2
+  1: 1,
+  2: 2,
+  build: 1,
+  manifest: 2,
 };
 const WebsocketCommandKindKeys = {
-  "1": "build",
-  "2": "manifest",
-  "build": "build",
-  "manifest": "manifest"
+  1: "build",
+  2: "manifest",
+  build: "build",
+  manifest: "manifest",
 };
 
 function decodeWebsocketMessage(bb) {
@@ -1688,23 +1680,26 @@ function decodeWebsocketMessage(bb) {
 }
 
 function encodeWebsocketMessage(message, bb) {
-
   var value = message["timestamp"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error("Missing required field \"timestamp\"");
+    throw new Error('Missing required field "timestamp"');
   }
 
   var value = message["kind"];
   if (value != null) {
     var encoded = WebsocketMessageKind[value];
-if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"WebsocketMessageKind\"");
-bb.writeByte(encoded);
+    if (encoded === void 0)
+      throw new Error(
+        "Invalid value " +
+          JSON.stringify(value) +
+          ' for enum "WebsocketMessageKind"'
+      );
+    bb.writeByte(encoded);
   } else {
-    throw new Error("Missing required field \"kind\"");
+    throw new Error('Missing required field "kind"');
   }
-
 }
 
 function decodeWebsocketMessageWelcome(bb) {
@@ -1716,23 +1711,24 @@ function decodeWebsocketMessageWelcome(bb) {
 }
 
 function encodeWebsocketMessageWelcome(message, bb) {
-
   var value = message["epoch"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error("Missing required field \"epoch\"");
+    throw new Error('Missing required field "epoch"');
   }
 
   var value = message["javascriptReloader"];
   if (value != null) {
     var encoded = Reloader[value];
-if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"Reloader\"");
-bb.writeByte(encoded);
+    if (encoded === void 0)
+      throw new Error(
+        "Invalid value " + JSON.stringify(value) + ' for enum "Reloader"'
+      );
+    bb.writeByte(encoded);
   } else {
-    throw new Error("Missing required field \"javascriptReloader\"");
+    throw new Error('Missing required field "javascriptReloader"');
   }
-
 }
 
 function decodeWebsocketMessageFileChangeNotification(bb) {
@@ -1744,23 +1740,24 @@ function decodeWebsocketMessageFileChangeNotification(bb) {
 }
 
 function encodeWebsocketMessageFileChangeNotification(message, bb) {
-
   var value = message["id"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error("Missing required field \"id\"");
+    throw new Error('Missing required field "id"');
   }
 
   var value = message["loader"];
   if (value != null) {
     var encoded = Loader[value];
-if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"Loader\"");
-bb.writeByte(encoded);
+    if (encoded === void 0)
+      throw new Error(
+        "Invalid value " + JSON.stringify(value) + ' for enum "Loader"'
+      );
+    bb.writeByte(encoded);
   } else {
-    throw new Error("Missing required field \"loader\"");
+    throw new Error('Missing required field "loader"');
   }
-
 }
 
 function decodeWebsocketCommand(bb) {
@@ -1772,23 +1769,26 @@ function decodeWebsocketCommand(bb) {
 }
 
 function encodeWebsocketCommand(message, bb) {
-
   var value = message["kind"];
   if (value != null) {
     var encoded = WebsocketCommandKind[value];
-if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"WebsocketCommandKind\"");
-bb.writeByte(encoded);
+    if (encoded === void 0)
+      throw new Error(
+        "Invalid value " +
+          JSON.stringify(value) +
+          ' for enum "WebsocketCommandKind"'
+      );
+    bb.writeByte(encoded);
   } else {
-    throw new Error("Missing required field \"kind\"");
+    throw new Error('Missing required field "kind"');
   }
 
   var value = message["timestamp"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error("Missing required field \"timestamp\"");
+    throw new Error('Missing required field "timestamp"');
   }
-
 }
 
 function decodeWebsocketCommandBuild(bb) {
@@ -1799,14 +1799,12 @@ function decodeWebsocketCommandBuild(bb) {
 }
 
 function encodeWebsocketCommandBuild(message, bb) {
-
   var value = message["id"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error("Missing required field \"id\"");
+    throw new Error('Missing required field "id"');
   }
-
 }
 
 function decodeWebsocketCommandManifest(bb) {
@@ -1817,14 +1815,12 @@ function decodeWebsocketCommandManifest(bb) {
 }
 
 function encodeWebsocketCommandManifest(message, bb) {
-
   var value = message["id"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error("Missing required field \"id\"");
+    throw new Error('Missing required field "id"');
   }
-
 }
 
 function decodeWebsocketMessageBuildSuccess(bb) {
@@ -1839,44 +1835,45 @@ function decodeWebsocketMessageBuildSuccess(bb) {
 }
 
 function encodeWebsocketMessageBuildSuccess(message, bb) {
-
   var value = message["id"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error("Missing required field \"id\"");
+    throw new Error('Missing required field "id"');
   }
 
   var value = message["from_timestamp"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error("Missing required field \"from_timestamp\"");
+    throw new Error('Missing required field "from_timestamp"');
   }
 
   var value = message["loader"];
   if (value != null) {
     var encoded = Loader[value];
-if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"Loader\"");
-bb.writeByte(encoded);
+    if (encoded === void 0)
+      throw new Error(
+        "Invalid value " + JSON.stringify(value) + ' for enum "Loader"'
+      );
+    bb.writeByte(encoded);
   } else {
-    throw new Error("Missing required field \"loader\"");
+    throw new Error('Missing required field "loader"');
   }
 
   var value = message["module_path"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error("Missing required field \"module_path\"");
+    throw new Error('Missing required field "module_path"');
   }
 
   var value = message["blob_length"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error("Missing required field \"blob_length\"");
+    throw new Error('Missing required field "blob_length"');
   }
-
 }
 
 function decodeWebsocketMessageBuildFailure(bb) {
@@ -1891,44 +1888,45 @@ function decodeWebsocketMessageBuildFailure(bb) {
 }
 
 function encodeWebsocketMessageBuildFailure(message, bb) {
-
   var value = message["id"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error("Missing required field \"id\"");
+    throw new Error('Missing required field "id"');
   }
 
   var value = message["from_timestamp"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error("Missing required field \"from_timestamp\"");
+    throw new Error('Missing required field "from_timestamp"');
   }
 
   var value = message["loader"];
   if (value != null) {
     var encoded = Loader[value];
-if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"Loader\"");
-bb.writeByte(encoded);
+    if (encoded === void 0)
+      throw new Error(
+        "Invalid value " + JSON.stringify(value) + ' for enum "Loader"'
+      );
+    bb.writeByte(encoded);
   } else {
-    throw new Error("Missing required field \"loader\"");
+    throw new Error('Missing required field "loader"');
   }
 
   var value = message["module_path"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error("Missing required field \"module_path\"");
+    throw new Error('Missing required field "module_path"');
   }
 
   var value = message["log"];
   if (value != null) {
     encodeLog(value, bb);
   } else {
-    throw new Error("Missing required field \"log\"");
+    throw new Error('Missing required field "log"');
   }
-
 }
 
 function decodeDependencyManifest(bb) {
@@ -1939,47 +1937,44 @@ function decodeDependencyManifest(bb) {
 }
 
 function encodeDependencyManifest(message, bb) {
-
   var value = message["ids"];
   if (value != null) {
-   bb.writeUint32ByteArray(value);
+    bb.writeUint32ByteArray(value);
   } else {
-    throw new Error("Missing required field \"ids\"");
+    throw new Error('Missing required field "ids"');
   }
-
 }
 
 function decodeFileList(bb) {
   var result = {};
 
   var length = bb.readVarUint();
-  var values = result["ptrs"] = Array(length);
+  var values = (result["ptrs"] = Array(length));
   for (var i = 0; i < length; i++) values[i] = decodeStringPointer(bb);
   result["files"] = bb.readString();
   return result;
 }
 
 function encodeFileList(message, bb) {
-
   var value = message["ptrs"];
   if (value != null) {
-    var values = value, n = values.length;
+    var values = value,
+      n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       encodeStringPointer(value, bb);
     }
   } else {
-    throw new Error("Missing required field \"ptrs\"");
+    throw new Error('Missing required field "ptrs"');
   }
 
   var value = message["files"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error("Missing required field \"files\"");
+    throw new Error('Missing required field "files"');
   }
-
 }
 
 function decodeWebsocketMessageResolveIDs(bb) {
@@ -1991,54 +1986,51 @@ function decodeWebsocketMessageResolveIDs(bb) {
 }
 
 function encodeWebsocketMessageResolveIDs(message, bb) {
-
   var value = message["id"];
   if (value != null) {
-   bb.writeUint32ByteArray(value);
+    bb.writeUint32ByteArray(value);
   } else {
-    throw new Error("Missing required field \"id\"");
+    throw new Error('Missing required field "id"');
   }
 
   var value = message["list"];
   if (value != null) {
     encodeFileList(value, bb);
   } else {
-    throw new Error("Missing required field \"list\"");
+    throw new Error('Missing required field "list"');
   }
-
 }
 
 function decodeWebsocketCommandResolveIDs(bb) {
   var result = {};
 
   var length = bb.readVarUint();
-  var values = result["ptrs"] = Array(length);
+  var values = (result["ptrs"] = Array(length));
   for (var i = 0; i < length; i++) values[i] = decodeStringPointer(bb);
   result["files"] = bb.readString();
   return result;
 }
 
 function encodeWebsocketCommandResolveIDs(message, bb) {
-
   var value = message["ptrs"];
   if (value != null) {
-    var values = value, n = values.length;
+    var values = value,
+      n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       encodeStringPointer(value, bb);
     }
   } else {
-    throw new Error("Missing required field \"ptrs\"");
+    throw new Error('Missing required field "ptrs"');
   }
 
   var value = message["files"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error("Missing required field \"files\"");
+    throw new Error('Missing required field "files"');
   }
-
 }
 
 function decodeWebsocketMessageManifestSuccess(bb) {
@@ -2052,37 +2044,38 @@ function decodeWebsocketMessageManifestSuccess(bb) {
 }
 
 function encodeWebsocketMessageManifestSuccess(message, bb) {
-
   var value = message["id"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error("Missing required field \"id\"");
+    throw new Error('Missing required field "id"');
   }
 
   var value = message["module_path"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error("Missing required field \"module_path\"");
+    throw new Error('Missing required field "module_path"');
   }
 
   var value = message["loader"];
   if (value != null) {
     var encoded = Loader[value];
-if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"Loader\"");
-bb.writeByte(encoded);
+    if (encoded === void 0)
+      throw new Error(
+        "Invalid value " + JSON.stringify(value) + ' for enum "Loader"'
+      );
+    bb.writeByte(encoded);
   } else {
-    throw new Error("Missing required field \"loader\"");
+    throw new Error('Missing required field "loader"');
   }
 
   var value = message["manifest"];
   if (value != null) {
     encodeDependencyManifest(value, bb);
   } else {
-    throw new Error("Missing required field \"manifest\"");
+    throw new Error('Missing required field "manifest"');
   }
-
 }
 
 function decodeWebsocketMessageManifestFailure(bb) {
@@ -2096,138 +2089,139 @@ function decodeWebsocketMessageManifestFailure(bb) {
 }
 
 function encodeWebsocketMessageManifestFailure(message, bb) {
-
   var value = message["id"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error("Missing required field \"id\"");
+    throw new Error('Missing required field "id"');
   }
 
   var value = message["from_timestamp"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error("Missing required field \"from_timestamp\"");
+    throw new Error('Missing required field "from_timestamp"');
   }
 
   var value = message["loader"];
   if (value != null) {
     var encoded = Loader[value];
-if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"Loader\"");
-bb.writeByte(encoded);
+    if (encoded === void 0)
+      throw new Error(
+        "Invalid value " + JSON.stringify(value) + ' for enum "Loader"'
+      );
+    bb.writeByte(encoded);
   } else {
-    throw new Error("Missing required field \"loader\"");
+    throw new Error('Missing required field "loader"');
   }
 
   var value = message["log"];
   if (value != null) {
     encodeLog(value, bb);
   } else {
-    throw new Error("Missing required field \"log\"");
-  }
-
-}
-
-export { Loader }
-export { LoaderKeys }
-export { ResolveMode }
-export { ResolveModeKeys }
-export { Platform }
-export { PlatformKeys }
-export { JSXRuntime }
-export { JSXRuntimeKeys }
-export { decodeJSX }
-export { encodeJSX }
-export { decodeStringPointer }
-export { encodeStringPointer }
-export { decodeJavascriptBundledModule }
-export { encodeJavascriptBundledModule }
-export { decodeJavascriptBundledPackage }
-export { encodeJavascriptBundledPackage }
-export { decodeJavascriptBundle }
-export { encodeJavascriptBundle }
-export { decodeJavascriptBundleContainer }
-export { encodeJavascriptBundleContainer }
-export { ScanDependencyMode }
-export { ScanDependencyModeKeys }
-export { ModuleImportType }
-export { ModuleImportTypeKeys }
-export { decodeModuleImportRecord }
-export { encodeModuleImportRecord }
-export { decodeModule }
-export { encodeModule }
-export { decodeStringMap }
-export { encodeStringMap }
-export { decodeLoaderMap }
-export { encodeLoaderMap }
-export { DotEnvBehavior }
-export { DotEnvBehaviorKeys }
-export { decodeEnvConfig }
-export { encodeEnvConfig }
-export { decodeLoadedEnvConfig }
-export { encodeLoadedEnvConfig }
-export { decodeFrameworkConfig }
-export { encodeFrameworkConfig }
-export { decodeLoadedFramework }
-export { encodeLoadedFramework }
-export { decodeLoadedRouteConfig }
-export { encodeLoadedRouteConfig }
-export { decodeRouteConfig }
-export { encodeRouteConfig }
-export { decodeTransformOptions }
-export { encodeTransformOptions }
-export { decodeFileHandle }
-export { encodeFileHandle }
-export { decodeTransform }
-export { encodeTransform }
-export { TransformResponseStatus }
-export { TransformResponseStatusKeys }
-export { decodeOutputFile }
-export { encodeOutputFile }
-export { decodeTransformResponse }
-export { encodeTransformResponse }
-export { MessageKind }
-export { MessageKindKeys }
-export { decodeLocation }
-export { encodeLocation }
-export { decodeMessageData }
-export { encodeMessageData }
-export { decodeMessage }
-export { encodeMessage }
-export { decodeLog }
-export { encodeLog }
-export { Reloader }
-export { ReloaderKeys }
-export { WebsocketMessageKind }
-export { WebsocketMessageKindKeys }
-export { WebsocketCommandKind }
-export { WebsocketCommandKindKeys }
-export { decodeWebsocketMessage }
-export { encodeWebsocketMessage }
-export { decodeWebsocketMessageWelcome }
-export { encodeWebsocketMessageWelcome }
-export { decodeWebsocketMessageFileChangeNotification }
-export { encodeWebsocketMessageFileChangeNotification }
-export { decodeWebsocketCommand }
-export { encodeWebsocketCommand }
-export { decodeWebsocketCommandBuild }
-export { encodeWebsocketCommandBuild }
-export { decodeWebsocketCommandManifest }
-export { encodeWebsocketCommandManifest }
-export { decodeWebsocketMessageBuildSuccess }
-export { encodeWebsocketMessageBuildSuccess }
-export { decodeWebsocketMessageBuildFailure }
-export { encodeWebsocketMessageBuildFailure }
-export { decodeDependencyManifest }
-export { encodeDependencyManifest }
-export { decodeFileList }
-export { encodeFileList }
-export { decodeWebsocketMessageResolveIDs }
-export { encodeWebsocketMessageResolveIDs }
-export { decodeWebsocketCommandResolveIDs }
-export { encodeWebsocketCommandResolveIDs }
-export { decodeWebsocketMessageManifestSuccess }
-export { encodeWebsocketMessageManifestSuccess }
-export { decodeWebsocketMessageManifestFailure }
-export { encodeWebsocketMessageManifestFailure }
\ No newline at end of file
+    throw new Error('Missing required field "log"');
+  }
+}
+
+export { Loader };
+export { LoaderKeys };
+export { ResolveMode };
+export { ResolveModeKeys };
+export { Platform };
+export { PlatformKeys };
+export { JSXRuntime };
+export { JSXRuntimeKeys };
+export { decodeJSX };
+export { encodeJSX };
+export { decodeStringPointer };
+export { encodeStringPointer };
+export { decodeJavascriptBundledModule };
+export { encodeJavascriptBundledModule };
+export { decodeJavascriptBundledPackage };
+export { encodeJavascriptBundledPackage };
+export { decodeJavascriptBundle };
+export { encodeJavascriptBundle };
+export { decodeJavascriptBundleContainer };
+export { encodeJavascriptBundleContainer };
+export { ScanDependencyMode };
+export { ScanDependencyModeKeys };
+export { ModuleImportType };
+export { ModuleImportTypeKeys };
+export { decodeModuleImportRecord };
+export { encodeModuleImportRecord };
+export { decodeModule };
+export { encodeModule };
+export { decodeStringMap };
+export { encodeStringMap };
+export { decodeLoaderMap };
+export { encodeLoaderMap };
+export { DotEnvBehavior };
+export { DotEnvBehaviorKeys };
+export { decodeEnvConfig };
+export { encodeEnvConfig };
+export { decodeLoadedEnvConfig };
+export { encodeLoadedEnvConfig };
+export { decodeFrameworkConfig };
+export { encodeFrameworkConfig };
+export { decodeLoadedFramework };
+export { encodeLoadedFramework };
+export { decodeLoadedRouteConfig };
+export { encodeLoadedRouteConfig };
+export { decodeRouteConfig };
+export { encodeRouteConfig };
+export { decodeTransformOptions };
+export { encodeTransformOptions };
+export { decodeFileHandle };
+export { encodeFileHandle };
+export { decodeTransform };
+export { encodeTransform };
+export { TransformResponseStatus };
+export { TransformResponseStatusKeys };
+export { decodeOutputFile };
+export { encodeOutputFile };
+export { decodeTransformResponse };
+export { encodeTransformResponse };
+export { MessageKind };
+export { MessageKindKeys };
+export { decodeLocation };
+export { encodeLocation };
+export { decodeMessageData };
+export { encodeMessageData };
+export { decodeMessage };
+export { encodeMessage };
+export { decodeLog };
+export { encodeLog };
+export { Reloader };
+export { ReloaderKeys };
+export { WebsocketMessageKind };
+export { WebsocketMessageKindKeys };
+export { WebsocketCommandKind };
+export { WebsocketCommandKindKeys };
+export { decodeWebsocketMessage };
+export { encodeWebsocketMessage };
+export { decodeWebsocketMessageWelcome };
+export { encodeWebsocketMessageWelcome };
+export { decodeWebsocketMessageFileChangeNotification };
+export { encodeWebsocketMessageFileChangeNotification };
+export { decodeWebsocketCommand };
+export { encodeWebsocketCommand };
+export { decodeWebsocketCommandBuild };
+export { encodeWebsocketCommandBuild };
+export { decodeWebsocketCommandManifest };
+export { encodeWebsocketCommandManifest };
+export { decodeWebsocketMessageBuildSuccess };
+export { encodeWebsocketMessageBuildSuccess };
+export { decodeWebsocketMessageBuildFailure };
+export { encodeWebsocketMessageBuildFailure };
+export { decodeDependencyManifest };
+export { encodeDependencyManifest };
+export { decodeFileList };
+export { encodeFileList };
+export { decodeWebsocketMessageResolveIDs };
+export { encodeWebsocketMessageResolveIDs };
+export { decodeWebsocketCommandResolveIDs };
+export { encodeWebsocketCommandResolveIDs };
+export { decodeWebsocketMessageManifestSuccess };
+export { encodeWebsocketMessageManifestSuccess };
+export { decodeWebsocketMessageManifestFailure };
+export { encodeWebsocketMessageManifestFailure };
diff --git a/src/api/schema.peechy b/src/api/schema.peechy
index 4d2baaaef..a40cacef1 100644
--- a/src/api/schema.peechy
+++ b/src/api/schema.peechy
@@ -213,15 +213,13 @@ message TransformOptions {
 
   string[] extension_order = 17;
 
-  ScanDependencyMode only_scan_dependencies = 18;
+  bool generate_node_module_bundle = 18;
 
-  bool generate_node_module_bundle = 19;
+  string node_modules_bundle_path = 19;
+  string node_modules_bundle_path_server = 20;
 
-  string node_modules_bundle_path = 20;
-  string node_modules_bundle_path_server = 21;
-
-  FrameworkConfig framework = 22;
-  RouteConfig router = 23;
+  FrameworkConfig framework = 21;
+  RouteConfig router = 22;
 }
 
 struct FileHandle {
diff --git a/src/api/schema.zig b/src/api/schema.zig
index 56feccb75..69a77082a 100644
--- a/src/api/schema.zig
+++ b/src/api/schema.zig
@@ -1140,9 +1140,6 @@ serve: ?bool = null,
 /// extension_order
 extension_order: []const []const u8,
 
-/// only_scan_dependencies
-only_scan_dependencies: ?ScanDependencyMode = null,
-
 /// generate_node_module_bundle
 generate_node_module_bundle: ?bool = null,
 
@@ -1218,21 +1215,18 @@ pub fn decode(reader: anytype) anyerror!TransformOptions {
         this.extension_order = try reader.readArray([]const u8); 
 },
       18 => {
-        this.only_scan_dependencies = try reader.readValue(ScanDependencyMode); 
-},
-      19 => {
         this.generate_node_module_bundle = try reader.readValue(bool); 
 },
-      20 => {
+      19 => {
         this.node_modules_bundle_path = try reader.readValue([]const u8); 
 },
-      21 => {
+      20 => {
         this.node_modules_bundle_path_server = try reader.readValue([]const u8); 
 },
-      22 => {
+      21 => {
         this.framework = try reader.readValue(FrameworkConfig); 
 },
-      23 => {
+      22 => {
         this.router = try reader.readValue(RouteConfig); 
 },
       else => {
@@ -1312,28 +1306,24 @@ if (this.extension_order) |extension_order| {
   try writer.writeFieldID(17);
    try writer.writeArray([]const u8, extension_order);
 }
-if (this.only_scan_dependencies) |only_scan_dependencies| {
-  try writer.writeFieldID(18);
-   try writer.writeEnum(only_scan_dependencies);
-}
 if (this.generate_node_module_bundle) |generate_node_module_bundle| {
-  try writer.writeFieldID(19);
+  try writer.writeFieldID(18);
    try writer.writeInt(@intCast(u8, @boolToInt(generate_node_module_bundle)));
 }
 if (this.node_modules_bundle_path) |node_modules_bundle_path| {
-  try writer.writeFieldID(20);
+  try writer.writeFieldID(19);
    try writer.writeValue(node_modules_bundle_path);
 }
 if (this.node_modules_bundle_path_server) |node_modules_bundle_path_server| {
-  try writer.writeFieldID(21);
+  try writer.writeFieldID(20);
    try writer.writeValue(node_modules_bundle_path_server);
 }
 if (this.framework) |framework| {
-  try writer.writeFieldID(22);
+  try writer.writeFieldID(21);
    try writer.writeValue(framework);
 }
 if (this.router) |router| {
-  try writer.writeFieldID(23);
+  try writer.writeFieldID(22);
    try writer.writeValue(router);
 }
 try writer.endMessage();
diff --git a/src/bundler.zig b/src/bundler.zig
index bf78c760d..105d29f54 100644
--- a/src/bundler.zig
+++ b/src/bundler.zig
@@ -159,12 +159,6 @@ pub const ServerEntryPoint = struct {
             &entry.code_buffer,
             \\//Auto-generated file
             \\import * as start from '{s}{s}';
-            \\if ('default' in start && typeof start.default === 'function') {{
-            \\  const result = start.default();
-            \\  if (result && typeof result === 'object' && result instanceof Promise) {{
-            \\    result.then(undefined, undefined);
-            \\  }}
-            \\}}
             \\export * from '{s}{s}';
         ,
             .{
@@ -651,7 +645,7 @@ pub fn NewBundler(cache_files: bool) type {
                 try bundler.configureDefines();
 
                 const tmpname = try bundler.fs.tmpname(
-                    ".jsb",
+                    ".bun",
                     std.mem.span(&tmpname_buf),
                     std.hash.Wyhash.hash(0, std.mem.span(destination)),
                 );
@@ -853,7 +847,7 @@ pub fn NewBundler(cache_files: bool) type {
                 const extname = std.fs.path.extension(basename);
                 javascript_bundle.import_from_name = try std.fmt.allocPrint(
                     this.allocator,
-                    "/{s}.{x}.jsb",
+                    "/{s}.{x}.bun",
                     .{
                         basename[0 .. basename.len - extname.len],
                         etag_u64,
diff --git a/src/cli.zig b/src/cli.zig
index 5c1be01de..b7cbc97ba 100644
--- a/src/cli.zig
+++ b/src/cli.zig
@@ -1,6 +1,6 @@
 usingnamespace @import("global.zig");
-
 usingnamespace @import("./http.zig");
+
 const std = @import("std");
 const lex = @import("js_lexer.zig");
 const logger = @import("logger.zig");
@@ -28,679 +28,528 @@ const Router = @import("./router.zig");
 
 const NodeModuleBundle = @import("./node_module_bundle.zig").NodeModuleBundle;
 
+const BunCommand = @import("./cli/bun_command.zig").BunCommand;
+const DevCommand = @import("./cli/dev_command.zig").DevCommand;
+const DiscordCommand = @import("./cli/discord_command.zig").DiscordCommand;
+const BuildCommand = @import("./cli/build_command.zig").BuildCommand;
+const RunCommand = @import("./cli/run_command.zig").RunCommand;
+
+var start_time: i128 = undefined;
+
 pub const Cli = struct {
-    const LoaderMatcher = strings.ExactSizeMatcher(4);
-    pub fn ColonListType(comptime t: type, value_resolver: anytype) type {
-        return struct {
-            pub fn init(allocator: *std.mem.Allocator, count: usize) !@This() {
-                var keys = try allocator.alloc(string, count);
-                var values = try allocator.alloc(t, count);
-
-                return @This(){ .keys = keys, .values = values };
-            }
-            keys: []string,
-            values: []t,
-
-            pub fn load(self: *@This(), input: []const string) !void {
-                for (input) |str, i| {
-                    // Support either ":" or "=" as the separator, preferring whichever is first.
-                    // ":" is less confusing IMO because that syntax is used with flags
-                    // but "=" is what esbuild uses and I want this to be somewhat familiar for people using esbuild
-                    const midpoint = std.math.min(strings.indexOfChar(str, ':') orelse std.math.maxInt(usize), strings.indexOfChar(str, '=') orelse std.math.maxInt(usize));
-                    if (midpoint == std.math.maxInt(usize)) {
-                        return error.InvalidSeparator;
-                    }
+    var wait_group: sync.WaitGroup = undefined;
+    pub fn startTransform(allocator: *std.mem.Allocator, args: Api.TransformOptions, log: *logger.Log) anyerror!void {}
+    pub fn start(allocator: *std.mem.Allocator, stdout: anytype, stderr: anytype, comptime MainPanicHandler: type) anyerror!void {
+        start_time = std.time.nanoTimestamp();
+        var log = logger.Log.init(allocator);
+        var panicker = MainPanicHandler.init(&log);
+        MainPanicHandler.Singleton = &panicker;
+
+        try Command.start(allocator, &log);
+        std.mem.doNotOptimizeAway(&log);
+    }
+};
+
+const LoaderMatcher = strings.ExactSizeMatcher(4);
+pub fn ColonListType(comptime t: type, value_resolver: anytype) type {
+    return struct {
+        pub fn init(allocator: *std.mem.Allocator, count: usize) !@This() {
+            var keys = try allocator.alloc(string, count);
+            var values = try allocator.alloc(t, count);
 
-                    self.keys[i] = str[0..midpoint];
-                    self.values[i] = try value_resolver(str[midpoint + 1 .. str.len]);
+            return @This(){ .keys = keys, .values = values };
+        }
+        keys: []string,
+        values: []t,
+
+        pub fn load(self: *@This(), input: []const string) !void {
+            for (input) |str, i| {
+                // Support either ":" or "=" as the separator, preferring whichever is first.
+                // ":" is less confusing IMO because that syntax is used with flags
+                // but "=" is what esbuild uses and I want this to be somewhat familiar for people using esbuild
+                const midpoint = std.math.min(strings.indexOfChar(str, ':') orelse std.math.maxInt(usize), strings.indexOfChar(str, '=') orelse std.math.maxInt(usize));
+                if (midpoint == std.math.maxInt(usize)) {
+                    return error.InvalidSeparator;
                 }
-            }
 
-            pub fn resolve(allocator: *std.mem.Allocator, input: []const string) !@This() {
-                var list = try init(allocator, input.len);
-                try list.load(input);
-                return list;
-            }
-        };
-    }
-    pub const LoaderColonList = ColonListType(Api.Loader, Arguments.loader_resolver);
-    pub const DefineColonList = ColonListType(string, Arguments.noop_resolver);
-
-    pub const Arguments = struct {
-        pub fn loader_resolver(in: string) !Api.Loader {
-            const Matcher = strings.ExactSizeMatcher(4);
-            switch (Matcher.match(in)) {
-                Matcher.case("jsx") => return Api.Loader.jsx,
-                Matcher.case("js") => return Api.Loader.js,
-                Matcher.case("ts") => return Api.Loader.ts,
-                Matcher.case("tsx") => return Api.Loader.tsx,
-                Matcher.case("css") => return Api.Loader.css,
-                Matcher.case("file") => return Api.Loader.file,
-                Matcher.case("json") => return Api.Loader.json,
-                else => {
-                    return error.InvalidLoader;
-                },
+                self.keys[i] = str[0..midpoint];
+                self.values[i] = try value_resolver(str[midpoint + 1 .. str.len]);
             }
         }
 
-        pub fn noop_resolver(in: string) !string {
-            return in;
+        pub fn resolve(allocator: *std.mem.Allocator, input: []const string) !@This() {
+            var list = try init(allocator, input.len);
+            try list.load(input);
+            return list;
         }
-
-        pub fn fileReadError(err: anyerror, stderr: anytype, filename: string, kind: string) noreturn {
-            stderr.writer().print("Error reading file \"{s}\" for {s}: {s}", .{ filename, kind, @errorName(err) }) catch {};
-            std.process.exit(1);
+    };
+}
+pub const LoaderColonList = ColonListType(Api.Loader, Arguments.loader_resolver);
+pub const DefineColonList = ColonListType(string, Arguments.noop_resolver);
+
+pub const Arguments = struct {
+    pub fn loader_resolver(in: string) !Api.Loader {
+        const Matcher = strings.ExactSizeMatcher(4);
+        switch (Matcher.match(in)) {
+            Matcher.case("jsx") => return Api.Loader.jsx,
+            Matcher.case("js") => return Api.Loader.js,
+            Matcher.case("ts") => return Api.Loader.ts,
+            Matcher.case("tsx") => return Api.Loader.tsx,
+            Matcher.case("css") => return Api.Loader.css,
+            Matcher.case("file") => return Api.Loader.file,
+            Matcher.case("json") => return Api.Loader.json,
+            else => {
+                return error.InvalidLoader;
+            },
         }
+    }
 
-        pub fn readFile(
-            allocator: *std.mem.Allocator,
-            cwd: string,
-            filename: string,
-        ) ![]u8 {
-            var paths = [_]string{ cwd, filename };
-            const outpath = try std.fs.path.resolve(allocator, &paths);
-            defer allocator.free(outpath);
-            var file = try std.fs.openFileAbsolute(outpath, std.fs.File.OpenFlags{ .read = true, .write = false });
-            defer file.close();
-            const stats = try file.stat();
-            return try file.readToEndAlloc(allocator, stats.size);
-        }
+    pub fn noop_resolver(in: string) !string {
+        return in;
+    }
 
-        pub fn parse(allocator: *std.mem.Allocator, stdout: anytype, stderr: anytype) !Api.TransformOptions {
-            @setEvalBranchQuota(9999);
-            const params = comptime [_]clap.Param(clap.Help){
-                clap.parseParam("-h, --help                        Display this help and exit.              ") catch unreachable,
-                clap.parseParam("-r, --resolve <STR>               Determine import/require behavior. \"disable\" ignores. \"dev\" bundles node_modules and builds everything else as independent entry points") catch unreachable,
-                clap.parseParam("-d, --define <STR>...             Substitute K:V while parsing, e.g. --define process.env.NODE_ENV:development") catch unreachable,
-                clap.parseParam("-l, --loader <STR>...             Parse files with .ext:loader, e.g. --loader .js:jsx. Valid loaders: jsx, js, json, tsx (not implemented yet), ts (not implemented yet), css (not implemented yet)") catch unreachable,
-                clap.parseParam("-o, --outdir <STR>                Save output to directory (default: \"out\" if none provided and multiple entry points passed)") catch unreachable,
-                clap.parseParam("-e, --external <STR>...           Exclude module from transpilation (can use * wildcards). ex: -e react") catch unreachable,
-                clap.parseParam("-i, --inject <STR>...             Inject module at the top of every file") catch unreachable,
-                clap.parseParam("--cwd <STR>                       Absolute path to resolve entry points from.") catch unreachable,
-                clap.parseParam("--origin <STR>                    Rewrite import paths to start with --origin. Useful for web browsers. Default: \"/\"") catch unreachable,
-                clap.parseParam("--serve                           Start a local dev server. This also sets resolve to \"lazy\".") catch unreachable,
-                clap.parseParam("--static-dir <STR>                Top-level directory for .html files, fonts or anything external. Defaults to \"<cwd>/public\", to match create-react-app and Next.js") catch unreachable,
-                clap.parseParam("--jsx-factory <STR>               Changes the function called when compiling JSX elements using the classic JSX runtime") catch unreachable,
-                clap.parseParam("--jsx-fragment <STR>              Changes the function called when compiling JSX fragments using the classic JSX runtime") catch unreachable,
-                clap.parseParam("--jsx-import-source <STR>         Declares the module specifier to be used for importing the jsx and jsxs factory functions. Default: \"react\"") catch unreachable,
-                clap.parseParam("--jsx-runtime <STR>               \"automatic\" (default) or \"classic\"") catch unreachable,
-                clap.parseParam("--jsx-production                  Use jsx instead of jsxDEV (default) for the automatic runtime") catch unreachable,
-                clap.parseParam("--extension-order <STR>...        defaults to: .tsx,.ts,.jsx,.js,.json ") catch unreachable,
-                clap.parseParam("--disable-react-fast-refresh      Disable React Fast Refresh. Enabled if --serve is set and --jsx-production is not set. Otherwise, it's a noop.") catch unreachable,
-                clap.parseParam("--tsconfig-override <STR>         Load tsconfig from path instead of cwd/tsconfig.json") catch unreachable,
-                clap.parseParam("--platform <STR>                  \"browser\" or \"node\". Defaults to \"browser\"") catch unreachable,
-                clap.parseParam("--main-fields <STR>...            Main fields to lookup in package.json. Defaults to --platform dependent") catch unreachable,
-                clap.parseParam("--scan                            Instead of bundling or transpiling, print a list of every file imported by an entry point, recursively") catch unreachable,
-                clap.parseParam("--new-jsb                         Generate a new node_modules.jsb file from node_modules and entry point(s)") catch unreachable,
-                clap.parseParam("--jsb <STR>                       Use a Bun JavaScript Bundle (default: \"./node_modules.jsb\" if exists)") catch unreachable,
-                clap.parseParam("--jsb-for-server <STR>            Use a server-only Bun JavaScript Bundle (default: \"./node_modules.server.jsb\" if exists)") catch unreachable,
-                clap.parseParam("--use <STR>                       Use a JavaScript framework (package name or path to package)") catch unreachable,
-                clap.parseParam("--production                      This sets the defaults to production. Applies to jsx & framework") catch unreachable,
-
-                clap.parseParam("<POS>...                          Entry point(s) to use. Can be individual files, npm packages, or one directory. If one directory, it will auto-detect entry points using a filesystem router. If you're using a framework, passing entry points are optional.") catch unreachable,
-            };
+    pub fn fileReadError(err: anyerror, stderr: anytype, filename: string, kind: string) noreturn {
+        stderr.writer().print("Error reading file \"{s}\" for {s}: {s}", .{ filename, kind, @errorName(err) }) catch {};
+        std.process.exit(1);
+    }
 
-            var diag = clap.Diagnostic{};
+    pub fn readFile(
+        allocator: *std.mem.Allocator,
+        cwd: string,
+        filename: string,
+    ) ![]u8 {
+        var paths = [_]string{ cwd, filename };
+        const outpath = try std.fs.path.resolve(allocator, &paths);
+        defer allocator.free(outpath);
+        var file = try std.fs.openFileAbsolute(outpath, std.fs.File.OpenFlags{ .read = true, .write = false });
+        defer file.close();
+        const stats = try file.stat();
+        return try file.readToEndAlloc(allocator, stats.size);
+    }
 
-            var args = clap.parse(clap.Help, &params, .{ .diagnostic = &diag }) catch |err| {
-                // Report useful error and exit
-                diag.report(stderr.writer(), err) catch {};
-                return err;
-            };
+    pub fn resolve_jsx_runtime(str: string) !Api.JsxRuntime {
+        if (strings.eqlComptime(str, "automatic")) {
+            return Api.JsxRuntime.automatic;
+        } else if (strings.eqlComptime(str, "fallback")) {
+            return Api.JsxRuntime.classic;
+        } else {
+            return error.InvalidJSXRuntime;
+        }
+    }
 
-            if (args.flag("--help")) {
-                try clap.help(stderr.writer(), &params);
-                std.process.exit(1);
-            }
+    const ParamType = clap.Param(clap.Help);
+
+    const params: [25]ParamType = brk: {
+        @setEvalBranchQuota(9999);
+        break :brk [_]ParamType{
+            clap.parseParam("-r, --resolve <STR>               Determine import/require behavior. \"disable\" ignores. \"dev\" bundles node_modules and builds everything else as independent entry points") catch unreachable,
+            clap.parseParam("-h, --help                        Display this help and exit.              ") catch unreachable,
+            clap.parseParam("-d, --define <STR>...             Substitute K:V while parsing, e.g. --define process.env.NODE_ENV:development") catch unreachable,
+            clap.parseParam("-l, --loader <STR>...             Parse files with .ext:loader, e.g. --loader .js:jsx. Valid loaders: jsx, js, json, tsx (not implemented yet), ts (not implemented yet), css (not implemented yet)") catch unreachable,
+            clap.parseParam("-o, --outdir <STR>                Save output to directory (default: \"out\" if none provided and multiple entry points passed)") catch unreachable,
+            clap.parseParam("-e, --external <STR>...           Exclude module from transpilation (can use * wildcards). ex: -e react") catch unreachable,
+            clap.parseParam("-i, --inject <STR>...             Inject module at the top of every file") catch unreachable,
+            clap.parseParam("--cwd <STR>                       Absolute path to resolve files & entry points from. This just changes the process' cwd.") catch unreachable,
+            clap.parseParam("--use <STR>                       Choose a framework, e.g. \"--use next\". It checks first for a package named \"bun-framework-packagename\" and then \"packagename\".") catch unreachable,
+            clap.parseParam("--origin <STR>                    Rewrite import paths to start with --origin. Default: \"/\"") catch unreachable,
+            clap.parseParam("--static-dir <STR>                Top-level directory for .html files, fonts or anything external. Defaults to \"<cwd>/public\", to match create-react-app and Next.js") catch unreachable,
+            clap.parseParam("--extension-order <STR>...        defaults to: .tsx,.ts,.jsx,.js,.json ") catch unreachable,
+            clap.parseParam("--tsconfig-override <STR>         Load tsconfig from path instead of cwd/tsconfig.json") catch unreachable,
+            clap.parseParam("--platform <STR>                  \"browser\" or \"node\". Defaults to \"browser\"") catch unreachable,
+            clap.parseParam("--main-fields <STR>...            Main fields to lookup in package.json. Defaults to --platform dependent") catch unreachable,
+            clap.parseParam("--disable-react-fast-refresh      Disable React Fast Refresh") catch unreachable,
+            clap.parseParam("--jsx-factory <STR>               Changes the function called when compiling JSX elements using the classic JSX runtime") catch unreachable,
+            clap.parseParam("--jsx-fragment <STR>              Changes the function called when compiling JSX fragments using the classic JSX runtime") catch unreachable,
+            clap.parseParam("--jsx-import-source <STR>         Declares the module specifier to be used for importing the jsx and jsxs factory functions. Default: \"react\"") catch unreachable,
+            clap.parseParam("--jsx-runtime <STR>               \"automatic\" (default) or \"classic\"") catch unreachable,
+            clap.parseParam("--jsx-production                  Use jsx instead of jsxDEV (default) for the automatic runtime") catch unreachable,
+            clap.parseParam("--bunfile <STR>                   Use a .bun file (default: node_modules.bun)") catch unreachable,
+            clap.parseParam("--server-bunfile <STR>            Use a .server.bun file (default: node_modules.server.bun)") catch unreachable,
+            clap.parseParam("--production                      [work in progress] generate production code") catch unreachable,
+
+            clap.parseParam("<POS>...                          ") catch unreachable,
+        };
+    };
 
-            var cwd_paths = [_]string{args.option("--cwd") orelse try std.process.getCwdAlloc(allocator)};
-            var cwd = try std.fs.path.resolve(allocator, &cwd_paths);
-            var tsconfig_override = if (args.option("--tsconfig-override")) |ts| (Arguments.readFile(allocator, cwd, ts) catch |err| fileReadError(err, stderr, ts, "tsconfig.json")) else null;
-            var origin = args.option("--origin");
-            var defines_tuple = try DefineColonList.resolve(allocator, args.options("--define"));
-            var loader_tuple = try LoaderColonList.resolve(allocator, args.options("--define"));
-
-            var define_keys = defines_tuple.keys;
-            var define_values = defines_tuple.values;
-            var loader_keys = loader_tuple.keys;
-            var loader_values = loader_tuple.values;
-            var entry_points = args.positionals();
-            var inject = args.options("--inject");
-            var output_dir = args.option("--outdir");
-            const serve = args.flag("--serve");
-
-            const production = args.flag("--production");
-
-            var write = entry_points.len > 1 or output_dir != null;
-            if (write and output_dir == null) {
-                var _paths = [_]string{ cwd, "out" };
-                output_dir = try std.fs.path.resolve(allocator, &_paths);
-            }
-            var externals = std.mem.zeroes([][]u8);
-            if (args.options("--external").len > 0) {
-                externals = try allocator.alloc([]u8, args.options("--external").len);
-                for (args.options("--external")) |external, i| {
-                    externals[i] = constStrToU8(external);
-                }
-            }
+    pub fn parse(allocator: *std.mem.Allocator, comptime cmd: Command.Tag) !Api.TransformOptions {
+        var diag = clap.Diagnostic{};
 
-            var jsx_factory = args.option("--jsx-factory");
-            var jsx_fragment = args.option("--jsx-fragment");
-            var jsx_import_source = args.option("--jsx-import-source");
-            var jsx_runtime = args.option("--jsx-runtime");
-            var jsx_production = args.flag("--jsx-production") or production;
-            var react_fast_refresh = false;
+        var args = clap.parse(clap.Help, &params, .{ .diagnostic = &diag }) catch |err| {
+            // Report useful error and exit
+            diag.report(Output.errorWriter(), err) catch {};
+            return err;
+        };
 
-            var framework_entry_point = args.option("--use");
+        var cwd_paths = [_]string{args.option("--cwd") orelse try std.process.getCwdAlloc(allocator)};
+        var cwd = try std.fs.path.resolve(allocator, &cwd_paths);
 
-            if (serve or args.flag("--new-jsb")) {
-                react_fast_refresh = true;
-                if (args.flag("--disable-react-fast-refresh") or jsx_production) {
-                    react_fast_refresh = false;
-                }
+        var defines_tuple = try DefineColonList.resolve(allocator, args.options("--define"));
+        var loader_tuple = try LoaderColonList.resolve(allocator, args.options("--define"));
+        var externals = std.mem.zeroes([][]u8);
+        if (args.options("--external").len > 0) {
+            externals = try allocator.alloc([]u8, args.options("--external").len);
+            for (args.options("--external")) |external, i| {
+                externals[i] = constStrToU8(external);
             }
+        }
 
-            var main_fields = args.options("--main-fields");
-
-            var node_modules_bundle_path = args.option("--jsb") orelse brk: {
-                if (args.flag("--new-jsb")) {
-                    break :brk null;
-                }
+        var opts = Api.TransformOptions{
+            .tsconfig_override = if (args.option("--tsconfig-override")) |ts| (Arguments.readFile(allocator, cwd, ts) catch |err| fileReadError(err, Output.errorStream(), ts, "tsconfig.json")) else null,
+            .external = externals,
+            .absolute_working_dir = cwd,
+            .origin = args.option("--origin"),
+            .define = .{
+                .keys = defines_tuple.keys,
+                .values = defines_tuple.values,
+            },
+            .loaders = .{
+                .extensions = loader_tuple.keys,
+                .loaders = loader_tuple.values,
+            },
 
-                const node_modules_bundle_path_absolute = resolve_path.joinAbs(cwd, .auto, "node_modules.jsb");
+            .serve = cmd == .DevCommand,
+            .main_fields = args.options("--main-fields"),
+            .generate_node_module_bundle = cmd == .BunCommand,
+            .inject = args.options("--inject"),
+            .extension_order = args.options("--extension-order"),
+            .entry_points = undefined,
+        };
 
-                break :brk std.fs.realpathAlloc(allocator, node_modules_bundle_path_absolute) catch null;
-            };
+        const print_help = args.flag("--help");
+        if (print_help) {
+            clap.help(Output.errorWriter(), &params) catch {};
+            std.os.exit(0);
+        }
 
-            var node_modules_bundle_path_server = args.option("--jsb-for-server") orelse brk: {
-                if (args.flag("--new-jsb")) {
-                    break :brk null;
+        var output_dir = args.option("--outdir");
+
+        var define_keys = defines_tuple.keys;
+        var define_values = defines_tuple.values;
+        var loader_keys = loader_tuple.keys;
+        var loader_values = loader_tuple.values;
+        var entry_points = args.positionals();
+
+        switch (comptime cmd) {
+            .BunCommand => {
+                if (entry_points.len > 0 and (strings.eqlComptime(
+                    entry_points[0],
+                    "bun",
+                ))) {
+                    entry_points = entry_points[1..];
                 }
+            },
+            .DevCommand => {
+                if (entry_points.len > 0 and (strings.eqlComptime(
+                    entry_points[0],
+                    "dev",
+                ) or strings.eqlComptime(
+                    entry_points[0],
+                    "d",
+                ))) {
+                    entry_points = entry_points[1..];
+                }
+            },
+            .BuildCommand => {
+                if (entry_points.len > 0 and (strings.eqlComptime(
+                    entry_points[0],
+                    "build",
+                ) or strings.eqlComptime(
+                    entry_points[0],
+                    "b",
+                ))) {
+                    entry_points = entry_points[1..];
+                }
+            },
+            .RunCommand => {
+                if (entry_points.len > 0 and (strings.eqlComptime(
+                    entry_points[0],
+                    "run",
+                ) or strings.eqlComptime(
+                    entry_points[0],
+                    "r",
+                ))) {
+                    entry_points = entry_points[1..];
+                }
+            },
+            else => {},
+        }
 
-                const node_modules_bundle_path_absolute = resolve_path.joinAbs(cwd, .auto, "node_modules.server.jsb");
+        const production = args.flag("--production");
 
-                break :brk std.fs.realpathAlloc(allocator, node_modules_bundle_path_absolute) catch null;
-            };
+        var write = entry_points.len > 1 or output_dir != null;
+        if (write and output_dir == null) {
+            var _paths = [_]string{ cwd, "out" };
+            output_dir = try std.fs.path.resolve(allocator, &_paths);
+        }
+        opts.write = write;
+        opts.entry_points = entry_points;
+
+        var jsx_factory = args.option("--jsx-factory");
+        var jsx_fragment = args.option("--jsx-fragment");
+        var jsx_import_source = args.option("--jsx-import-source");
+        var jsx_runtime = args.option("--jsx-runtime");
+        var jsx_production = args.flag("--jsx-production") or production;
+        const react_fast_refresh = switch (comptime cmd) {
+            .BunCommand, .DevCommand => !(args.flag("--disable-react-fast-refresh") or jsx_production),
+            else => true,
+        };
 
-            if (args.flag("--new-jsb")) {
-                node_modules_bundle_path = null;
-                node_modules_bundle_path_server = null;
-            }
+        opts.node_modules_bundle_path = args.option("--bunfile") orelse brk: {
+            const node_modules_bundle_path_absolute = resolve_path.joinAbs(cwd, .auto, "node_modules.bun");
 
-            var route_config: ?Api.RouteConfig = null;
-            if (args.option("--static-dir")) |public_dir| {
-                route_config = route_config orelse Api.RouteConfig{ .extensions = &.{}, .dir = &.{} };
+            break :brk std.fs.realpathAlloc(allocator, node_modules_bundle_path_absolute) catch null;
+        };
 
-                route_config.?.static_dir = public_dir;
-            }
+        opts.node_modules_bundle_path_server = args.option("--server-bunfile") orelse brk: {
+            const node_modules_bundle_path_absolute = resolve_path.joinAbs(cwd, .auto, "node_modules.server.bun");
 
-            const PlatformMatcher = strings.ExactSizeMatcher(8);
-            const ResoveMatcher = strings.ExactSizeMatcher(8);
-
-            var resolve = Api.ResolveMode.lazy;
-            if (args.option("--resolve")) |_resolve| {
-                switch (PlatformMatcher.match(_resolve)) {
-                    PlatformMatcher.case("disable") => {
-                        resolve = Api.ResolveMode.disable;
-                    },
-                    PlatformMatcher.case("bundle") => {
-                        resolve = Api.ResolveMode.bundle;
-                    },
-                    PlatformMatcher.case("dev") => {
-                        resolve = Api.ResolveMode.dev;
-                    },
-                    PlatformMatcher.case("lazy") => {
-                        resolve = Api.ResolveMode.lazy;
-                    },
-                    else => {
-                        diag.name.long = "--resolve";
-                        diag.arg = _resolve;
-                        try diag.report(stderr.writer(), error.InvalidResolveOption);
-                        std.process.exit(1);
-                    },
-                }
-            }
+            break :brk std.fs.realpathAlloc(allocator, node_modules_bundle_path_absolute) catch null;
+        };
 
-            var platform: ?Api.Platform = null;
-
-            if (args.option("--platform")) |_platform| {
-                switch (PlatformMatcher.match(_platform)) {
-                    PlatformMatcher.case("browser") => {
-                        platform = Api.Platform.browser;
-                    },
-                    PlatformMatcher.case("node") => {
-                        platform = Api.Platform.node;
-                    },
-                    else => {
-                        diag.name.long = "--platform";
-                        diag.arg = _platform;
-                        try diag.report(stderr.writer(), error.InvalidPlatform);
-                        std.process.exit(1);
-                    },
+        switch (comptime cmd) {
+            .DevCommand, .BuildCommand => {
+                if (args.option("--static-dir")) |public_dir| {
+                    opts.router = Api.RouteConfig{ .extensions = &.{}, .dir = &.{}, .static_dir = public_dir };
                 }
-            }
+            },
+            else => {},
+        }
 
-            var jsx: ?Api.Jsx = null;
-            if (jsx_factory != null or
-                jsx_fragment != null or
-                jsx_import_source != null or
-                jsx_runtime != null or
-                jsx_production or react_fast_refresh)
-            {
-                var default_factory = "".*;
-                var default_fragment = "".*;
-                var default_import_source = "".*;
-                jsx = Api.Jsx{
-                    .factory = constStrToU8(jsx_factory orelse &default_factory),
-                    .fragment = constStrToU8(jsx_fragment orelse &default_fragment),
-                    .import_source = constStrToU8(jsx_import_source orelse &default_import_source),
-                    .runtime = if (jsx_runtime != null) try resolve_jsx_runtime(jsx_runtime.?) else Api.JsxRuntime.automatic,
-                    .development = !jsx_production,
-                    .react_fast_refresh = react_fast_refresh,
-                };
-            }
+        const ResolveMatcher = strings.ExactSizeMatcher(8);
 
-            var javascript_framework: ?Api.FrameworkConfig = null;
+        opts.resolve = Api.ResolveMode.lazy;
 
-            if (framework_entry_point) |entry| {
-                javascript_framework = Api.FrameworkConfig{
-                    .package = entry,
-                    .development = !production,
-                };
-            }
+        switch (comptime cmd) {
+            .BuildCommand => {
+                if (args.option("--resolve")) |_resolve| {
+                    switch (ResolveMatcher.match(_resolve)) {
+                        ResolveMatcher.case("disable") => {
+                            opts.resolve = Api.ResolveMode.disable;
+                        },
+                        ResolveMatcher.case("bundle") => {
+                            opts.resolve = Api.ResolveMode.bundle;
+                        },
+                        ResolveMatcher.case("dev") => {
+                            opts.resolve = Api.ResolveMode.dev;
+                        },
+                        ResolveMatcher.case("lazy") => {
+                            opts.resolve = Api.ResolveMode.lazy;
+                        },
+                        else => {
+                            diag.name.long = "--resolve";
+                            diag.arg = _resolve;
+                            try diag.report(Output.errorWriter(), error.InvalidResolveOption);
+                            std.process.exit(1);
+                        },
+                    }
+                }
+            },
+            else => {},
+        }
 
-            if (entry_points.len == 0 and javascript_framework == null and node_modules_bundle_path == null) {
-                try clap.help(stderr.writer(), &params);
-                try diag.report(stderr.writer(), error.MissingEntryPoint);
-                std.process.exit(1);
-            }
+        const PlatformMatcher = strings.ExactSizeMatcher(8);
 
-            return Api.TransformOptions{
-                .jsx = jsx,
-                .output_dir = output_dir,
-                .resolve = resolve,
-                .external = externals,
-                .absolute_working_dir = cwd,
-                .tsconfig_override = tsconfig_override,
-                .origin = origin,
-                .define = .{
-                    .keys = define_keys,
-                    .values = define_values,
+        if (args.option("--platform")) |_platform| {
+            switch (PlatformMatcher.match(_platform)) {
+                PlatformMatcher.case("browser") => {
+                    opts.platform = Api.Platform.browser;
                 },
-                .loaders = .{
-                    .extensions = loader_keys,
-                    .loaders = loader_values,
+                PlatformMatcher.case("node") => {
+                    opts.platform = Api.Platform.node;
                 },
-                .node_modules_bundle_path = node_modules_bundle_path,
-                .node_modules_bundle_path_server = node_modules_bundle_path_server,
-                .write = write,
-                .router = route_config,
-                .serve = serve,
-                .inject = inject,
-                .entry_points = entry_points,
-                .extension_order = args.options("--extension-order"),
-                .main_fields = args.options("--main-fields"),
-                .platform = platform,
-                .only_scan_dependencies = if (args.flag("--scan")) Api.ScanDependencyMode.all else Api.ScanDependencyMode._none,
-                .generate_node_module_bundle = if (args.flag("--new-jsb")) true else false,
-                .framework = javascript_framework,
-            };
-        }
-    };
-    pub fn resolve_jsx_runtime(str: string) !Api.JsxRuntime {
-        if (strings.eql(str, "automatic")) {
-            return Api.JsxRuntime.automatic;
-        } else if (strings.eql(str, "fallback")) {
-            return Api.JsxRuntime.classic;
-        } else {
-            return error.InvalidJSXRuntime;
+                else => {
+                    diag.name.long = "--platform";
+                    diag.arg = _platform;
+                    try diag.report(Output.errorWriter(), error.InvalidPlatform);
+                    std.process.exit(1);
+                },
+            }
         }
-    }
-    pub fn printScanResults(scan_results: bundler.ScanResult.Summary, allocator: *std.mem.Allocator) !void {
-        var stdout = std.io.getStdOut();
-        const print_start = std.time.nanoTimestamp();
-        try std.json.stringify(scan_results.list(), .{}, stdout.writer());
-        Output.printError("\nJSON printing took: {d}\n", .{std.time.nanoTimestamp() - print_start});
-    }
-    var wait_group: sync.WaitGroup = undefined;
-    pub fn startTransform(allocator: *std.mem.Allocator, args: Api.TransformOptions, log: *logger.Log) anyerror!void {}
-    pub fn start(allocator: *std.mem.Allocator, stdout: anytype, stderr: anytype, comptime MainPanicHandler: type) anyerror!void {
-        const start_time = std.time.nanoTimestamp();
-        var log = logger.Log.init(allocator);
-        var panicker = MainPanicHandler.init(&log);
-        MainPanicHandler.Singleton = &panicker;
-
-        var args = try Arguments.parse(alloc.static, stdout, stderr);
-        if ((args.entry_points.len == 1 and args.entry_points[0].len > ".jsb".len and args.entry_points[0][args.entry_points[0].len - ".jsb".len] == '.' and strings.eqlComptime(args.entry_points[0][args.entry_points[0].len - "jsb".len ..], "jsb"))) {
-            var out_buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;
-            var input = try std.fs.openFileAbsolute(try std.os.realpath(args.entry_points[0], &out_buffer), .{ .read = true });
 
-            const params = comptime [_]clap.Param(clap.Help){
-                clap.parseParam("--summary    Print a summary") catch unreachable,
-                clap.parseParam("<POS>...     ") catch unreachable,
+        if (jsx_factory != null or
+            jsx_fragment != null or
+            jsx_import_source != null or
+            jsx_runtime != null or
+            jsx_production or react_fast_refresh)
+        {
+            var default_factory = "".*;
+            var default_fragment = "".*;
+            var default_import_source = "".*;
+            opts.jsx = Api.Jsx{
+                .factory = constStrToU8(jsx_factory orelse &default_factory),
+                .fragment = constStrToU8(jsx_fragment orelse &default_fragment),
+                .import_source = constStrToU8(jsx_import_source orelse &default_import_source),
+                .runtime = if (jsx_runtime != null) try resolve_jsx_runtime(jsx_runtime.?) else Api.JsxRuntime.automatic,
+                .development = !jsx_production,
+                .react_fast_refresh = react_fast_refresh,
             };
+        }
 
-            var jsBundleArgs = clap.parse(clap.Help, &params, .{ .allocator = allocator }) catch |err| {
-                try NodeModuleBundle.printBundle(std.fs.File, input, @TypeOf(stdout), stdout);
-                return;
+        if (args.option("--use")) |entry| {
+            opts.framework = Api.FrameworkConfig{
+                .package = entry,
+                .development = !production,
             };
+        }
 
-            if (jsBundleArgs.flag("--summary")) {
-                try NodeModuleBundle.printSummaryFromDisk(std.fs.File, input, @TypeOf(stdout), stdout, allocator);
-            } else {
-                try NodeModuleBundle.printBundle(std.fs.File, input, @TypeOf(stdout), stdout);
-            }
-
-            return;
+        if (entry_points.len == 0 and opts.framework == null and opts.node_modules_bundle_path == null) {
+            return error.MissingEntryPoint;
         }
 
-        if (args.serve orelse false) {
-            try Server.start(allocator, args);
+        opts.output_dir = output_dir;
+        return opts;
+    }
+};
 
-            return;
-        }
+const AutoCommand = struct {
+    pub fn exec(allocator: *std.mem.Allocator) !void {
+        try HelpCommand.execWithReason(allocator, .invalid_command);
+    }
+};
+const InitCommand = struct {
+    pub fn exec(allocator: *std.mem.Allocator) !void {}
+};
+const HelpCommand = struct {
+    pub fn exec(allocator: *std.mem.Allocator) !void {
+        @setCold(true);
+        execWithReason(allocator, .explicit);
+    }
 
-        // if ((args.only_scan_dependencies orelse ._none) == .all) {
-        //     return try printScanResults(try bundler.Bundler.scanDependencies(allocator, &log, args), allocator);
-        // }
+    pub const Reason = enum {
+        explicit,
+        invalid_command,
+    };
+    pub fn execWithReason(allocator: *std.mem.Allocator, comptime reason: Reason) void {
+        @setCold(true);
+        var cwd_buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
+        const cwd = std.os.getcwd(&cwd_buf) catch unreachable;
+        const dirname = std.fs.path.basename(cwd);
+        const fmt =
+            \\> <r> <b><white>init<r>                           Setup Bun in \"{s}\"
+            \\> <r> <b><green>dev    <r><d>  ./a.ts ./b.jsx<r>        Start a Bun Dev Server
+            \\<d>*<r> <b><cyan>build  <r><d>  ./a.ts ./b.jsx<r>        Make JavaScript-like code runnable & bundle CSS
+            \\> <r> <b><magenta>bun    <r><d>  ./a.ts ./b.jsx<r>        Bundle dependencies of input files into a <r><magenta>.bun<r>
+            \\> <r> <green>run    <r><d>  ./a.ts        <r>        Run a JavaScript-like file with Bun.js
+            \\> <r> <b><blue>discord<r>                        Open Bun's Discord server
+            \\> <r> <b><d>help      <r>                     Print this help menu
+            \\
+        ;
+
+        switch (reason) {
+            .explicit => Output.pretty("Bun: a fast bundler & transpiler for web software.\n\n" ++ fmt, .{dirname}),
+            .invalid_command => Output.prettyError("<r><red>Uh-oh<r> not sure what to do with that command.\n\n" ++ fmt, .{dirname}),
+        }
 
-        if ((args.generate_node_module_bundle orelse false)) {
-            var log_ = try allocator.create(logger.Log);
-            log_.* = log;
+        Output.flush();
 
-            var this_bundler = try bundler.ServeBundler.init(allocator, log_, args, null, null);
-            this_bundler.configureLinker();
-            var filepath: [*:0]const u8 = "node_modules.jsb";
-            var server_bundle_filepath: [*:0]const u8 = "node_modules.server.jsb";
-            try this_bundler.configureRouter(true);
+        if (reason == .invalid_command) {
+            std.process.exit(1);
+        }
+    }
+};
 
-            var loaded_route_config: ?Api.LoadedRouteConfig = brk: {
-                if (this_bundler.options.routes.routes_enabled) {
-                    break :brk this_bundler.options.routes.toAPI();
-                }
-                break :brk null;
-            };
-            var loaded_framework: ?Api.LoadedFramework = brk: {
-                if (this_bundler.options.framework) |*conf| {
-                    break :brk conf.toAPI(allocator, this_bundler.fs.top_level_dir, true);
-                }
-                break :brk null;
+pub const Command = struct {
+    pub const Context = struct {
+        start_time: i128,
+        args: Api.TransformOptions = std.mem.zeroes(Api.TransformOptions),
+        log: *logger.Log,
+        allocator: *std.mem.Allocator,
+
+        pub fn create(allocator: *std.mem.Allocator, log: *logger.Log, comptime command: Command.Tag) !Context {
+            return Command.Context{
+                .args = try Arguments.parse(allocator, command),
+                .log = log,
+                .start_time = start_time,
+                .allocator = allocator,
             };
-            var env_loader = this_bundler.env;
-            wait_group = sync.WaitGroup.init();
-            var server_bundler_generator_thread: ?std.Thread = null;
-            var generated_server = false;
-            if (this_bundler.options.framework) |*framework| {
-                if (framework.toAPI(allocator, this_bundler.fs.top_level_dir, false)) |_server_conf| {
-                    const ServerBundleGeneratorThread = struct {
-                        inline fn _generate(
-                            logs: *logger.Log,
-                            env_loader_: *DotEnv.Loader,
-                            allocator_: *std.mem.Allocator,
-                            transform_args: Api.TransformOptions,
-                            _filepath: [*:0]const u8,
-                            server_conf: Api.LoadedFramework,
-                            route_conf_: ?Api.LoadedRouteConfig,
-                            router: ?Router,
-                        ) !void {
-                            var server_bundler = try bundler.ServeBundler.init(
-                                allocator_,
-                                logs,
-                                try configureTransformOptionsForBun(allocator_, transform_args),
-                                null,
-                                env_loader_,
-                            );
-                            server_bundler.configureLinker();
-                            server_bundler.router = router;
-                            try server_bundler.configureDefines();
-                            _ = try bundler.ServeBundler.GenerateNodeModuleBundle.generate(
-                                &server_bundler,
-                                allocator_,
-                                server_conf,
-                                route_conf_,
-                                _filepath,
-                            );
-                            std.mem.doNotOptimizeAway(&server_bundler);
-                        }
-                        pub fn generate(
-                            logs: *logger.Log,
-                            env_loader_: *DotEnv.Loader,
-                            transform_args: Api.TransformOptions,
-                            _filepath: [*:0]const u8,
-                            server_conf: Api.LoadedFramework,
-                            route_conf_: ?Api.LoadedRouteConfig,
-                            router: ?Router,
-                        ) void {
-                            if (FeatureFlags.parallel_jsb) {
-                                try alloc.setup(std.heap.c_allocator);
-                                var stdout_ = std.io.getStdOut();
-                                var stderr_ = std.io.getStdErr();
-                                var output_source = Output.Source.init(stdout_, stderr_);
-                                Output.Source.set(&output_source);
-
-                                Output.enable_ansi_colors = stderr_.isTty();
-                            }
-
-                            defer Output.flush();
-                            defer {
-                                if (FeatureFlags.parallel_jsb) {
-                                    wait_group.done();
-                                }
-                            }
-
-                            _generate(logs, env_loader_, std.heap.c_allocator, transform_args, _filepath, server_conf, route_conf_, router) catch return;
-                        }
-                    };
-
-                    if (FeatureFlags.parallel_jsb) {
-                        wait_group.add();
-                        server_bundler_generator_thread = try std.Thread.spawn(
-                            .{},
-                            ServerBundleGeneratorThread.generate,
-                            .{
-                                log_,
-                                env_loader,
-                                args,
-                                server_bundle_filepath,
-                                _server_conf,
-                                loaded_route_config,
-                                this_bundler.router,
-                            },
-                        );
-                        generated_server = true;
-                    } else {
-                        ServerBundleGeneratorThread.generate(
-                            log_,
-                            env_loader,
-                            args,
-                            server_bundle_filepath,
-                            _server_conf,
-                            loaded_route_config,
-                            this_bundler.router,
-                        );
-                        generated_server = true;
-                    }
-                }
-            }
-
-            defer {
-                if (server_bundler_generator_thread) |thread| {
-                    thread.join();
-                }
-            }
+        }
+    };
 
-            {
-                // Always generate the client-only bundle
-                // we can revisit this decision if people ask
-                var node_modules_ = try bundler.ServeBundler.GenerateNodeModuleBundle.generate(
-                    &this_bundler,
-                    allocator,
-                    loaded_framework,
-                    loaded_route_config,
-                    filepath,
-                );
-
-                if (server_bundler_generator_thread) |thread| {
-                    wait_group.wait();
-                }
+    pub fn which(allocator: *std.mem.Allocator) Tag {
+        var args_iter = std.process.args();
+        // first one is the executable name
+        const skipped = args_iter.skip();
 
-                if (node_modules_) |node_modules| {
-                    if (log_.errors > 0) {
-                        try log_.print(Output.errorWriter());
-                    } else {
-                        var elapsed = @divTrunc(std.time.nanoTimestamp() - start_time, @as(i128, std.time.ns_per_ms));
-                        var bundle = NodeModuleBundle.init(node_modules, allocator);
-                        bundle.printSummary();
-                        const indent = comptime " ";
-                        Output.prettyln(indent ++ "<d>{d:6}ms elapsed", .{@intCast(u32, elapsed)});
-
-                        if (generated_server) {
-                            Output.prettyln(indent ++ "<r>Saved to ./{s}, ./{s}", .{ filepath, server_bundle_filepath });
-                        } else {
-                            Output.prettyln(indent ++ "<r>Saved to ./{s}", .{filepath});
-                        }
-
-                        try log_.printForLogLevel(Output.errorWriter());
-                    }
-                } else {
-                    try log_.print(Output.errorWriter());
-                }
-            }
-            return;
+        if (!skipped) {
+            return .AutoCommand;
         }
 
-        var result: options.TransformResult = undefined;
-        switch (args.resolve orelse Api.ResolveMode.dev) {
-            Api.ResolveMode.disable => {
-                result = try bundler.Transformer.transform(
-                    allocator,
-                    &log,
-                    args,
-                );
-            },
-            .lazy => {
-                result = try bundler.ServeBundler.bundle(
-                    allocator,
-                    &log,
-                    args,
-                );
-            },
-            else => {
-                result = try bundler.Bundler.bundle(
-                    allocator,
-                    &log,
-                    args,
-                );
-            },
-        }
-        var did_write = false;
-        var stderr_writer = stderr.writer();
-        var buffered_writer = std.io.bufferedWriter(stderr_writer);
-        defer buffered_writer.flush() catch {};
-        var writer = buffered_writer.writer();
-        var err_writer = writer;
-
-        var open_file_limit: usize = 32;
-        if (args.write) |write| {
-            if (write) {
-                const root_dir = result.root_dir orelse unreachable;
-                if (std.os.getrlimit(.NOFILE)) |limit| {
-                    open_file_limit = limit.cur;
-                } else |err| {}
-
-                var all_paths = try allocator.alloc([]const u8, result.output_files.len);
-                var max_path_len: usize = 0;
-                var max_padded_size: usize = 0;
-                for (result.output_files) |f, i| {
-                    all_paths[i] = f.input.text;
-                }
+        const next_arg = (args_iter.next(allocator) orelse return .AutoCommand) catch unreachable;
 
-                var from_path = resolve_path.longestCommonPath(all_paths);
+        const first_arg_name = std.mem.span(next_arg);
+        const RootCommandMatcher = strings.ExactSizeMatcher(8);
 
-                for (result.output_files) |f, i| {
-                    max_path_len = std.math.max(
-                        std.math.max(from_path.len, f.input.text.len) + 2 - from_path.len,
-                        max_path_len,
-                    );
-                }
+        return switch (RootCommandMatcher.match(first_arg_name)) {
+            RootCommandMatcher.case("init") => .InitCommand,
+            RootCommandMatcher.case("bun") => .BunCommand,
+            RootCommandMatcher.case("discord") => .DiscordCommand,
+
+            RootCommandMatcher.case("b"), RootCommandMatcher.case("build") => .BuildCommand,
+            RootCommandMatcher.case("r"), RootCommandMatcher.case("run") => .RunCommand,
+            RootCommandMatcher.case("d"), RootCommandMatcher.case("dev") => .DevCommand,
 
-                did_write = true;
+            RootCommandMatcher.case("help") => .HelpCommand,
+            else => .AutoCommand,
+        };
+    }
 
-                // On posix, file handles automatically close on process exit by the OS
-                // Closing files shows up in profiling.
-                // So don't do that unless we actually need to.
-                const do_we_need_to_close = !FeatureFlags.store_file_descriptors or (@intCast(usize, root_dir.fd) + open_file_limit) < result.output_files.len;
+    pub fn start(allocator: *std.mem.Allocator, log: *logger.Log) !void {
+        const tag = which(allocator);
+        switch (tag) {
+            .DiscordCommand => return try DiscordCommand.exec(allocator),
+            .HelpCommand => return try HelpCommand.exec(allocator),
+            .InitCommand => return try InitCommand.exec(allocator),
+            else => {},
+        }
 
-                var filepath_buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
-                filepath_buf[0] = '.';
-                filepath_buf[1] = '/';
+        switch (tag) {
+            .BunCommand => {
+                const ctx = try Command.Context.create(allocator, log, .BunCommand);
 
-                for (result.output_files) |f, i| {
-                    var rel_path: []const u8 = undefined;
-                    switch (f.value) {
-                        // easy mode: write the buffer
-                        .buffer => |value| {
-                            rel_path = resolve_path.relative(from_path, f.input.text);
+                try BunCommand.exec(ctx);
+            },
+            .DevCommand => {
+                const ctx = try Command.Context.create(allocator, log, .DevCommand);
 
-                            try root_dir.writeFile(rel_path, value);
-                        },
-                        .move => |value| {
-                            // const primary = f.input.text[from_path.len..];
-                            // std.mem.copy(u8, filepath_buf[2..], primary);
-                            // rel_path = filepath_buf[0 .. primary.len + 2];
-                            rel_path = value.pathname;
+                try DevCommand.exec(ctx);
+            },
+            .BuildCommand => {
+                const ctx = try Command.Context.create(allocator, log, .BuildCommand);
 
-                            // try f.moveTo(result.outbase, constStrToU8(rel_path), root_dir.fd);
-                        },
-                        .copy => |value| {
-                            rel_path = value.pathname;
+                try BuildCommand.exec(ctx);
+            },
+            .RunCommand => {
+                const ctx = try Command.Context.create(allocator, log, .RunCommand);
 
-                            try f.copyTo(result.outbase, constStrToU8(rel_path), root_dir.fd);
+                try RunCommand.exec(ctx);
+            },
+            .AutoCommand => {
+                const ctx = Command.Context.create(allocator, log, .AutoCommand) catch |e| {
+                    switch (e) {
+                        error.MissingEntryPoint => {
+                            HelpCommand.execWithReason(allocator, .explicit);
+                            return;
                         },
-                        .noop => {},
-                        .pending => |value| {
-                            unreachable;
+                        else => {
+                            return e;
                         },
                     }
+                };
 
-                    // Print summary
-                    _ = try writer.write("\n");
-                    const padding_count = 2 + (std.math.max(rel_path.len, max_path_len) - rel_path.len);
-                    try writer.writeByteNTimes(' ', 2);
-                    try writer.writeAll(rel_path);
-                    try writer.writeByteNTimes(' ', padding_count);
-                    const size = @intToFloat(f64, f.size) / 1000.0;
-                    try std.fmt.formatFloatDecimal(size, .{ .precision = 2 }, writer);
-                    try writer.writeAll(" KB\n");
-                }
-            }
-        }
-
-        if (isDebug) {
-            err_writer.print("\nExpr count:       {d}\n", .{js_ast.Expr.icount}) catch {};
-            err_writer.print("Stmt count:       {d}\n", .{js_ast.Stmt.icount}) catch {};
-            err_writer.print("Binding count:    {d}\n", .{js_ast.Binding.icount}) catch {};
-            err_writer.print("File Descriptors: {d} / {d}\n", .{
-                fs.FileSystem.max_fd,
-                open_file_limit,
-            }) catch {};
-        }
-
-        for (result.errors) |err| {
-            try err.writeFormat(err_writer);
-            _ = try err_writer.write("\n");
-        }
-
-        for (result.warnings) |err| {
-            try err.writeFormat(err_writer);
-            _ = try err_writer.write("\n");
-        }
-
-        const duration = std.time.nanoTimestamp() - start_time;
-
-        if (did_write and duration < @as(i128, @as(i128, std.time.ns_per_s) * @as(i128, 2))) {
-            var elapsed = @divTrunc(duration, @as(i128, std.time.ns_per_ms));
-            try err_writer.print("\nCompleted in {d}ms", .{elapsed});
+                try BuildCommand.exec(ctx);
+            },
+            else => unreachable,
         }
     }
+
+    pub const Tag = enum {
+        InitCommand,
+        BunCommand,
+        DevCommand,
+        DiscordCommand,
+        BuildCommand,
+        RunCommand,
+        AutoCommand,
+        HelpCommand,
+    };
 };
diff --git a/src/cli/build_command.zig b/src/cli/build_command.zig
new file mode 100644
index 000000000..0779a691a
--- /dev/null
+++ b/src/cli/build_command.zig
@@ -0,0 +1,160 @@
+usingnamespace @import("../global.zig");
+const std = @import("std");
+
+const lex = @import("../js_lexer.zig");
+const logger = @import("../logger.zig");
+const alloc = @import("../alloc.zig");
+const options = @import("../options.zig");
+const js_parser = @import("../js_parser.zig");
+const js_ast = @import("../js_ast.zig");
+const linker = @import("../linker.zig");
+usingnamespace @import("../ast/base.zig");
+usingnamespace @import("../defines.zig");
+const panicky = @import("../panic_handler.zig");
+const allocators = @import("../allocators.zig");
+const sync = @import(".././sync.zig");
+const Api = @import("../api/schema.zig").Api;
+const resolve_path = @import("../resolver/resolve_path.zig");
+const configureTransformOptionsForBun = @import("../javascript/jsc/config.zig").configureTransformOptionsForBun;
+const Command = @import("../cli.zig").Command;
+const bundler = @import("../bundler.zig");
+const NodeModuleBundle = @import("../node_module_bundle.zig").NodeModuleBundle;
+const fs = @import("../fs.zig");
+
+pub const BuildCommand = struct {
+    pub fn exec(ctx: Command.Context) !void {
+        var result: options.TransformResult = undefined;
+        switch (ctx.args.resolve orelse Api.ResolveMode.dev) {
+            Api.ResolveMode.disable => {
+                result = try bundler.Transformer.transform(
+                    ctx.allocator,
+                    ctx.log,
+                    ctx.args,
+                );
+            },
+            .lazy => {
+                result = try bundler.ServeBundler.bundle(
+                    ctx.allocator,
+                    ctx.log,
+                    ctx.args,
+                );
+            },
+            else => {
+                result = try bundler.Bundler.bundle(
+                    ctx.allocator,
+                    ctx.log,
+                    ctx.args,
+                );
+            },
+        }
+        var did_write = false;
+        var stderr_writer = Output.errorWriter();
+        var buffered_writer = Output.errorWriter();
+        defer Output.flush();
+        var writer = Output.writer();
+        var err_writer = writer;
+
+        var open_file_limit: usize = 32;
+        if (ctx.args.write) |write| {
+            if (write) {
+                const root_dir = result.root_dir orelse unreachable;
+                if (std.os.getrlimit(.NOFILE)) |limit| {
+                    open_file_limit = limit.cur;
+                } else |err| {}
+
+                var all_paths = try ctx.allocator.alloc([]const u8, result.output_files.len);
+                var max_path_len: usize = 0;
+                var max_padded_size: usize = 0;
+                for (result.output_files) |f, i| {
+                    all_paths[i] = f.input.text;
+                }
+
+                var from_path = resolve_path.longestCommonPath(all_paths);
+
+                for (result.output_files) |f, i| {
+                    max_path_len = std.math.max(
+                        std.math.max(from_path.len, f.input.text.len) + 2 - from_path.len,
+                        max_path_len,
+                    );
+                }
+
+                did_write = true;
+
+                // On posix, file handles automatically close on process exit by the OS
+                // Closing files shows up in profiling.
+                // So don't do that unless we actually need to.
+                const do_we_need_to_close = !FeatureFlags.store_file_descriptors or (@intCast(usize, root_dir.fd) + open_file_limit) < result.output_files.len;
+
+                var filepath_buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
+                filepath_buf[0] = '.';
+                filepath_buf[1] = '/';
+
+                for (result.output_files) |f, i| {
+                    var rel_path: []const u8 = undefined;
+                    switch (f.value) {
+                        // easy mode: write the buffer
+                        .buffer => |value| {
+                            rel_path = resolve_path.relative(from_path, f.input.text);
+
+                            try root_dir.writeFile(rel_path, value);
+                        },
+                        .move => |value| {
+                            // const primary = f.input.text[from_path.len..];
+                            // std.mem.copy(u8, filepath_buf[2..], primary);
+                            // rel_path = filepath_buf[0 .. primary.len + 2];
+                            rel_path = value.pathname;
+
+                            // try f.moveTo(result.outbase, constStrToU8(rel_path), root_dir.fd);
+                        },
+                        .copy => |value| {
+                            rel_path = value.pathname;
+
+                            try f.copyTo(result.outbase, allocators.constStrToU8(rel_path), root_dir.fd);
+                        },
+                        .noop => {},
+                        .pending => |value| {
+                            unreachable;
+                        },
+                    }
+
+                    // Print summary
+                    _ = try writer.write("\n");
+                    const padding_count = 2 + (std.math.max(rel_path.len, max_path_len) - rel_path.len);
+                    try writer.writeByteNTimes(' ', 2);
+                    try writer.writeAll(rel_path);
+                    try writer.writeByteNTimes(' ', padding_count);
+                    const size = @intToFloat(f64, f.size) / 1000.0;
+                    try std.fmt.formatFloatDecimal(size, .{ .precision = 2 }, writer);
+                    try writer.writeAll(" KB\n");
+                }
+            }
+        }
+
+        if (isDebug) {
+            err_writer.print("\nExpr count:       {d}\n", .{js_ast.Expr.icount}) catch {};
+            err_writer.print("Stmt count:       {d}\n", .{js_ast.Stmt.icount}) catch {};
+            err_writer.print("Binding count:    {d}\n", .{js_ast.Binding.icount}) catch {};
+            err_writer.print("File Descriptors: {d} / {d}\n", .{
+                fs.FileSystem.max_fd,
+                open_file_limit,
+            }) catch {};
+        }
+
+        for (result.errors) |err| {
+            try err.writeFormat(err_writer);
+            _ = try err_writer.write("\n");
+        }
+
+        for (result.warnings) |err| {
+            try err.writeFormat(err_writer);
+            _ = try err_writer.write("\n");
+        }
+
+        const duration = std.time.nanoTimestamp() - ctx.start_time;
+
+        if (did_write and duration < @as(i128, @as(i128, std.time.ns_per_s) * @as(i128, 2))) {
+            var elapsed = @divTrunc(duration, @as(i128, std.time.ns_per_ms));
+            try err_writer.print("\nCompleted in {d}ms", .{elapsed});
+        }
+    }
+};
diff --git a/src/cli/bun_command.zig b/src/cli/bun_command.zig
new file mode 100644
index 000000000..858e8fc70
--- /dev/null
+++ b/src/cli/bun_command.zig
@@ -0,0 +1,193 @@
+const std = @import("std");
+const Command = @import("../cli.zig").Command;
+usingnamespace @import("../global.zig");
+
+const lex = @import("../js_lexer.zig");
+const logger = @import("../logger.zig");
+const alloc = @import("../alloc.zig");
+const options = @import("../options.zig");
+const js_parser = @import("../js_parser.zig");
+const json_parser = @import("../json_parser.zig");
+const js_printer = @import("../js_printer.zig");
+const js_ast = @import("../js_ast.zig");
+const linker = @import("../linker.zig");
+usingnamespace @import("../ast/base.zig");
+usingnamespace @import("../defines.zig");
+const panicky = @import("../panic_handler.zig");
+const sync = @import(".././sync.zig");
+const Api = @import("../api/schema.zig").Api;
+const resolve_path = @import(".././resolver/resolve_path.zig");
+const configureTransformOptionsForBun = @import(".././javascript/jsc/config.zig").configureTransformOptionsForBun;
+const bundler = @import("../bundler.zig");
+const NodeModuleBundle = @import("../node_module_bundle.zig").NodeModuleBundle;
+const DotEnv = @import("../env_loader.zig");
+
+const fs = @import("../fs.zig");
+const Router = @import("../router.zig");
+
+var wait_group: sync.WaitGroup = undefined;
+const ServerBundleGeneratorThread = struct {
+    inline fn _generate(
+        logs: *logger.Log,
+        env_loader_: *DotEnv.Loader,
+        allocator_: *std.mem.Allocator,
+        transform_args: Api.TransformOptions,
+        _filepath: [*:0]const u8,
+        server_conf: Api.LoadedFramework,
+        route_conf_: ?Api.LoadedRouteConfig,
+        router: ?Router,
+    ) !void {
+        var server_bundler = try bundler.ServeBundler.init(
+            allocator_,
+            logs,
+            try configureTransformOptionsForBun(allocator_, transform_args),
+            null,
+            env_loader_,
+        );
+        server_bundler.configureLinker();
+        server_bundler.router = router;
+        try server_bundler.configureDefines();
+        _ = try bundler.ServeBundler.GenerateNodeModuleBundle.generate(
+            &server_bundler,
+            allocator_,
+            server_conf,
+            route_conf_,
+            _filepath,
+        );
+        std.mem.doNotOptimizeAway(&server_bundler);
+    }
+    pub fn generate(
+        logs: *logger.Log,
+        env_loader_: *DotEnv.Loader,
+        transform_args: Api.TransformOptions,
+        _filepath: [*:0]const u8,
+        server_conf: Api.LoadedFramework,
+        route_conf_: ?Api.LoadedRouteConfig,
+        router: ?Router,
+    ) void {
+        if (FeatureFlags.parallel_bun) {
+            try alloc.setup(std.heap.c_allocator);
+            var stdout_ = std.io.getStdOut();
+            var stderr_ = std.io.getStdErr();
+            var output_source = Output.Source.init(stdout_, stderr_);
+            Output.Source.set(&output_source);
+        }
+
+        defer Output.flush();
+        defer {
+            if (FeatureFlags.parallel_bun) {
+                wait_group.done();
+            }
+        }
+
+        _generate(logs, env_loader_, std.heap.c_allocator, transform_args, _filepath, server_conf, route_conf_, router) catch return;
+    }
+};
+
+pub const BunCommand = struct {
+    pub fn exec(
+        ctx: Command.Context,
+    ) !void {
+        var allocator = ctx.allocator;
+        var log = ctx.log;
+
+        var this_bundler = try bundler.ServeBundler.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";
+        try this_bundler.configureRouter(true);
+
+        var loaded_route_config: ?Api.LoadedRouteConfig = brk: {
+            if (this_bundler.options.routes.routes_enabled) {
+                break :brk this_bundler.options.routes.toAPI();
+            }
+            break :brk null;
+        };
+        var loaded_framework: ?Api.LoadedFramework = brk: {
+            if (this_bundler.options.framework) |*conf| {
+                break :brk conf.toAPI(allocator, this_bundler.fs.top_level_dir, true);
+            }
+            break :brk null;
+        };
+        var env_loader = this_bundler.env;
+        wait_group = sync.WaitGroup.init();
+        var server_bundler_generator_thread: ?std.Thread = null;
+        var generated_server = false;
+        if (this_bundler.options.framework) |*framework| {
+            if (framework.toAPI(allocator, this_bundler.fs.top_level_dir, false)) |_server_conf| {
+                if (FeatureFlags.parallel_bun) {
+                    wait_group.add();
+                    server_bundler_generator_thread = try std.Thread.spawn(
+                        .{},
+                        ServerBundleGeneratorThread.generate,
+                        .{
+                            log,
+                            env_loader,
+                            ctx.args,
+                            server_bundle_filepath,
+                            _server_conf,
+                            loaded_route_config,
+                            this_bundler.router,
+                        },
+                    );
+                    generated_server = true;
+                } else {
+                    ServerBundleGeneratorThread.generate(
+                        log,
+                        env_loader,
+                        ctx.args,
+                        server_bundle_filepath,
+                        _server_conf,
+                        loaded_route_config,
+                        this_bundler.router,
+                    );
+                    generated_server = true;
+                }
+            }
+        }
+
+        defer {
+            if (server_bundler_generator_thread) |thread| {
+                thread.join();
+            }
+        }
+
+        {
+            // Always generate the client-only bundle
+            // we can revisit this decision if people ask
+            var node_modules_ = try bundler.ServeBundler.GenerateNodeModuleBundle.generate(
+                &this_bundler,
+                allocator,
+                loaded_framework,
+                loaded_route_config,
+                filepath,
+            );
+
+            if (server_bundler_generator_thread) |thread| {
+                wait_group.wait();
+            }
+
+            if (node_modules_) |node_modules| {
+                if (log.errors > 0) {
+                    try log.print(Output.errorWriter());
+                } else {
+                    var elapsed = @divTrunc(std.time.nanoTimestamp() - ctx.start_time, @as(i128, std.time.ns_per_ms));
+                    var bundle = NodeModuleBundle.init(node_modules, allocator);
+                    bundle.printSummary();
+                    const indent = comptime " ";
+                    Output.prettyln(indent ++ "<d>{d:6}ms elapsed", .{@intCast(u32, elapsed)});
+
+                    if (generated_server) {
+                        Output.prettyln(indent ++ "<r>Saved to ./{s}, ./{s}", .{ filepath, server_bundle_filepath });
+                    } else {
+                        Output.prettyln(indent ++ "<r>Saved to ./{s}", .{filepath});
+                    }
+
+                    try log.printForLogLevel(Output.errorWriter());
+                }
+            } else {
+                try log.print(Output.errorWriter());
+            }
+        }
+    }
+};
diff --git a/src/cli/dev_command.zig b/src/cli/dev_command.zig
new file mode 100644
index 000000000..6587309b6
--- /dev/null
+++ b/src/cli/dev_command.zig
@@ -0,0 +1,8 @@
+const Server = @import("../http.zig").Server;
+const Command = @import("../cli.zig").Command;
+
+pub const DevCommand = struct {
+    pub fn exec(ctx: Command.Context) !void {
+        try Server.start(ctx.allocator, ctx.args);
+    }
+};
diff --git a/src/cli/discord_command.zig b/src/cli/discord_command.zig
new file mode 100644
index 000000000..3fea0626b
--- /dev/null
+++ b/src/cli/discord_command.zig
@@ -0,0 +1,10 @@
+usingnamespace @import("../global.zig");
+const std = @import("std");
+const open = @import("../open.zig");
+
+pub const DiscordCommand = struct {
+    const discord_url: string = "https://bun.sh/discord";
+    pub fn exec(allocator: *std.mem.Allocator) !void {
+        try open.openURL(discord_url);
+    }
+};
diff --git a/src/cli/init_command.zig b/src/cli/init_command.zig
new file mode 100644
index 000000000..a0cadc3a6
--- /dev/null
+++ b/src/cli/init_command.zig
@@ -0,0 +1,24 @@
+usingnamespace @import("../global.zig");
+const std = @import("std");
+
+const lex = @import("../js_lexer.zig");
+const logger = @import("../logger.zig");
+const alloc = @import("../alloc.zig");
+const options = @import("../options.zig");
+const js_parser = @import("../js_parser.zig");
+const json_parser = @import("../json_parser.zig");
+const js_printer = @import("../js_printer.zig");
+const js_ast = @import("../js_ast.zig");
+const linker = @import("../linker.zig");
+const panicky = @import("../panic_handler.zig");
+const sync = @import(".././sync.zig");
+const Api = @import("../api/schema.zig").Api;
+const resolve_path = @import(".././resolver/resolve_path.zig");
+const configureTransformOptionsForBun = @import(".././javascript/jsc/config.zig").configureTransformOptionsForBun;
+const Command = @import("../cli.zig").Command;
+const bundler = @import("../bundler.zig");
+const NodeModuleBundle = @import("../node_module_bundle.zig").NodeModuleBundle;
+
+pub const InitCommand = struct {
+    pub fn exec(ctx: Command.Context) !void {}
+};
diff --git a/src/cli/run_command.zig b/src/cli/run_command.zig
new file mode 100644
index 000000000..b5131ece1
--- /dev/null
+++ b/src/cli/run_command.zig
@@ -0,0 +1,26 @@
+usingnamespace @import("../global.zig");
+const std = @import("std");
+
+const lex = @import("../js_lexer.zig");
+const logger = @import("../logger.zig");
+const alloc = @import("../alloc.zig");
+const options = @import("../options.zig");
+const js_parser = @import("../js_parser.zig");
+const json_parser = @import("../json_parser.zig");
+const js_printer = @import("../js_printer.zig");
+const js_ast = @import("../js_ast.zig");
+const linker = @import("../linker.zig");
+usingnamespace @import("../ast/base.zig");
+usingnamespace @import("../defines.zig");
+const panicky = @import("../panic_handler.zig");
+const sync = @import(".././sync.zig");
+const Api = @import("../api/schema.zig").Api;
+const resolve_path = @import(".././resolver/resolve_path.zig");
+const configureTransformOptionsForBun = @import(".././javascript/jsc/config.zig").configureTransformOptionsForBun;
+const Command = @import("../cli.zig").Command;
+const bundler = @import("../bundler.zig");
+const NodeModuleBundle = @import("../node_module_bundle.zig").NodeModuleBundle;
+
+pub const RunCommand = struct {
+    pub fn exec(ctx: Command.Context) !void {}
+};
diff --git a/src/exact_size_matcher.zig b/src/exact_size_matcher.zig
index 7ac31eee8..3fd6c2056 100644
--- a/src/exact_size_matcher.zig
+++ b/src/exact_size_matcher.zig
@@ -47,13 +47,6 @@ pub fn ExactSizeMatcher(comptime max_bytes: usize) type {
                 @compileError("str: \"" ++ str ++ "\" too long");
             }
         }
-
-        fn hash(comptime str: anytype) ?T {
-            if (str.len > max_bytes) return null;
-            var tmp = [_]u8{0} ** max_bytes;
-            std.mem.copy(u8, &tmp, str[0..str.len]);
-            return std.mem.readIntNative(T, &tmp);
-        }
     };
 }
 
diff --git a/src/global.zig b/src/global.zig
index e13b978f7..c2ef71ecb 100644
--- a/src/global.zig
+++ b/src/global.zig
@@ -8,6 +8,7 @@ pub const FeatureFlags = @import("feature_flags.zig");
 
 pub const Output = struct {
     threadlocal var source: Source = undefined;
+    threadlocal var source_set: bool = false;
     pub const Source = struct {
         pub const StreamType: type = brk: {
             if (isWasm) {
@@ -32,6 +33,7 @@ pub const Output = struct {
             stream: StreamType,
             err: StreamType,
         ) Source {
+            source_set = true;
             return Source{
                 .stream = stream,
                 .error_stream = err,
@@ -42,10 +44,18 @@ pub const Output = struct {
 
         pub fn set(_source: *Source) void {
             source = _source.*;
+            source_set = true;
+
+            enable_ansi_colors = _source.error_stream.supportsAnsiEscapeCodes();
+
+            is_stdout_piped = !_source.stream.isTty();
+            is_stderr_piped = !_source.error_stream.isTty();
         }
     };
     pub var enable_ansi_colors = isNative;
     pub var enable_buffering = true;
+    pub var is_stdout_piped = false;
+    pub var is_stderr_piped = false;
 
     pub fn enableBuffering() void {
         enable_buffering = true;
@@ -59,19 +69,22 @@ pub const Output = struct {
     pub const WriterType: type = @typeInfo(std.meta.declarationInfo(Source.StreamType, "writer").data.Fn.fn_type).Fn.return_type.?;
 
     pub fn errorWriter() WriterType {
+        std.debug.assert(source_set);
         return source.error_stream.writer();
     }
 
     pub fn errorStream() Source.StreamType {
+        std.debug.assert(source_set);
         return source.error_stream;
     }
 
     pub fn writer() WriterType {
+        std.debug.assert(source_set);
         return source.stream.writer();
     }
 
     pub fn flush() void {
-        if (isNative) {
+        if (isNative and source_set) {
             source.buffered_stream.flush() catch {};
             source.buffered_error_stream.flush() catch {};
             // source.stream.flush() catch {};
@@ -106,6 +119,7 @@ pub const Output = struct {
     fn _noop(comptime fmt: string, args: anytype) void {}
 
     pub fn _debug(comptime fmt: string, args: anytype) void {
+        std.debug.assert(source_set);
         if (fmt[fmt.len - 1] != '\n') {
             return print(fmt ++ "\n", args);
         }
@@ -114,6 +128,8 @@ pub const Output = struct {
     }
 
     pub fn print(comptime fmt: string, args: anytype) void {
+        std.debug.assert(source_set);
+
         if (comptime isWasm) {
             source.stream.seekTo(0) catch return;
             source.stream.writer().print(fmt, args) catch return;
diff --git a/src/http.zig b/src/http.zig
index da7ebabda..9cd1fee4b 100644
--- a/src/http.zig
+++ b/src/http.zig
@@ -131,8 +131,6 @@ pub const RequestContext = struct {
     match_file_path_buf: [std.fs.MAX_PATH_BYTES]u8 = undefined,
     res_headers_count: usize = 0,
 
-    pub const bundle_prefix = "__bun";
-
     pub fn getFullURL(this: *RequestContext) [:0]const u8 {
         if (this.full_url.len == 0) {
             if (this.bundler.options.origin.isAbsolute()) {
@@ -729,7 +727,7 @@ pub const RequestContext = struct {
             // defer stdout.flush() catch {};
             // defer stderr.flush() catch {};
             Output.Source.set(&output_source);
-            Output.enable_ansi_colors = stderr.isTty();
+
             js_ast.Stmt.Data.Store.create(std.heap.c_allocator);
             js_ast.Expr.Data.Store.create(std.heap.c_allocator);
 
@@ -1206,7 +1204,7 @@ pub const RequestContext = struct {
                                 }
                             },
                             else => {
-                                Output.prettyErrorln("<r>[Websocket]: Unknown cmd: <b>{d}<r>. This might be a version mismatch. Try updating your node_modules.jsb", .{@enumToInt(cmd.kind)});
+                                Output.prettyErrorln("<r>[Websocket]: Unknown cmd: <b>{d}<r>. This might be a version mismatch. Try updating your node_modules.bun", .{@enumToInt(cmd.kind)});
                             },
                         }
                     },
@@ -1603,7 +1601,7 @@ pub const RequestContext = struct {
     }
 
     pub fn handleReservedRoutes(ctx: *RequestContext, server: *Server) !bool {
-        if (strings.eqlComptime(ctx.url.extname, "jsb") and ctx.bundler.options.node_modules_bundle != null) {
+        if (strings.eqlComptime(ctx.url.extname, "bun") and ctx.bundler.options.node_modules_bundle != null) {
             try ctx.sendJSB();
             return true;
         }
diff --git a/src/js_parser/js_parser.zig b/src/js_parser/js_parser.zig
index 1840cd302..a06277b5e 100644
--- a/src/js_parser/js_parser.zig
+++ b/src/js_parser/js_parser.zig
@@ -1729,7 +1729,7 @@ pub const Parser = struct {
 
         // Symbol use counts are unavailable
         // So we say "did we parse any JSX?"
-        // if yes, just automatically add the import so that .jsb knows to include the file.
+        // if yes, just automatically add the import so that .bun knows to include the file.
         if (self.options.jsx.parse and p.needs_jsx_import) {
             _ = p.addImportRecord(
                 .require,
diff --git a/src/linker.zig b/src/linker.zig
index c1bacb49b..9b0918d42 100644
--- a/src/linker.zig
+++ b/src/linker.zig
@@ -245,7 +245,7 @@ pub fn NewLinker(comptime BundlerType: type) type {
                                                     null,
                                                     logger.Loc.Empty,
                                                     linker.allocator,
-                                                    "\"{s}\" version changed, we'll need to regenerate the .jsb.\nOld version: \"{s}\"\nNew version: \"{s}\"",
+                                                    "\"{s}\" version changed, please regenerate the .bun.\nOld version: \"{s}\"\nNew version: \"{s}\"\nRun this command:\nbun bun",
                                                     .{
                                                         package_json.name,
                                                         node_modules_bundle.str(node_modules_bundle.bundle.packages[possible_pkg_ids[0]].version),
@@ -271,7 +271,7 @@ pub fn NewLinker(comptime BundlerType: type) type {
                                                     null,
                                                     logger.Loc.Empty,
                                                     linker.allocator,
-                                                    "New dependency import: \"{s}/{s}\"\nWe'll need to regenerate the .jsb.",
+                                                    "New dependency import: \"{s}/{s}\"\nPlease run `bun bun` to update the .bun.",
                                                     .{
                                                         package_json.name,
                                                         package_relative_path,
diff --git a/src/main.zig b/src/main.zig
index ea21f9599..50c22a499 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -38,7 +38,6 @@ pub fn main() anyerror!void {
     var output_source = Output.Source.init(stdout, stderr);
 
     Output.Source.set(&output_source);
-    Output.enable_ansi_colors = stderr.isTty();
     defer Output.flush();
     try cli.Cli.start(std.heap.c_allocator, stdout, stderr, MainPanicHandler);
 
diff --git a/src/main_javascript.zig b/src/main_javascript.zig
index 0f29d280b..15eac1467 100644
--- a/src/main_javascript.zig
+++ b/src/main_javascript.zig
@@ -46,7 +46,7 @@ pub fn main() anyerror!void {
     // defer stdout.flush() catch {};
     // defer stderr.flush() catch {};
     Output.Source.set(&output_source);
-    Output.enable_ansi_colors = stderr.isTty();
+
     defer Output.flush();
     try Cli.start(
         std.heap.c_allocator,
@@ -213,7 +213,7 @@ pub const Cli = struct {
             var jsx_production = args.flag("--jsx-production");
             var react_fast_refresh = false;
 
-            if (serve or args.flag("--new-jsb")) {
+            if (serve or args.flag("--new-bun")) {
                 react_fast_refresh = true;
                 if (args.flag("--disable-react-fast-refresh") or jsx_production) {
                     react_fast_refresh = false;
@@ -222,12 +222,12 @@ pub const Cli = struct {
 
             var main_fields = args.options("--main-fields");
 
-            var node_modules_bundle_path = args.option("--jsb") orelse brk: {
-                if (args.flag("--new-jsb")) {
+            var node_modules_bundle_path = args.option("--bun") orelse brk: {
+                if (args.flag("--new-bun")) {
                     break :brk null;
                 }
 
-                const node_modules_bundle_path_absolute = resolve_path.joinAbs(cwd, .auto, "node_modules.jsb");
+                const node_modules_bundle_path_absolute = resolve_path.joinAbs(cwd, .auto, "node_modules.bun");
                 std.fs.accessAbsolute(node_modules_bundle_path_absolute, .{}) catch |err| {
                     break :brk null;
                 };
@@ -239,7 +239,7 @@ pub const Cli = struct {
                 node_modules_bundle_path = try std.fs.realpathAlloc(allocator, node_modules_bundle_path.?);
             }
 
-            if (args.flag("--new-jsb")) {
+            if (args.flag("--new-bun")) {
                 node_modules_bundle_path = null;
             }
 
@@ -340,8 +340,7 @@ pub const Cli = struct {
                 .entry_points = entry_points,
                 .extension_order = args.options("--extension-order"),
                 .main_fields = args.options("--main-fields"),
-                .only_scan_dependencies = if (args.flag("--scan")) Api.ScanDependencyMode.all else Api.ScanDependencyMode._none,
-                .generate_node_module_bundle = if (args.flag("--new-jsb")) true else false,
+                .generate_node_module_bundle = if (args.flag("--new-bun")) true else false,
             };
         }
     };
@@ -381,7 +380,6 @@ pub const Cli = struct {
                 // defer stdout.flush() catch {};
                 // defer stderr.flush() catch {};
                 Output.Source.set(&output_source);
-                Output.enable_ansi_colors = stderr.isTty();
 
                 var log = logger.Log.init(this.allocator);
 
diff --git a/src/node_module_bundle.zig b/src/node_module_bundle.zig
index 2208c8b9a..79eeb2b3a 100644
--- a/src/node_module_bundle.zig
+++ b/src/node_module_bundle.zig
@@ -104,7 +104,7 @@ pub const NodeModuleBundle = struct {
                 // Saving us an allocation
                 if (@ptrToInt(prev_package_ids_for_name.ptr) != @ptrToInt(entry.value_ptr.ptr)) {
                     Output.prettyErrorln(
-                        \\<r><red>Fatal<r>: incorrect package sorting order detected in .jsb file.\n
+                        \\<r><red>Fatal<r>: incorrect package sorting order detected in .bun file.\n
                         \\This is a bug! Please create an issue.\n
                         \\If this bug blocks you from doing work, for now 
                         \\please <b>avoid having multiple versions of <cyan>"{s}"<r> in the same bundle.\n
diff --git a/src/open.zig b/src/open.zig
new file mode 100644
index 000000000..d88cd5748
--- /dev/null
+++ b/src/open.zig
@@ -0,0 +1,26 @@
+usingnamespace @import("./global.zig");
+const std = @import("std");
+const alloc = @import("./alloc.zig");
+
+const opener = switch (std.Target.current.os.tag) {
+    .macos => "/usr/bin/open",
+    .windows => "start",
+    else => "xdg-open",
+};
+
+pub fn openURL(url: string) !void {
+    if (comptime isWasi) {
+        Output.prettyln("-> {s}", .{url});
+        Output.flush();
+        return;
+    }
+
+    var args_buf = [_]string{ opener, url };
+    var child_process = try std.ChildProcess.init(&args_buf, alloc.dynamic);
+    child_process.stderr_behavior = .Pipe;
+    child_process.stdin_behavior = .Ignore;
+    child_process.stdout_behavior = .Pipe;
+    try child_process.spawn();
+    _ = try child_process.wait();
+    return;
+}
diff --git a/src/options.zig b/src/options.zig
index ab8b18710..81c01f4fd 100644
--- a/src/options.zig
+++ b/src/options.zig
@@ -555,11 +555,11 @@ pub const Timings = struct {
 
 pub const DefaultUserDefines = struct {
     pub const HotModuleReloading = struct {
-        pub const Key = "process.env.SPEEDY_HMR_ENABLED";
+        pub const Key = "process.env.BUN_HMR_ENABLED";
         pub const Value = "true";
     };
     pub const HotModuleReloadingVerbose = struct {
-        pub const Key = "process.env.SPEEDY_HMR_VERBOSE";
+        pub const Key = "process.env.BUN_HMR_VERBOSE";
         pub const Value = "true";
     };
     // This must be globally scoped so it doesn't disappear
diff --git a/src/runtime.footer.js b/src/runtime.footer.js
index 4171dd163..293c6d341 100644
--- a/src/runtime.footer.js
+++ b/src/runtime.footer.js
@@ -2,15 +2,15 @@
 // Public exports from runtime
 // Compatible with Bun's Runtime Environment and web browsers.
 export var $$m =
-  "$primordials" in globalThis ? $primordials.require : SPEEDY_RUNTIME.$$m;
-export var __HMRModule = SPEEDY_RUNTIME.__HMRModule;
-export var __FastRefreshModule = SPEEDY_RUNTIME.__FastRefreshModule;
-export var __HMRClient = SPEEDY_RUNTIME.__HMRClient;
-export var __markAsModule = SPEEDY_RUNTIME.__markAsModule;
-export var $$lzy = SPEEDY_RUNTIME.$$lzy;
-export var __toModule = SPEEDY_RUNTIME.__toModule;
-export var __commonJS = SPEEDY_RUNTIME.__commonJS;
-export var __require = SPEEDY_RUNTIME.__require;
-export var __name = SPEEDY_RUNTIME.__name;
-export var __export = SPEEDY_RUNTIME.__export;
-export var __reExport = SPEEDY_RUNTIME.__reExport;
+  "$primordials" in globalThis ? $primordials.require : BUN_RUNTIME.$$m;
+export var __HMRModule = BUN_RUNTIME.__HMRModule;
+export var __FastRefreshModule = BUN_RUNTIME.__FastRefreshModule;
+export var __HMRClient = BUN_RUNTIME.__HMRClient;
+export var __markAsModule = BUN_RUNTIME.__markAsModule;
+export var $$lzy = BUN_RUNTIME.$$lzy;
+export var __toModule = BUN_RUNTIME.__toModule;
+export var __commonJS = BUN_RUNTIME.__commonJS;
+export var __require = BUN_RUNTIME.__require;
+export var __name = BUN_RUNTIME.__name;
+export var __export = BUN_RUNTIME.__export;
+export var __reExport = BUN_RUNTIME.__reExport;
diff --git a/src/runtime.js b/src/runtime.js
index 3afbf80f7..2c14e3243 100644
--- a/src/runtime.js
+++ b/src/runtime.js
@@ -89,16 +89,16 @@ export var __commonJS = (cb, name) => {
 
 var require_cache = new WeakMap();
 
-export var __SPEEDY_INTERNAL_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = {
+export var __BUN_INTERNAL_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = {
   RequireFailedError: class {},
 };
 
 // __name(
-//   __SPEEDY_INTERNAL_DO_NOT_USE_OR_YOU_WILL_BE_FIRED__MODULE_LOAD_CACHE.RequireFailedError,
+//   __BUN_INTERNAL_DO_NOT_USE_OR_YOU_WILL_BE_FIRED__MODULE_LOAD_CACHE.RequireFailedError,
 //   "RequireFailedError"
 // );
 // __name(
-//   __SPEEDY_INTERNAL_DO_NOT_USE_OR_YOU_WILL_BE_FIRED__MODULE_LOAD_CACHE.Module,
+//   __BUN_INTERNAL_DO_NOT_USE_OR_YOU_WILL_BE_FIRED__MODULE_LOAD_CACHE.Module,
 //   "Module"
 // );
 
@@ -115,7 +115,7 @@ export var __require = (namespace) => {
       : namespace;
 
   if (typeof target !== "function") {
-    throw new __SPEEDY_INTERNAL_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.RequireFailedError(
+    throw new __BUN_INTERNAL_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.RequireFailedError(
       `Couldn't find module "${
         typeof namespace === "string"
           ? namespace
@@ -131,21 +131,21 @@ export var __require = (namespace) => {
 
 if (
   !(
-    "__SPEEDY_INTERNAL_DO_NOT_USE_OR_YOU_WILL_BE_FIRED__MODULE_LOAD_CACHE" in
+    "__BUN_INTERNAL_DO_NOT_USE_OR_YOU_WILL_BE_FIRED__MODULE_LOAD_CACHE" in
     globalThis
   )
 ) {
-  globalThis.__SPEEDY_INTERNAL_DO_NOT_USE_OR_YOU_WILL_BE_FIRED__MODULE_LOAD_CACHE =
+  globalThis.__BUN_INTERNAL_DO_NOT_USE_OR_YOU_WILL_BE_FIRED__MODULE_LOAD_CACHE =
     new Map();
 }
 
 if (
   !(
-    "__SPEEDY_INTERNAL_DO_NOT_USE_OR_YOU_WILL_BE_FIRED__MODULE_REGISTRY" in
+    "__BUN_INTERNAL_DO_NOT_USE_OR_YOU_WILL_BE_FIRED__MODULE_REGISTRY" in
     globalThis
   )
 ) {
-  globalThis.__SPEEDY_INTERNAL_DO_NOT_USE_OR_YOU_WILL_BE_FIRED__MODULE_REGISTRY =
+  globalThis.__BUN_INTERNAL_DO_NOT_USE_OR_YOU_WILL_BE_FIRED__MODULE_REGISTRY =
     new Map();
 }
 
diff --git a/src/runtime.version b/src/runtime.version
index 2de34e9ad..912f2289c 100644
--- a/src/runtime.version
+++ b/src/runtime.version
@@ -1 +1 @@
-bf074417343b306f
\ No newline at end of file
+68bb421a4d8dfbaf
\ No newline at end of file
diff --git a/src/runtime/hmr.ts b/src/runtime/hmr.ts
index f89223f95..0d63c2f5c 100644
--- a/src/runtime/hmr.ts
+++ b/src/runtime/hmr.ts
@@ -354,7 +354,7 @@ var __HMRModule, __FastRefreshModule, __HMRClient;
     }
   }
 
-  class HMRClient {
+  class HMRClient extends EventTarget {
     static client: HMRClient;
     socket: WebSocket;
     hasWelcomed: boolean = false;
@@ -366,6 +366,7 @@ var __HMRModule, __FastRefreshModule, __HMRClient;
     loaders = {
       css: new CSSLoader(),
     };
+
     start() {
       if (runOnce) {
         __hmrlog.warn(
@@ -460,7 +461,7 @@ var __HMRModule, __FastRefreshModule, __HMRClient;
       this.client = new HMRClient();
       this.client.verbose = verbose;
       this.client.start();
-      globalThis["SPEEDY_HMR"] = this.client;
+      globalThis["BUN_HMR"] = this.client;
     }
 
     handleBuildFailure(buffer: ByteBuffer, timestamp: number) {
diff --git a/src/watcher.zig b/src/watcher.zig
index 04959b413..074943409 100644
--- a/src/watcher.zig
+++ b/src/watcher.zig
@@ -117,7 +117,6 @@ pub fn NewWatcher(comptime ContextType: type) type {
             var stderr = std.io.getStdErr();
             var output_source = Output.Source.init(stdout, stderr);
             Output.Source.set(&output_source);
-            Output.enable_ansi_colors = stderr.isTty();
 
             defer Output.flush();
             if (FeatureFlags.verbose_watcher) Output.prettyln("Watcher started", .{});