Fix fs.WriteStream error handling for FileSink synchronous errors

This commit addresses EPIPE error handling in Node.js stdout/stderr compatibility.

Changes:
1. Added try/catch blocks in fs.WriteStream _write, writeFast, and _writev methods
   to properly handle synchronous errors from FileSink operations
2. Added treat_epipe_as_error flag to FileSink for stdout/stderr streams
3. Added logic to detect broken pipe conditions (0 bytes written) for stdout/stderr
4. Copied Node.js test case test-stdout-close-catch.js for validation

The main issue was that when FileSink.write() threw an error synchronously,
the fs.WriteStream code would call cb(null) instead of cb(err), preventing
proper error event emission on stdout/stderr streams.

Note: Full EPIPE detection still needs work as the underlying PipeWriter
treats EPIPE as completion rather than error. This partial fix improves
error handling but doesn't fully resolve the test case yet.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

.github/workflows/format.yml

@@ -46,8 +46,9 @@ jobs:
           version: 0.14.0
       - name: Zig Format
         run: |
+          bun scripts/zig-remove-unreferenced-top-level-decls.ts src/
           zig fmt src
-          ./scripts/sort-imports.ts src
+          bun scripts/sortImports src
           zig fmt src
       - name: Prettier Format
         run: |

.github/workflows/vscode-release.yml

@@ -1,47 +0,0 @@
-name: VSCode Extension Publish
-on:
-  workflow_dispatch:
-    inputs:
-      version:
-        description: "Version to publish (e.g. 0.0.25) - Check the marketplace for the latest version"
-        required: true
-        type: string
-
-jobs:
-  publish:
-    name: "Publish to VS Code Marketplace"
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup Bun
-        uses: ./.github/actions/setup-bun
-        with:
-          bun-version: "1.2.18"
-
-      - name: Install dependencies (root)
-        run: bun install
-
-      - name: Install dependencies
-        run: bun install
-        working-directory: packages/bun-vscode
-
-      - name: Set Version
-        run: bun pm version ${{ github.event.inputs.version }} --no-git-tag-version --allow-same-version
-        working-directory: packages/bun-vscode
-
-      - name: Build (inspector protocol)
-        run: bun install && bun run build
-        working-directory: packages/bun-inspector-protocol
-
-      - name: Build (vscode extension)
-        run: bun run build
-        working-directory: packages/bun-vscode
-
-      - name: Publish
-        if: success()
-        run: bunx vsce publish
-        env:
-          VSCE_PAT: ${{ secrets.VSCODE_EXTENSION }}
-        working-directory: packages/bun-vscode/extension

.vscode/settings.json

@@ -168,5 +168,5 @@
     "WebKit/WebInspectorUI": true,
   },
   "git.detectSubmodules": false,
-  // "bun.test.customScript": "./build/debug/bun-debug test"
+  "bun.test.customScript": "bun-debug test"
 }

CLAUDE.md

@@ -4,9 +4,9 @@ This is the Bun repository - an all-in-one JavaScript runtime & toolkit designed
 
 ### Build Commands
 
-- **Build debug version**: `bun bd`
+- **Build debug version**: `bun bd` or `bun run build:debug`
   - Creates a debug build at `./build/debug/bun-debug`
-  - Compilation takes ~5 minutes. Don't timeout, be patient.
+  - Compilation takes ~2.5 minutes
 - **Run tests with your debug build**: `bun bd test <test-file>`
   - **CRITICAL**: Never use `bun test` directly - it won't include your changes
 - **Run any command with debug build**: `bun bd <command>`

CONTRIBUTING.md

@@ -160,7 +160,6 @@ In particular, these are:
 
 - `./src/codegen/generate-jssink.ts` -- Generates `build/debug/codegen/JSSink.cpp`, `build/debug/codegen/JSSink.h` which implement various classes for interfacing with `ReadableStream`. This is internally how `FileSink`, `ArrayBufferSink`, `"type": "direct"` streams and other code related to streams works.
 - `./src/codegen/generate-classes.ts` -- Generates `build/debug/codegen/ZigGeneratedClasses*`, which generates Zig & C++ bindings for JavaScriptCore classes implemented in Zig. In `**/*.classes.ts` files, we define the interfaces for various classes, methods, prototypes, getters/setters etc which the code generator reads to generate boilerplate code implementing the JavaScript objects in C++ and wiring them up to Zig
-- `./src/codegen/cppbind.ts` -- Generates automatic Zig bindings for C++ functions marked with `[[ZIG_EXPORT]]` attributes.
 - `./src/codegen/bundle-modules.ts` -- Bundles built-in modules like `node:fs`, `bun:ffi` into files we can include in the final binary. In development, these can be reloaded without rebuilding Zig (you still need to run `bun run build`, but it re-reads the transpiled files from disk afterwards). In release builds, these are embedded into the binary.
 - `./src/codegen/bundle-functions.ts` -- Bundles globally-accessible functions implemented in JavaScript/TypeScript like `ReadableStream`, `WritableStream`, and a handful more. These are used similarly to the builtin modules, but the output more closely aligns with what WebKit/Safari does for Safari's built-in functions so that we can copy-paste the implementations from WebKit as a starting point.
 

LATEST

@@ -1 +1 @@
-1.2.19
+1.2.18

build.zig

@@ -752,13 +752,6 @@ fn addInternalImports(b: *Build, mod: *Module, opts: *BunBuildOptions) void {
             });
         }
     }
-    {
-        const cppImport = b.createModule(.{
-            .root_source_file = (std.Build.LazyPath{ .cwd_relative = opts.codegen_path }).path(b, "cpp.zig"),
-        });
-        mod.addImport("cpp", cppImport);
-        cppImport.addImport("bun", mod);
-    }
     inline for (.{
         .{ .import = "completions-bash", .file = b.path("completions/bun.bash") },
         .{ .import = "completions-zsh", .file = b.path("completions/bun.zsh") },

bun.lock

@@ -4,8 +4,6 @@
     "": {
       "name": "bun",
       "devDependencies": {
-        "@lezer/common": "^1.2.3",
-        "@lezer/cpp": "^1.1.3",
         "esbuild": "^0.21.4",
         "mitata": "^0.1.11",
         "peechy": "0.4.34",
@@ -89,14 +87,6 @@
 
     "@esbuild/win32-x64": ["@esbuild/win32-x64@0.21.5", "", { "os": "win32", "cpu": "x64" }, "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw=="],
 
-    "@lezer/common": ["@lezer/common@1.2.3", "", {}, "sha512-w7ojc8ejBqr2REPsWxJjrMFsA/ysDCFICn8zEOR9mrqzOu2amhITYuLD8ag6XZf0CFXDrhKqw7+tW8cX66NaDA=="],
-
-    "@lezer/cpp": ["@lezer/cpp@1.1.3", "", { "dependencies": { "@lezer/common": "^1.2.0", "@lezer/highlight": "^1.0.0", "@lezer/lr": "^1.0.0" } }, "sha512-ykYvuFQKGsRi6IcE+/hCSGUhb/I4WPjd3ELhEblm2wS2cOznDFzO+ubK2c+ioysOnlZ3EduV+MVQFCPzAIoY3w=="],
-
-    "@lezer/highlight": ["@lezer/highlight@1.2.1", "", { "dependencies": { "@lezer/common": "^1.0.0" } }, "sha512-Z5duk4RN/3zuVO7Jq0pGLJ3qynpxUVsh7IbUbGj88+uV2ApSAn6kWg2au3iJb+0Zi7kKtqffIESgNcRXWZWmSA=="],
-
-    "@lezer/lr": ["@lezer/lr@1.4.2", "", { "dependencies": { "@lezer/common": "^1.0.0" } }, "sha512-pu0K1jCIdnQ12aWNaAVU5bzi7Bd1w54J3ECgANPmYLtQKP0HBj2cE/5coBD66MT10xbtIuUr7tg0Shbsvk0mDA=="],
-
     "@types/bun": ["@types/bun@workspace:packages/@types/bun"],
 
     "@types/node": ["@types/node@22.15.18", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-v1DKRfUdyW+jJhZNEI1PYy29S2YRxMV5AOO/x/SjKmW0acCIOqmbj6Haf9eHAhsPmrhlHSxEhv/1WszcLWV4cg=="],

bunfig.toml

@@ -7,6 +7,3 @@
 # Instead, we can only scan the test directory for Bun's runtime tests
 root = "test"
 preload = "./test/preload.ts"
-
-[install]
-linker = "isolated"

cmake/sources/JavaScriptCodegenSources.txt

@@ -8,7 +8,6 @@ src/codegen/bundle-functions.ts
 src/codegen/bundle-modules.ts
 src/codegen/class-definitions.ts
 src/codegen/client-js.ts
-src/codegen/cppbind.ts
 src/codegen/create-hash-table.ts
 src/codegen/generate-classes.ts
 src/codegen/generate-compact-string-table.ts
@@ -18,4 +17,3 @@ src/codegen/generate-node-errors.ts
 src/codegen/helpers.ts
 src/codegen/internal-module-registry-scanner.ts
 src/codegen/replacements.ts
-src/codegen/shared-types.ts

cmake/sources/ZigSources.txt

@@ -242,6 +242,7 @@ src/bun.js/test/jest.zig
 src/bun.js/test/pretty_format.zig
 src/bun.js/test/snapshot.zig
 src/bun.js/test/test.zig
+src/bun.js/unbounded_queue.zig
 src/bun.js/uuid.zig
 src/bun.js/virtual_machine_exports.zig
 src/bun.js/VirtualMachine.zig
@@ -304,14 +305,12 @@ src/bundler/linker_context/generateCodeForLazyExport.zig
 src/bundler/linker_context/generateCompileResultForCssChunk.zig
 src/bundler/linker_context/generateCompileResultForHtmlChunk.zig
 src/bundler/linker_context/generateCompileResultForJSChunk.zig
-src/bundler/linker_context/OutputFileListBuilder.zig
 src/bundler/linker_context/postProcessCSSChunk.zig
 src/bundler/linker_context/postProcessHTMLChunk.zig
 src/bundler/linker_context/postProcessJSChunk.zig
 src/bundler/linker_context/prepareCssAstsForChunk.zig
 src/bundler/linker_context/renameSymbolsInChunk.zig
 src/bundler/linker_context/scanImportsAndExports.zig
-src/bundler/linker_context/StaticRouteVisitor.zig
 src/bundler/linker_context/writeOutputFilesToDisk.zig
 src/bundler/LinkerContext.zig
 src/bundler/LinkerGraph.zig
@@ -835,20 +834,17 @@ src/string/StringJoiner.zig
 src/string/unicode.zig
 src/string/visible.zig
 src/string/WTFStringImpl.zig
+src/sync.zig
 src/sys_uv.zig
 src/sys.zig
 src/system_timer.zig
 src/test/fixtures.zig
 src/test/recover.zig
+src/thread_pool.zig
 src/threading.zig
-src/threading/channel.zig
 src/threading/Condition.zig
 src/threading/Futex.zig
-src/threading/guarded_value.zig
 src/threading/Mutex.zig
-src/threading/ThreadPool.zig
-src/threading/unbounded_queue.zig
-src/threading/WaitGroup.zig
 src/tmp.zig
 src/toml/toml_lexer.zig
 src/toml/toml_parser.zig

cmake/targets/BuildBun.cmake

@@ -255,10 +255,6 @@ set(BUN_ZIG_GENERATED_CLASSES_SCRIPT ${CWD}/src/codegen/generate-classes.ts)
 
 absolute_sources(BUN_ZIG_GENERATED_CLASSES_SOURCES ${CWD}/cmake/sources/ZigGeneratedClassesSources.txt)
 
-# hand written cpp source files. Full list of "source" code (including codegen) is in BUN_CPP_SOURCES
-absolute_sources(BUN_CXX_SOURCES ${CWD}/cmake/sources/CxxSources.txt)
-absolute_sources(BUN_C_SOURCES ${CWD}/cmake/sources/CSources.txt)
-
 set(BUN_ZIG_GENERATED_CLASSES_OUTPUTS
   ${CODEGEN_PATH}/ZigGeneratedClasses.h
   ${CODEGEN_PATH}/ZigGeneratedClasses.cpp
@@ -312,27 +308,6 @@ set(BUN_JAVASCRIPT_OUTPUTS
   ${CWD}/src/bun.js/bindings/GeneratedJS2Native.zig
 )
 
-set(BUN_CPP_OUTPUTS
-  ${CODEGEN_PATH}/cpp.zig
-)
-
-register_command(
-  TARGET
-    bun-cppbind
-  COMMENT
-    "Generating C++ --> Zig bindings"
-  COMMAND
-    ${BUN_EXECUTABLE}
-      ${CWD}/src/codegen/cppbind.ts
-      ${CWD}/src
-      ${CODEGEN_PATH}
-  SOURCES
-    ${BUN_JAVASCRIPT_CODEGEN_SOURCES}
-    ${BUN_CXX_SOURCES}
-  OUTPUTS
-    ${BUN_CPP_OUTPUTS}
-)
-
 register_command(
   TARGET
     bun-js-modules
@@ -562,7 +537,6 @@ set(BUN_ZIG_GENERATED_SOURCES
   ${BUN_ERROR_CODE_OUTPUTS}
   ${BUN_ZIG_GENERATED_CLASSES_OUTPUTS}
   ${BUN_JAVASCRIPT_OUTPUTS}
-  ${BUN_CPP_OUTPUTS}
 )
 
 # In debug builds, these are not embedded, but rather referenced at runtime.
@@ -632,7 +606,6 @@ register_command(
   TARGETS
     clone-zig
     clone-zstd
-    bun-cppbind
   SOURCES
     ${BUN_ZIG_SOURCES}
     ${BUN_ZIG_GENERATED_SOURCES}
@@ -645,6 +618,10 @@ set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "build.zig")
 
 set(BUN_USOCKETS_SOURCE ${CWD}/packages/bun-usockets)
 
+# hand written cpp source files. Full list of "source" code (including codegen) is in BUN_CPP_SOURCES
+absolute_sources(BUN_CXX_SOURCES ${CWD}/cmake/sources/CxxSources.txt)
+absolute_sources(BUN_C_SOURCES ${CWD}/cmake/sources/CSources.txt)
+
 if(WIN32)
   list(APPEND BUN_CXX_SOURCES ${CWD}/src/bun.js/bindings/windows/rescle.cpp)
   list(APPEND BUN_CXX_SOURCES ${CWD}/src/bun.js/bindings/windows/rescle-binding.cpp)
@@ -708,7 +685,7 @@ if(WIN32)
     ${CODEGEN_PATH}/windows-app-info.rc
     @ONLY
   )
-  set(WINDOWS_RESOURCES ${CODEGEN_PATH}/windows-app-info.rc ${CWD}/src/bun.exe.manifest)
+  set(WINDOWS_RESOURCES ${CODEGEN_PATH}/windows-app-info.rc)
 endif()
 
 # --- Executable ---
@@ -981,16 +958,6 @@ if(APPLE)
     -Wl,-map,${bun}.linker-map
   )
 
-  if(DEBUG)
-    target_link_options(${bun} PUBLIC
-    # Suppress ALL linker warnings on macOS.
-    # The intent is to only suppress linker alignment warnings.
-    # As of July 21st, 2025 there doesn't seem to be a more specific suppression just for linker alignment warnings.
-    # If you find one, please update this to only be for linker alignment.
-    -Wl,-w
-    )
-  endif()
-
   # don't strip in debug, this seems to be needed so that the Zig std library
   # `*dbHelper` DWARF symbols (used by LLDB for pretty printing) are in the
   # output executable

cmake/targets/BuildLibArchive.cmake

@@ -4,7 +4,7 @@ register_repository(
   REPOSITORY
     libarchive/libarchive
   COMMIT
-    7118f97c26bf0b2f426728b482f86508efc81d02
+    898dc8319355b7e985f68a9819f182aaed61b53a
 )
 
 register_cmake_command(
@@ -20,14 +20,11 @@ register_cmake_command(
     -DENABLE_WERROR=OFF
     -DENABLE_BZip2=OFF
     -DENABLE_CAT=OFF
-    -DENABLE_CPIO=OFF
-    -DENABLE_UNZIP=OFF
     -DENABLE_EXPAT=OFF
     -DENABLE_ICONV=OFF
     -DENABLE_LIBB2=OFF
     -DENABLE_LibGCC=OFF
     -DENABLE_LIBXML2=OFF
-    -DENABLE_WIN32_XMLLITE=OFF
     -DENABLE_LZ4=OFF
     -DENABLE_LZMA=OFF
     -DENABLE_LZO=OFF

cmake/targets/BuildLolHtml.cmake

@@ -4,7 +4,7 @@ register_repository(
   REPOSITORY
     cloudflare/lol-html
   COMMIT
-    d64457d9ff0143deef025d5df7e8586092b9afb7
+    67f1d4ffd6b74db7e053fb129dcce620193c180d
 )
 
 set(LOLHTML_CWD ${VENDOR_PATH}/lolhtml/c-api)

cmake/tools/SetupZig.cmake

@@ -20,7 +20,7 @@ else()
   unsupported(CMAKE_SYSTEM_NAME)
 endif()
 
-set(ZIG_COMMIT "edc6229b1fafb1701a25fb4e17114cc756991546")
+set(ZIG_COMMIT "0a0120fa92cd7f6ab244865688b351df634f0707")
 optionx(ZIG_TARGET STRING "The zig target to use" DEFAULT ${DEFAULT_ZIG_TARGET})
 
 if(CMAKE_BUILD_TYPE STREQUAL "Release")

docs/bundler/executables.md

@@ -88,20 +88,6 @@ The order of the `--target` flag does not matter, as long as they're delimited b
 
 On x64 platforms, Bun uses SIMD optimizations which require a modern CPU supporting AVX2 instructions. The `-baseline` build of Bun is for older CPUs that don't support these optimizations. Normally, when you install Bun we automatically detect which version to use but this can be harder to do when cross-compiling since you might not know the target CPU. You usually don't need to worry about it on Darwin x64, but it is relevant for Windows x64 and Linux x64. If you or your users see `"Illegal instruction"` errors, you might need to use the baseline version.
 
-## Build-time constants
-
-Use the `--define` flag to inject build-time constants into your executable, such as version numbers, build timestamps, or configuration values:
-
-```bash
-$ bun build --compile --define BUILD_VERSION='"1.2.3"' --define BUILD_TIME='"2024-01-15T10:30:00Z"' src/cli.ts --outfile mycli
-```
-
-These constants are embedded directly into your compiled binary at build time, providing zero runtime overhead and enabling dead code elimination optimizations.
-
-{% callout type="info" %}
-For comprehensive examples and advanced patterns, see the [Build-time constants guide](/guides/runtime/build-time-constants).
-{% /callout %}
-
 ## Deploying to production
 
 Compiled executables reduce memory usage and improve Bun's start time.

docs/cli/install.md

@@ -183,30 +183,6 @@ Bun supports installing dependencies from Git, GitHub, and local or remotely-hos
 }
 ```
 
-## Installation strategies
-
-Bun supports two package installation strategies that determine how dependencies are organized in `node_modules`:
-
-### Hoisted installs (default for single projects)
-
-The traditional npm/Yarn approach that flattens dependencies into a shared `node_modules` directory:
-
-```bash
-$ bun install --linker hoisted
-```
-
-### Isolated installs
-
-A pnpm-like approach that creates strict dependency isolation to prevent phantom dependencies:
-
-```bash
-$ bun install --linker isolated
-```
-
-Isolated installs create a central package store in `node_modules/.bun/` with symlinks in the top-level `node_modules`. This ensures packages can only access their declared dependencies.
-
-For complete documentation on isolated installs, refer to [Package manager > Isolated installs](https://bun.com/docs/install/isolated).
-
 ## Configuration
 
 The default behavior of `bun install` can be configured in `bunfig.toml`. The default values are shown below.
@@ -237,15 +213,11 @@ dryRun = false
 
 # equivalent to `--concurrent-scripts` flag
 concurrentScripts = 16 # (cpu count or GOMAXPROCS) x2
-
-# installation strategy: "hoisted" or "isolated"
-# default: "hoisted"
-linker = "hoisted"
 ```
 
 ## CI/CD
 
-Use the official [`oven-sh/setup-bun`](https://github.com/oven-sh/setup-bun) action to install `bun` in a GitHub Actions pipeline:
+Looking to speed up your CI? Use the official [`oven-sh/setup-bun`](https://github.com/oven-sh/setup-bun) action to install `bun` in a GitHub Actions pipeline.
 
 ```yaml#.github/workflows/release.yml
 name: bun-types
@@ -264,31 +236,4 @@ jobs:
         run: bun run build
 ```
 
-For CI/CD environments that want to enforce reproducible builds, use `bun ci` to fail the build if the package.json is out of sync with the lockfile:
-
-```bash
-$ bun ci
-```
-
-This is equivalent to `bun install --frozen-lockfile`. It installs exact versions from `bun.lock` and fails if `package.json` doesn't match the lockfile. To use `bun ci` or `bun install --frozen-lockfile`, you must commit `bun.lock` to version control.
-
-And instead of running `bun install`, run `bun ci`.
-
-```yaml#.github/workflows/release.yml
-name: bun-types
-jobs:
-  build:
-    name: build-app
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repo
-        uses: actions/checkout@v4
-      - name: Install bun
-        uses: oven-sh/setup-bun@v2
-      - name: Install dependencies
-        run: bun ci
-      - name: Build app
-        run: bun run build
-```
-
 {% bunCLIUsage command="install" /%}

docs/cli/test.md

@@ -258,7 +258,7 @@ Set any of the following environment variables to enable AI-friendly output:
 
 - `CLAUDECODE=1` - For Claude Code
 - `REPL_ID=1` - For Replit
-- `AGENT=1` - Generic AI agent flag
+- `IS_CODE_AGENT=1` - Generic AI agent flag
 
 ### Behavior
 
@@ -267,6 +267,7 @@ When an AI agent environment is detected:
 - Only test failures are displayed in detail
 - Passing, skipped, and todo test indicators are hidden
 - Summary statistics remain intact
+- JUnit XML reporting is preserved
 
 ```bash
 # Example: Enable quiet output for Claude Code

docs/cli/update.md

@@ -10,86 +10,6 @@ To update a specific dependency to the latest version:
 $ bun update [package]
 ```
 
-## `--interactive`
-
-For a more controlled update experience, use the `--interactive` flag to select which packages to update:
-
-```sh
-$ bun update --interactive
-$ bun update -i
-```
-
-This launches an interactive terminal interface that shows all outdated packages with their current and target versions. You can then select which packages to update.
-
-### Interactive Interface
-
-The interface displays packages grouped by dependency type:
-
-```
-? Select packages to update - Space to toggle, Enter to confirm, a to select all, n to select none, i to invert, l to toggle latest
-
-  dependencies                Current  Target   Latest
-    □ react                   17.0.2   18.2.0   18.3.1
-    □ lodash                  4.17.20  4.17.21  4.17.21
-
-  devDependencies             Current  Target   Latest
-    □ typescript              4.8.0    5.0.0    5.3.3
-    □ @types/node             16.11.7  18.0.0   20.11.5
-
-  optionalDependencies        Current  Target   Latest
-    □ some-optional-package   1.0.0    1.1.0    1.2.0
-```
-
-**Sections:**
-
-- Packages are grouped under section headers: `dependencies`, `devDependencies`, `peerDependencies`, `optionalDependencies`
-- Each section shows column headers aligned with the package data
-
-**Columns:**
-
-- **Package**: Package name (may have suffix like ` dev`, ` peer`, ` optional` for clarity)
-- **Current**: Currently installed version
-- **Target**: Version that would be installed (respects semver constraints)
-- **Latest**: Latest available version
-
-### Keyboard Controls
-
-**Selection:**
-
-- **Space**: Toggle package selection
-- **Enter**: Confirm selections and update
-- **a/A**: Select all packages
-- **n/N**: Select none
-- **i/I**: Invert selection
-
-**Navigation:**
-
-- **↑/↓ Arrow keys** or **j/k**: Move cursor
-- **l/L**: Toggle between target and latest version for current package
-
-**Exit:**
-
-- **Ctrl+C** or **Ctrl+D**: Cancel without updating
-
-### Visual Indicators
-
-- **☑** Selected packages (will be updated)
-- **□** Unselected packages
-- **>** Current cursor position
-- **Colors**: Red (major), yellow (minor), green (patch) version changes
-- **Underlined**: Currently selected update target
-
-### Package Grouping
-
-Packages are organized in sections by dependency type:
-
-- **dependencies** - Regular runtime dependencies
-- **devDependencies** - Development dependencies
-- **peerDependencies** - Peer dependencies
-- **optionalDependencies** - Optional dependencies
-
-Within each section, individual packages may have additional suffixes (` dev`, ` peer`, ` optional`) for extra clarity.
-
 ## `--latest`
 
 By default, `bun update` will update to the latest version of a dependency that satisfies the version range specified in your `package.json`.
@@ -100,8 +20,6 @@ To update to the latest version, regardless of if it's compatible with the curre
 $ bun update --latest
 ```
 
-In interactive mode, you can toggle individual packages between their target version (respecting semver) and latest version using the **l** key.
-
 For example, with the following `package.json`:
 
 ```json

docs/guides/runtime/build-time-constants.md

@@ -1,293 +0,0 @@
----
-name: Build-time constants with --define
----
-
-The `--define` flag can be used with `bun build` and `bun build --compile` to inject build-time constants into your application. This is especially useful for embedding metadata like build versions, timestamps, or configuration flags directly into your compiled executables.
-
-```sh
-$ bun build --compile --define BUILD_VERSION='"1.2.3"' --define BUILD_TIME='"2024-01-15T10:30:00Z"' src/index.ts --outfile myapp
-```
-
----
-
-## Why use build-time constants?
-
-Build-time constants are embedded directly into your compiled code, making them:
-
-- **Zero runtime overhead** - No environment variable lookups or file reads
-- **Immutable** - Values are baked into the binary at compile time
-- **Optimizable** - Dead code elimination can remove unused branches
-- **Secure** - No external dependencies or configuration files to manage
-
-This is similar to `gcc -D` or `#define` in C/C++, but for JavaScript/TypeScript.
-
----
-
-## Basic usage
-
-### With `bun build`
-
-```sh
-# Bundle with build-time constants
-$ bun build --define BUILD_VERSION='"1.0.0"' --define NODE_ENV='"production"' src/index.ts --outdir ./dist
-```
-
-### With `bun build --compile`
-
-```sh
-# Compile to executable with build-time constants
-$ bun build --compile --define BUILD_VERSION='"1.0.0"' --define BUILD_TIME='"2024-01-15T10:30:00Z"' src/cli.ts --outfile mycli
-```
-
-### JavaScript API
-
-```ts
-await Bun.build({
-  entrypoints: ["./src/index.ts"],
-  outdir: "./dist",
-  define: {
-    BUILD_VERSION: '"1.0.0"',
-    BUILD_TIME: '"2024-01-15T10:30:00Z"',
-    DEBUG: "false",
-  },
-});
-```
-
----
-
-## Common use cases
-
-### Version information
-
-Embed version and build metadata directly into your executable:
-
-{% codetabs %}
-
-```ts#src/version.ts
-// These constants are replaced at build time
-declare const BUILD_VERSION: string;
-declare const BUILD_TIME: string;
-declare const GIT_COMMIT: string;
-
-export function getVersion() {
-  return {
-    version: BUILD_VERSION,
-    buildTime: BUILD_TIME,
-    commit: GIT_COMMIT,
-  };
-}
-```
-
-```sh#Build command
-$ bun build --compile \
-  --define BUILD_VERSION='"1.2.3"' \
-  --define BUILD_TIME='"2024-01-15T10:30:00Z"' \
-  --define GIT_COMMIT='"abc123"' \
-  src/cli.ts --outfile mycli
-```
-
-{% /codetabs %}
-
-### Feature flags
-
-Use build-time constants to enable/disable features:
-
-```ts
-// Replaced at build time
-declare const ENABLE_ANALYTICS: boolean;
-declare const ENABLE_DEBUG: boolean;
-
-function trackEvent(event: string) {
-  if (ENABLE_ANALYTICS) {
-    // This entire block is removed if ENABLE_ANALYTICS is false
-    console.log("Tracking:", event);
-  }
-}
-
-if (ENABLE_DEBUG) {
-  console.log("Debug mode enabled");
-}
-```
-
-```sh
-# Production build - analytics enabled, debug disabled
-$ bun build --compile --define ENABLE_ANALYTICS=true --define ENABLE_DEBUG=false src/app.ts --outfile app-prod
-
-# Development build - both enabled
-$ bun build --compile --define ENABLE_ANALYTICS=false --define ENABLE_DEBUG=true src/app.ts --outfile app-dev
-```
-
-### Configuration
-
-Replace configuration objects at build time:
-
-```ts
-declare const CONFIG: {
-  apiUrl: string;
-  timeout: number;
-  retries: number;
-};
-
-// CONFIG is replaced with the actual object at build time
-const response = await fetch(CONFIG.apiUrl, {
-  timeout: CONFIG.timeout,
-});
-```
-
-```sh
-$ bun build --compile --define 'CONFIG={"apiUrl":"https://api.example.com","timeout":5000,"retries":3}' src/app.ts --outfile app
-```
-
----
-
-## Advanced patterns
-
-### Environment-specific builds
-
-Create different executables for different environments:
-
-```json
-{
-  "scripts": {
-    "build:dev": "bun build --compile --define NODE_ENV='\"development\"' --define API_URL='\"http://localhost:3000\"' src/app.ts --outfile app-dev",
-    "build:staging": "bun build --compile --define NODE_ENV='\"staging\"' --define API_URL='\"https://staging.example.com\"' src/app.ts --outfile app-staging",
-    "build:prod": "bun build --compile --define NODE_ENV='\"production\"' --define API_URL='\"https://api.example.com\"' src/app.ts --outfile app-prod"
-  }
-}
-```
-
-### Using shell commands for dynamic values
-
-Generate build-time constants from shell commands:
-
-```sh
-# Use git to get current commit and timestamp
-$ bun build --compile \
-  --define BUILD_VERSION="\"$(git describe --tags --always)\"" \
-  --define BUILD_TIME="\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\"" \
-  --define GIT_COMMIT="\"$(git rev-parse HEAD)\"" \
-  src/cli.ts --outfile mycli
-```
-
-### Build automation script
-
-Create a build script that automatically injects build metadata:
-
-```ts
-// build.ts
-import { $ } from "bun";
-
-const version = await $`git describe --tags --always`.text();
-const buildTime = new Date().toISOString();
-const gitCommit = await $`git rev-parse HEAD`.text();
-
-await Bun.build({
-  entrypoints: ["./src/cli.ts"],
-  outdir: "./dist",
-  define: {
-    BUILD_VERSION: JSON.stringify(version.trim()),
-    BUILD_TIME: JSON.stringify(buildTime),
-    GIT_COMMIT: JSON.stringify(gitCommit.trim()),
-  },
-});
-
-console.log(`Built with version ${version.trim()}`);
-```
-
----
-
-## Important considerations
-
-### Value format
-
-Values must be valid JSON that will be parsed and inlined as JavaScript expressions:
-
-```sh
-# ✅ Strings must be JSON-quoted
---define VERSION='"1.0.0"'
-
-# ✅ Numbers are JSON literals
---define PORT=3000
-
-# ✅ Booleans are JSON literals
---define DEBUG=true
-
-# ✅ Objects and arrays (use single quotes to wrap the JSON)
---define 'CONFIG={"host":"localhost","port":3000}'
-
-# ✅ Arrays work too
---define 'FEATURES=["auth","billing","analytics"]'
-
-# ❌ This won't work - missing quotes around string
---define VERSION=1.0.0
-```
-
-### Property keys
-
-You can use property access patterns as keys, not just simple identifiers:
-
-```sh
-# ✅ Replace process.env.NODE_ENV with "production"
---define 'process.env.NODE_ENV="production"'
-
-# ✅ Replace process.env.API_KEY with the actual key
---define 'process.env.API_KEY="abc123"'
-
-# ✅ Replace nested properties
---define 'window.myApp.version="1.0.0"'
-
-# ✅ Replace array access
---define 'process.argv[2]="--production"'
-```
-
-This is particularly useful for environment variables:
-
-```ts
-// Before compilation
-if (process.env.NODE_ENV === "production") {
-  console.log("Production mode");
-}
-
-// After compilation with --define 'process.env.NODE_ENV="production"'
-if ("production" === "production") {
-  console.log("Production mode");
-}
-
-// After optimization
-console.log("Production mode");
-```
-
-### TypeScript declarations
-
-For TypeScript projects, declare your constants to avoid type errors:
-
-```ts
-// types/build-constants.d.ts
-declare const BUILD_VERSION: string;
-declare const BUILD_TIME: string;
-declare const NODE_ENV: "development" | "staging" | "production";
-declare const DEBUG: boolean;
-```
-
-### Cross-platform compatibility
-
-When building for multiple platforms, constants work the same way:
-
-```sh
-# Linux
-$ bun build --compile --target=bun-linux-x64 --define PLATFORM='"linux"' src/app.ts --outfile app-linux
-
-# macOS
-$ bun build --compile --target=bun-darwin-x64 --define PLATFORM='"darwin"' src/app.ts --outfile app-macos
-
-# Windows
-$ bun build --compile --target=bun-windows-x64 --define PLATFORM='"windows"' src/app.ts --outfile app-windows.exe
-```
-
----
-
-## Related
-
-- [Define constants at runtime](/guides/runtime/define-constant) - Using `--define` with `bun run`
-- [Building executables](/bundler/executables) - Complete guide to `bun build --compile`
-- [Bundler API](/bundler) - Full bundler documentation including `define` option

docs/install/index.md

@@ -81,14 +81,6 @@ $ bun install --verbose # debug logging
 $ bun install --silent  # no logging
 ```
 
-To use isolated installs instead of the default hoisted strategy:
-
-```bash
-$ bun install --linker isolated
-```
-
-Isolated installs create strict dependency isolation similar to pnpm, preventing phantom dependencies and ensuring more deterministic builds. For complete documentation, see [Isolated installs](https://bun.com/docs/install/isolated).
-
 {% details summary="Configuring behavior" %}
 The default behavior of `bun install` can be configured in `bunfig.toml`:
 
@@ -118,10 +110,6 @@ dryRun = false
 
 # equivalent to `--concurrent-scripts` flag
 concurrentScripts = 16 # (cpu count or GOMAXPROCS) x2
-
-# installation strategy: "hoisted" or "isolated"
-# default: "hoisted"
-linker = "hoisted"
 ```
 
 {% /details %}

docs/install/isolated.md

@@ -1,195 +0,0 @@
-Bun provides an alternative package installation strategy called **isolated installs** that creates strict dependency isolation similar to pnpm's approach. This mode prevents phantom dependencies and ensures reproducible, deterministic builds.
-
-## What are isolated installs?
-
-Isolated installs create a non-hoisted dependency structure where packages can only access their explicitly declared dependencies. This differs from the traditional "hoisted" installation strategy used by npm and Yarn, where dependencies are flattened into a shared `node_modules` directory.
-
-### Key benefits
-
-- **Prevents phantom dependencies** — Packages cannot accidentally import dependencies they haven't declared
-- **Deterministic resolution** — Same dependency tree regardless of what else is installed
-- **Better for monorepos** — Workspace isolation prevents cross-contamination between packages
-- **Reproducible builds** — More predictable resolution behavior across environments
-
-## Using isolated installs
-
-### Command line
-
-Use the `--linker` flag to specify the installation strategy:
-
-```bash
-# Use isolated installs
-$ bun install --linker isolated
-
-# Use traditional hoisted installs
-$ bun install --linker hoisted
-```
-
-### Configuration file
-
-Set the default linker strategy in your `bunfig.toml`:
-
-```toml
-[install]
-linker = "isolated"
-```
-
-### Default behavior
-
-By default, Bun uses the **hoisted** installation strategy for all projects. To use isolated installs, you must explicitly specify the `--linker isolated` flag or set it in your configuration file.
-
-## How isolated installs work
-
-### Directory structure
-
-Instead of hoisting dependencies, isolated installs create a two-tier structure:
-
-```
-node_modules/
-├── .bun/                          # Central package store
-│   ├── package@1.0.0/             # Versioned package installations
-│   │   └── node_modules/
-│   │       └── package/           # Actual package files
-│   ├── @scope+package@2.1.0/      # Scoped packages (+ replaces /)
-│   │   └── node_modules/
-│   │       └── @scope/
-│   │           └── package/
-│   └── ...
-└── package-name -> .bun/package@1.0.0/node_modules/package  # Symlinks
-```
-
-### Resolution algorithm
-
-1. **Central store** — All packages are installed in `node_modules/.bun/package@version/` directories
-2. **Symlinks** — Top-level `node_modules` contains symlinks pointing to the central store
-3. **Peer resolution** — Complex peer dependencies create specialized directory names
-4. **Deduplication** — Packages with identical package IDs and peer dependency sets are shared
-
-### Workspace handling
-
-In monorepos, workspace dependencies are handled specially:
-
-- **Workspace packages** — Symlinked directly to their source directories, not the store
-- **Workspace dependencies** — Can access other workspace packages in the monorepo
-- **External dependencies** — Installed in the isolated store with proper isolation
-
-## Comparison with hoisted installs
-
-| Aspect                    | Hoisted (npm/Yarn)                         | Isolated (pnpm-like)                    |
-| ------------------------- | ------------------------------------------ | --------------------------------------- |
-| **Dependency access**     | Packages can access any hoisted dependency | Packages only see declared dependencies |
-| **Phantom dependencies**  | ❌ Possible                                | ✅ Prevented                            |
-| **Disk usage**            | ✅ Lower (shared installs)                 | ✅ Similar (uses symlinks)              |
-| **Determinism**           | ❌ Less deterministic                      | ✅ More deterministic                   |
-| **Node.js compatibility** | ✅ Standard behavior                       | ✅ Compatible via symlinks              |
-| **Best for**              | Single projects, legacy code               | Monorepos, strict dependency management |
-
-## Advanced features
-
-### Peer dependency handling
-
-Isolated installs handle peer dependencies through sophisticated resolution:
-
-```bash
-# Package with peer dependencies creates specialized paths
-node_modules/.bun/package@1.0.0_react@18.2.0/
-```
-
-The directory name encodes both the package version and its peer dependency versions, ensuring each unique combination gets its own installation.
-
-### Backend strategies
-
-Bun uses different file operation strategies for performance:
-
-- **Clonefile** (macOS) — Copy-on-write filesystem clones for maximum efficiency
-- **Hardlink** (Linux/Windows) — Hardlinks to save disk space
-- **Copyfile** (fallback) — Full file copies when other methods aren't available
-
-### Debugging isolated installs
-
-Enable verbose logging to understand the installation process:
-
-```bash
-$ bun install --linker isolated --verbose
-```
-
-This shows:
-
-- Store entry creation
-- Symlink operations
-- Peer dependency resolution
-- Deduplication decisions
-
-## Troubleshooting
-
-### Compatibility issues
-
-Some packages may not work correctly with isolated installs due to:
-
-- **Hardcoded paths** — Packages that assume a flat `node_modules` structure
-- **Dynamic imports** — Runtime imports that don't follow Node.js resolution
-- **Build tools** — Tools that scan `node_modules` directly
-
-If you encounter issues, you can:
-
-1. **Switch to hoisted mode** for specific projects:
-
-   ```bash
-   $ bun install --linker hoisted
-   ```
-
-2. **Report compatibility issues** to help improve isolated install support
-
-### Performance considerations
-
-- **Install time** — May be slightly slower due to symlink operations
-- **Disk usage** — Similar to hoisted (uses symlinks, not file copies)
-- **Memory usage** — Higher during install due to complex peer resolution
-
-## Migration guide
-
-### From npm/Yarn
-
-```bash
-# Remove existing node_modules and lockfiles
-$ rm -rf node_modules package-lock.json yarn.lock
-
-# Install with isolated linker
-$ bun install --linker isolated
-```
-
-### From pnpm
-
-Isolated installs are conceptually similar to pnpm, so migration should be straightforward:
-
-```bash
-# Remove pnpm files
-$ rm -rf node_modules pnpm-lock.yaml
-
-# Install with Bun's isolated linker
-$ bun install --linker isolated
-```
-
-The main difference is that Bun uses symlinks in `node_modules` while pnpm uses a global store with symlinks.
-
-## When to use isolated installs
-
-**Use isolated installs when:**
-
-- Working in monorepos with multiple packages
-- Strict dependency management is required
-- Preventing phantom dependencies is important
-- Building libraries that need deterministic dependencies
-
-**Use hoisted installs when:**
-
-- Working with legacy code that assumes flat `node_modules`
-- Compatibility with existing build tools is required
-- Working in environments where symlinks aren't well supported
-- You prefer the simpler traditional npm behavior
-
-## Related documentation
-
-- [Package manager > Workspaces](https://bun.com/docs/install/workspaces) — Monorepo workspace management
-- [Package manager > Lockfile](https://bun.com/docs/install/lockfile) — Understanding Bun's lockfile format
-- [CLI > install](https://bun.com/docs/cli/install) — Complete `bun install` command reference

docs/nav.ts

@@ -183,9 +183,6 @@ export default {
       description:
         "Bun's package manager installs all packages into a shared global cache to avoid redundant re-downloads.",
     }),
-    page("install/isolated", "Isolated installs", {
-      description: "Create strict dependency isolation, preventing phantom dependencies.",
-    }),
     page("install/workspaces", "Workspaces", {
       description: "Bun's package manager supports workspaces and monorepo development workflows.",
     }),

misctools/http_bench.zig

@@ -196,7 +196,7 @@ pub fn main() anyerror!void {
         response_body: MutableString = undefined,
         context: HTTP.HTTPChannelContext = undefined,
     };
-    const Batch = bun.ThreadPool.Batch;
+    const Batch = @import("../src/thread_pool.zig").Batch;
     var groups = try default_allocator.alloc(Group, args.count);
     var repeat_i: usize = 0;
     while (repeat_i < args.repeat + 1) : (repeat_i += 1) {

package.json

@@ -1,14 +1,12 @@
 {
   "private": true,
   "name": "bun",
-  "version": "1.2.20",
+  "version": "1.2.19",
   "workspaces": [
     "./packages/bun-types",
     "./packages/@types/bun"
   ],
   "devDependencies": {
-    "@lezer/common": "^1.2.3",
-    "@lezer/cpp": "^1.1.3",
     "esbuild": "^0.21.4",
     "mitata": "^0.1.11",
     "peechy": "0.4.34",
@@ -30,8 +28,8 @@
     "watch-windows": "bun run zig build check-windows --watch -fincremental --prominent-compile-errors --global-cache-dir build/debug/zig-check-cache --zig-lib-dir vendor/zig/lib",
     "bd:v": "(bun run --silent build:debug &> /tmp/bun.debug.build.log || (cat /tmp/bun.debug.build.log && rm -rf /tmp/bun.debug.build.log && exit 1)) && rm -f /tmp/bun.debug.build.log && ./build/debug/bun-debug",
     "bd": "BUN_DEBUG_QUIET_LOGS=1 bun --silent bd:v",
-    "build:debug": "export COMSPEC=\"C:\\Windows\\System32\\cmd.exe\" && bun scripts/glob-sources.mjs > /dev/null && bun ./scripts/build.mjs -GNinja -DCMAKE_BUILD_TYPE=Debug -B build/debug --log-level=NOTICE",
-    "build:debug:asan": "bun ./scripts/build.mjs -GNinja -DCMAKE_BUILD_TYPE=Debug -DENABLE_ASAN=ON -B build/debug-asan --log-level=NOTICE",
+    "build:debug": "bun scripts/glob-sources.mjs > /dev/null && bun ./scripts/build.mjs -GNinja -DCMAKE_BUILD_TYPE=Debug -B build/debug",
+    "build:debug:asan": "bun ./scripts/build.mjs -GNinja -DCMAKE_BUILD_TYPE=Debug -DENABLE_ASAN=ON -B build/debug-asan",
     "build:release": "bun ./scripts/build.mjs -GNinja -DCMAKE_BUILD_TYPE=Release -B build/release",
     "build:ci": "bun ./scripts/build.mjs -GNinja -DCMAKE_BUILD_TYPE=Release -DCMAKE_VERBOSE_MAKEFILE=ON -DCI=true -B build/release-ci --verbose --fresh",
     "build:assert": "bun ./scripts/build.mjs -GNinja -DCMAKE_BUILD_TYPE=RelWithDebInfo -DENABLE_ASSERTIONS=ON -DENABLE_LOGS=ON -B build/release-assert",

packages/bun-vscode/README.md

@@ -27,17 +27,11 @@ At its core is the _Bun runtime_, a fast JavaScript runtime designed as a drop-i
 - Run scripts from package.json
 - Visual lockfile viewer for old binary lockfiles (`bun.lockb`)
 
-## Bun test runner integration
-
-Run and debug tests directly from VSCode's Testing panel. The extension automatically discovers test files, shows inline test status, and provides rich error messages with diffs.
-
-![Test runner example](https://raw.githubusercontent.com/oven-sh/bun/refs/heads/main/packages/bun-vscode/assets/bun-test.gif)
-
 ## In-editor error messages
 
 When running programs with Bun from a Visual Studio Code terminal, Bun will connect to the extension and report errors as they happen, at the exact location they happened. We recommend using this feature with `bun --watch` so you can see errors on every save.
 
-![Error messages example](https://raw.githubusercontent.com/oven-sh/bun/refs/heads/main/packages/bun-vscode/assets/error-messages.gif)
+![Error messages example](https://raw.githubusercontent.com/oven-sh/bun/refs/heads/main/packages/bun-vscode/error-messages.gif)
 
 <div align="center">
 <sup>In the example above VSCode is saving on every keypress. Under normal configuration you'd only see errors on every save.</sup>

packages/bun-vscode/bun.lock

@@ -102,6 +102,8 @@
 
     "@types/ws": ["@types/ws@8.5.12", "", { "dependencies": { "@types/node": "*" } }, "sha512-3tPRkv1EtkDpzlgyKyI8pGsGZAGPEaXeu0DOj5DI25Ja91bdAYddYHbADRYVrZMRbfW+1l5YwXVDKohDJNQxkQ=="],
 
+    "@types/xml2js": ["@types/xml2js@0.4.14", "", { "dependencies": { "@types/node": "*" } }, "sha512-4YnrRemBShWRO2QjvUin8ESA41rH+9nQGLUGZV/1IDhi3SL9OhdpNC/MrulTWuptXKwhx/aDxE7toV0f/ypIXQ=="],
+
     "@vscode/debugadapter": ["@vscode/debugadapter@1.61.0", "", { "dependencies": { "@vscode/debugprotocol": "1.61.0" } }, "sha512-VDGLUFDVAdnftUebZe4uQCIFUbJ7rTc2Grps4D/CXl+qyzTZSQLv5VADEOZ6kBYG4SvlnMLql5vPQ0G6XvUCvQ=="],
 
     "@vscode/debugadapter-testsupport": ["@vscode/debugadapter-testsupport@1.61.0", "", { "dependencies": { "@vscode/debugprotocol": "1.61.0" } }, "sha512-M/8aNX1aFvupd+SP0NLEVLKUK9y52BuCK5vKO2gzdpSoRUR2fR8oFbGkTie+/p2Yrcswnuf7hFx0xWkV9avRdg=="],

packages/bun-vscode/package.json

@@ -10,13 +10,15 @@
   "devDependencies": {
     "@types/bun": "^1.1.10",
     "@types/vscode": "^1.60.0",
+    "@types/xml2js": "^0.4.14",
     "@vscode/debugadapter": "^1.56.0",
     "@vscode/debugadapter-testsupport": "^1.56.0",
     "@vscode/test-cli": "^0.0.10",
     "@vscode/test-electron": "^2.4.1",
     "@vscode/vsce": "^2.20.1",
     "esbuild": "^0.19.2",
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "xml2js": "^0.6.2"
   },
   "activationEvents": [
     "onStartupFinished"
@@ -71,7 +73,7 @@
         },
         "bun.test.filePattern": {
           "type": "string",
-          "default": "**/*{.test.,.spec.,_test_,_spec_}{js,ts,tsx,jsx,mts,cts,cjs,mjs}",
+          "default": "**/*{.test.,.spec.,_test_,_spec_}{js,ts,tsx,jsx,mts,cts}",
           "description": "Glob pattern to find test files"
         },
         "bun.test.customFlag": {
@@ -81,14 +83,8 @@
         },
         "bun.test.customScript": {
           "type": "string",
-          "default": "bun test",
+          "default": "",
           "description": "Custom script to use instead of `bun test`, for example script from `package.json`"
-        },
-        "bun.test.enable": {
-          "type": "boolean",
-          "description": "If the test explorer should be enabled and integrated with your editor",
-          "scope": "window",
-          "default": true
         }
       }
     },

packages/bun-vscode/src/features/tests/__tests__/bun-test-controller.static-parser.test.ts

@@ -1,864 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { MockTestController, MockWorkspaceFolder } from "./vscode-types.mock";
-import "./vscode.mock";
-import { makeTestController, makeWorkspaceFolder } from "./vscode.mock";
-
-const { BunTestController } = await import("../bun-test-controller");
-
-const mockTestController: MockTestController = makeTestController();
-const mockWorkspaceFolder: MockWorkspaceFolder = makeWorkspaceFolder("/test/workspace");
-
-const controller = new BunTestController(mockTestController, mockWorkspaceFolder, true);
-const internal = controller._internal;
-
-const { expandEachTests, parseTestBlocks, getBraceDepth } = internal;
-
-describe("BunTestController (static file parser)", () => {
-  describe("expandEachTests", () => {
-    describe("$variable syntax", () => {
-      test("should not expand $variable patterns (Bun behavior)", () => {
-        const content = `test.each([
-          { a: 1, b: 2, expected: 3 },
-          { a: 5, b: 5, expected: 10 }
-        ])('$a + $b = $expected', ({ a, b, expected }) => {})`;
-
-        const result = expandEachTests("test.each([", "$a + $b = $expected", content, 0, "test", 1);
-
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe("$a + $b = $expected");
-      });
-
-      test("should not expand string values with quotes", () => {
-        const content = `test.each([
-          { name: "Alice", city: "NYC" },
-          { name: "Bob", city: "LA" }
-        ])('$name from $city', ({ name, city }) => {})`;
-
-        const result = expandEachTests("test.each([", "$name from $city", content, 0, "test", 1);
-
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe("$name from $city");
-      });
-
-      test("should not expand nested property access", () => {
-        const content = `test.each([
-          { user: { name: "Alice", profile: { city: "NYC" } } },
-          { user: { name: "Bob", profile: { city: "LA" } } }
-        ])('$user.name from $user.profile.city', ({ user }) => {})`;
-
-        const result = expandEachTests("test.each([", "$user.name from $user.profile.city", content, 0, "test", 1);
-
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe("$user.name from $user.profile.city");
-      });
-
-      test("should not expand array indexing", () => {
-        const content = `test.each([
-          { users: [{ name: "Alice" }, { name: "Bob" }] },
-          { users: [{ name: "Carol" }, { name: "Dave" }] }
-        ])('first user: $users.0.name', ({ users }) => {})`;
-
-        const result = expandEachTests("test.each([", "first user: $users.0.name", content, 0, "test", 1);
-
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe("first user: $users.0.name");
-      });
-
-      test("should return template as-is for missing properties", () => {
-        const content = `test.each([
-          { a: 1 },
-          { a: 2 }
-        ])('$a and $missing', ({ a }) => {})`;
-
-        const result = expandEachTests("test.each([", "$a and $missing", content, 0, "test", 1);
-
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe("$a and $missing");
-      });
-
-      test("should handle edge cases with special identifiers", () => {
-        const content = `test.each([
-          { _valid: "ok", $dollar: "yes", _123mix: "mixed" }
-        ])('$_valid | $$dollar | $_123mix', (obj) => {})`;
-
-        const result = expandEachTests("test.each([", "$_valid | $$dollar | $_123mix", content, 0, "test", 1);
-
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe("$_valid | $$dollar | $_123mix");
-      });
-
-      test("should handle invalid identifiers as literals", () => {
-        const content = `test.each([
-          { valid: "test" }
-        ])('$valid | $123invalid | $has-dash', (obj) => {})`;
-
-        const result = expandEachTests("test.each([", "$valid | $123invalid | $has-dash", content, 0, "test", 1);
-
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe("$valid | $123invalid | $has-dash");
-      });
-    });
-
-    describe("% formatters", () => {
-      test("should handle %i for integers", () => {
-        const content = `test.each([
-          [1, 2, 3],
-          [5, 5, 10]
-        ])('%i + %i = %i', (a, b, expected) => {})`;
-
-        const result = expandEachTests("test.each([", "%i + %i = %i", content, 0, "test", 1);
-
-        expect(result).toHaveLength(2);
-        expect(result[0].name).toBe("1 + 2 = 3");
-        expect(result[1].name).toBe("5 + 5 = 10");
-      });
-
-      test("should handle %s for strings", () => {
-        const content = `test.each([
-          ["hello", "world"],
-          ["foo", "bar"]
-        ])('%s %s', (a, b) => {})`;
-
-        const result = expandEachTests("test.each([", "%s %s", content, 0, "test", 1);
-
-        expect(result).toHaveLength(2);
-        expect(result[0].name).toBe("hello world");
-        expect(result[1].name).toBe("foo bar");
-      });
-
-      test("should handle %f and %d for numbers", () => {
-        const content = `test.each([
-          [1.5, 2.7],
-          [3.14, 2.71]
-        ])('%f and %d', (a, b) => {})`;
-
-        const result = expandEachTests("test.each([", "%f and %d", content, 0, "test", 1);
-
-        expect(result).toHaveLength(2);
-        expect(result[0].name).toBe("1.5 and 2.7");
-        expect(result[1].name).toBe("3.14 and 2.71");
-      });
-
-      test("should handle %o and %j for objects", () => {
-        const content = `test.each([
-          [{ a: 1 }, { b: 2 }]
-        ])('%o and %j', (obj1, obj2) => {})`;
-
-        const result = expandEachTests("test.each([", "%o and %j", content, 0, "test", 1);
-
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe("%o and %j");
-      });
-
-      test("should handle %# for index", () => {
-        const content = `test.each([
-          [1, 2],
-          [3, 4],
-          [5, 6]
-        ])('Test #%#: %i + %i', (a, b) => {})`;
-
-        const result = expandEachTests("test.each([", "Test #%#: %i + %i", content, 0, "test", 1);
-
-        expect(result).toHaveLength(3);
-        expect(result[0].name).toBe("Test #1: 1 + 2");
-        expect(result[1].name).toBe("Test #2: 3 + 4");
-        expect(result[2].name).toBe("Test #3: 5 + 6");
-      });
-
-      test("should handle %% for literal percent", () => {
-        const content = `test.each([
-          [50],
-          [100]
-        ])('%i%% complete', (percent) => {})`;
-
-        const result = expandEachTests("test.each([", "%i%% complete", content, 0, "test", 1);
-
-        expect(result).toHaveLength(2);
-        expect(result[0].name).toBe("50% complete");
-        expect(result[1].name).toBe("100% complete");
-      });
-    });
-
-    describe("describe.each", () => {
-      test("should work with describe.each", () => {
-        const content = `describe.each([
-          { module: "fs", method: "readFile" },
-          { module: "path", method: "join" }
-        ])('$module module', ({ module, method }) => {})`;
-
-        const result = expandEachTests("describe.each([", "$module module", content, 0, "describe", 1);
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe("$module module");
-        expect(result[0].type).toBe("describe");
-      });
-    });
-
-    describe("error handling", () => {
-      test("should handle non-.each tests", () => {
-        const result = expandEachTests("test", "regular test", "test('regular test', () => {})", 0, "test", 1);
-
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe("regular test");
-      });
-
-      test("should handle malformed JSON", () => {
-        const content = `test.each([
-          { invalid json }
-        ])('test', () => {})`;
-
-        const result = expandEachTests("test.each([", "test", content, 0, "test", 1);
-
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe("test");
-      });
-
-      test("should handle non-array values", () => {
-        const content = `test.each({ not: "array" })('test', () => {})`;
-
-        const result = expandEachTests("test.each([", "test", content, 0, "test", 1);
-
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe("test");
-      });
-    });
-
-    describe("mixed formatters", () => {
-      test("should handle both $ and % in objects", () => {
-        const content = `test.each([
-          { name: "Test", index: 0 }
-        ])('$name #%#', (obj) => {})`;
-
-        const result = expandEachTests("test.each([", "$name #%#", content, 0, "test", 1);
-
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe("$name #%#");
-      });
-    });
-
-    describe("edge cases", () => {
-      test("should handle complex nested objects", () => {
-        const content = `test.each([
-          { 
-            user: { 
-              profile: { 
-                address: { 
-                  city: "NYC", 
-                  coords: { lat: 40.7128, lng: -74.0060 } 
-                } 
-              } 
-            } 
-          }
-        ])('User from $user.profile.address.city at $user.profile.address.coords.lat', ({ user }) => {})`;
-
-        const result = expandEachTests(
-          "test.each([",
-          "User from $user.profile.address.city at $user.profile.address.coords.lat",
-          content,
-          0,
-          "test",
-          1,
-        );
-
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe("User from $user.profile.address.city at $user.profile.address.coords.lat");
-      });
-
-      test("should handle arrays with inline comments", () => {
-        const content = `test.each([
-          { a: 1 }, // first test
-          { a: 2 }, // second test
-          // { a: 3 }, // commented out test
-          { a: 4 } /* final test */
-        ])('test $a', ({ a }) => {})`;
-
-        const result = expandEachTests("test.each([", "test $a", content, 0, "test", 1);
-
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe("test $a");
-      });
-
-      test("should handle arrays with multiline comments", () => {
-        const content = `test.each([
-          { name: "test1" },
-          /* This is a
-             multiline comment
-             that spans several lines */
-          { name: "test2" },
-          /**
-           * JSDoc style comment
-           * with multiple lines
-           */
-          { name: "test3" }
-        ])('$name', ({ name }) => {})`;
-
-        const result = expandEachTests("test.each([", "$name", content, 0, "test", 1);
-
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe("$name");
-      });
-
-      test("should handle malformed array syntax gracefully", () => {
-        const content = `test.each([
-          { a: 1 },
-          { a: 2,,, }, // extra commas
-          { a: 3, }, // trailing comma
-          { a: 4 },,, // extra trailing commas
-        ])('test $a', ({ a }) => {})`;
-
-        const result = expandEachTests("test.each([", "test $a", content, 0, "test", 1);
-
-        expect(result.length).toBeGreaterThanOrEqual(1);
-      });
-
-      test("should handle strings with comment-like content", () => {
-        const content = `test.each([
-          { comment: "// this is not a comment" },
-          { comment: "/* neither is this */" },
-          { url: "https://example.com/path" }
-        ])('Test: $comment $url', (data) => {})`;
-
-        const result = expandEachTests("test.each([", "Test: $comment $url", content, 0, "test", 1);
-
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe("Test: $comment $url");
-      });
-
-      test("should handle special characters in strings", () => {
-        const content = `test.each([
-          { char: "\\n" },
-          { char: "\\t" },
-          { char: "\\"" },
-          { char: "\\'" },
-          { char: "\\\\" },
-          { char: "\`" }
-        ])('Special char: $char', ({ char }) => {})`;
-
-        const result = expandEachTests("test.each([", "Special char: $char", content, 0, "test", 1);
-
-        expect(result.length).toBeGreaterThanOrEqual(1);
-      });
-
-      test("should handle empty arrays", () => {
-        const content = `test.each([])('should handle empty', () => {})`;
-
-        const result = expandEachTests("test.each([", "should handle empty", content, 0, "test", 1);
-
-        expect(result).toHaveLength(0);
-      });
-
-      test("should handle undefined and null values", () => {
-        const content = `test.each([
-          { value: undefined },
-          { value: null },
-          { value: false },
-          { value: 0 },
-          { value: "" }
-        ])('Value: $value', ({ value }) => {})`;
-
-        const result = expandEachTests("test.each([", "Value: $value", content, 0, "test", 1);
-
-        if (result.length === 1) {
-          expect(result[0].name).toBe("Value: $value");
-        } else {
-          expect(result).toHaveLength(5);
-          expect(result[0].name).toBe("Value: undefined");
-          expect(result[1].name).toBe("Value: null");
-          expect(result[2].name).toBe("Value: false");
-          expect(result[3].name).toBe("Value: 0");
-          expect(result[4].name).toBe("Value: ");
-        }
-      });
-
-      test("should handle circular references gracefully", () => {
-        const content = `test.each([
-          { a: { b: "[Circular]" } },
-          { a: { b: { c: "[Circular]" } } }
-        ])('Circular: $a.b', ({ a }) => {})`;
-
-        const result = expandEachTests("test.each([", "Circular: $a.b", content, 0, "test", 1);
-
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe("Circular: $a.b");
-      });
-
-      test("should handle very long property paths", () => {
-        const content = `test.each([
-          { 
-            a: { 
-              b: { 
-                c: { 
-                  d: { 
-                    e: { 
-                      f: { 
-                        g: "deeply nested" 
-                      } 
-                    } 
-                  } 
-                } 
-              } 
-            } 
-          }
-        ])('Value: $a.b.c.d.e.f.g', (data) => {})`;
-
-        const result = expandEachTests("test.each([", "Value: $a.b.c.d.e.f.g", content, 0, "test", 1);
-
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe("Value: $a.b.c.d.e.f.g");
-      });
-
-      test("should handle syntax errors in array", () => {
-        const content = `test.each([
-          { a: 1 }
-          { a: 2 } // missing comma
-          { a: 3 }
-        ])('test $a', ({ a }) => {})`;
-
-        const result = expandEachTests("test.each([", "test $a", content, 0, "test", 1);
-
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe("test $a");
-      });
-
-      test("should handle arrays with trailing commas", () => {
-        const content = `test.each([
-          { a: 1 },
-          { a: 2 },
-        ])('test $a', ({ a }) => {})`;
-
-        const result = expandEachTests("test.each([", "test $a", content, 0, "test", 1);
-
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe("test $a");
-      });
-
-      test("should handle mixed data types in arrays", () => {
-        const content = `test.each([
-          ["string", 123, true, null, undefined],
-          [{ obj: true }, [1, 2, 3], new Date("2024-01-01")]
-        ])('test %s %i %s %s %s', (...args) => {})`;
-
-        const result = expandEachTests("test.each([", "test %s %i %s %s %s", content, 0, "test", 1);
-
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe("test %s %i %s %s %s");
-      });
-
-      test("should handle regex-like strings", () => {
-        const content = `test.each([
-          { pattern: "/^test.*$/" },
-          { pattern: "\\\\d{3}-\\\\d{4}" },
-          { pattern: "[a-zA-Z]+" }
-        ])('Pattern: $pattern', ({ pattern }) => {})`;
-
-        const result = expandEachTests("test.each([", "Pattern: $pattern", content, 0, "test", 1);
-
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe("Pattern: $pattern");
-      });
-
-      test("should handle invalid property access gracefully", () => {
-        const content = `test.each([
-          { a: { b: null } },
-          { a: null },
-          { },
-          { a: { } }
-        ])('Access: $a.b.c.d', (data) => {})`;
-
-        const result = expandEachTests("test.each([", "Access: $a.b.c.d", content, 0, "test", 1);
-
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe("Access: $a.b.c.d");
-      });
-
-      test("should handle object methods and computed properties", () => {
-        const content = `test.each([
-          { fn: function() {}, method() {}, arrow: () => {} },
-          { ["computed"]: "value", [Symbol.for("sym")]: "symbol" }
-        ])('Object with methods', (obj) => {})`;
-
-        const result = expandEachTests("test.each([", "Object with methods", content, 0, "test", 1);
-
-        expect(result.length).toBeGreaterThanOrEqual(1);
-      });
-    });
-  });
-
-  describe("parseTestBlocks", () => {
-    test("should parse simple test blocks", () => {
-      const content = `
-        test("should add numbers", () => {
-          expect(1 + 1).toBe(2);
-        });
-        
-        test("should multiply numbers", () => {
-          expect(2 * 3).toBe(6);
-        });
-      `;
-
-      const result = parseTestBlocks(content);
-
-      expect(result).toHaveLength(2);
-      expect(result[0].name).toBe("should add numbers");
-      expect(result[0].type).toBe("test");
-      expect(result[1].name).toBe("should multiply numbers");
-      expect(result[1].type).toBe("test");
-    });
-
-    test("should parse describe blocks with nested tests", () => {
-      const content = `
-        describe("Math operations", () => {
-          test("addition", () => {
-            expect(1 + 1).toBe(2);
-          });
-          
-          test("subtraction", () => {
-            expect(5 - 3).toBe(2);
-          });
-        });
-      `;
-
-      const result = parseTestBlocks(content);
-
-      expect(result).toHaveLength(1);
-      expect(result[0].name).toBe("Math operations");
-      expect(result[0].type).toBe("describe");
-      expect(result[0].children).toHaveLength(2);
-      expect(result[0].children[0].name).toBe("addition");
-      expect(result[0].children[1].name).toBe("subtraction");
-    });
-
-    test("should handle test modifiers", () => {
-      const content = `
-        test.skip("skipped test", () => {});
-        test.todo("todo test", () => {});
-        test.only("only test", () => {});
-        test.failing("failing test", () => {});
-      `;
-
-      const result = parseTestBlocks(content);
-
-      expect(result).toHaveLength(4);
-      expect(result[0].name).toBe("skipped test");
-      expect(result[1].name).toBe("todo test");
-      expect(result[2].name).toBe("only test");
-      expect(result[3].name).toBe("failing test");
-    });
-
-    test("should handle conditional tests", () => {
-      const content = `
-        test.if(true)("conditional test", () => {});
-        test.skipIf(false)("skip if test", () => {});
-        test.todoIf(true)("todo if test", () => {});
-      `;
-
-      const result = parseTestBlocks(content);
-
-      expect(result).toHaveLength(3);
-      expect(result[0].name).toBe("conditional test");
-      expect(result[1].name).toBe("skip if test");
-      expect(result[2].name).toBe("todo if test");
-    });
-
-    test("should ignore comments", () => {
-      const content = `
-        // This is a comment with test("fake test", () => {})
-        /* Multi-line comment
-           test("another fake test", () => {})
-        */
-        test("real test", () => {});
-      `;
-
-      const result = parseTestBlocks(content);
-
-      expect(result).toHaveLength(1);
-      expect(result[0].name).toBe("real test");
-    });
-
-    test("should handle nested describe blocks", () => {
-      const content = `
-        describe("Outer", () => {
-          describe("Inner", () => {
-            test("deeply nested", () => {});
-          });
-          test("shallow test", () => {});
-        });
-      `;
-
-      const result = parseTestBlocks(content);
-
-      expect(result).toHaveLength(1);
-      expect(result[0].name).toBe("Outer");
-      expect(result[0].children).toHaveLength(2);
-      expect(result[0].children[0].name).toBe("Inner");
-      expect(result[0].children[0].children).toHaveLength(1);
-      expect(result[0].children[0].children[0].name).toBe("deeply nested");
-      expect(result[0].children[1].name).toBe("shallow test");
-    });
-
-    test("should handle it() as alias for test()", () => {
-      const content = `
-        it("should work with it", () => {});
-        it.skip("should skip with it", () => {});
-      `;
-
-      const result = parseTestBlocks(content);
-
-      expect(result).toHaveLength(2);
-      expect(result[0].name).toBe("should work with it");
-      expect(result[0].type).toBe("test");
-      expect(result[1].name).toBe("should skip with it");
-    });
-
-    test("should handle different quote types", () => {
-      const content = `
-        test('single quotes', () => {});
-        test("double quotes", () => {});
-        test(\`template literals\`, () => {});
-      `;
-
-      const result = parseTestBlocks(content);
-
-      expect(result).toHaveLength(3);
-      expect(result[0].name).toBe("single quotes");
-      expect(result[1].name).toBe("double quotes");
-      expect(result[2].name).toBe("template literals");
-    });
-
-    test("should handle escaped quotes in test names", () => {
-      const content = `
-        test("test with \\"escaped\\" quotes", () => {});
-        test('test with \\'escaped\\' quotes', () => {});
-      `;
-
-      const result = parseTestBlocks(content);
-
-      expect(result).toHaveLength(2);
-      expect(result[0].name).toBe('test with "escaped" quotes');
-      expect(result[1].name).toBe("test with 'escaped' quotes");
-    });
-
-    test("should handle comments within test names", () => {
-      const content = `
-        test("test with // comment syntax", () => {});
-        test("test with /* comment */ syntax", () => {});
-        test("test with URL https://example.com", () => {});
-      `;
-
-      const result = parseTestBlocks(content);
-
-      expect(result.length).toBeGreaterThanOrEqual(1);
-
-      const hasCommentSyntax = result.some(r => r.name.includes("comment syntax"));
-      const hasURL = result.some(r => r.name.includes("https://example.com"));
-
-      expect(hasCommentSyntax || hasURL).toBe(true);
-    });
-
-    test("should ignore code that looks like tests in strings", () => {
-      const content = `
-        const str = "test('fake test', () => {})";
-        const template = \`describe("fake describe", () => {})\`;
-        
-        // Real test
-        test("real test", () => {
-          const example = 'test("nested fake", () => {})';
-        });
-      `;
-
-      const result = parseTestBlocks(content);
-
-      expect(result.length).toBeGreaterThanOrEqual(1);
-      expect(result.some(r => r.name === "real test")).toBe(true);
-    });
-
-    test("should handle tests with complex modifier chains", () => {
-      const content = `
-        test.skip.failing("skipped failing test", () => {});
-        test.only.todo("only todo test", () => {});
-        describe.skip.each([1, 2])("skip each %i", (n) => {});
-        it.failing.each([{a: 1}])("failing each $a", ({a}) => {});
-      `;
-
-      const result = parseTestBlocks(content);
-
-      expect(result.length).toBeGreaterThan(0);
-    });
-
-    test("should handle weird spacing and formatting", () => {
-      const content = `
-        test  (  "extra spaces"  ,  ( )  =>  {  }  )  ;
-        test
-        (
-          "multiline test"
-          ,
-          (
-          )
-          =>
-          {
-          }
-        )
-        ;
-        test\t(\t"tabs"\t,\t()\t=>\t{}\t);
-      `;
-
-      const result = parseTestBlocks(content);
-
-      expect(result).toHaveLength(3);
-      expect(result[0].name).toBe("extra spaces");
-      expect(result[1].name).toBe("multiline test");
-      expect(result[2].name).toBe("tabs");
-    });
-
-    test("should handle test.each with complex patterns", () => {
-      const content = `
-        test.each([
-          [1, 2, 3],
-          [4, 5, 9]
-        ])("when %i + %i, result should be %i", (a, b, expected) => {});
-        
-        describe.each([
-          { db: "postgres" },
-          { db: "mysql" }
-        ])("Database $db", ({ db }) => {
-          test("should connect", () => {});
-        });
-      `;
-
-      const result = parseTestBlocks(content);
-
-      expect(result).toHaveLength(3);
-      expect(result[0].name).toBe("when 1 + 2, result should be 3");
-      expect(result[0].type).toBe("test");
-      expect(result[1].name).toBe("when 4 + 5, result should be 9");
-      expect(result[1].type).toBe("test");
-      expect(result[2].name).toBe("Database $db");
-      expect(result[2].type).toBe("describe");
-    });
-
-    test("should handle Unicode and emoji in test names", () => {
-      const content = `
-        test("测试中文", () => {});
-        test("テスト日本語", () => {});
-        test("тест русский", () => {});
-        test("🚀 rocket test", () => {});
-        test("Test with 🎉 celebration", () => {});
-      `;
-
-      const result = parseTestBlocks(content);
-
-      expect(result).toHaveLength(5);
-      expect(result[0].name).toBe("测试中文");
-      expect(result[1].name).toBe("テスト日本語");
-      expect(result[2].name).toBe("тест русский");
-      expect(result[3].name).toBe("🚀 rocket test");
-      expect(result[4].name).toBe("Test with 🎉 celebration");
-    });
-
-    test("should handle test names with interpolation-like syntax", () => {
-      const content = `
-        test("test with \${variable}", () => {});
-        test("test with \$dollar", () => {});
-        test("test with %percent", () => {});
-        test(\`template literal test\`, () => {});
-      `;
-
-      const result = parseTestBlocks(content);
-
-      expect(result).toHaveLength(4);
-      expect(result[0].name).toBe("test with ${variable}");
-      expect(result[1].name).toBe("test with $dollar");
-      expect(result[2].name).toBe("test with %percent");
-      expect(result[3].name).toBe("template literal test");
-    });
-
-    test("should handle async/await in test definitions", () => {
-      const content = `
-        test("sync test", () => {});
-        test("async test", async () => {});
-        test("test with await", async () => {
-          await something();
-        });
-        it("async it", async function() {});
-      `;
-
-      const result = parseTestBlocks(content);
-
-      expect(result).toHaveLength(4);
-      expect(result[0].name).toBe("sync test");
-      expect(result[1].name).toBe("async test");
-      expect(result[2].name).toBe("test with await");
-      expect(result[3].name).toBe("async it");
-    });
-
-    test("should handle generator functions and other ES6+ syntax", () => {
-      const content = `
-        test("generator test", function* () {
-          yield 1;
-        });
-        
-        test.each\`
-          a    | b    | expected
-          \${1} | \${1} | \${2}
-          \${1} | \${2} | \${3}
-        \`('$a + $b = $expected', ({ a, b, expected }) => {});
-      `;
-
-      const result = parseTestBlocks(content);
-
-      expect(result.length).toBeGreaterThanOrEqual(1);
-      expect(result[0].name).toBe("generator test");
-    });
-  });
-
-  describe("getBraceDepth", () => {
-    test("should count braces correctly", () => {
-      const content = "{ { } }";
-      expect(getBraceDepth(content, 0, content.length)).toBe(0);
-      expect(getBraceDepth(content, 0, 3)).toBe(2);
-      expect(getBraceDepth(content, 0, 5)).toBe(1);
-    });
-
-    test("should ignore braces in strings", () => {
-      const content = '{ "string with { braces }" }';
-      expect(getBraceDepth(content, 0, content.length)).toBe(0);
-    });
-
-    test("should ignore braces in template literals", () => {
-      const content = "{ `template with { braces }` }";
-      expect(getBraceDepth(content, 0, content.length)).toBe(0);
-    });
-
-    test("should handle escaped quotes", () => {
-      const content = '{ "escaped \\" quote" }';
-      expect(getBraceDepth(content, 0, content.length)).toBe(0);
-    });
-
-    test("should handle mixed quotes", () => {
-      const content = `{ "double" + 'single' + \`template\` }`;
-      expect(getBraceDepth(content, 0, content.length)).toBe(0);
-    });
-
-    test("should handle nested braces", () => {
-      const content = "{ a: { b: { c: 1 } } }";
-      expect(getBraceDepth(content, 0, 10)).toBe(2);
-      expect(getBraceDepth(content, 0, 15)).toBe(3);
-    });
-
-    test("should handle complex template literals", () => {
-      const content = '{ `${foo({ bar: "baz" })} and ${nested.value}` }';
-      expect(getBraceDepth(content, 0, content.length)).toBe(0);
-    });
-
-    test("should handle edge cases", () => {
-      expect(getBraceDepth("", 0, 0)).toBe(0);
-
-      expect(getBraceDepth("{{{}}}", 0, 6)).toBe(0);
-
-      expect(getBraceDepth("{{{", 0, 3)).toBe(3);
-      expect(getBraceDepth("}}}", 0, 3)).toBe(-3);
-
-      const templateContent = "{ `${foo}` + `${bar}` }";
-      expect(getBraceDepth(templateContent, 0, templateContent.length)).toBe(0);
-    });
-  });
-});

packages/bun-vscode/src/features/tests/__tests__/vscode-types.mock.ts

@@ -1,570 +0,0 @@
-/**
- * Mock VSCode types and classes for testing
- * These should be as close as possible to the real VSCode API
- */
-
-export interface MockUri {
-  readonly scheme: string;
-  readonly authority: string;
-  readonly path: string;
-  readonly query: string;
-  readonly fragment: string;
-  readonly fsPath: string;
-  toString(): string;
-}
-
-export class MockUri implements MockUri {
-  constructor(
-    public readonly scheme: string,
-    public readonly authority: string,
-    public readonly path: string,
-    public readonly query: string,
-    public readonly fragment: string,
-    public readonly fsPath: string,
-  ) {}
-
-  static file(path: string): MockUri {
-    return new MockUri("file", "", path, "", "", path);
-  }
-
-  toString(): string {
-    return `${this.scheme}://${this.authority}${this.path}`;
-  }
-}
-
-export class MockPosition {
-  constructor(
-    public readonly line: number,
-    public readonly character: number,
-  ) {}
-}
-
-export class MockRange {
-  constructor(
-    public readonly start: MockPosition,
-    public readonly end: MockPosition,
-  ) {}
-}
-
-export class MockLocation {
-  constructor(
-    public readonly uri: MockUri,
-    public readonly range: MockRange,
-  ) {}
-}
-
-export class MockTestTag {
-  constructor(public readonly id: string) {}
-}
-
-export class MockTestMessage {
-  public location?: MockLocation;
-  public actualOutput?: string;
-  public expectedOutput?: string;
-
-  constructor(public message: string | MockMarkdownString) {}
-
-  static diff(message: string, expected: string, actual: string): MockTestMessage {
-    const msg = new MockTestMessage(message);
-    msg.expectedOutput = expected;
-    msg.actualOutput = actual;
-    return msg;
-  }
-}
-
-export class MockMarkdownString {
-  constructor(public value: string = "") {}
-
-  appendCodeblock(code: string, language?: string): MockMarkdownString {
-    this.value += `\n\`\`\`${language || ""}\n${code}\n\`\`\``;
-    return this;
-  }
-
-  appendMarkdown(value: string): MockMarkdownString {
-    this.value += value;
-    return this;
-  }
-
-  appendText(value: string): MockMarkdownString {
-    this.value += value.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&");
-    return this;
-  }
-}
-
-export interface MockTestItem {
-  readonly id: string;
-  readonly uri?: MockUri;
-  readonly children: MockTestItemCollection;
-  readonly parent?: MockTestItem;
-  label: string;
-  description?: string;
-  tags: readonly MockTestTag[];
-  canResolveChildren: boolean;
-  busy: boolean;
-  range?: MockRange;
-  error?: string | MockMarkdownString;
-}
-
-export interface MockTestItemCollection {
-  readonly size: number;
-  add(item: MockTestItem): void;
-  replace(items: readonly MockTestItem[]): void;
-  forEach(callback: (item: MockTestItem, id: string, collection: MockTestItemCollection) => void): void;
-  get(itemId: string): MockTestItem | undefined;
-  delete(itemId: string): void;
-  [Symbol.iterator](): Iterator<[string, MockTestItem]>;
-}
-
-export class MockTestItemCollection implements MockTestItemCollection {
-  private items = new Map<string, MockTestItem>();
-
-  get size(): number {
-    return this.items.size;
-  }
-
-  add(item: MockTestItem): void {
-    this.items.set(item.id, item);
-  }
-
-  replace(items: readonly MockTestItem[]): void {
-    this.items.clear();
-    for (const item of items) {
-      this.items.set(item.id, item);
-    }
-  }
-
-  forEach(callback: (item: MockTestItem, id: string, collection: MockTestItemCollection) => void): void {
-    this.items.forEach((item, id) => callback(item, id, this));
-  }
-
-  get(itemId: string): MockTestItem | undefined {
-    return this.items.get(itemId);
-  }
-
-  delete(itemId: string): void {
-    this.items.delete(itemId);
-  }
-
-  [Symbol.iterator](): Iterator<[string, MockTestItem]> {
-    return this.items[Symbol.iterator]();
-  }
-
-  clear(): void {
-    this.items.clear();
-  }
-
-  set(id: string, item: MockTestItem): void {
-    this.items.set(id, item);
-  }
-
-  values(): IterableIterator<MockTestItem> {
-    return this.items.values();
-  }
-
-  keys(): IterableIterator<string> {
-    return this.items.keys();
-  }
-
-  entries(): IterableIterator<[string, MockTestItem]> {
-    return this.items.entries();
-  }
-}
-
-export class MockTestItem implements MockTestItem {
-  public canResolveChildren: boolean = false;
-  public busy: boolean = false;
-  public description?: string;
-  public range?: MockRange;
-  public error?: string | MockMarkdownString;
-  public readonly children: MockTestItemCollection;
-
-  constructor(
-    public readonly id: string,
-    public label: string,
-    public readonly uri?: MockUri,
-    public readonly parent?: MockTestItem,
-    public tags: readonly MockTestTag[] = [],
-  ) {
-    this.children = new MockTestItemCollection();
-  }
-}
-
-export interface MockTestController {
-  readonly items: MockTestItemCollection;
-  createTestItem(id: string, label: string, uri?: MockUri): MockTestItem;
-  createRunProfile(
-    label: string,
-    kind: MockTestRunProfileKind,
-    runHandler: (request: MockTestRunRequest, token: MockCancellationToken) => void | Promise<void>,
-    isDefault?: boolean,
-  ): MockTestRunProfile;
-  createTestRun(request: MockTestRunRequest, name?: string, persist?: boolean): MockTestRun;
-  invalidateTestResults(items?: readonly MockTestItem[]): void;
-  resolveHandler?: (item: MockTestItem | undefined) => Promise<void> | void;
-  refreshHandler?: (token?: MockCancellationToken) => Promise<void> | void;
-}
-
-export class MockTestController implements MockTestController {
-  public readonly items: MockTestItemCollection;
-  public resolveHandler?: (item: MockTestItem | undefined) => Promise<void> | void;
-  public refreshHandler?: (token?: MockCancellationToken) => Promise<void> | void;
-
-  constructor(
-    public readonly id: string,
-    public readonly label: string,
-  ) {
-    this.items = new MockTestItemCollection();
-  }
-
-  createTestItem(id: string, label: string, uri?: MockUri): MockTestItem {
-    return new MockTestItem(id, label, uri);
-  }
-
-  createRunProfile(
-    label: string,
-    kind: MockTestRunProfileKind,
-    runHandler: (request: MockTestRunRequest, token: MockCancellationToken) => void | Promise<void>,
-    isDefault?: boolean,
-  ): MockTestRunProfile {
-    return new MockTestRunProfile(label, kind, runHandler, isDefault);
-  }
-
-  createTestRun(request: MockTestRunRequest, name?: string, persist?: boolean): MockTestRun {
-    return new MockTestRun(name, persist);
-  }
-
-  invalidateTestResults(items?: readonly MockTestItem[]): void {
-    // Mock implementation - in real VSCode this would invalidate test results
-  }
-
-  dispose(): void {
-    this.items.clear();
-  }
-}
-
-export enum MockTestRunProfileKind {
-  Run = 1,
-  Debug = 2,
-  Coverage = 3,
-}
-
-export interface MockTestRunProfile {
-  readonly label: string;
-  readonly kind: MockTestRunProfileKind;
-  readonly isDefault: boolean;
-  readonly runHandler: (request: MockTestRunRequest, token: MockCancellationToken) => void | Promise<void>;
-  dispose(): void;
-}
-
-export class MockTestRunProfile implements MockTestRunProfile {
-  constructor(
-    public readonly label: string,
-    public readonly kind: MockTestRunProfileKind,
-    public readonly runHandler: (request: MockTestRunRequest, token: MockCancellationToken) => void | Promise<void>,
-    public readonly isDefault: boolean = false,
-  ) {}
-
-  dispose(): void {
-    // No-op for mock
-  }
-}
-
-export interface MockTestRunRequest {
-  readonly include?: readonly MockTestItem[];
-  readonly exclude?: readonly MockTestItem[];
-  readonly profile?: MockTestRunProfile;
-}
-
-export class MockTestRunRequest implements MockTestRunRequest {
-  constructor(
-    public readonly include?: readonly MockTestItem[],
-    public readonly exclude?: readonly MockTestItem[],
-    public readonly profile?: MockTestRunProfile,
-  ) {}
-}
-
-export interface MockTestRun {
-  readonly name?: string;
-  readonly token: MockCancellationToken;
-  appendOutput(output: string, location?: MockLocation, test?: MockTestItem): void;
-  end(): void;
-  enqueued(test: MockTestItem): void;
-  errored(test: MockTestItem, message: MockTestMessage | readonly MockTestMessage[], duration?: number): void;
-  failed(test: MockTestItem, message: MockTestMessage | readonly MockTestMessage[], duration?: number): void;
-  passed(test: MockTestItem, duration?: number): void;
-  skipped(test: MockTestItem): void;
-  started(test: MockTestItem): void;
-}
-
-export class MockTestRun implements MockTestRun {
-  public readonly token: MockCancellationToken;
-  private _ended: boolean = false;
-
-  constructor(
-    public readonly name?: string,
-    public readonly persist: boolean = true,
-  ) {
-    this.token = new MockCancellationToken();
-  }
-
-  appendOutput(output: string, location?: MockLocation, test?: MockTestItem): void {
-    if (this._ended) return;
-    // For mock, just store output - in real VS Code this would appear in test output
-  }
-
-  end(): void {
-    this._ended = true;
-  }
-
-  enqueued(test: MockTestItem): void {
-    if (this._ended) return;
-    // Mock implementation
-  }
-
-  errored(test: MockTestItem, message: MockTestMessage | readonly MockTestMessage[], duration?: number): void {
-    if (this._ended) return;
-    // Mock implementation
-  }
-
-  failed(test: MockTestItem, message: MockTestMessage | readonly MockTestMessage[], duration?: number): void {
-    if (this._ended) return;
-    // Mock implementation
-  }
-
-  passed(test: MockTestItem, duration?: number): void {
-    if (this._ended) return;
-    // Mock implementation
-  }
-
-  skipped(test: MockTestItem): void {
-    if (this._ended) return;
-    // Mock implementation
-  }
-
-  started(test: MockTestItem): void {
-    if (this._ended) return;
-    // Mock implementation
-  }
-}
-
-export interface MockCancellationToken {
-  readonly isCancellationRequested: boolean;
-  onCancellationRequested(listener: () => void): MockDisposable;
-}
-
-export class MockCancellationToken implements MockCancellationToken {
-  private _isCancellationRequested: boolean = false;
-  private _listeners: (() => void)[] = [];
-
-  get isCancellationRequested(): boolean {
-    return this._isCancellationRequested;
-  }
-
-  onCancellationRequested(listener: () => void): MockDisposable {
-    this._listeners.push(listener);
-    return new MockDisposable(() => {
-      const index = this._listeners.indexOf(listener);
-      if (index >= 0) {
-        this._listeners.splice(index, 1);
-      }
-    });
-  }
-
-  cancel(): void {
-    this._isCancellationRequested = true;
-    this._listeners.forEach(listener => listener());
-  }
-}
-
-export interface MockDisposable {
-  dispose(): void;
-}
-
-export class MockDisposable implements MockDisposable {
-  constructor(private readonly disposeFunc?: () => void) {}
-
-  dispose(): void {
-    this.disposeFunc?.();
-  }
-}
-
-export interface MockTextDocument {
-  readonly uri: MockUri;
-  readonly fileName: string;
-  readonly isUntitled: boolean;
-  readonly languageId: string;
-  readonly version: number;
-  readonly isDirty: boolean;
-  readonly isClosed: boolean;
-  readonly eol: MockEndOfLine;
-  readonly lineCount: number;
-  getText(range?: MockRange): string;
-  getWordRangeAtPosition(position: MockPosition, regex?: RegExp): MockRange | undefined;
-  lineAt(line: number | MockPosition): MockTextLine;
-  offsetAt(position: MockPosition): number;
-  positionAt(offset: number): MockPosition;
-  save(): Promise<boolean>;
-  validatePosition(position: MockPosition): MockPosition;
-  validateRange(range: MockRange): MockRange;
-}
-
-export enum MockEndOfLine {
-  LF = 1,
-  CRLF = 2,
-}
-
-export interface MockTextLine {
-  readonly lineNumber: number;
-  readonly text: string;
-  readonly range: MockRange;
-  readonly rangeIncludingLineBreak: MockRange;
-  readonly firstNonWhitespaceCharacterIndex: number;
-  readonly isEmptyOrWhitespace: boolean;
-}
-
-export interface MockWorkspaceFolder {
-  readonly uri: MockUri;
-  readonly name: string;
-  readonly index: number;
-}
-
-export class MockWorkspaceFolder implements MockWorkspaceFolder {
-  constructor(
-    public readonly uri: MockUri,
-    public readonly name: string,
-    public readonly index: number = 0,
-  ) {}
-}
-
-export interface MockFileSystemWatcher extends MockDisposable {
-  readonly ignoreCreateEvents: boolean;
-  readonly ignoreChangeEvents: boolean;
-  readonly ignoreDeleteEvents: boolean;
-  onDidCreate(listener: (uri: MockUri) => void): MockDisposable;
-  onDidChange(listener: (uri: MockUri) => void): MockDisposable;
-  onDidDelete(listener: (uri: MockUri) => void): MockDisposable;
-}
-
-export class MockFileSystemWatcher implements MockFileSystemWatcher {
-  public readonly ignoreCreateEvents: boolean = false;
-  public readonly ignoreChangeEvents: boolean = false;
-  public readonly ignoreDeleteEvents: boolean = false;
-
-  private _createListeners: ((uri: MockUri) => void)[] = [];
-  private _changeListeners: ((uri: MockUri) => void)[] = [];
-  private _deleteListeners: ((uri: MockUri) => void)[] = [];
-
-  onDidCreate(listener: (uri: MockUri) => void): MockDisposable {
-    this._createListeners.push(listener);
-    return new MockDisposable(() => {
-      const index = this._createListeners.indexOf(listener);
-      if (index >= 0) this._createListeners.splice(index, 1);
-    });
-  }
-
-  onDidChange(listener: (uri: MockUri) => void): MockDisposable {
-    this._changeListeners.push(listener);
-    return new MockDisposable(() => {
-      const index = this._changeListeners.indexOf(listener);
-      if (index >= 0) this._changeListeners.splice(index, 1);
-    });
-  }
-
-  onDidDelete(listener: (uri: MockUri) => void): MockDisposable {
-    this._deleteListeners.push(listener);
-    return new MockDisposable(() => {
-      const index = this._deleteListeners.indexOf(listener);
-      if (index >= 0) this._deleteListeners.splice(index, 1);
-    });
-  }
-
-  dispose(): void {
-    this._createListeners.length = 0;
-    this._changeListeners.length = 0;
-    this._deleteListeners.length = 0;
-  }
-
-  // Helper methods for testing
-  triggerCreate(uri: MockUri): void {
-    this._createListeners.forEach(listener => listener(uri));
-  }
-
-  triggerChange(uri: MockUri): void {
-    this._changeListeners.forEach(listener => listener(uri));
-  }
-
-  triggerDelete(uri: MockUri): void {
-    this._deleteListeners.forEach(listener => listener(uri));
-  }
-}
-
-export interface MockRelativePattern {
-  readonly base: string;
-  readonly pattern: string;
-}
-
-export class MockRelativePattern implements MockRelativePattern {
-  constructor(
-    public readonly base: string | MockWorkspaceFolder,
-    public readonly pattern: string,
-  ) {}
-
-  get baseUri(): MockUri {
-    if (typeof this.base === "string") {
-      return MockUri.file(this.base);
-    }
-    return this.base.uri;
-  }
-}
-
-export interface MockConfiguration {
-  get<T>(section: string, defaultValue?: T): T | undefined;
-  has(section: string): boolean;
-  inspect<T>(section: string): MockConfigurationInspect<T> | undefined;
-  update(section: string, value: any, configurationTarget?: MockConfigurationTarget): Promise<void>;
-}
-
-export interface MockConfigurationInspect<T> {
-  readonly key: string;
-  readonly defaultValue?: T;
-  readonly globalValue?: T;
-  readonly workspaceValue?: T;
-  readonly workspaceFolderValue?: T;
-}
-
-export enum MockConfigurationTarget {
-  Global = 1,
-  Workspace = 2,
-  WorkspaceFolder = 3,
-}
-
-export class MockConfiguration implements MockConfiguration {
-  private _values = new Map<string, any>();
-
-  get<T>(section: string, defaultValue?: T): T | undefined {
-    return this._values.get(section) ?? defaultValue;
-  }
-
-  has(section: string): boolean {
-    return this._values.has(section);
-  }
-
-  inspect<T>(section: string): MockConfigurationInspect<T> | undefined {
-    return {
-      key: section,
-      defaultValue: undefined,
-      globalValue: this._values.get(section),
-      workspaceValue: undefined,
-      workspaceFolderValue: undefined,
-    };
-  }
-
-  async update(section: string, value: any, configurationTarget?: MockConfigurationTarget): Promise<void> {
-    this._values.set(section, value);
-  }
-
-  // Helper for testing
-  setValue(section: string, value: any): void {
-    this._values.set(section, value);
-  }
-}

packages/bun-vscode/src/features/tests/__tests__/vscode.mock.ts

@@ -1,56 +0,0 @@
-import { mock } from "bun:test";
-import {
-  MockConfiguration,
-  MockDisposable,
-  MockFileSystemWatcher,
-  MockLocation,
-  MockMarkdownString,
-  MockPosition,
-  MockRange,
-  MockRelativePattern,
-  MockTestController,
-  MockTestMessage,
-  MockTestRunProfileKind,
-  MockTestTag,
-  MockUri,
-  MockWorkspaceFolder,
-} from "./vscode-types.mock";
-
-mock.module("vscode", () => ({
-  window: {
-    createOutputChannel: () => ({
-      appendLine: () => {},
-    }),
-    visibleTextEditors: [],
-  },
-  workspace: {
-    getConfiguration: (section?: string) => new MockConfiguration(),
-    onDidOpenTextDocument: () => new MockDisposable(),
-    textDocuments: [],
-    createFileSystemWatcher: (pattern: string | MockRelativePattern) => new MockFileSystemWatcher(),
-    findFiles: async (include: string, exclude?: string, maxResults?: number, token?: any) => {
-      return []; // Mock implementation
-    },
-  },
-  Uri: MockUri,
-  TestTag: MockTestTag,
-  Position: MockPosition,
-  Range: MockRange,
-  Location: MockLocation,
-  TestMessage: MockTestMessage,
-  MarkdownString: MockMarkdownString,
-  TestRunProfileKind: MockTestRunProfileKind,
-  RelativePattern: MockRelativePattern,
-  debug: {
-    addBreakpoints: () => {},
-    startDebugging: async () => true,
-  },
-}));
-
-export function makeTestController(): MockTestController {
-  return new MockTestController("test-controller", "Test Controller");
-}
-
-export function makeWorkspaceFolder(path: string): MockWorkspaceFolder {
-  return new MockWorkspaceFolder(MockUri.file(path), path.split("/").pop() || "workspace", 0);
-}

packages/bun-vscode/src/features/tests/bun-test-controller.ts

@@ -17,7 +17,7 @@ export const debug = vscode.window.createOutputChannel("Bun - Test Runner");
 
 export type TestNode = {
   name: string;
-  type: "describe" | "test";
+  type: "describe" | "test" | "it";
   line: number;
   children: TestNode[];
   parent?: TestNode;
@@ -51,15 +51,11 @@ export class BunTestController implements vscode.Disposable {
   private currentRunType: "file" | "individual" = "file";
   private requestedTestIds: Set<string> = new Set();
   private discoveredTestIds: Set<string> = new Set();
-  private executedTestCount: number = 0;
-  private totalTestsStarted: number = 0;
 
   constructor(
     private readonly testController: vscode.TestController,
     private readonly workspaceFolder: vscode.WorkspaceFolder,
-    readonly isTest: boolean = false,
   ) {
-    if (isTest) return;
     this.setupTestController();
     this.setupWatchers();
     this.setupOpenDocumentListener();
@@ -71,7 +67,10 @@ export class BunTestController implements vscode.Disposable {
     try {
       this.signal = await this.createSignal();
       await this.signal.ready;
+      debug.appendLine(`Signal initialized at: ${this.signal.url}`);
+
       this.signal.on("Signal.Socket.connect", (socket: net.Socket) => {
+        debug.appendLine("Bun connected to signal socket");
         this.handleSocketConnection(socket, this.currentRun!);
       });
 
@@ -90,9 +89,8 @@ export class BunTestController implements vscode.Disposable {
     };
 
     this.testController.refreshHandler = async token => {
-      const files = await this.discoverInitialTests(token, false);
+      const files = await this.discoverInitialTests(token);
       if (!files?.length) return;
-      if (token.isCancellationRequested) return;
 
       const filePaths = new Set(files.map(f => f.fsPath));
       for (const [, testItem] of this.testController.items) {
@@ -136,21 +134,15 @@ export class BunTestController implements vscode.Disposable {
   }
 
   private isTestFile(document: vscode.TextDocument): boolean {
-    return (
-      document?.uri?.scheme === "file" && /\.(test|spec)\.(js|jsx|ts|tsx|cjs|mjs|mts|cts)$/.test(document.uri.fsPath)
-    );
+    return document?.uri?.scheme === "file" && /\.(test|spec)\.(js|jsx|ts|tsx|cjs|mts)$/.test(document.uri.fsPath);
   }
 
-  private async discoverInitialTests(
-    cancellationToken?: vscode.CancellationToken,
-    reset: boolean = true,
-  ): Promise<vscode.Uri[] | undefined> {
+  private async discoverInitialTests(cancellationToken?: vscode.CancellationToken): Promise<vscode.Uri[] | undefined> {
     try {
       const tests = await this.findTestFiles(cancellationToken);
-      this.createFileTestItems(tests, reset);
+      this.createFileTestItems(tests);
       return tests;
-    } catch (error) {
-      debug.appendLine(`Error in discoverInitialTests: ${error}`);
+    } catch {
       return undefined;
     }
   }
@@ -187,8 +179,6 @@ export class BunTestController implements vscode.Disposable {
     const ignoreGlobs = new Set(["**/node_modules/**"]);
 
     for (const ignore of ignores) {
-      if (cancellationToken?.isCancellationRequested) return [];
-
       try {
         const content = await fs.readFile(ignore.fsPath, { encoding: "utf8" });
         const lines = content
@@ -205,15 +195,13 @@ export class BunTestController implements vscode.Disposable {
             ignoreGlobs.add(path.join(cwd.trim(), line.trim()));
           }
         }
-      } catch {
-        debug.appendLine(`Error in buildIgnoreGlobs: ${ignore.fsPath}`);
-      }
+      } catch {}
     }
 
     return [...ignoreGlobs.values()];
   }
 
-  private createFileTestItems(files: vscode.Uri[], reset: boolean = true): void {
+  private createFileTestItems(files: vscode.Uri[]): void {
     if (files.length === 0) {
       return;
     }
@@ -226,9 +214,7 @@ export class BunTestController implements vscode.Disposable {
           path.relative(this.workspaceFolder.uri.fsPath, file.fsPath) || file.fsPath,
           file,
         );
-        if (reset) {
-          fileTestItem.children.replace([]);
-        }
+        fileTestItem.children.replace([]);
         fileTestItem.canResolveChildren = true;
         this.testController.items.add(fileTestItem);
       }
@@ -288,13 +274,7 @@ export class BunTestController implements vscode.Disposable {
     return { bunCommand, testArgs };
   }
 
-  private async discoverTests(
-    testItem?: vscode.TestItem | false,
-    filePath?: string,
-    cancellationToken?: vscode.CancellationToken,
-  ): Promise<void> {
-    if (cancellationToken?.isCancellationRequested) return;
-
+  private async discoverTests(testItem?: vscode.TestItem | false, filePath?: string): Promise<void> {
     let targetPath = filePath;
     if (!targetPath && testItem) {
       targetPath = testItem?.uri?.fsPath || this.workspaceFolder.uri.fsPath;
@@ -317,24 +297,17 @@ export class BunTestController implements vscode.Disposable {
         );
         this.testController.items.add(fileTestItem);
       }
-      if (!this.currentRun) {
-        fileTestItem.children.replace([]);
-      }
+      fileTestItem.children.replace([]);
       fileTestItem.canResolveChildren = false;
 
       this.addTestNodes(testNodes, fileTestItem, targetPath);
-    } catch {
-      debug.appendLine(`Error in discoverTests: ${targetPath}`);
-    }
+    } catch {}
   }
 
   private parseTestBlocks(fileContent: string): TestNode[] {
     const cleanContent = fileContent
       .replace(/\/\*[\s\S]*?\*\//g, match => match.replace(/[^\n\r]/g, " "))
-      .replace(/('(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*`)|\/\/.*$/gm, (match, str) => {
-        if (str) return str;
-        return " ".repeat(match.length);
-      });
+      .replace(/\/\/.*$/gm, match => " ".repeat(match.length));
 
     const testRegex =
       /\b(describe|test|it)(?:\.(?:skip|todo|failing|only))?(?:\.(?:if|todoIf|skipIf)\s*\([^)]*\))?(?:\.each\s*\([^)]*\))?\s*\(\s*(['"`])((?:\\\2|.)*?)\2\s*(?:,|\))/g;
@@ -346,7 +319,6 @@ export class BunTestController implements vscode.Disposable {
     match = testRegex.exec(cleanContent);
     while (match !== null) {
       const [full, type, , name] = match;
-      const _type = type === "it" ? "test" : type;
       const line = cleanContent.slice(0, match.index).split("\n").length - 1;
 
       while (
@@ -357,14 +329,7 @@ export class BunTestController implements vscode.Disposable {
         stack.pop();
       }
 
-      const expandedNodes = this.expandEachTests(
-        full,
-        name,
-        cleanContent,
-        match.index,
-        _type as TestNode["type"],
-        line,
-      );
+      const expandedNodes = this.expandEachTests(full, name, cleanContent, match.index, type as TestNode["type"], line);
 
       for (const node of expandedNodes) {
         if (stack.length === 0) {
@@ -468,16 +433,16 @@ export class BunTestController implements vscode.Disposable {
         throw new Error("Not an array");
       }
 
-      return eachValues.map((val, testIndex) => {
-        let testName = name.replace(/%%/g, "%").replace(/%#/g, (testIndex + 1).toString());
+      return eachValues.map(val => {
+        let testName = name;
         if (Array.isArray(val)) {
           let idx = 0;
-          testName = testName.replace(/%[isfdojp#%]/g, () => {
+          testName = testName.replace(/%[isfd]/g, () => {
             const v = val[idx++];
             return typeof v === "object" ? JSON.stringify(v) : String(v);
           });
         } else {
-          testName = testName.replace(/%[isfdojp#%]/g, () => {
+          testName = testName.replace(/%[isfd]/g, () => {
             return typeof val === "object" ? JSON.stringify(val) : String(val);
           });
         }
@@ -510,22 +475,19 @@ export class BunTestController implements vscode.Disposable {
         : this.escapeTestName(node.name);
       const testId = `${filePath}#${nodePath}`;
 
-      let testItem = parent.children.get(testId);
-      if (!testItem) {
-        testItem = this.testController.createTestItem(testId, this.stripAnsi(node.name), vscode.Uri.file(filePath));
+      const testItem = this.testController.createTestItem(testId, this.stripAnsi(node.name), vscode.Uri.file(filePath));
 
-        if (node.type) testItem.tags = [new vscode.TestTag(node.type)];
+      testItem.tags = [new vscode.TestTag(node.type === "describe" ? "describe" : "test")];
 
-        if (typeof node.line === "number") {
-          testItem.range = new vscode.Range(
-            new vscode.Position(node.line, 0),
-            new vscode.Position(node.line, node.name.length),
-          );
-        }
-
-        parent.children.add(testItem);
+      if (typeof node.line === "number") {
+        testItem.range = new vscode.Range(
+          new vscode.Position(node.line, 0),
+          new vscode.Position(node.line, node.name.length),
+        );
       }
 
+      parent.children.add(testItem);
+
       if (node.children.length > 0) {
         this.addTestNodes(node.children, testItem, filePath, nodePath);
       }
@@ -538,7 +500,7 @@ export class BunTestController implements vscode.Disposable {
   }
 
   private escapeTestName(source: string): string {
-    return source.replace(/[^\w \-\u0080-\uFFFF]/g, "\\$&");
+    return source.replace(/[^a-zA-Z0-9_\ ]/g, "\\$&");
   }
 
   private async createSignal(): Promise<UnixSignal | TCPSocketSignal> {
@@ -555,23 +517,6 @@ export class BunTestController implements vscode.Disposable {
     token: vscode.CancellationToken,
     isDebug: boolean,
   ): Promise<void> {
-    if (this.currentRun) {
-      this.closeAllActiveProcesses();
-      this.disconnectInspector();
-      if (this.currentRun) {
-        this.currentRun.appendOutput("\n\x1b[33mCancelled: Starting new test run\x1b[0m\n");
-        this.currentRun.end();
-        this.currentRun = null;
-      }
-    }
-    this.totalTestsStarted++;
-    if (this.totalTestsStarted > 15) {
-      this.closeAllActiveProcesses();
-      this.disconnectInspector();
-      this.signal?.close();
-      this.signal = null;
-    }
-
     const run = this.testController.createTestRun(request);
 
     token.onCancellationRequested(() => {
@@ -580,14 +525,6 @@ export class BunTestController implements vscode.Disposable {
       this.disconnectInspector();
     });
 
-    if ("onDidDispose" in run) {
-      (run.onDidDispose as vscode.Event<void>)(() => {
-        run?.end?.();
-        this.closeAllActiveProcesses();
-        this.disconnectInspector();
-      });
-    }
-
     const queue: vscode.TestItem[] = [];
 
     if (request.include) {
@@ -610,9 +547,7 @@ export class BunTestController implements vscode.Disposable {
       await this.runTestsWithInspector(queue, run, token);
     } catch (error) {
       for (const test of queue) {
-        const msg = new vscode.TestMessage(`Error: ${error}`);
-        msg.location = new vscode.Location(test.uri!, test.range || new vscode.Range(0, 0, 0, 0));
-        run.errored(test, msg);
+        run.errored(test, new vscode.TestMessage(`Error: ${error}`));
       }
     } finally {
       run.end();
@@ -622,11 +557,8 @@ export class BunTestController implements vscode.Disposable {
   private async runTestsWithInspector(
     tests: vscode.TestItem[],
     run: vscode.TestRun,
-    token: vscode.CancellationToken,
+    _token: vscode.CancellationToken,
   ): Promise<void> {
-    const time = performance.now();
-    if (token.isCancellationRequested) return;
-
     this.disconnectInspector();
 
     const allFiles = new Set<string>();
@@ -637,20 +569,13 @@ export class BunTestController implements vscode.Disposable {
     }
 
     if (allFiles.size === 0) {
-      const errorMsg = "No test files found to run.";
-      run.appendOutput(`\x1b[31mError: ${errorMsg}\x1b[0m\n`);
-      for (const test of tests) {
-        const msg = new vscode.TestMessage(errorMsg);
-        msg.location = new vscode.Location(test.uri!, test.range || new vscode.Range(0, 0, 0, 0));
-        run.errored(test, msg);
-      }
-      throw new Error(errorMsg);
+      run.appendOutput("No test files found to run.\n");
+      return;
     }
 
     for (const test of tests) {
-      if (token.isCancellationRequested) return;
       if (test.uri && test.canResolveChildren) {
-        await this.discoverTests(test, undefined, token);
+        await this.discoverTests(test);
       }
     }
 
@@ -659,7 +584,6 @@ export class BunTestController implements vscode.Disposable {
 
     this.requestedTestIds.clear();
     this.discoveredTestIds.clear();
-    this.executedTestCount = 0;
     for (const test of tests) {
       this.requestedTestIds.add(test.id);
     }
@@ -683,38 +607,21 @@ export class BunTestController implements vscode.Disposable {
         resolve();
       };
 
-      const handleCancel = () => {
-        clearTimeout(timeout);
-        this.signal!.off("Signal.Socket.connect", handleConnect);
-        reject(new Error("Test run cancelled"));
-      };
-      token.onCancellationRequested(handleCancel);
-
       this.signal!.once("Signal.Socket.connect", handleConnect);
     });
 
     const { bunCommand, testArgs } = this.getBunExecutionConfig();
-
-    let args = [...testArgs, ...allFiles];
-    let printedArgs = `\x1b[34;1m>\x1b[0m \x1b[34;1m${bunCommand} ${testArgs.join(" ")}\x1b[2m`;
-
-    for (const file of allFiles) {
-      const f = path.relative(this.workspaceFolder.uri.fsPath, file) || file;
-      if (f.includes(" ")) {
-        printedArgs += ` ".${path.sep}${f}"`;
-      } else {
-        printedArgs += ` .${path.sep}${f}`;
-      }
-    }
+    let args = [...testArgs, ...Array.from(allFiles)];
 
     if (isIndividualTestRun) {
       const pattern = this.buildTestNamePattern(tests);
       if (pattern) {
-        args.push("--test-name-pattern", pattern);
-        printedArgs += `\x1b[0m\x1b[2m --test-name-pattern "${pattern}"\x1b[0m`;
+        args.push("--test-name-pattern", process.platform === "win32" ? `"${pattern}"` : pattern);
       }
     }
-    run.appendOutput(printedArgs + "\x1b[0m\r\n\r\n");
+
+    run.appendOutput(`\r\n\x1b[34m>\x1b[0m \x1b[2m${bunCommand} ${args.join(" ")}\x1b[0m\r\n\r\n`);
+    args.push(`--inspect-wait=${this.signal!.url}`);
 
     for (const test of tests) {
       if (isIndividualTestRun || tests.length === 1) {
@@ -724,52 +631,34 @@ export class BunTestController implements vscode.Disposable {
       }
     }
 
-    let inspectorUrl: string | undefined =
-      this.signal.url.startsWith("ws") || this.signal.url.startsWith("tcp")
-        ? `${this.signal!.url}?wait=1`
-        : `${this.signal!.url}`;
-
-    // right now there isnt a way to tell socket method to wait for the connection
-    if (!inspectorUrl?.includes("?wait=1")) {
-      args.push(`--inspect-wait=${this.signal!.url}`);
-      inspectorUrl = undefined;
-    }
-
     const proc = spawn(bunCommand, args, {
       cwd: this.workspaceFolder.uri.fsPath,
       env: {
+        ...process.env,
         BUN_DEBUG_QUIET_LOGS: "1",
         FORCE_COLOR: "1",
-        BUN_INSPECT: inspectorUrl,
-        ...process.env,
+        NO_COLOR: "0",
       },
     });
 
     this.activeProcesses.add(proc);
 
-    let stdout = "";
-
     proc.on("exit", (code, signal) => {
-      if (code !== 0 && code !== 1) {
-        debug.appendLine(`Test process failed: exit ${code}, signal ${signal}`);
-      }
+      debug.appendLine(`Process exited with code ${code}, signal ${signal}`);
     });
 
     proc.on("error", error => {
-      stdout += `Process error: ${error.message}\n`;
       debug.appendLine(`Process error: ${error.message}`);
     });
 
     proc.stdout?.on("data", data => {
       const dataStr = data.toString();
-      stdout += dataStr;
       const formattedOutput = dataStr.replace(/\n/g, "\r\n");
       run.appendOutput(formattedOutput);
     });
 
     proc.stderr?.on("data", data => {
       const dataStr = data.toString();
-      stdout += dataStr;
       const formattedOutput = dataStr.replace(/\n/g, "\r\n");
       run.appendOutput(formattedOutput);
     });
@@ -777,57 +666,35 @@ export class BunTestController implements vscode.Disposable {
     try {
       await socketPromise;
     } catch (error) {
-      debug.appendLine(`Connection failed: ${error} (URL: ${this.signal!.url})`);
+      debug.appendLine(`Failed to establish inspector connection: ${error}`);
+      debug.appendLine(`Signal URL was: ${this.signal!.url}`);
+      debug.appendLine(`Command was: ${bunCommand} ${args.join(" ")}`);
       throw error;
     }
 
     await new Promise<void>((resolve, reject) => {
-      const handleClose = (code: number | null) => {
+      proc.on("close", code => {
         this.activeProcesses.delete(proc);
         if (code === 0 || code === 1) {
           resolve();
         } else {
-          reject(new Error(`Process exited with code ${code}. Please check the console for more details.`));
+          reject(new Error(`Process exited with code ${code}`));
         }
-      };
+      });
 
-      const handleError = (error: Error) => {
+      proc.on("error", error => {
         this.activeProcesses.delete(proc);
         reject(error);
-      };
-
-      const handleCancel = () => {
-        proc.kill("SIGTERM");
-        this.activeProcesses.delete(proc);
-        reject(new Error("Test run cancelled"));
-      };
-
-      proc.on("close", handleClose);
-      proc.on("error", handleError);
-
-      token.onCancellationRequested(handleCancel);
+      });
     }).finally(() => {
-      if (this.discoveredTestIds.size === 0) {
-        const errorMsg =
-          "No tests were executed. This could mean:\r\n- All tests were filtered out\r\n- The test runner crashed before running tests\r\n- No tests match the pattern";
-        run.appendOutput(`\n\x1b[31m\x1b[1mError:\x1b[0m\x1b[31m ${errorMsg}\x1b[0m\n`);
-
-        for (const test of tests) {
-          if (!this.testResultHistory.has(test.id)) {
-            const msg = new vscode.TestMessage(errorMsg + "\n\n----------\n" + stdout + "\n----------\n");
-            msg.location = new vscode.Location(test.uri!, test.range || new vscode.Range(0, 0, 0, 0));
-            run.errored(test, msg);
-          }
-        }
+      if (isIndividualTestRun) {
+        this.applyPreviousResults(tests, run);
       }
 
-      if (this.discoveredTestIds.size > 0 && this.executedTestCount > 0) {
-        if (isIndividualTestRun) {
-          this.applyPreviousResults(tests, run);
-          this.cleanupUndiscoveredTests(tests);
-        } else {
-          this.cleanupStaleTests(tests);
-        }
+      if (isIndividualTestRun) {
+        this.cleanupUndiscoveredTests(tests);
+      } else {
+        this.cleanupStaleTests(tests);
       }
 
       if (this.activeProcesses.has(proc)) {
@@ -837,7 +704,6 @@ export class BunTestController implements vscode.Disposable {
 
       this.disconnectInspector();
       this.currentRun = null;
-      debug.appendLine(`Test run completed in ${performance.now() - time}ms`);
     });
   }
 
@@ -859,7 +725,7 @@ export class BunTestController implements vscode.Disposable {
             run.passed(item, previousResult.duration);
             break;
           case "failed":
-            run.failed(item, [], previousResult.duration);
+            run.failed(item, previousResult.message || new vscode.TestMessage("Test failed"), previousResult.duration);
             break;
           case "skipped":
             run.skipped(item);
@@ -897,11 +763,16 @@ export class BunTestController implements vscode.Disposable {
       this.handleLifecycleError(event, run);
     });
 
+    this.debugAdapter.on("Inspector.event", e => {
+      debug.appendLine(`Received inspector event: ${e.method}`);
+    });
+
     this.debugAdapter.on("Inspector.error", e => {
       debug.appendLine(`Inspector error: ${e}`);
     });
 
     socket.on("close", () => {
+      debug.appendLine("Inspector connection closed");
       this.debugAdapter = null;
     });
 
@@ -928,6 +799,7 @@ export class BunTestController implements vscode.Disposable {
     const { id: inspectorTestId, url: sourceURL, name, type, parentId, line } = params;
 
     if (!sourceURL) {
+      debug.appendLine(`Warning: Test found without URL: ${name}`);
       return;
     }
 
@@ -942,6 +814,8 @@ export class BunTestController implements vscode.Disposable {
       this.inspectorToVSCode.set(inspectorTestId, testItem);
       this.vscodeToInspector.set(testItem.id, inspectorTestId);
       this.discoveredTestIds.add(testItem.id);
+    } else {
+      debug.appendLine(`Could not find VS Code test item for: ${name} in ${path.basename(filePath)}`);
     }
   }
 
@@ -1057,7 +931,6 @@ export class BunTestController implements vscode.Disposable {
     if (!testItem) return;
 
     const duration = elapsed / 1000000;
-    this.executedTestCount++;
 
     if (
       this.currentRunType === "individual" &&
@@ -1086,6 +959,7 @@ export class BunTestController implements vscode.Disposable {
         break;
       case "skip":
       case "todo":
+      case "skipped_because_label":
         run.skipped(testItem);
         this.testResultHistory.set(testItem.id, { status: "skipped" });
         break;
@@ -1096,8 +970,6 @@ export class BunTestController implements vscode.Disposable {
         run.failed(testItem, timeoutMsg, duration);
         this.testResultHistory.set(testItem.id, { status: "failed", message: timeoutMsg, duration });
         break;
-      case "skipped_because_label":
-        break;
     }
   }
 
@@ -1206,10 +1078,7 @@ export class BunTestController implements vscode.Disposable {
     const lines = messageLinesRaw;
 
     const errorLine = lines[0].trim();
-    const messageLines = lines
-      .slice(1)
-      .filter(line => line.trim())
-      .join("\n");
+    const messageLines = lines.slice(1).join("\n");
 
     const errorType = errorLine.replace(/^(E|e)rror: /, "").trim();
 
@@ -1221,8 +1090,8 @@ export class BunTestController implements vscode.Disposable {
         const regex = /^Expected:\s*([\s\S]*?)\nReceived:\s*([\s\S]*?)$/;
         let testMessage = vscode.TestMessage.diff(
           errorLine,
-          messageLines.trim().match(regex)?.[1].trim() || "",
-          messageLines.trim().match(regex)?.[2].trim() || "",
+          messageLines.match(regex)?.[1].trim() || "",
+          messageLines.match(regex)?.[2].trim() || "",
         );
         if (!messageLines.match(regex)) {
           const code = messageLines
@@ -1284,7 +1153,7 @@ export class BunTestController implements vscode.Disposable {
       lastEffortMsg = lastEffortMsg.reverse();
     }
 
-    const msg = errorType.startsWith("expect")
+    const msg = errorLine.startsWith("error: expect")
       ? `${lastEffortMsg.join("\n")}\n${errorLine.trim()}`.trim()
       : `${errorLine.trim()}\n${messageLines}`.trim();
 
@@ -1332,15 +1201,12 @@ export class BunTestController implements vscode.Disposable {
 
       t = t.replaceAll(/\$\{[^}]+\}/g, ".*?");
       t = t.replaceAll(/\\\$\\\{[^}]+\\\}/g, ".*?");
-      t = t.replaceAll(/\\%[isfdojp#%]|(\\%)|(\\#)/g, ".*?");
-      t = t.replaceAll(/\$[\w\.\[\]]+/g, ".*?");
+      t = t.replaceAll(/\\%[isfd]/g, ".*?");
 
-      if (test?.tags?.some(tag => tag.id === "test" || tag.id === "it")) {
+      if (test.tags.some(tag => tag.id === "test" || tag.id === "it")) {
         testNames.push(`^ ${t}$`);
-      } else if (test?.tags?.some(tag => tag.id === "describe")) {
-        testNames.push(`^ ${t} `);
       } else {
-        testNames.push(t);
+        testNames.push(`^ ${t} `);
       }
     }
 
@@ -1376,13 +1242,7 @@ export class BunTestController implements vscode.Disposable {
     const isIndividualTestRun = this.shouldUseTestNamePattern(tests);
 
     if (testFiles.size === 0) {
-      const errorMsg = "No test files found to debug.";
-      run.appendOutput(`\x1b[31mError: ${errorMsg}\x1b[0m\n`);
-      for (const test of tests) {
-        const msg = new vscode.TestMessage(errorMsg);
-        msg.location = new vscode.Location(test.uri!, test.range || new vscode.Range(0, 0, 0, 0));
-        run.errored(test, msg);
-      }
+      run.appendOutput("No test files found to debug.\n");
       run.end();
       return;
     }
@@ -1408,7 +1268,7 @@ export class BunTestController implements vscode.Disposable {
 
       const pattern = this.buildTestNamePattern(tests);
       if (pattern) {
-        args.push("--test-name-pattern", pattern);
+        args.push("--test-name-pattern", process.platform === "win32" ? `"${pattern}"` : pattern);
       }
     }
 
@@ -1429,12 +1289,9 @@ export class BunTestController implements vscode.Disposable {
       if (!res) throw new Error("Failed to start debugging session");
     } catch (error) {
       for (const test of tests) {
-        const msg = new vscode.TestMessage(`Error starting debugger: ${error}`);
-        msg.location = new vscode.Location(test.uri!, test.range || new vscode.Range(0, 0, 0, 0));
-        run.errored(test, msg);
+        run.errored(test, new vscode.TestMessage(`Error starting debugger: ${error}`));
       }
     }
-    run.appendOutput("\n\x1b[33mDebug session started. Please open the debug console to see its output.\x1b[0m\r\n");
     run.end();
   }
 
@@ -1461,32 +1318,6 @@ export class BunTestController implements vscode.Disposable {
     }
     this.disposables = [];
   }
-
-  // a sus way to expose internal functions to the test suite
-  public get _internal() {
-    return {
-      expandEachTests: this.expandEachTests.bind(this),
-      parseTestBlocks: this.parseTestBlocks.bind(this),
-      getBraceDepth: this.getBraceDepth.bind(this),
-
-      buildTestNamePattern: this.buildTestNamePattern.bind(this),
-      stripAnsi: this.stripAnsi.bind(this),
-      processErrorData: this.processErrorData.bind(this),
-      escapeTestName: this.escapeTestName.bind(this),
-      shouldUseTestNamePattern: this.shouldUseTestNamePattern.bind(this),
-
-      isTestFile: this.isTestFile.bind(this),
-      customFilePattern: this.customFilePattern.bind(this),
-      getBunExecutionConfig: this.getBunExecutionConfig.bind(this),
-
-      findTestByPath: this.findTestByPath.bind(this),
-      findTestByName: this.findTestByName.bind(this),
-      createTestItem: this.createTestItem.bind(this),
-
-      createErrorMessage: this.createErrorMessage.bind(this),
-      cleanupTestItem: this.cleanupTestItem.bind(this),
-    };
-  }
 }
 
 function windowsVscodeUri(uri: string): string {

packages/bun-vscode/src/features/tests/index.ts

@@ -7,14 +7,8 @@ export async function registerTests(context: vscode.ExtensionContext) {
     return;
   }
 
-  const config = vscode.workspace.getConfiguration("bun.test");
-  const enable = config.get<boolean>("enable", true);
-  if (!enable) {
-    return;
-  }
-
   try {
-    const controller = vscode.tests.createTestController("bun", "Bun Tests");
+    const controller = vscode.tests.createTestController("bun-tests", "Bun Tests");
     context.subscriptions.push(controller);
 
     const bunTestController = new BunTestController(controller, workspaceFolder);

patches/libarchive/CMakeLists.txt.patch

@@ -2,8 +2,8 @@
 +++ CMakeLists.txt
 @@ -1,5 +1,5 @@
  #
--cmake_minimum_required(VERSION 3.17 FATAL_ERROR)
-+cmake_minimum_required(VERSION 3.17...3.30 FATAL_ERROR)
- 
- PROJECT(libarchive C)
- #
+-CMAKE_MINIMUM_REQUIRED(VERSION 2.8.12 FATAL_ERROR)
++CMAKE_MINIMUM_REQUIRED(VERSION 2.8.12...3.5 FATAL_ERROR)
+ if(POLICY CMP0065)
+   cmake_policy(SET CMP0065 NEW) #3.4 don't use `-rdynamic` with executables
+ endif()

patches/libarchive/archive_write_add_filter_gzip.c.patch

@@ -1,29 +1,22 @@
---- a/libarchive/archive_write_add_filter_gzip.c	2025-07-21 06:29:58.505101515 +0000
-+++ b/libarchive/archive_write_add_filter_gzip.c	2025-07-21 06:44:09.023676935 +0000
-@@ -59,12 +59,13 @@
+--- a/libarchive/archive_write_add_filter_gzip.c
++++ b/libarchive/archive_write_add_filter_gzip.c
+@@ -58,6 +58,7 @@ archive_write_set_compression_gzip(struct archive *a)
+ struct private_data {
  	int		 compression_level;
  	int		 timestamp;
- 	char	*original_filename;
-+	unsigned char	 os;
++	unsigned char 	os;
  #ifdef HAVE_ZLIB_H
  	z_stream	 stream;
  	int64_t		 total_in;
- 	unsigned char	*compressed;
- 	size_t		 compressed_buffer_size;
--	unsigned long	 crc;
-+	uint32_t	 crc;
- #else
- 	struct archive_write_program_data *pdata;
- #endif
-@@ -108,6 +109,7 @@
+@@ -106,6 +107,7 @@ archive_write_add_filter_gzip(struct archive *_a)
+ 		archive_set_error(&a->archive, ENOMEM, "Out of memory");
  		return (ARCHIVE_FATAL);
  	}
- 	f->data = data;
 +	data->os = 3; /* default Unix */
+ 	f->data = data;
  	f->open = &archive_compressor_gzip_open;
  	f->options = &archive_compressor_gzip_options;
- 	f->close = &archive_compressor_gzip_close;
-@@ -177,6 +179,30 @@
+@@ -166,6 +168,30 @@ archive_compressor_gzip_options(struct archive_write_filter *f, const char *key,
  		return (ARCHIVE_OK);
  	}
  
@@ -54,7 +47,7 @@
  	/* Note: The "warn" return is just to inform the options
  	 * supervisor that we didn't handle it.  It will generate
  	 * a suitable error if no one used this option. */
-@@ -236,7 +262,7 @@
+@@ -226,7 +252,7 @@ archive_compressor_gzip_open(struct archive_write_filter *f)
  	    data->compressed[8] = 4;
      else
  	    data->compressed[8] = 0;

scripts/debug-coredump.ts

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import { parseArgs } from "node:util";
 
 // usage: bun debug-coredump.ts
@@ -44,8 +44,8 @@ if (!fs.existsSync(join(dir, "bun-profile")) || !fs.existsSync(join(dir, `bun-${
   await Bun.$`bash -c ${`age -d -i <(echo "$AGE_CORES_IDENTITY")`} < ${cores} | tar -zxvC ${dir}`;
 
   console.log("moving cores out of nested directory");
-  for await (const file of new Bun.Glob("bun-cores-*/*.core").scan(dir)) {
-    fs.renameSync(join(dir, file), join(dir, `bun-${pid}.core`));
+  for await (const file of new Bun.Glob("bun-cores-*/bun-*.core").scan(dir)) {
+    fs.renameSync(join(dir, file), join(dir, basename(file)));
   }
 } else {
   console.log(`already downloaded in ${dir}`);

scripts/glob-sources.mjs

@@ -20,7 +20,7 @@ async function globSources(output, patterns, excludes = []) {
 
   const sources =
     paths
-      .map(path => normalize(relative(root, path).replaceAll("\\", "/")))
+      .map(path => normalize(relative(root, path)))
       .sort((a, b) => a.localeCompare(b))
       .join("\n")
       .trim() + "\n";

scripts/p-limit.mjs

@@ -1,109 +0,0 @@
-/**
- * p-limit@6.2.0
- * https://github.com/sindresorhus/p-limit
- * MIT (c) Sindre Sorhus
- */
-
-import Queue from "./yocto-queue.mjs";
-
-export default function pLimit(concurrency) {
-  validateConcurrency(concurrency);
-
-  const queue = new Queue();
-  let activeCount = 0;
-
-  const resumeNext = () => {
-    if (activeCount < concurrency && queue.size > 0) {
-      queue.dequeue()();
-      // Since `pendingCount` has been decreased by one, increase `activeCount` by one.
-      activeCount++;
-    }
-  };
-
-  const next = () => {
-    activeCount--;
-
-    resumeNext();
-  };
-
-  const run = async (function_, resolve, arguments_) => {
-    const result = (async () => function_(...arguments_))();
-
-    resolve(result);
-
-    try {
-      await result;
-    } catch {}
-
-    next();
-  };
-
-  const enqueue = (function_, resolve, arguments_) => {
-    // Queue `internalResolve` instead of the `run` function
-    // to preserve asynchronous context.
-    new Promise(internalResolve => {
-      queue.enqueue(internalResolve);
-    }).then(run.bind(undefined, function_, resolve, arguments_));
-
-    (async () => {
-      // This function needs to wait until the next microtask before comparing
-      // `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
-      // after the `internalResolve` function is dequeued and called. The comparison in the if-statement
-      // needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
-      await Promise.resolve();
-
-      if (activeCount < concurrency) {
-        resumeNext();
-      }
-    })();
-  };
-
-  const generator = (function_, ...arguments_) =>
-    new Promise(resolve => {
-      enqueue(function_, resolve, arguments_);
-    });
-
-  Object.defineProperties(generator, {
-    activeCount: {
-      get: () => activeCount,
-    },
-    pendingCount: {
-      get: () => queue.size,
-    },
-    clearQueue: {
-      value() {
-        queue.clear();
-      },
-    },
-    concurrency: {
-      get: () => concurrency,
-
-      set(newConcurrency) {
-        validateConcurrency(newConcurrency);
-        concurrency = newConcurrency;
-
-        queueMicrotask(() => {
-          // eslint-disable-next-line no-unmodified-loop-condition
-          while (activeCount < concurrency && queue.size > 0) {
-            resumeNext();
-          }
-        });
-      },
-    },
-  });
-
-  return generator;
-}
-
-export function limitFunction(function_, option) {
-  const { concurrency } = option;
-  const limit = pLimit(concurrency);
-
-  return (...arguments_) => limit(() => function_(...arguments_));
-}
-
-function validateConcurrency(concurrency) {
-  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
-    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
-  }
-}

scripts/runner.node.mjs

@@ -28,10 +28,9 @@ import {
   writeFileSync,
 } from "node:fs";
 import { readFile } from "node:fs/promises";
-import { availableParallelism, userInfo } from "node:os";
+import { userInfo } from "node:os";
 import { basename, dirname, extname, join, relative, sep } from "node:path";
 import { parseArgs } from "node:util";
-import pLimit from "./p-limit.mjs";
 import {
   getAbi,
   getAbiVersion,
@@ -64,7 +63,6 @@ import {
   unzip,
   uploadArtifact,
 } from "./utils.mjs";
-
 let isQuiet = false;
 const cwd = import.meta.dirname ? dirname(import.meta.dirname) : process.cwd();
 const testsPath = join(cwd, "test");
@@ -155,10 +153,6 @@ const { values: options, positionals: filters } = parseArgs({
       type: "boolean",
       default: isBuildkite && isLinux,
     },
-    ["parallel"]: {
-      type: "boolean",
-      default: false,
-    },
   },
 });
 
@@ -347,10 +341,6 @@ async function runTests() {
   const failedResults = [];
   const maxAttempts = 1 + (parseInt(options["retries"]) || 0);
 
-  const parallelism = options["parallel"] ? availableParallelism() : 1;
-  console.log("parallelism", parallelism);
-  const limit = pLimit(parallelism);
-
   /**
    * @param {string} title
    * @param {function} fn
@@ -365,15 +355,12 @@ async function runTests() {
         await new Promise(resolve => setTimeout(resolve, 5000 + Math.random() * 10_000));
       }
 
-      let grouptitle = `${getAnsi("gray")}[${index}/${total}]${getAnsi("reset")} ${title}`;
-      if (attempt > 1) grouptitle += ` ${getAnsi("gray")}[attempt #${attempt}]${getAnsi("reset")}`;
-
-      if (parallelism > 1) {
-        console.log(grouptitle);
-        result = await fn();
-      } else {
-        result = await startGroup(grouptitle, fn);
-      }
+      result = await startGroup(
+        attempt === 1
+          ? `${getAnsi("gray")}[${index}/${total}]${getAnsi("reset")} ${title}`
+          : `${getAnsi("gray")}[${index}/${total}]${getAnsi("reset")} ${title} ${getAnsi("gray")}[attempt #${attempt}]${getAnsi("reset")}`,
+        fn,
+      );
 
       const { ok, stdoutPreview, error } = result;
       if (ok) {
@@ -388,7 +375,6 @@ async function runTests() {
       const color = attempt >= maxAttempts ? "red" : "yellow";
       const label = `${getAnsi(color)}[${index}/${total}] ${title} - ${error}${getAnsi("reset")}`;
       startGroup(label, () => {
-        if (parallelism > 1) return;
         process.stderr.write(stdoutPreview);
       });
 
@@ -448,62 +434,48 @@ async function runTests() {
   }
 
   if (!failedResults.length) {
-    await Promise.all(
-      tests.map(testPath =>
-        limit(() => {
-          const absoluteTestPath = join(testsPath, testPath);
-          const title = relative(cwd, absoluteTestPath).replaceAll(sep, "/");
-          if (isNodeTest(testPath)) {
-            const testContent = readFileSync(absoluteTestPath, "utf-8");
-            const runWithBunTest =
-              title.includes("needs-test") || testContent.includes("bun:test") || testContent.includes("node:test");
-            const subcommand = runWithBunTest ? "test" : "run";
-            const env = {
-              FORCE_COLOR: "0",
-              NO_COLOR: "1",
-              BUN_DEBUG_QUIET_LOGS: "1",
-            };
-            if ((basename(execPath).includes("asan") || !isCI) && shouldValidateExceptions(testPath)) {
-              env.BUN_JSC_validateExceptionChecks = "1";
-            }
-            return runTest(title, async () => {
-              const { ok, error, stdout } = await spawnBun(execPath, {
-                cwd: cwd,
-                args: [
-                  subcommand,
-                  "--config=" + join(import.meta.dirname, "../bunfig.node-test.toml"),
-                  absoluteTestPath,
-                ],
-                timeout: getNodeParallelTestTimeout(title),
-                env,
-                stdout: parallelism > 1 ? () => {} : chunk => pipeTestStdout(process.stdout, chunk),
-                stderr: parallelism > 1 ? () => {} : chunk => pipeTestStdout(process.stderr, chunk),
-              });
-              const mb = 1024 ** 3;
-              const stdoutPreview = stdout.slice(0, mb).split("\n").slice(0, 50).join("\n");
-              return {
-                testPath: title,
-                ok: ok,
-                status: ok ? "pass" : "fail",
-                error: error,
-                errors: [],
-                tests: [],
-                stdout: stdout,
-                stdoutPreview: stdoutPreview,
-              };
-            });
-          } else {
-            return runTest(title, async () =>
-              spawnBunTest(execPath, join("test", testPath), {
-                cwd,
-                stdout: parallelism > 1 ? () => {} : chunk => pipeTestStdout(process.stdout, chunk),
-                stderr: parallelism > 1 ? () => {} : chunk => pipeTestStdout(process.stderr, chunk),
-              }),
-            );
-          }
-        }),
-      ),
-    );
+    for (const testPath of tests) {
+      const absoluteTestPath = join(testsPath, testPath);
+      const title = relative(cwd, absoluteTestPath).replaceAll(sep, "/");
+      if (isNodeTest(testPath)) {
+        const testContent = readFileSync(absoluteTestPath, "utf-8");
+        const runWithBunTest =
+          title.includes("needs-test") || testContent.includes("bun:test") || testContent.includes("node:test");
+        const subcommand = runWithBunTest ? "test" : "run";
+        const env = {
+          FORCE_COLOR: "0",
+          NO_COLOR: "1",
+          BUN_DEBUG_QUIET_LOGS: "1",
+        };
+        if ((basename(execPath).includes("asan") || !isCI) && shouldValidateExceptions(testPath)) {
+          env.BUN_JSC_validateExceptionChecks = "1";
+        }
+        await runTest(title, async () => {
+          const { ok, error, stdout } = await spawnBun(execPath, {
+            cwd: cwd,
+            args: [subcommand, "--config=" + join(import.meta.dirname, "../bunfig.node-test.toml"), absoluteTestPath],
+            timeout: getNodeParallelTestTimeout(title),
+            env,
+            stdout: chunk => pipeTestStdout(process.stdout, chunk),
+            stderr: chunk => pipeTestStdout(process.stderr, chunk),
+          });
+          const mb = 1024 ** 3;
+          const stdoutPreview = stdout.slice(0, mb).split("\n").slice(0, 50).join("\n");
+          return {
+            testPath: title,
+            ok: ok,
+            status: ok ? "pass" : "fail",
+            error: error,
+            errors: [],
+            tests: [],
+            stdout: stdout,
+            stdoutPreview: stdoutPreview,
+          };
+        });
+      } else {
+        await runTest(title, async () => spawnBunTest(execPath, join("test", testPath)));
+      }
+    }
   }
 
   if (vendorTests?.length) {
@@ -1087,7 +1059,7 @@ async function spawnBunTest(execPath, testPath, options = { cwd }) {
   const env = {
     GITHUB_ACTIONS: "true", // always true so annotations are parsed
   };
-  if ((basename(execPath).includes("asan") || !isCI) && shouldValidateExceptions(relative(cwd, absPath))) {
+  if (basename(execPath).includes("asan") && shouldValidateExceptions(relative(cwd, absPath))) {
     env.BUN_JSC_validateExceptionChecks = "1";
   }
 
@@ -1096,8 +1068,8 @@ async function spawnBunTest(execPath, testPath, options = { cwd }) {
     cwd: options["cwd"],
     timeout: isReallyTest ? timeout : 30_000,
     env,
-    stdout: options.stdout,
-    stderr: options.stderr,
+    stdout: chunk => pipeTestStdout(process.stdout, chunk),
+    stderr: chunk => pipeTestStdout(process.stderr, chunk),
   });
   const { tests, errors, stdout: stdoutPreview } = parseTestStdout(stdout, testPath);
 

scripts/sortImports.ts

@@ -1,4 +1,3 @@
-#!/usr/bin/env bun
 import { readdirSync } from "fs";
 import path from "path";
 
@@ -17,9 +16,10 @@ const usage = String.raw`
 Usage: bun scripts/sortImports [options] <files...>
 
 Options:
-  --help         Show this help message
-  --include-pub  Also sort ${"`pub`"} imports
-  --keep-unused  Don't remove unused imports
+  --help                   Show this help message
+  --no-include-pub         Exclude pub imports from sorting
+  --no-remove-unused       Don't remove unused imports
+  --include-unsorted       Process files even if they don't have @sortImports marker
 
 Examples:
   bun scripts/sortImports src
@@ -34,9 +34,9 @@ if (filePaths.length === 0) {
 }
 
 const config = {
-  includePub: args.includes("--include-pub"),
-  removeUnused: !args.includes("--keep-unused"),
-  normalizePaths: "./",
+  includePub: !args.includes("--no-include-pub"),
+  removeUnused: !args.includes("--no-remove-unused"),
+  includeUnsorted: args.includes("--include-unsorted"),
 };
 
 // Type definitions
@@ -68,11 +68,11 @@ function parseDeclarations(
     const line = lines[i];
 
     if (line === "// @sortImports") {
-      lines[i] = DELETED_LINE;
+      lines[i] = "";
       continue;
     }
 
-    const inlineDeclPattern = /^(?:pub )?const ([a-zA-Z0-9_]+) = (.+);(\s*\/\/[^\n]*)?$/;
+    const inlineDeclPattern = /^(?:pub )?const ([a-zA-Z0-9_]+) = (.+);$/;
     const match = line.match(inlineDeclPattern);
 
     if (!match) continue;
@@ -275,6 +275,8 @@ function sortGroupsAndDeclarations(groups: Map<string, Group>): string[] {
 // Generate the sorted output
 function generateSortedOutput(lines: string[], groups: Map<string, Group>, sortedGroupKeys: string[]): string[] {
   const outputLines = [...lines];
+  outputLines.push("");
+  outputLines.push("// @sortImports");
 
   for (const groupKey of sortedGroupKeys) {
     const groupDeclarations = groups.get(groupKey)!;
@@ -286,36 +288,22 @@ function generateSortedOutput(lines: string[], groups: Map<string, Group>, sorte
     // Add declarations to output and mark original lines for removal
     for (const declaration of groupDeclarations.declarations) {
       outputLines.push(declaration.whole);
-      outputLines[declaration.index] = DELETED_LINE;
+      outputLines[declaration.index] = "";
     }
   }
 
   return outputLines;
 }
 
-function extractThisDeclaration(declarations: Map<string, Declaration>): Declaration | null {
-  for (const declaration of declarations.values()) {
-    if (declaration.value === "@This()") {
-      declarations.delete(declaration.key);
-      return declaration;
-    }
-  }
-  return null;
-}
-
-const DELETED_LINE = "%DELETED_LINE%";
-
 // Main execution function for a single file
 async function processFile(filePath: string): Promise<void> {
   const originalFileContents = await Bun.file(filePath).text();
   let fileContents = originalFileContents;
 
-  if (config.normalizePaths === "") {
-    fileContents = fileContents.replaceAll(`@import("./`, `@import("`);
-  } else if (config.normalizePaths === "./") {
-    fileContents = fileContents.replaceAll(/@import\("([A-Za-z0-9_-][^"]*\.zig)"\)/g, '@import("./$1")');
-    fileContents = fileContents.replaceAll(`@import("./../`, `@import("../`);
+  if (!config.includeUnsorted && !originalFileContents.includes("// @sortImports")) {
+    return;
   }
+  console.log(`Processing: ${filePath}`);
 
   let needsRecurse = true;
   while (needsRecurse) {
@@ -324,7 +312,6 @@ async function processFile(filePath: string): Promise<void> {
     const lines = fileContents.split("\n");
 
     const { declarations, unusedLineIndices } = parseDeclarations(lines, fileContents);
-    const thisDeclaration = extractThisDeclaration(declarations);
     const groups = groupDeclarationsByImportPath(declarations);
 
     promoteItemsWithChildGroups(groups);
@@ -336,33 +323,13 @@ async function processFile(filePath: string): Promise<void> {
     // Remove unused declarations
     if (config.removeUnused) {
       for (const line of unusedLineIndices) {
-        sortedLines[line] = DELETED_LINE;
+        sortedLines[line] = "";
         needsRecurse = true;
       }
     }
-    if (thisDeclaration) {
-      sortedLines[thisDeclaration.index] = DELETED_LINE;
-    }
-    if (thisDeclaration) {
-      let firstNonFileCommentLine = 0;
-      for (const line of sortedLines) {
-        if (line.startsWith("//!")) {
-          firstNonFileCommentLine++;
-        } else {
-          break;
-        }
-      }
-      const insert = [thisDeclaration.whole, ""];
-      if (firstNonFileCommentLine > 0) insert.unshift("");
-      sortedLines.splice(firstNonFileCommentLine, 0, ...insert);
-    }
     fileContents = sortedLines.join("\n");
   }
 
-  // Remove deleted lines
-  fileContents = fileContents.replaceAll(DELETED_LINE + "\n", "");
-  // fileContents = fileContents.replaceAll(DELETED_LINE, ""); // any remaining lines
-
   // Remove any leading newlines
   fileContents = fileContents.replace(/^\n+/, "");
 
@@ -376,6 +343,7 @@ async function processFile(filePath: string): Promise<void> {
   if (fileContents === "\n") fileContents = "";
 
   if (fileContents === originalFileContents) {
+    console.log(`✓ No changes: ${filePath}`);
     return;
   }
 
@@ -401,7 +369,7 @@ async function main() {
           successCount++;
         } catch (error) {
           errorCount++;
-          console.error(`Failed to process ${path.join(filePath, file)}:\n`, error);
+          console.error(`Failed to process ${filePath}`);
         }
       }
       continue;
@@ -412,7 +380,7 @@ async function main() {
       successCount++;
     } catch (error) {
       errorCount++;
-      console.error(`Failed to process ${filePath}:\n`, error);
+      console.error(`Failed to process ${filePath}`);
     }
   }
 

scripts/utils.mjs

@@ -2850,14 +2850,6 @@ export function printEnvironment() {
         }
       });
     }
-    if (isLinux) {
-      startGroup("Memory", () => {
-        const shell = which(["sh", "bash"]);
-        if (shell) {
-          spawnSync([shell, "-c", "free -m -w"], { stdio: "inherit" });
-        }
-      });
-    }
     if (isWindows) {
       startGroup("Disk (win)", () => {
         const shell = which(["pwsh"]);
@@ -2865,14 +2857,6 @@ export function printEnvironment() {
           spawnSync([shell, "-c", "get-psdrive"], { stdio: "inherit" });
         }
       });
-      startGroup("Memory", () => {
-        const shell = which(["pwsh"]);
-        if (shell) {
-          spawnSync([shell, "-c", "Get-Counter '\\Memory\\Available MBytes'"], { stdio: "inherit" });
-          console.log();
-          spawnSync([shell, "-c", "Get-CimInstance Win32_PhysicalMemory"], { stdio: "inherit" });
-        }
-      });
     }
   }
 

scripts/yocto-queue.mjs

@@ -1,90 +0,0 @@
-/**
- * yocto-queue@1.2.1
- * https://github.com/sindresorhus/yocto-queue
- * MIT (c) Sindre Sorhus
- */
-
-/*
-How it works:
-`this.#head` is an instance of `Node` which keeps track of its current value and nests another instance of `Node` that keeps the value that comes after it. When a value is provided to `.enqueue()`, the code needs to iterate through `this.#head`, going deeper and deeper to find the last value. However, iterating through every single item is slow. This problem is solved by saving a reference to the last value as `this.#tail` so that it can reference it to add a new value.
-*/
-
-class Node {
-  value;
-  next;
-
-  constructor(value) {
-    this.value = value;
-  }
-}
-
-export default class Queue {
-  #head;
-  #tail;
-  #size;
-
-  constructor() {
-    this.clear();
-  }
-
-  enqueue(value) {
-    const node = new Node(value);
-
-    if (this.#head) {
-      this.#tail.next = node;
-      this.#tail = node;
-    } else {
-      this.#head = node;
-      this.#tail = node;
-    }
-
-    this.#size++;
-  }
-
-  dequeue() {
-    const current = this.#head;
-    if (!current) {
-      return;
-    }
-
-    this.#head = this.#head.next;
-    this.#size--;
-    return current.value;
-  }
-
-  peek() {
-    if (!this.#head) {
-      return;
-    }
-
-    return this.#head.value;
-
-    // TODO: Node.js 18.
-    // return this.#head?.value;
-  }
-
-  clear() {
-    this.#head = undefined;
-    this.#tail = undefined;
-    this.#size = 0;
-  }
-
-  get size() {
-    return this.#size;
-  }
-
-  *[Symbol.iterator]() {
-    let current = this.#head;
-
-    while (current) {
-      yield current.value;
-      current = current.next;
-    }
-  }
-
-  *drain() {
-    while (this.#head) {
-      yield this.dequeue();
-    }
-  }
-}

scripts/zig-remove-unreferenced-top-level-decls.ts

@@ -0,0 +1,155 @@
+import * as fs from "fs";
+import * as path from "path";
+
+/**
+ * Removes unreferenced top-level const declarations from a Zig file
+ * Handles patterns like: const <IDENTIFIER> = @import(...) or const <IDENTIFIER> = ...
+ */
+export function removeUnreferencedImports(content: string): string {
+  let modified = true;
+  let result = content;
+
+  // Keep iterating until no more changes are made
+  while (modified) {
+    modified = false;
+    const lines = result.split("\n");
+    const newLines: string[] = [];
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      // Match top-level const declarations: const <IDENTIFIER> = ...
+      const constMatch = line.match(/^const\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=(.*)$/);
+
+      if (constMatch) {
+        const identifier = constMatch[1];
+        const assignmentPart = constMatch[2];
+
+        // Skip lines that contain '{' in the assignment (likely structs/objects)
+        if (assignmentPart.includes("{")) {
+          newLines.push(line);
+          continue;
+        }
+
+        // Check if this identifier is referenced anywhere else in the file
+        const isReferenced = isIdentifierReferenced(identifier, lines, i);
+
+        if (!isReferenced) {
+          // Skip this line (delete it)
+          modified = true;
+          console.log(`Removing unreferenced import: ${identifier}`);
+          continue;
+        }
+      }
+
+      newLines.push(line);
+    }
+
+    result = newLines.join("\n");
+  }
+
+  return result;
+}
+
+/**
+ * Check if an identifier is referenced anywhere in the file except at the declaration line
+ */
+function isIdentifierReferenced(identifier: string, lines: string[], declarationLineIndex: number): boolean {
+  // Create a regex that matches the identifier as a whole word
+  // This prevents matching partial words (e.g. "std" shouldn't match "stdx")
+  const identifierRegex = new RegExp(`\\b${escapeRegex(identifier)}\\b`);
+
+  for (let i = 0; i < lines.length; i++) {
+    // Skip the declaration line itself
+    if (i === declarationLineIndex) {
+      continue;
+    }
+
+    const line = lines[i];
+
+    // Check if the identifier appears in this line
+    if (identifierRegex.test(line)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Escape special regex characters in a string
+ */
+function escapeRegex(string: string): string {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Process a single Zig file
+ */
+export function processZigFile(filePath: string): void {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const cleaned = removeUnreferencedImports(content);
+
+    if (content !== cleaned) {
+      fs.writeFileSync(filePath, cleaned);
+      console.log(`Cleaned: ${filePath}`);
+    } else {
+      console.log(`No changes: ${filePath}`);
+    }
+  } catch (error) {
+    console.error(`Error processing ${filePath}:`, error);
+  }
+}
+
+/**
+ * Process multiple Zig files or directories
+ */
+export function processFiles(paths: string[]): void {
+  for (const inputPath of paths) {
+    const stat = fs.statSync(inputPath);
+
+    if (stat.isDirectory()) {
+      // Process all .zig files in directory recursively
+      processDirectory(inputPath);
+    } else if (inputPath.endsWith(".zig")) {
+      processZigFile(inputPath);
+    } else {
+      console.warn(`Skipping non-Zig file: ${inputPath}`);
+    }
+  }
+}
+
+/**
+ * Recursively process all .zig files in a directory
+ */
+function processDirectory(dirPath: string): void {
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+
+    if (entry.isDirectory()) {
+      processDirectory(fullPath);
+    } else if (entry.name.endsWith(".zig")) {
+      processZigFile(fullPath);
+    }
+  }
+}
+
+// CLI usage
+if (require.main === module) {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    console.log("Usage: bun zig-remove-unreferenced-top-level-decls.ts <file1.zig> [file2.zig] [directory]...");
+    console.log("");
+    console.log("Examples:");
+    console.log("  bun zig-remove-unreferenced-top-level-decls.ts file.zig");
+    console.log("  bun zig-remove-unreferenced-top-level-decls.ts src/");
+    console.log("  bun zig-remove-unreferenced-top-level-decls.ts file1.zig file2.zig src/");
+    process.exit(1);
+  }
+
+  processFiles(args);
+}

src/Global.zig

@@ -1,4 +1,12 @@
-const Global = @This();
+const std = @import("std");
+const Environment = @import("./env.zig");
+
+const Output = @import("output.zig");
+const use_mimalloc = bun.use_mimalloc;
+const Mimalloc = bun.Mimalloc;
+const bun = @import("bun");
+
+const version_string = Environment.version_string;
 
 /// Does not have the canary tag, because it is exposed in `Bun.version`
 /// "1.0.0" or "1.0.0-debug"
@@ -183,6 +191,9 @@ pub fn crash() noreturn {
     Global.exit(1);
 }
 
+const Global = @This();
+const string = bun.string;
+
 pub const BunInfo = struct {
     bun_version: string,
     platform: Analytics.GenerateHeader.GeneratePlatform.Platform,
@@ -220,14 +231,3 @@ pub export fn Bun__onExit() void {
 comptime {
     _ = Bun__onExit;
 }
-
-const Output = @import("./output.zig");
-const std = @import("std");
-
-const Environment = @import("./env.zig");
-const version_string = Environment.version_string;
-
-const bun = @import("bun");
-const Mimalloc = bun.Mimalloc;
-const string = bun.string;
-const use_mimalloc = bun.use_mimalloc;

src/HTMLScanner.zig

@@ -1,4 +1,10 @@
-const HTMLScanner = @This();
+const std = @import("std");
+const bun = @import("bun");
+const ImportRecord = @import("./import_record.zig").ImportRecord;
+const ImportKind = @import("./import_record.zig").ImportKind;
+const lol = @import("./deps/lol-html.zig");
+const logger = bun.logger;
+const fs = bun.fs;
 
 allocator: std.mem.Allocator,
 import_records: ImportRecord.List = .{},
@@ -297,12 +303,4 @@ pub fn HTMLProcessor(
     };
 }
 
-const lol = @import("./deps/lol-html.zig");
-const std = @import("std");
-
-const ImportKind = @import("./import_record.zig").ImportKind;
-const ImportRecord = @import("./import_record.zig").ImportRecord;
-
-const bun = @import("bun");
-const fs = bun.fs;
-const logger = bun.logger;
+const HTMLScanner = @This();

src/OutputFile.zig

@@ -1,5 +1,3 @@
-const OutputFile = @This();
-
 // Instead of keeping files in-memory, we:
 // 1. Write directly to disk
 // 2. (Optional) move the file to the destination
@@ -22,24 +20,8 @@ side: ?bun.bake.Side,
 /// This is only set for the JS bundle, and not files associated with an
 /// entrypoint like sourcemaps and bytecode
 entry_point_index: ?u32,
-referenced_css_chunks: []const Index = &.{},
+referenced_css_files: []const Index = &.{},
 source_index: Index.Optional = .none,
-bake_extra: BakeExtra = .{},
-
-pub const zero_value = OutputFile{
-    .loader = .file,
-    .src_path = Fs.Path.init(""),
-    .value = .noop,
-    .output_kind = .chunk,
-    .side = null,
-    .entry_point_index = null,
-};
-
-pub const BakeExtra = struct {
-    is_route: bool = false,
-    fully_static: bool = false,
-    bake_is_runtime: bool = false,
-};
 
 pub const Index = bun.GenericIndex(u32, OutputFile);
 
@@ -48,7 +30,7 @@ pub fn deinit(this: *OutputFile) void {
 
     bun.default_allocator.free(this.src_path.text);
     bun.default_allocator.free(this.dest_path);
-    bun.default_allocator.free(this.referenced_css_chunks);
+    bun.default_allocator.free(this.referenced_css_files);
 }
 
 // Depending on:
@@ -117,13 +99,6 @@ pub const Value = union(Kind) {
         }
     }
 
-    pub fn asSlice(v: Value) []const u8 {
-        return switch (v) {
-            .buffer => |buf| buf.bytes,
-            else => "",
-        };
-    }
-
     pub fn toBunString(v: Value) bun.String {
         return switch (v) {
             .noop => bun.String.empty,
@@ -231,8 +206,7 @@ pub const Options = struct {
     },
     side: ?bun.bake.Side,
     entry_point_index: ?u32,
-    referenced_css_chunks: []const Index = &.{},
-    bake_extra: BakeExtra = .{},
+    referenced_css_files: []const Index = &.{},
 };
 
 pub fn init(options: Options) OutputFile {
@@ -266,8 +240,7 @@ pub fn init(options: Options) OutputFile {
         },
         .side = options.side,
         .entry_point_index = options.entry_point_index,
-        .referenced_css_chunks = options.referenced_css_chunks,
-        .bake_extra = options.bake_extra,
+        .referenced_css_files = options.referenced_css_files,
     };
 }
 
@@ -516,16 +489,16 @@ pub fn toBlob(
     };
 }
 
+const OutputFile = @This();
 const string = []const u8;
-
-const resolve_path = @import("./resolver/resolve_path.zig");
-const resolver = @import("./resolver/resolver.zig");
-const std = @import("std");
-const Loader = @import("./options.zig").Loader;
-const Output = @import("./Global.zig").Output;
-
-const bun = @import("bun");
-const Environment = bun.Environment;
 const FileDescriptorType = bun.FileDescriptor;
-const Fs = bun.fs;
+
+const std = @import("std");
+const bun = @import("bun");
 const JSC = bun.JSC;
+const Fs = bun.fs;
+const Loader = @import("./options.zig").Loader;
+const resolver = @import("./resolver/resolver.zig");
+const resolve_path = @import("./resolver/resolve_path.zig");
+const Output = @import("./Global.zig").Output;
+const Environment = bun.Environment;

src/Progress.zig

@@ -14,7 +14,12 @@
 //! * `refresh_rate_ms`
 //! * `initial_delay_ms`
 
+const std = @import("std");
+const builtin = @import("builtin");
+const windows = std.os.windows;
+const assert = bun.assert;
 const Progress = @This();
+const bun = @import("bun");
 
 /// `null` if the current node (and its children) should
 /// not print on update()
@@ -448,10 +453,3 @@ test "basic functionality" {
         node.end();
     }
 }
-
-const builtin = @import("builtin");
-const std = @import("std");
-const windows = std.os.windows;
-
-const bun = @import("bun");
-const assert = bun.assert;

src/StandaloneModuleGraph.zig

@@ -1,6 +1,20 @@
 //! Originally, we tried using LIEF to inject the module graph into a MachO segment
 //! But this incurred a fixed 350ms overhead on every build, which is unacceptable
 //! so we give up on codesigning support on macOS for now until we can find a better solution
+const bun = @import("bun");
+const std = @import("std");
+const Schema = bun.Schema.Api;
+const strings = bun.strings;
+const Output = bun.Output;
+const Global = bun.Global;
+const Environment = bun.Environment;
+const Syscall = bun.sys;
+const SourceMap = bun.sourcemap;
+const StringPointer = bun.StringPointer;
+
+const macho = bun.macho;
+const pe = bun.pe;
+const w = std.os.windows;
 
 pub const StandaloneModuleGraph = struct {
     bytes: []const u8 = "",
@@ -718,10 +732,6 @@ pub const StandaloneModuleGraph = struct {
                     cleanup(zname, cloned_executable_fd);
                     Global.exit(1);
                 };
-                // Set executable permissions when running on POSIX hosts, even for Windows targets
-                if (comptime !Environment.isWindows) {
-                    _ = bun.c.fchmod(cloned_executable_fd.native(), 0o777);
-                }
                 return cloned_executable_fd;
             },
             else => {
@@ -1310,18 +1320,3 @@ pub const StandaloneModuleGraph = struct {
         bun.assert(header_list.items.len == string_payload_start_location);
     }
 };
-
-const std = @import("std");
-const w = std.os.windows;
-
-const bun = @import("bun");
-const Environment = bun.Environment;
-const Global = bun.Global;
-const Output = bun.Output;
-const SourceMap = bun.sourcemap;
-const StringPointer = bun.StringPointer;
-const Syscall = bun.sys;
-const macho = bun.macho;
-const pe = bun.pe;
-const strings = bun.strings;
-const Schema = bun.Schema.Api;

src/StaticHashMap.zig

@@ -1,5 +1,13 @@
 // https://github.com/lithdew/rheia/blob/162293d0f0e8d6572a8954c0add83f13f76b3cc6/hash_map.zig
 // Apache License 2.0
+const std = @import("std");
+
+const mem = std.mem;
+const math = std.math;
+const testing = std.testing;
+
+const bun = @import("bun");
+const assert = bun.assert;
 
 pub fn AutoHashMap(comptime K: type, comptime V: type, comptime max_load_percentage: comptime_int) type {
     return HashMap(K, V, std.hash_map.AutoContext(K), max_load_percentage);
@@ -777,11 +785,3 @@ test "SortedHashMap: collision test" {
     try testing.expectEqual(@as(usize, 1), map.delete(prefix ++ [_]u8{1}).?);
     try testing.expectEqual(@as(usize, 2), map.delete(prefix ++ [_]u8{2}).?);
 }
-
-const bun = @import("bun");
-const assert = bun.assert;
-
-const std = @import("std");
-const math = std.math;
-const mem = std.mem;
-const testing = std.testing;

src/Watcher.zig

@@ -1,7 +1,5 @@
 //! Bun's cross-platform filesystem watcher. Runs on its own thread.
-
 const Watcher = @This();
-
 const DebugLogScope = bun.Output.Scoped(.watcher, false);
 const log = DebugLogScope.log;
 
@@ -128,6 +126,7 @@ pub fn getHash(filepath: string) HashType {
 
 pub const WatchItemIndex = u16;
 pub const max_eviction_count = 8096;
+const WindowsWatcher = @import("./watcher/WindowsWatcher.zig");
 // TODO: some platform-specific behavior is implemented in
 // this file instead of the platform-specific file.
 // ideally, the constants above can be inlined
@@ -674,15 +673,13 @@ pub fn onMaybeWatchDirectory(watch: *Watcher, file_path: string, dir_fd: bun.Sto
     }
 }
 
-const WindowsWatcher = @import("./watcher/WindowsWatcher.zig");
-const options = @import("./options.zig");
 const std = @import("std");
-const PackageJSON = @import("./resolver/package_json.zig").PackageJSON;
-
 const bun = @import("bun");
-const Environment = bun.Environment;
-const FeatureFlags = bun.FeatureFlags;
-const Mutex = bun.Mutex;
-const Output = bun.Output;
 const string = bun.string;
+const Output = bun.Output;
+const Environment = bun.Environment;
 const strings = bun.strings;
+const FeatureFlags = bun.FeatureFlags;
+const options = @import("./options.zig");
+const Mutex = bun.Mutex;
+const PackageJSON = @import("./resolver/package_json.zig").PackageJSON;

src/allocators.zig

@@ -1,3 +1,9 @@
+const std = @import("std");
+
+const Environment = @import("./env.zig");
+const bun = @import("bun");
+const OOM = bun.OOM;
+
 pub fn isSliceInBufferT(comptime T: type, slice: []const T, buffer: []const T) bool {
     return (@intFromPtr(buffer.ptr) <= @intFromPtr(slice.ptr) and
         (@intFromPtr(slice.ptr) + slice.len * @sizeOf(T)) <= (@intFromPtr(buffer.ptr) + buffer.len * @sizeOf(T)));
@@ -284,6 +290,8 @@ pub fn BSSList(comptime ValueType: type, comptime _count: anytype) type {
     };
 }
 
+const Mutex = bun.Mutex;
+
 /// Append-only list.
 /// Stores an initial count in .bss section of the object file
 /// Overflows to heap when count is exceeded.
@@ -761,10 +769,3 @@ pub fn BSSMap(comptime ValueType: type, comptime count: anytype, comptime store_
         }
     };
 }
-
-const Environment = @import("./env.zig");
-const std = @import("std");
-
-const bun = @import("bun");
-const Mutex = bun.Mutex;
-const OOM = bun.OOM;

src/allocators/AllocationScope.zig

@@ -1,6 +1,5 @@
 //! AllocationScope wraps another allocator, providing leak and invalid free assertions.
 //! It also allows measuring how much memory a scope has allocated.
-
 const AllocationScope = @This();
 
 pub const enabled = bun.Environment.enableAllocScopes;
@@ -254,7 +253,6 @@ pub inline fn downcast(a: Allocator) ?*AllocationScope {
 
 const std = @import("std");
 const Allocator = std.mem.Allocator;
-
 const bun = @import("bun");
 const Output = bun.Output;
 const StoredTrace = bun.crash_handler.StoredTrace;

src/allocators/MemoryReportingAllocator.zig

@@ -1,5 +1,4 @@
 const MemoryReportingAllocator = @This();
-
 const log = bun.Output.scoped(.MEM, false);
 
 child_allocator: std.mem.Allocator,
@@ -85,8 +84,7 @@ pub const VTable = std.mem.Allocator.VTable{
 };
 
 const std = @import("std");
-
 const bun = @import("bun");
+const jsc = bun.jsc;
 const Environment = bun.Environment;
 const Output = bun.Output;
-const jsc = bun.jsc;

src/allocators/NullableAllocator.zig

@@ -1,4 +1,6 @@
 //! A nullable allocator the same size as `std.mem.Allocator`.
+const std = @import("std");
+const bun = @import("bun");
 
 const NullableAllocator = @This();
 
@@ -44,6 +46,3 @@ comptime {
         @compileError("Expected the sizes to be the same.");
     }
 }
-
-const bun = @import("bun");
-const std = @import("std");

src/allocators/linux_memfd_allocator.zig

@@ -1,3 +1,6 @@
+const bun = @import("bun");
+const std = @import("std");
+
 /// When cloning large amounts of data potentially multiple times, we can
 /// leverage copy-on-write memory to avoid actually copying the data. To do that
 /// on Linux, we need to use a memfd, which is a Linux-specific feature.
@@ -182,6 +185,3 @@ pub const LinuxMemFdAllocator = struct {
         }
     }
 };
-
-const bun = @import("bun");
-const std = @import("std");

src/allocators/max_heap_allocator.zig

@@ -1,3 +1,6 @@
+const bun = @import("bun");
+const std = @import("std");
+
 /// Single allocation only.
 ///
 pub const MaxHeapAllocator = struct {
@@ -48,6 +51,3 @@ pub const MaxHeapAllocator = struct {
         };
     }
 };
-
-const bun = @import("bun");
-const std = @import("std");

src/allocators/memory_allocator.zig

@@ -1,4 +1,11 @@
+const mem = @import("std").mem;
+const std = @import("std");
+const bun = @import("bun");
 const log = bun.Output.scoped(.mimalloc, true);
+const assert = bun.assert;
+const Allocator = mem.Allocator;
+const mimalloc = @import("./mimalloc.zig");
+const Environment = @import("../env.zig");
 
 fn mimalloc_free(
     _: *anyopaque,
@@ -143,13 +150,3 @@ const z_allocator_vtable = Allocator.VTable{
     .remap = &std.mem.Allocator.noRemap,
     .free = &ZAllocator.free_with_z_allocator,
 };
-
-const Environment = @import("../env.zig");
-const mimalloc = @import("./mimalloc.zig");
-const std = @import("std");
-
-const bun = @import("bun");
-const assert = bun.assert;
-
-const mem = @import("std").mem;
-const Allocator = mem.Allocator;

src/allocators/mimalloc.zig

@@ -202,6 +202,7 @@ pub const MI_SMALL_WSIZE_MAX = @as(c_int, 128);
 pub const MI_SMALL_SIZE_MAX = MI_SMALL_WSIZE_MAX * @import("std").zig.c_translation.sizeof(?*anyopaque);
 pub const MI_ALIGNMENT_MAX = (@as(c_int, 16) * @as(c_int, 1024)) * @as(c_ulong, 1024);
 
+const std = @import("std");
 pub fn canUseAlignedAlloc(len: usize, alignment: usize) bool {
     return alignment > 0 and std.math.isPowerOfTwo(alignment) and !mi_malloc_satisfies_alignment(alignment, len);
 }
@@ -210,5 +211,3 @@ inline fn mi_malloc_satisfies_alignment(alignment: usize, size: usize) bool {
     return (alignment == @sizeOf(*anyopaque) or
         (alignment == MI_MAX_ALIGN_SIZE and size >= (MI_MAX_ALIGN_SIZE / 2)));
 }
-
-const std = @import("std");

src/allocators/mimalloc_arena.zig

@@ -1,3 +1,12 @@
+const mem = @import("std").mem;
+const std = @import("std");
+
+const mimalloc = @import("./mimalloc.zig");
+const Environment = @import("../env.zig");
+const FeatureFlags = @import("../feature_flags.zig");
+const Allocator = mem.Allocator;
+const assert = bun.assert;
+const bun = @import("bun");
 const log = bun.Output.scoped(.mimalloc, true);
 
 pub const Arena = struct {
@@ -158,14 +167,3 @@ const c_allocator_vtable = Allocator.VTable{
     .remap = &Arena.remap,
     .free = &Arena.free,
 };
-
-const Environment = @import("../env.zig");
-const FeatureFlags = @import("../feature_flags.zig");
-const mimalloc = @import("./mimalloc.zig");
-const std = @import("std");
-
-const bun = @import("bun");
-const assert = bun.assert;
-
-const mem = @import("std").mem;
-const Allocator = mem.Allocator;

src/analytics/analytics_schema.zig

@@ -1,3 +1,5 @@
+const std = @import("std");
+
 pub const Reader = struct {
     const Self = @This();
     pub const ReadError = error{EOF};
@@ -516,5 +518,3 @@ pub const analytics = struct {
         }
     };
 };
-
-const std = @import("std");

src/analytics/analytics_thread.zig

@@ -1,3 +1,11 @@
+const bun = @import("bun");
+const Environment = bun.Environment;
+
+const std = @import("std");
+
+const Analytics = @import("./analytics_schema.zig").analytics;
+const Semver = bun.Semver;
+
 /// Enables analytics. This is used by:
 /// - crash_handler.zig's `report` function to anonymously report crashes
 ///
@@ -367,10 +375,3 @@ pub const GenerateHeader = struct {
         }
     };
 };
-
-const std = @import("std");
-const Analytics = @import("./analytics_schema.zig").analytics;
-
-const bun = @import("bun");
-const Environment = bun.Environment;
-const Semver = bun.Semver;

src/api/schema.zig

@@ -1,3 +1,8 @@
+const std = @import("std");
+const bun = @import("bun");
+const js_ast = bun.JSAst;
+const OOM = bun.OOM;
+
 pub const Reader = struct {
     const Self = @This();
     pub const ReadError = error{EOF};
@@ -1951,27 +1956,6 @@ pub const Api = struct {
 
         _,
 
-        pub fn fromJS(global: *bun.JSC.JSGlobalObject, value: bun.JSC.JSValue) bun.JSError!?SourceMapMode {
-            if (value.isString()) {
-                const str = try value.toSliceOrNull(global);
-                defer str.deinit();
-                const utf8 = str.slice();
-                if (bun.strings.eqlComptime(utf8, "none")) {
-                    return .none;
-                }
-                if (bun.strings.eqlComptime(utf8, "inline")) {
-                    return .@"inline";
-                }
-                if (bun.strings.eqlComptime(utf8, "external")) {
-                    return .external;
-                }
-                if (bun.strings.eqlComptime(utf8, "linked")) {
-                    return .linked;
-                }
-            }
-            return null;
-        }
-
         pub fn jsonStringify(self: @This(), writer: anytype) !void {
             return try writer.write(@tagName(self));
         }
@@ -3365,9 +3349,3 @@ pub const Api = struct {
         }
     };
 };
-
-const std = @import("std");
-
-const bun = @import("bun");
-const OOM = bun.OOM;
-const js_ast = bun.JSAst;

src/ast/ASTMemoryAllocator.zig

@@ -85,6 +85,8 @@ pub fn initWithoutStack(this: *ASTMemoryAllocator, arena: std.mem.Allocator) voi
     this.bump_allocator = this.stack_allocator.get();
 }
 
+// @sortImports
+
 const bun = @import("bun");
 const std = @import("std");
 

src/ast/Ast.zig

@@ -112,7 +112,7 @@ pub fn deinit(this: *Ast) void {
     if (this.import_records.len > 0) this.import_records.deinitWithAllocator(bun.default_allocator);
 }
 
-pub const Class = G.Class;
+// @sortImports
 
 const std = @import("std");
 const Runtime = @import("../runtime.zig").Runtime;
@@ -128,7 +128,6 @@ const Ast = js_ast.Ast;
 const CharFreq = js_ast.CharFreq;
 const ExportsKind = js_ast.ExportsKind;
 const Expr = js_ast.Expr;
-const G = js_ast.G;
 const InlinedEnumValue = js_ast.InlinedEnumValue;
 const LocRef = js_ast.LocRef;
 const NamedExport = js_ast.NamedExport;
@@ -139,3 +138,6 @@ const RefHashCtx = js_ast.RefHashCtx;
 const Scope = js_ast.Scope;
 const SlotCounts = js_ast.SlotCounts;
 const Symbol = js_ast.Symbol;
+
+const G = js_ast.G;
+pub const Class = G.Class;

src/ast/B.zig

@@ -87,7 +87,7 @@ pub const B = union(Binding.Tag) {
     }
 };
 
-pub const Class = G.Class;
+// @sortImports
 
 const std = @import("std");
 
@@ -100,5 +100,7 @@ const Binding = js_ast.Binding;
 const Expr = js_ast.Expr;
 const ExprNodeIndex = js_ast.ExprNodeIndex;
 const Flags = js_ast.Flags;
-const G = js_ast.G;
 const Ref = js_ast.Ref;
+
+const G = js_ast.G;
+pub const Class = G.Class;

src/ast/Binding.zig

@@ -147,6 +147,8 @@ pub fn alloc(allocator: std.mem.Allocator, t: anytype, loc: logger.Loc) Binding
     }
 }
 
+// @sortImports
+
 const std = @import("std");
 
 const bun = @import("bun");

src/ast/BundledAst.zig

@@ -201,11 +201,7 @@ pub fn addUrlForCss(
     }
 }
 
-pub const CommonJSNamedExports = Ast.CommonJSNamedExports;
-pub const ConstValuesMap = Ast.ConstValuesMap;
-pub const NamedExports = Ast.NamedExports;
-pub const NamedImports = Ast.NamedImports;
-pub const TopLevelSymbolToParts = Ast.TopLevelSymbolToParts;
+// @sortImports
 
 const std = @import("std");
 
@@ -217,7 +213,6 @@ const strings = bun.strings;
 const MimeType = bun.http.MimeType;
 
 const js_ast = bun.js_ast;
-const Ast = js_ast.Ast;
 const BundledAst = js_ast.BundledAst;
 const CharFreq = js_ast.CharFreq;
 const ExportsKind = js_ast.ExportsKind;
@@ -227,3 +222,10 @@ const Scope = js_ast.Scope;
 const SlotCounts = js_ast.SlotCounts;
 const Symbol = js_ast.Symbol;
 const TlaCheck = js_ast.TlaCheck;
+
+const Ast = js_ast.Ast;
+pub const CommonJSNamedExports = Ast.CommonJSNamedExports;
+pub const ConstValuesMap = Ast.ConstValuesMap;
+pub const NamedExports = Ast.NamedExports;
+pub const NamedImports = Ast.NamedImports;
+pub const TopLevelSymbolToParts = Ast.TopLevelSymbolToParts;

src/ast/CharFreq.zig

@@ -124,7 +124,7 @@ pub fn compile(this: *const CharFreq, allocator: std.mem.Allocator) NameMinifier
     return minifier;
 }
 
-pub const Class = G.Class;
+// @sortImports
 
 const std = @import("std");
 
@@ -133,5 +133,7 @@ const string = bun.string;
 
 const js_ast = bun.js_ast;
 const CharFreq = js_ast.CharFreq;
-const G = js_ast.G;
 const NameMinifier = js_ast.NameMinifier;
+
+const G = js_ast.G;
+pub const Class = G.Class;

src/ast/E.zig

@@ -1416,7 +1416,7 @@ pub const Import = struct {
     }
 };
 
-pub const Class = G.Class;
+// @sortImports
 
 const std = @import("std");
 
@@ -1438,8 +1438,10 @@ const Expr = js_ast.Expr;
 const ExprNodeIndex = js_ast.ExprNodeIndex;
 const ExprNodeList = js_ast.ExprNodeList;
 const Flags = js_ast.Flags;
-const G = js_ast.G;
 const Op = js_ast.Op;
 const OptionalChain = js_ast.OptionalChain;
 const Ref = js_ast.Ref;
 const ToJSError = js_ast.ToJSError;
+
+const G = js_ast.G;
+pub const Class = G.Class;

src/ast/Expr.zig

@@ -3201,14 +3201,18 @@ pub fn StoredData(tag: Tag) type {
     };
 }
 
+extern fn JSC__jsToNumber(latin1_ptr: [*]const u8, len: usize) f64;
+
 fn stringToEquivalentNumberValue(str: []const u8) f64 {
     // +"" -> 0
     if (str.len == 0) return 0;
     if (!bun.strings.isAllASCII(str))
         return std.math.nan(f64);
-    return bun.cpp.JSC__jsToNumber(str.ptr, str.len);
+    return JSC__jsToNumber(str.ptr, str.len);
 }
 
+// @sortImports
+
 const JSPrinter = @import("../js_printer.zig");
 const std = @import("std");
 

src/ast/G.zig

@@ -208,6 +208,8 @@ pub const Arg = struct {
     }
 };
 
+// @sortImports
+
 const std = @import("std");
 
 const bun = @import("bun");

src/ast/Macro.zig

@@ -631,6 +631,8 @@ pub const Runner = struct {
     extern "c" fn Bun__startMacro(function: *const anyopaque, *anyopaque) void;
 };
 
+// @sortImports
+
 const DotEnv = @import("../env_loader.zig");
 const std = @import("std");
 

src/ast/NewStore.zig

@@ -164,6 +164,8 @@ pub fn NewStore(comptime types: []const type, comptime count: usize) type {
     };
 }
 
+// @sortImports
+
 const std = @import("std");
 
 const bun = @import("bun");

src/ast/Op.zig

@@ -281,6 +281,8 @@ pub const Table = brk: {
     break :brk table;
 };
 
+// @sortImports
+
 const std = @import("std");
 
 const bun = @import("bun");

src/ast/S.zig

@@ -212,6 +212,8 @@ pub const Continue = struct {
     label: ?LocRef = null,
 };
 
+// @sortImports
+
 const bun = @import("bun");
 const logger = bun.logger;
 const string = bun.string;

src/ast/Scope.zig

@@ -205,6 +205,8 @@ pub inline fn kindStopsHoisting(s: *const Scope) bool {
     return @intFromEnum(s.kind) >= @intFromEnum(Kind.entry);
 }
 
+// @sortImports
+
 const std = @import("std");
 
 const bun = @import("bun");

src/ast/ServerComponentBoundary.zig

@@ -112,6 +112,8 @@ pub const List = struct {
     };
 };
 
+// @sortImports
+
 const bun = @import("bun");
 const std = @import("std");
 

src/ast/Stmt.zig

@@ -406,6 +406,8 @@ pub fn caresAboutScope(self: *Stmt) bool {
     };
 }
 
+// @sortImports
+
 const std = @import("std");
 
 const bun = @import("bun");

src/ast/Symbol.zig

@@ -468,10 +468,7 @@ pub inline fn isHoisted(self: *const Symbol) bool {
     return Symbol.isKindHoisted(self.kind);
 }
 
-pub const isKindFunction = Symbol.Kind.isFunction;
-pub const isKindHoisted = Symbol.Kind.isHoisted;
-pub const isKindHoistedOrFunction = Symbol.Kind.isHoistedOrFunction;
-pub const isKindPrivate = Symbol.Kind.isPrivate;
+// @sortImports
 
 const std = @import("std");
 
@@ -485,3 +482,8 @@ const G = js_ast.G;
 const ImportItemStatus = js_ast.ImportItemStatus;
 const Ref = js_ast.Ref;
 const Symbol = js_ast.Symbol;
+
+pub const isKindFunction = Symbol.Kind.isFunction;
+pub const isKindHoisted = Symbol.Kind.isHoisted;
+pub const isKindHoistedOrFunction = Symbol.Kind.isHoistedOrFunction;
+pub const isKindPrivate = Symbol.Kind.isPrivate;

src/ast/TS.zig

@@ -126,7 +126,7 @@ pub const TSNamespaceMember = struct {
     };
 };
 
-pub const Class = G.Class;
+// @sortImports
 
 const std = @import("std");
 
@@ -135,5 +135,7 @@ const logger = bun.logger;
 
 const js_ast = bun.js_ast;
 const E = js_ast.E;
-const G = js_ast.G;
 const Ref = js_ast.Ref;
+
+const G = js_ast.G;
+pub const Class = G.Class;

src/ast/UseDirective.zig

@@ -55,6 +55,8 @@ pub const UseDirective = enum(u2) {
     }
 };
 
+// @sortImports
+
 const std = @import("std");
 
 const bun = @import("bun");

src/ast/base.zig

@@ -1,3 +1,8 @@
+const std = @import("std");
+const bun = @import("bun");
+
+const js_ast = bun.JSAst;
+
 pub const NodeIndex = u32;
 pub const NodeIndexNone = 4294967293;
 
@@ -232,8 +237,3 @@ pub const Ref = packed struct(u64) {
         return &resolved_symbol_table[ref.innerIndex()];
     }
 };
-
-const std = @import("std");
-
-const bun = @import("bun");
-const js_ast = bun.JSAst;

src/async/posix_event_loop.zig

@@ -1,3 +1,10 @@
+const bun = @import("bun");
+const Output = bun.Output;
+const JSC = bun.JSC;
+const uws = bun.uws;
+const Environment = bun.Environment;
+const std = @import("std");
+
 pub const Loop = uws.Loop;
 
 /// Track if an object whose file descriptor is being watched should keep the event loop alive.
@@ -1222,11 +1229,3 @@ pub const Closer = struct {
         closer.fd.close();
     }
 };
-
-const std = @import("std");
-
-const bun = @import("bun");
-const Environment = bun.Environment;
-const JSC = bun.JSC;
-const Output = bun.Output;
-const uws = bun.uws;

src/async/windows_event_loop.zig

@@ -1,3 +1,10 @@
+const bun = @import("bun");
+const Output = bun.Output;
+const JSC = bun.JSC;
+const uws = bun.uws;
+const Environment = bun.Environment;
+const std = @import("std");
+const uv = bun.windows.libuv;
 pub const Loop = uv.Loop;
 
 pub const KeepAlive = struct {
@@ -112,6 +119,8 @@ pub const KeepAlive = struct {
     }
 };
 
+const Posix = @import("./posix_event_loop.zig");
+
 pub const FilePoll = struct {
     fd: bun.FileDescriptor,
     owner: Owner = undefined,
@@ -410,13 +419,3 @@ pub const Closer = struct {
         bun.destroy(closer);
     }
 };
-
-const Posix = @import("./posix_event_loop.zig");
-const std = @import("std");
-
-const bun = @import("bun");
-const Environment = bun.Environment;
-const JSC = bun.JSC;
-const Output = bun.Output;
-const uws = bun.uws;
-const uv = bun.windows.libuv;

src/baby_list.zig

@@ -1,3 +1,8 @@
+const std = @import("std");
+const Environment = @import("./env.zig");
+const strings = @import("./string_immutable.zig");
+const bun = @import("bun");
+
 /// This is like ArrayList except it stores the length and capacity as u32
 /// In practice, it is very unusual to have lengths above 4 GB
 pub fn BabyList(comptime Type: type) type {
@@ -469,8 +474,3 @@ pub fn OffsetList(comptime Type: type) type {
         }
     };
 }
-
-const Environment = @import("./env.zig");
-const bun = @import("bun");
-const std = @import("std");
-const strings = @import("./string_immutable.zig");

src/bake/BakeGlobalObject.cpp

@@ -9,7 +9,6 @@
 #include "JavaScriptCore/JSSourceCode.h"
 
 extern "C" BunString BakeProdResolve(JSC::JSGlobalObject*, BunString a, BunString b);
-extern "C" BunString BakeToWindowsPath(BunString a);
 
 namespace Bake {
 using namespace JSC;
@@ -108,18 +107,7 @@ static JSC::JSInternalPromise* resolvedInternalPromise(JSC::JSGlobalObject* glob
     return promise;
 }
 
-extern "C" BunString BakeProdLoad(void* perThreadData, BunString a);
-
-extern "C" bool BakeGlobalObject__isBakeGlobalObject(JSC::JSGlobalObject* global)
-{
-    return global->JSCell::inherits(Bake::GlobalObject::info());
-}
-
-extern "C" void* BakeGlobalObject__getPerThreadData(JSC::JSGlobalObject* global)
-{
-    Bake::GlobalObject* bake = jsCast<Bake::GlobalObject*>(global);
-    return bake->m_perThreadData;
-}
+extern "C" BunString BakeProdLoad(ProductionPerThread* perThreadData, BunString a);
 
 JSC::JSInternalPromise* bakeModuleLoaderFetch(JSC::JSGlobalObject* globalObject,
     JSC::JSModuleLoader* loader, JSC::JSValue key,
@@ -146,33 +134,12 @@ JSC::JSInternalPromise* bakeModuleLoaderFetch(JSC::JSGlobalObject* globalObject,
                     JSC::SourceProviderSourceType::Module));
                 return resolvedInternalPromise(globalObject, JSC::JSSourceCode::create(vm, WTFMove(sourceCode)));
             }
-
-            // We unconditionally prefix the key with "bake:" inside
-            // BakeProdResolve in production.zig.
-            //
-            // But if someone does: `await import(resolve(import.meta.dir, "nav.ts"))`
-            // we don't actually want to load it from the Bake production module
-            // map and instead make it go through the normal codepath.
-            auto bakePrefixRemoved = moduleKey.substringSharingImpl("bake:"_s.length());
-
-#ifdef _WIN32
-            // We normalize paths to contain forward slashes in bake so we don't
-            // have to worry about platform paths. Now we have to worry about
-            // it, because `moduleLoaderFetch(...)` may read the path from disk
-            // and so we need to give a Windows path to it.
-            auto temp = BakeToWindowsPath(Bun::toString(bakePrefixRemoved));
-            bakePrefixRemoved = temp.toWTFString();
-#endif
-            JSString* bakePrefixRemovedString = jsNontrivialString(vm, bakePrefixRemoved);
-            JSValue bakePrefixRemovedJsvalue = bakePrefixRemovedString;
-            return Zig::GlobalObject::moduleLoaderFetch(globalObject, loader, bakePrefixRemovedJsvalue, parameters, script);
+            return rejectedInternalPromise(globalObject, createTypeError(globalObject, makeString("Bundle does not have \""_s, moduleKey, "\". This is a bug in Bun's bundler."_s)));
         }
         return rejectedInternalPromise(globalObject, createTypeError(globalObject, "BakeGlobalObject does not have per-thread data configured"_s));
     }
 
-    auto result = Zig::GlobalObject::moduleLoaderFetch(globalObject, loader, key, parameters, script);
-    RETURN_IF_EXCEPTION(scope, rejectedInternalPromise(globalObject, scope.exception()->value()));
-    return result;
+    return Zig::GlobalObject::moduleLoaderFetch(globalObject, loader, key, parameters, script);
 }
 
 GlobalObject* GlobalObject::create(JSC::VM& vm, JSC::Structure* structure,
@@ -238,16 +205,7 @@ const JSC::GlobalObjectMethodTable& GlobalObject::globalObjectMethodTable()
 // TODO: remove this entire method
 extern "C" GlobalObject* BakeCreateProdGlobal(void* console)
 {
-    RefPtr<JSC::VM> vmPtr = JSC::VM::tryCreate(JSC::HeapType::Large);
-    if (!vmPtr) [[unlikely]] {
-        BUN_PANIC("Failed to allocate JavaScriptCore Virtual Machine. Did your computer run out of memory? Or maybe you compiled Bun with a mismatching libc++ version or compiler?");
-    }
-    // We need to unsafely ref this so it stays alive, later in
-    // `Zig__GlobalObject__destructOnExit` will call
-    // `vm.derefSuppressingSaferCPPChecking()` to free it.
-    vmPtr->refSuppressingSaferCPPChecking();
-    JSC::VM& vm = *vmPtr;
-
+    JSC::VM& vm = JSC::VM::create(JSC::HeapType::Large).leakRef();
     vm.heap.acquireAccess();
     JSC::JSLockHolder locker(vm);
     BunVirtualMachine* bunVM = Bun__getVM();
@@ -267,11 +225,6 @@ extern "C" GlobalObject* BakeCreateProdGlobal(void* console)
     global->setStackTraceLimit(10); // Node.js defaults to 10
     global->isThreadLocalDefaultGlobalObject = true;
 
-    // if (shouldDisableStopIfNecessaryTimer) {
-    vm.heap.disableStopIfNecessaryTimer();
-    // }
-
-    // if you process.nextTick on a microtask we need thsi
     // TODO: it segfaults! process.nextTick is scoped out for now i guess!
     // vm.setOnComputeErrorInfo(computeErrorInfoWrapper);
     // vm.setOnEachMicrotaskTick([global](JSC::VM &vm) -> void {
@@ -287,7 +240,7 @@ extern "C" GlobalObject* BakeCreateProdGlobal(void* console)
     return global;
 }
 
-extern "C" void BakeGlobalObject__attachPerThreadData(GlobalObject* global, void* perThreadData)
+extern "C" void BakeGlobalObject__attachPerThreadData(GlobalObject* global, ProductionPerThread* perThreadData)
 {
     global->m_perThreadData = perThreadData;
 }

src/bake/BakeGlobalObject.h

@@ -4,11 +4,13 @@
 
 namespace Bake {
 
+struct ProductionPerThread;
+
 class GlobalObject : public Zig::GlobalObject {
 public:
     using Base = Zig::GlobalObject;
 
-    void* m_perThreadData = nullptr;
+    ProductionPerThread* m_perThreadData = nullptr;
     DECLARE_INFO;
 
     template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
@@ -37,7 +39,4 @@ public:
     }
 };
 
-extern "C" void* BakeGlobalObject__getPerThreadData(JSC::JSGlobalObject* global);
-extern "C" void BakeGlobalObject__attachPerThreadData(GlobalObject* global, void* perThreadData);
-
 }; // namespace Kit

src/bake/BakeSourceProvider.cpp

@@ -22,7 +22,7 @@ extern "C" BunString BakeSourceProvider__getSourceSlice(SourceProvider* provider
     return Bun::toStringView(provider->source());
 }
 
-extern "C" JSC::EncodedJSValue BakeLoadInitialServerCode(JSC::JSGlobalObject* global, BunString source, bool separateSSRGraph) {
+extern "C" JSC::EncodedJSValue BakeLoadInitialServerCode(GlobalObject* global, BunString source, bool separateSSRGraph) {
   auto& vm = JSC::getVM(global);
   auto scope = DECLARE_THROW_SCOPE(vm);
 

src/bake/DevServer.zig

@@ -7,9 +7,7 @@
 //!
 //! All work is held in-memory, using manually managed data-oriented design.
 //! For questions about DevServer, please consult the delusional @paperclover
-
 const DevServer = @This();
-
 pub const debug = bun.Output.Scoped(.DevServer, false);
 pub const igLog = bun.Output.scoped(.IncrementalGraph, false);
 pub const mapLog = bun.Output.scoped(.SourceMapStore, false);
@@ -8523,53 +8521,58 @@ pub fn getDeinitCountForTesting() usize {
     return dev_server_deinit_count_for_testing;
 }
 
-const ThreadlocalArena = @import("../allocators/mimalloc_arena.zig").Arena;
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const Mutex = bun.Mutex;
+const ArrayListUnmanaged = std.ArrayListUnmanaged;
+const AutoArrayHashMapUnmanaged = std.AutoArrayHashMapUnmanaged;
 
 const bun = @import("bun");
-const AllocationScope = bun.AllocationScope;
 const Environment = bun.Environment;
-const Mutex = bun.Mutex;
-const Output = bun.Output;
-const StringJoiner = bun.StringJoiner;
-const Watcher = bun.Watcher;
 const assert = bun.assert;
 const assert_eql = bun.assert_eql;
-const bake = bun.bake;
 const DynamicBitSetUnmanaged = bun.bit_set.DynamicBitSetUnmanaged;
+
+const bake = bun.bake;
+const FrameworkRouter = bake.FrameworkRouter;
+const Route = FrameworkRouter.Route;
+const OpaqueFileId = FrameworkRouter.OpaqueFileId;
+
 const Log = bun.logger.Log;
-const MimeType = bun.http.MimeType;
-const RefPtr = bun.ptr.RefPtr;
-const StaticRoute = bun.server.StaticRoute;
+const Output = bun.Output;
+
 const Transpiler = bun.transpiler.Transpiler;
-const EventLoopTimer = bun.api.Timer.EventLoopTimer;
+const BundleV2 = bun.bundle_v2.BundleV2;
+const Chunk = bun.bundle_v2.Chunk;
+const ContentHasher = bun.bundle_v2.ContentHasher;
+
+const uws = bun.uws;
+const AnyWebSocket = uws.AnyWebSocket;
+const Request = uws.Request;
+const AnyResponse = bun.uws.AnyResponse;
+
+const MimeType = bun.http.MimeType;
 
 const JSC = bun.JSC;
 const JSValue = JSC.JSValue;
 const VirtualMachine = JSC.VirtualMachine;
 const HTMLBundle = JSC.API.HTMLBundle;
-const AnyBlob = JSC.WebCore.Blob.Any;
 const Plugin = JSC.API.JSBundler.Plugin;
+const EventLoopTimer = bun.api.Timer.EventLoopTimer;
 
-const BunFrontendDevServerAgent = JSC.Debugger.BunFrontendDevServerAgent;
-const DebuggerId = JSC.Debugger.DebuggerId;
+const ThreadlocalArena = @import("../allocators/mimalloc_arena.zig").Arena;
 
-const FrameworkRouter = bake.FrameworkRouter;
-const OpaqueFileId = FrameworkRouter.OpaqueFileId;
-const Route = FrameworkRouter.Route;
+const Watcher = bun.Watcher;
+const StaticRoute = bun.server.StaticRoute;
 
-const BundleV2 = bun.bundle_v2.BundleV2;
-const Chunk = bun.bundle_v2.Chunk;
-const ContentHasher = bun.bundle_v2.ContentHasher;
+const AnyBlob = JSC.WebCore.Blob.Any;
 
 const SourceMap = bun.sourcemap;
 const VLQ = SourceMap.VLQ;
 
-const uws = bun.uws;
-const AnyResponse = bun.uws.AnyResponse;
-const AnyWebSocket = uws.AnyWebSocket;
-const Request = uws.Request;
+const StringJoiner = bun.StringJoiner;
+const AllocationScope = bun.AllocationScope;
+const BunFrontendDevServerAgent = JSC.Debugger.BunFrontendDevServerAgent;
+const DebuggerId = JSC.Debugger.DebuggerId;
 
-const std = @import("std");
-const ArrayListUnmanaged = std.ArrayListUnmanaged;
-const AutoArrayHashMapUnmanaged = std.AutoArrayHashMapUnmanaged;
-const Allocator = std.mem.Allocator;
+const RefPtr = bun.ptr.RefPtr;

src/bake/FrameworkRouter.zig

@@ -1,7 +1,6 @@
 //! Discovers routes from the filesystem, as instructed by the framework
 //! configuration. Agnotic to all different paradigms. Supports incrementally
 //! updating for DevServer, or serializing to a binary for use in production.
-
 const FrameworkRouter = @This();
 
 /// Metadata for route files is specified out of line, either in DevServer where
@@ -288,11 +287,6 @@ pub const EncodedPattern = struct {
                 },
                 .param => |name| {
                     const end = strings.indexOfCharPos(path, '/', i) orelse path.len;
-                    // Check if we're about to exceed the maximum number of parameters
-                    if (param_num >= MatchedParams.max_count) {
-                        // TODO: ideally we should throw a nice user message
-                        bun.Output.panic("Route pattern matched more than {d} parameters. Path: {s}", .{ MatchedParams.max_count, path });
-                    }
                     params.params.len = @intCast(param_num + 1);
                     params.params.buffer[param_num] = .{
                         .key = name,
@@ -301,30 +295,8 @@ pub const EncodedPattern = struct {
                     param_num += 1;
                     i = if (end == path.len) end else end + 1;
                 },
-                .catch_all_optional, .catch_all => |name| {
-                    // Capture remaining path segments as individual parameters
-                    if (i < path.len) {
-                        var segment_start = i;
-                        while (segment_start < path.len) {
-                            const segment_end = strings.indexOfCharPos(path, '/', segment_start) orelse path.len;
-                            if (segment_start < segment_end) {
-                                // Check if we're about to exceed the maximum number of parameters
-                                if (param_num >= MatchedParams.max_count) {
-                                    // TODO: ideally we should throw a nice user message
-                                    bun.Output.panic("Route pattern matched more than {d} parameters. Path: {s}", .{ MatchedParams.max_count, path });
-                                }
-                                params.params.len = @intCast(param_num + 1);
-                                params.params.buffer[param_num] = .{
-                                    .key = name,
-                                    .value = path[segment_start..segment_end],
-                                };
-                                param_num += 1;
-                            }
-                            segment_start = if (segment_end == path.len) segment_end else segment_end + 1;
-                        }
-                    }
-                    return true;
-                },
+                .catch_all_optional => return true,
+                .catch_all => break,
                 .group => continue,
             }
         }
@@ -1364,17 +1336,15 @@ pub const JSFrameworkRouter = struct {
 };
 
 const std = @import("std");
+const mem = std.mem;
+const Allocator = mem.Allocator;
 
 const bun = @import("bun");
 const strings = bun.strings;
+const Resolver = bun.resolver.Resolver;
+const DirInfo = bun.resolver.DirInfo;
 
 const JSC = bun.JSC;
-const CallFrame = JSC.CallFrame;
-const JSGlobalObject = JSC.JSGlobalObject;
 const JSValue = JSC.JSValue;
-
-const DirInfo = bun.resolver.DirInfo;
-const Resolver = bun.resolver.Resolver;
-
-const mem = std.mem;
-const Allocator = mem.Allocator;
+const JSGlobalObject = JSC.JSGlobalObject;
+const CallFrame = JSC.CallFrame;

src/bake/bake.d.ts

@@ -418,9 +418,9 @@ declare module "bun" {
     }
 
     type GetParamIterator =
-      | AsyncIterable<Record<string, string | string[]>, GetParamsFinalOpts>
-      | Iterable<Record<string, string | string[]>, GetParamsFinalOpts>
-      | ({ pages: Array<Record<string, string | string[]>> } & GetParamsFinalOpts);
+      | AsyncIterable<Record<string, string>, GetParamsFinalOpts>
+      | Iterable<Record<string, string>, GetParamsFinalOpts>
+      | ({ pages: Array<Record<string, string>> } & GetParamsFinalOpts);
 
     type GetParamsFinalOpts = void | null | {
       /**
@@ -478,7 +478,7 @@ declare module "bun" {
        */
       readonly layouts: ReadonlyArray<any>;
       /** Received route params. `null` if the route does not take params */
-      readonly params: null | Record<string, string | string[]>;
+      readonly params: null | Record<string, string>;
       /**
        * A list of js files that the route will need to be interactive.
        */

src/bake/bake.zig

@@ -38,18 +38,6 @@ pub const UserOptions = struct {
         errdefer allocations.free();
         var bundler_options = SplitBundlerOptions.empty;
 
-        if (try config.getOptional(global, "bundlerOptions", JSValue)) |js_options| {
-            if (try js_options.getOptional(global, "server", JSValue)) |server_options| {
-                bundler_options.server = try BuildConfigSubset.fromJS(global, server_options);
-            }
-            if (try js_options.getOptional(global, "client", JSValue)) |client_options| {
-                bundler_options.client = try BuildConfigSubset.fromJS(global, client_options);
-            }
-            if (try js_options.getOptional(global, "ssr", JSValue)) |ssr_options| {
-                bundler_options.ssr = try BuildConfigSubset.fromJS(global, ssr_options);
-            }
-        }
-
         const framework = try Framework.fromJS(
             try config.get(global, "framework") orelse {
                 return global.throwInvalidArguments("'" ++ api_name ++ "' is missing 'framework'", .{});
@@ -167,45 +155,6 @@ const BuildConfigSubset = struct {
     env: bun.Schema.Api.DotEnvBehavior = ._none,
     env_prefix: ?[]const u8 = null,
     define: bun.Schema.Api.StringMap = .{ .keys = &.{}, .values = &.{} },
-    source_map: bun.Schema.Api.SourceMapMode = .external,
-
-    minify_syntax: ?bool = null,
-    minify_identifiers: ?bool = null,
-    minify_whitespace: ?bool = null,
-
-    pub fn fromJS(global: *JSC.JSGlobalObject, js_options: JSValue) bun.JSError!BuildConfigSubset {
-        var options = BuildConfigSubset{};
-
-        if (try js_options.getOptional(global, "sourcemap", JSValue)) |val| brk: {
-            if (try bun.Schema.Api.SourceMapMode.fromJS(global, val)) |sourcemap| {
-                options.source_map = sourcemap;
-                break :brk;
-            }
-
-            return bun.JSC.Node.validators.throwErrInvalidArgType(global, "sourcemap", .{}, "\"inline\" | \"external\" | \"linked\"", val);
-        }
-
-        if (try js_options.getOptional(global, "minify", JSValue)) |minify_options| brk: {
-            if (minify_options.isBoolean() and minify_options.asBoolean()) {
-                options.minify_syntax = minify_options.asBoolean();
-                options.minify_identifiers = minify_options.asBoolean();
-                options.minify_whitespace = minify_options.asBoolean();
-                break :brk;
-            }
-
-            if (try minify_options.getBooleanLoose(global, "whitespace")) |value| {
-                options.minify_whitespace = value;
-            }
-            if (try minify_options.getBooleanLoose(global, "syntax")) |value| {
-                options.minify_syntax = value;
-            }
-            if (try minify_options.getBooleanLoose(global, "identifiers")) |value| {
-                options.minify_identifiers = value;
-            }
-        }
-
-        return options;
-    }
 };
 
 /// A "Framework" in our eyes is simply set of bundler options that a framework
@@ -628,6 +577,11 @@ pub const Framework = struct {
             try bundler_options.parsePluginArray(plugin_array, global);
         }
 
+        if (try opts.getOptional(global, "bundlerOptions", JSValue)) |js_options| {
+            _ = js_options; // TODO:
+            // try bundler_options.parseInto(global, js_options, .root);
+        }
+
         return framework;
     }
 
@@ -649,7 +603,7 @@ pub const Framework = struct {
             else => .none,
         };
 
-        return initTranspilerWithOptions(
+        return initTranspilerWithSourceMap(
             framework,
             arena,
             log,
@@ -658,13 +612,10 @@ pub const Framework = struct {
             out,
             bundler_options,
             source_map,
-            null,
-            null,
-            null,
         );
     }
 
-    pub fn initTranspilerWithOptions(
+    pub fn initTranspilerWithSourceMap(
         framework: *Framework,
         arena: std.mem.Allocator,
         log: *bun.logger.Log,
@@ -673,9 +624,6 @@ pub const Framework = struct {
         out: *bun.transpiler.Transpiler,
         bundler_options: *const BuildConfigSubset,
         source_map: bun.options.SourceMapOption,
-        minify_whitespace: ?bool,
-        minify_syntax: ?bool,
-        minify_identifiers: ?bool,
     ) !void {
         const JSAst = bun.JSAst;
 
@@ -740,9 +688,9 @@ pub const Framework = struct {
 
         out.options.production = mode != .development;
         out.options.tree_shaking = mode != .development;
-        out.options.minify_syntax = minify_syntax orelse (mode != .development);
-        out.options.minify_identifiers = minify_identifiers orelse (mode != .development);
-        out.options.minify_whitespace = minify_whitespace orelse (mode != .development);
+        out.options.minify_syntax = mode != .development;
+        out.options.minify_identifiers = mode != .development;
+        out.options.minify_whitespace = mode != .development;
         out.options.css_chunking = true;
         out.options.framework = framework;
         out.options.inline_entrypoint_import_meta_main = true;

src/bake/production.zig

@@ -38,7 +38,9 @@ pub fn buildCommand(ctx: bun.CLI.Command.Context) !void {
     defer vm.deinit();
     // A special global object is used to allow registering virtual modules
     // that bypass Bun's normal module resolver and plugin system.
+    vm.global = BakeCreateProdGlobal(vm.console);
     vm.regular_event_loop.global = vm.global;
+    vm.jsc = vm.global.vm();
     vm.event_loop.ensureWaker();
     const b = &vm.transpiler;
     vm.preload = ctx.preloads;
@@ -80,21 +82,7 @@ pub fn buildCommand(ctx: bun.CLI.Command.Context) !void {
 
     const api_lock = vm.jsc.getAPILock();
     defer api_lock.release();
-
-    var pt: PerThread = .{
-        .input_files = &.{},
-        .bundled_outputs = &.{},
-        .output_indexes = &.{},
-        .module_keys = &.{},
-        .module_map = .{},
-        .source_maps = .{},
-
-        .vm = vm,
-        .loaded_files = bun.bit_set.AutoBitSet.initEmpty(vm.allocator, 0) catch unreachable,
-        .all_server_files = JSValue.null,
-    };
-
-    buildWithVm(ctx, cwd, vm, &pt) catch |err| switch (err) {
+    buildWithVm(ctx, cwd, vm) catch |err| switch (err) {
         error.JSError => |e| {
             bun.handleErrorReturnTrace(err, @errorReturnTrace());
             const err_value = vm.global.takeException(e);
@@ -108,34 +96,7 @@ pub fn buildCommand(ctx: bun.CLI.Command.Context) !void {
     };
 }
 
-pub fn writeSourcemapToDisk(
-    allocator: std.mem.Allocator,
-    file: *const OutputFile,
-    bundled_outputs: []const OutputFile,
-    source_maps: *bun.StringArrayHashMapUnmanaged(OutputFile.Index),
-) !void {
-    // don't call this if the file does not have sourcemaps!
-    bun.assert(file.source_map_index != std.math.maxInt(u32));
-
-    // TODO: should we just write the sourcemaps to disk?
-    const source_map_index = file.source_map_index;
-    const source_map_file: *const OutputFile = &bundled_outputs[source_map_index];
-    bun.assert(source_map_file.output_kind == .sourcemap);
-
-    const without_prefix = if (bun.strings.hasPrefixComptime(file.dest_path, "./") or
-        (Environment.isWindows and bun.strings.hasPrefixComptime(file.dest_path, ".\\")))
-        file.dest_path[2..]
-    else
-        file.dest_path;
-
-    try source_maps.put(
-        allocator,
-        try std.fmt.allocPrint(allocator, "bake:/{s}", .{without_prefix}),
-        OutputFile.Index.init(@intCast(source_map_index)),
-    );
-}
-
-pub fn buildWithVm(ctx: bun.CLI.Command.Context, cwd: []const u8, vm: *VirtualMachine, pt: *PerThread) !void {
+pub fn buildWithVm(ctx: bun.CLI.Command.Context, cwd: []const u8, vm: *VirtualMachine) !void {
     // Load and evaluate the configuration module
     const global = vm.global;
     const b = &vm.transpiler;
@@ -213,10 +174,10 @@ pub fn buildWithVm(ctx: bun.CLI.Command.Context, cwd: []const u8, vm: *VirtualMa
     var client_transpiler: bun.transpiler.Transpiler = undefined;
     var server_transpiler: bun.transpiler.Transpiler = undefined;
     var ssr_transpiler: bun.transpiler.Transpiler = undefined;
-    try framework.initTranspilerWithOptions(allocator, vm.log, .production_static, .server, &server_transpiler, &options.bundler_options.server, bun.options.SourceMapOption.fromApi(options.bundler_options.server.source_map), options.bundler_options.server.minify_whitespace, options.bundler_options.server.minify_syntax, options.bundler_options.server.minify_identifiers);
-    try framework.initTranspilerWithOptions(allocator, vm.log, .production_static, .client, &client_transpiler, &options.bundler_options.client, bun.options.SourceMapOption.fromApi(options.bundler_options.client.source_map), options.bundler_options.client.minify_whitespace, options.bundler_options.client.minify_syntax, options.bundler_options.client.minify_identifiers);
+    try framework.initTranspilerWithSourceMap(allocator, vm.log, .production_static, .server, &server_transpiler, &options.bundler_options.server, .@"inline");
+    try framework.initTranspilerWithSourceMap(allocator, vm.log, .production_static, .client, &client_transpiler, &options.bundler_options.client, .@"inline");
     if (separate_ssr_graph) {
-        try framework.initTranspilerWithOptions(allocator, vm.log, .production_static, .ssr, &ssr_transpiler, &options.bundler_options.ssr, bun.options.SourceMapOption.fromApi(options.bundler_options.ssr.source_map), options.bundler_options.ssr.minify_whitespace, options.bundler_options.ssr.minify_syntax, options.bundler_options.ssr.minify_identifiers);
+        try framework.initTranspilerWithSourceMap(allocator, vm.log, .production_static, .ssr, &ssr_transpiler, &options.bundler_options.ssr, .@"inline");
     }
 
     if (ctx.bundler_options.bake_debug_disable_minify) {
@@ -300,11 +261,6 @@ pub fn buildWithVm(ctx: bun.CLI.Command.Context, cwd: []const u8, vm: *VirtualMa
         .{ .js = vm.event_loop },
     );
     const bundled_outputs = bundled_outputs_list.items;
-    if (bundled_outputs.len == 0) {
-        Output.prettyln("done", .{});
-        Output.flush();
-        return;
-    }
 
     Output.prettyErrorln("Rendering routes", .{});
     Output.flush();
@@ -312,8 +268,6 @@ pub fn buildWithVm(ctx: bun.CLI.Command.Context, cwd: []const u8, vm: *VirtualMa
     var root_dir = try std.fs.cwd().makeOpenPath("dist", .{});
     defer root_dir.close();
 
-    var maybe_runtime_file_index: ?u32 = null;
-
     var css_chunks_count: usize = 0;
     var css_chunks_first: usize = 0;
 
@@ -324,22 +278,16 @@ pub fn buildWithVm(ctx: bun.CLI.Command.Context, cwd: []const u8, vm: *VirtualMa
     const module_keys = try vm.allocator.alloc(bun.String, entry_points.files.count());
     const output_indexes = entry_points.files.values();
     var output_module_map: bun.StringArrayHashMapUnmanaged(OutputFile.Index) = .{};
-    var source_maps: bun.StringArrayHashMapUnmanaged(OutputFile.Index) = .{};
     @memset(module_keys, bun.String.dead);
     for (bundled_outputs, 0..) |file, i| {
-        log("src_index={any} side={s} src={s} dest={s} - {?d}\n", .{
-            file.source_index.unwrap(),
+        log("{s} - {s} : {s} - {?d}\n", .{
             if (file.side) |s| @tagName(s) else "null",
             file.src_path.text,
             file.dest_path,
             file.entry_point_index,
         });
         if (file.loader.isCSS()) {
-            if (css_chunks_count == 0) {
-                css_chunks_first = i;
-            } else {
-                css_chunks_first = @min(css_chunks_first, i);
-            }
+            if (css_chunks_count == 0) css_chunks_first = i;
             css_chunks_count += 1;
         }
 
@@ -349,17 +297,6 @@ pub fn buildWithVm(ctx: bun.CLI.Command.Context, cwd: []const u8, vm: *VirtualMa
             }
         }
 
-        // The output file which contains the runtime (Index.runtime, contains
-        // wrapper functions like `__esm`) is marked as server side, but it is
-        // also used by client
-        if (file.bake_extra.bake_is_runtime) {
-            if (comptime bun.Environment.allow_assert) {
-                bun.assertf(maybe_runtime_file_index == null, "Runtime file should only be in one chunk.", .{});
-            }
-            maybe_runtime_file_index = @intCast(i);
-        }
-
-        // TODO: Maybe not do all the disk-writing in 1 thread?
         switch (file.side orelse continue) {
             .client => {
                 // Client-side resources will be written to disk for usage in on the client side
@@ -369,6 +306,7 @@ pub fn buildWithVm(ctx: bun.CLI.Command.Context, cwd: []const u8, vm: *VirtualMa
                 };
             },
             .server => {
+                // For Debugging
                 if (ctx.bundler_options.bake_debug_dump_server) {
                     _ = file.writeToDisk(root_dir, ".") catch |err| {
                         bun.handleErrorReturnTrace(err, @errorReturnTrace());
@@ -376,13 +314,6 @@ pub fn buildWithVm(ctx: bun.CLI.Command.Context, cwd: []const u8, vm: *VirtualMa
                     };
                 }
 
-                // If the file has a sourcemap, store it so we can put it on
-                // `PerThread` so we can provide sourcemapped stacktraces for
-                // server components.
-                if (file.source_map_index != std.math.maxInt(u32)) {
-                    try writeSourcemapToDisk(allocator, &file, bundled_outputs, &source_maps);
-                }
-
                 switch (file.output_kind) {
                     .@"entry-point", .chunk => {
                         const without_prefix = if (bun.strings.hasPrefixComptime(file.dest_path, "./") or
@@ -399,8 +330,6 @@ pub fn buildWithVm(ctx: bun.CLI.Command.Context, cwd: []const u8, vm: *VirtualMa
                             }
                         }
 
-                        log("  adding module map entry: output_module_map(bake:/{s}) = {d}\n", .{ without_prefix, i });
-
                         try output_module_map.put(
                             allocator,
                             try std.fmt.allocPrint(allocator, "bake:/{s}", .{without_prefix}),
@@ -413,34 +342,6 @@ pub fn buildWithVm(ctx: bun.CLI.Command.Context, cwd: []const u8, vm: *VirtualMa
                 }
             },
         }
-
-        // TODO: should we just write the sourcemaps to disk?
-        if (file.source_map_index != std.math.maxInt(u32)) {
-            try writeSourcemapToDisk(allocator, &file, bundled_outputs, &source_maps);
-        }
-    }
-    // Write the runtime file to disk if there are any client chunks
-    {
-        const runtime_file_index = maybe_runtime_file_index orelse {
-            bun.Output.panic("Runtime file not found. This is an unexpected bug in Bun. Please file a bug report on GitHub.", .{});
-        };
-        const any_client_chunks = any_client_chunks: {
-            for (bundled_outputs) |file| {
-                if (file.side) |s| {
-                    if (s == .client and !bun.strings.eqlComptime(file.src_path.text, "bun-framework-react/client.tsx")) {
-                        break :any_client_chunks true;
-                    }
-                }
-            }
-            break :any_client_chunks false;
-        };
-        if (any_client_chunks) {
-            const runtime_file: *const OutputFile = &bundled_outputs[runtime_file_index];
-            _ = runtime_file.writeToDisk(root_dir, ".") catch |err| {
-                bun.handleErrorReturnTrace(err, @errorReturnTrace());
-                Output.err(err, "Failed to write {} to output directory", .{bun.fmt.quote(runtime_file.dest_path)});
-            };
-        }
     }
 
     const per_thread_options: PerThread.Options = .{
@@ -449,10 +350,9 @@ pub fn buildWithVm(ctx: bun.CLI.Command.Context, cwd: []const u8, vm: *VirtualMa
         .output_indexes = output_indexes,
         .module_keys = module_keys,
         .module_map = output_module_map,
-        .source_maps = source_maps,
     };
 
-    pt.* = try PerThread.init(vm, per_thread_options);
+    var pt = try PerThread.init(vm, per_thread_options);
     pt.attach();
 
     // Static site generator
@@ -517,33 +417,15 @@ pub fn buildWithVm(ctx: bun.CLI.Command.Context, cwd: []const u8, vm: *VirtualMa
     const css_chunk_js_strings = try allocator.alloc(JSValue, css_chunks_count);
     for (bundled_outputs[css_chunks_first..][0..css_chunks_count], css_chunk_js_strings) |output_file, *str| {
         bun.assert(output_file.dest_path[0] != '.');
-        // CSS chunks must be in contiguous order!!
         bun.assert(output_file.loader.isCSS());
         str.* = (try bun.String.createFormat("{s}{s}", .{ public_path, output_file.dest_path })).toJS(global);
     }
 
-    // Route URL patterns with parameter placeholders.
-    // Examples: "/", "/about", "/blog/:slug", "/products/:category/:id"
     const route_patterns = try JSValue.createEmptyArray(global, navigatable_routes.items.len);
-
-    // File indices for each route's components (page, layouts).
-    // Example: [2, 5, 0] = page at index 2, layout at 5, root layout at 0
     const route_nested_files = try JSValue.createEmptyArray(global, navigatable_routes.items.len);
-
-    // Router type index (lower 8 bits) and flags (upper 24 bits).
-    // Example: 0x00000001 = router type 1, no flags
     const route_type_and_flags = try JSValue.createEmptyArray(global, navigatable_routes.items.len);
-
-    // Source file paths relative to project root.
-    // Examples: "pages/index.tsx", "pages/blog/[slug].tsx"
     const route_source_files = try JSValue.createEmptyArray(global, navigatable_routes.items.len);
-
-    // Parameter names for dynamic routes (reversed order), null for static routes.
-    // Examples: ["slug"] for /blog/[slug], ["id", "category"] for /products/[category]/[id]
     const route_param_info = try JSValue.createEmptyArray(global, navigatable_routes.items.len);
-
-    // CSS chunk URLs for each route.
-    // Example: ["/assets/main.css", "/assets/blog.css"]
     const route_style_references = try JSValue.createEmptyArray(global, navigatable_routes.items.len);
 
     var params_buf: std.ArrayListUnmanaged([]const u8) = .{};
@@ -562,18 +444,15 @@ pub fn buildWithVm(ctx: bun.CLI.Command.Context, cwd: []const u8, vm: *VirtualMa
             .param => {
                 params_buf.append(ctx.allocator, route.part.param) catch unreachable;
             },
-            .catch_all => {
-                params_buf.append(ctx.allocator, route.part.catch_all) catch unreachable;
-            },
-            .catch_all_optional => {
+            .catch_all, .catch_all_optional => {
                 return global.throw("catch-all routes are not supported in static site generation", .{});
             },
             else => {},
         }
         var file_count: u32 = 1;
-        var css_file_count: u32 = @intCast(main_file.referenced_css_chunks.len);
+        var css_file_count: u32 = @intCast(main_file.referenced_css_files.len);
         if (route.file_layout.unwrap()) |file| {
-            css_file_count += @intCast(pt.outputFile(file).referenced_css_chunks.len);
+            css_file_count += @intCast(pt.outputFile(file).referenced_css_files.len);
             file_count += 1;
         }
         var next: ?FrameworkRouter.Route.Index = route.parent.unwrap();
@@ -584,16 +463,13 @@ pub fn buildWithVm(ctx: bun.CLI.Command.Context, cwd: []const u8, vm: *VirtualMa
                 .param => {
                     params_buf.append(ctx.allocator, parent.part.param) catch unreachable;
                 },
-                .catch_all => {
-                    params_buf.append(ctx.allocator, parent.part.catch_all) catch unreachable;
-                },
-                .catch_all_optional => {
+                .catch_all, .catch_all_optional => {
                     return global.throw("catch-all routes are not supported in static site generation", .{});
                 },
                 else => {},
             }
             if (parent.file_layout.unwrap()) |file| {
-                css_file_count += @intCast(pt.outputFile(file).referenced_css_chunks.len);
+                css_file_count += @intCast(pt.outputFile(file).referenced_css_files.len);
                 file_count += 1;
             }
             next = parent.parent.unwrap();
@@ -607,13 +483,13 @@ pub fn buildWithVm(ctx: bun.CLI.Command.Context, cwd: []const u8, vm: *VirtualMa
         file_count = 1;
         css_file_count = 0;
         try file_list.putIndex(global, 0, try pt.preloadBundledModule(main_file_route_index));
-        for (main_file.referenced_css_chunks) |ref| {
+        for (main_file.referenced_css_files) |ref| {
             try styles.putIndex(global, css_file_count, css_chunk_js_strings[ref.get() - css_chunks_first]);
             css_file_count += 1;
         }
         if (route.file_layout.unwrap()) |file| {
             try file_list.putIndex(global, file_count, try pt.preloadBundledModule(file));
-            for (pt.outputFile(file).referenced_css_chunks) |ref| {
+            for (pt.outputFile(file).referenced_css_files) |ref| {
                 try styles.putIndex(global, css_file_count, css_chunk_js_strings[ref.get() - css_chunks_first]);
                 css_file_count += 1;
             }
@@ -624,7 +500,7 @@ pub fn buildWithVm(ctx: bun.CLI.Command.Context, cwd: []const u8, vm: *VirtualMa
             const parent = router.routePtr(parent_index);
             if (parent.file_layout.unwrap()) |file| {
                 try file_list.putIndex(global, file_count, try pt.preloadBundledModule(file));
-                for (pt.outputFile(file).referenced_css_chunks) |ref| {
+                for (pt.outputFile(file).referenced_css_files) |ref| {
                     try styles.putIndex(global, css_file_count, css_chunk_js_strings[ref.get() - css_chunks_first]);
                     css_file_count += 1;
                 }
@@ -644,7 +520,6 @@ pub fn buildWithVm(ctx: bun.CLI.Command.Context, cwd: []const u8, vm: *VirtualMa
         try route_nested_files.putIndex(global, @intCast(nav_index), file_list);
         try route_type_and_flags.putIndex(global, @intCast(nav_index), JSValue.jsNumberFromInt32(@bitCast(TypeAndFlags{
             .type = route.type.get(),
-            .no_client = main_file.bake_extra.fully_static,
         })));
 
         if (params_buf.items.len > 0) {
@@ -695,12 +570,6 @@ fn loadModule(vm: *VirtualMachine, global: *JSC.JSGlobalObject, key: JSValue) !J
     const promise = BakeLoadModuleByKey(global, key).asAnyPromise().?.internal;
     promise.setHandled(vm.jsc);
     vm.waitForPromise(.{ .internal = promise });
-    // TODO: Specially draining microtasks here because `waitForPromise` has a
-    //       bug which forgets to do it, but I don't want to fix it right now as it
-    //       could affect a lot of the codebase. This should be removed.
-    vm.eventLoop().drainMicrotasks() catch {
-        bun.Global.crash();
-    };
     switch (promise.unwrap(vm.jsc, .mark_handled)) {
         .pending => unreachable,
         .fulfilled => |val| {
@@ -729,33 +598,23 @@ fn BakeGetOnModuleNamespace(global: *JSC.JSGlobalObject, module: JSValue, proper
     return result;
 }
 
-/// Renders all routes for static site generation by calling the JavaScript implementation.
 extern fn BakeRenderRoutesForProdStatic(
     *JSC.JSGlobalObject,
-    /// Output directory path (e.g., "./dist")
     out_base: bun.String,
-    /// Server module paths (e.g., ["bake://page.js", "bake://layout.js"])
     all_server_files: JSValue,
-    /// Framework prerender functions by router type
     render_static: JSValue,
-    /// Framework getParams functions by router type
     get_params: JSValue,
-    /// Client entry URLs by router type (e.g., ["/client.js", null])
     client_entry_urls: JSValue,
-    /// Route patterns (e.g., ["/", "/about", "/blog/:slug"])
     patterns: JSValue,
-    /// File indices per route (e.g., [[0], [1], [2, 0]])
     files: JSValue,
-    /// Packed router type and flags (e.g., [0x00000000, 0x00000001])
     type_and_flags: JSValue,
-    /// Source paths (e.g., ["pages/index.tsx", "pages/blog/[slug].tsx"])
     src_route_files: JSValue,
-    /// Dynamic route params (e.g., [null, null, ["slug"]])
     param_information: JSValue,
-    /// CSS URLs per route (e.g., [["/main.css"], ["/main.css", "/blog.css"]])
     styles: JSValue,
 ) *JSC.JSPromise;
 
+extern fn BakeCreateProdGlobal(console_ptr: *anyopaque) *JSC.JSGlobalObject;
+
 /// The result of this function is a JSValue that wont be garbage collected, as
 /// it will always have at least one reference by the module loader.
 fn BakeRegisterProductionChunk(global: *JSC.JSGlobalObject, key: bun.String, source_code: bun.String) bun.JSError!JSValue {
@@ -768,21 +627,6 @@ fn BakeRegisterProductionChunk(global: *JSC.JSGlobalObject, key: bun.String, sou
     return result;
 }
 
-pub export fn BakeToWindowsPath(input: bun.String) callconv(.C) bun.String {
-    if (comptime bun.Environment.isPosix) {
-        @panic("This code should not be called on POSIX systems.");
-    }
-    var sfa = std.heap.stackFallback(1024, bun.default_allocator);
-    const alloc = sfa.get();
-    const input_utf8 = input.toUTF8(alloc);
-    defer input_utf8.deinit();
-    const input_slice = input_utf8.slice();
-    const output = bun.w_path_buffer_pool.get();
-    defer bun.w_path_buffer_pool.put(output);
-    const output_slice = bun.strings.toWPathNormalizeAutoExtend(output.*[0..], input_slice);
-    return bun.String.cloneUTF16(output_slice);
-}
-
 pub export fn BakeProdResolve(global: *JSC.JSGlobalObject, a_str: bun.String, specifier_str: bun.String) callconv(.C) bun.String {
     var sfa = std.heap.stackFallback(@sizeOf(bun.PathBuffer) * 2, bun.default_allocator);
     const alloc = sfa.get();
@@ -809,7 +653,7 @@ pub export fn BakeProdResolve(global: *JSC.JSGlobalObject, a_str: bun.String, sp
 
     return bun.String.createFormat("bake:{s}", .{bun.path.joinAbs(
         bun.Dirname.dirname(u8, referrer.slice()[5..]) orelse referrer.slice()[5..],
-        .posix, // force posix paths in bake
+        .auto,
         specifier.slice(),
     )}) catch return bun.String.dead;
 }
@@ -899,7 +743,6 @@ pub const PerThread = struct {
     module_keys: []const bun.String,
     /// Unordered
     module_map: bun.StringArrayHashMapUnmanaged(OutputFile.Index),
-    source_maps: bun.StringArrayHashMapUnmanaged(OutputFile.Index),
 
     // Thread-local
     vm: *JSC.VirtualMachine,
@@ -918,7 +761,6 @@ pub const PerThread = struct {
         module_keys: []const bun.String,
         /// Unordered
         module_map: bun.StringArrayHashMapUnmanaged(OutputFile.Index),
-        source_maps: bun.StringArrayHashMapUnmanaged(OutputFile.Index),
     };
 
     extern fn BakeGlobalObject__attachPerThreadData(global: *JSC.JSGlobalObject, pt: ?*PerThread) void;
@@ -940,7 +782,6 @@ pub const PerThread = struct {
             .vm = vm,
             .loaded_files = loaded_files,
             .all_server_files = all_server_files,
-            .source_maps = opts.source_maps,
         };
     }
 
@@ -966,7 +807,7 @@ pub const PerThread = struct {
     }
 
     // Must be run at the top of the event loop
-    pub fn loadBundledModule(pt: *PerThread, id: OpaqueFileId) !JSValue {
+    pub fn loadBundledModule(pt: *PerThread, id: OpaqueFileId) bun.JSError!JSValue {
         return try loadModule(
             pt.vm,
             pt.vm.global,
@@ -1001,20 +842,7 @@ pub export fn BakeProdLoad(pt: *PerThread, key: bun.String) bun.String {
     const allocator = sfa.get();
     const utf8 = key.toUTF8(allocator);
     defer utf8.deinit();
-    log("BakeProdLoad: {s}\n", .{utf8.slice()});
     if (pt.module_map.get(utf8.slice())) |value| {
-        log("  found in module_map: {s}\n", .{utf8.slice()});
-        return pt.bundled_outputs[value.get()].value.toBunString();
-    }
-    return bun.String.dead;
-}
-
-pub export fn BakeProdSourceMap(pt: *PerThread, key: bun.String) bun.String {
-    var sfa = std.heap.stackFallback(4096, bun.default_allocator);
-    const allocator = sfa.get();
-    const utf8 = key.toUTF8(allocator);
-    defer utf8.deinit();
-    if (pt.source_maps.get(utf8.slice())) |value| {
         return pt.bundled_outputs[value.get()].value.toBunString();
     }
     return bun.String.dead;
@@ -1022,30 +850,25 @@ pub export fn BakeProdSourceMap(pt: *PerThread, key: bun.String) bun.String {
 
 const TypeAndFlags = packed struct(i32) {
     type: u8,
-    /// Don't inclue the runtime client code (e.g.
-    /// bun-framework-react/client.tsx). This is used if we know a server
-    /// component does not include any downstream usages of "use client" and so
-    /// we can omit the client code entirely.
-    no_client: bool = false,
-    unused: u23 = 0,
+    unused: u24 = 0,
 };
 
-fn @"export"() void {
-    _ = BakeProdResolve;
-    _ = BakeProdLoad;
-}
-
 const std = @import("std");
 
 const bun = @import("bun");
 const Environment = bun.Environment;
 const Output = bun.Output;
-const bake = bun.bake;
 const OutputFile = bun.options.OutputFile;
 
+const bake = bun.bake;
+const FrameworkRouter = bake.FrameworkRouter;
+const OpaqueFileId = FrameworkRouter.OpaqueFileId;
+
 const JSC = bun.JSC;
 const JSValue = JSC.JSValue;
 const VirtualMachine = JSC.VirtualMachine;
 
-const FrameworkRouter = bake.FrameworkRouter;
-const OpaqueFileId = FrameworkRouter.OpaqueFileId;
+fn @"export"() void {
+    _ = BakeProdResolve;
+    _ = BakeProdLoad;
+}

src/base64/base64.zig

@@ -1,3 +1,6 @@
+const std = @import("std");
+const bun = @import("bun");
+
 const mixed_decoder = brk: {
     var decoder = zig_base64.standard.decoderWithIgnore("\xff \t\r\n" ++ [_]u8{
         std.ascii.control_code.vt,
@@ -553,6 +556,3 @@ const zig_base64 = struct {
         } else |err| if (err != error.NoSpaceLeft) return err;
     }
 };
-
-const bun = @import("bun");
-const std = @import("std");

src/bit_set.zig

@@ -35,6 +35,11 @@
 //!   A variant of DynamicBitSet which does not store a pointer to its
 //!   allocator, in order to save space.
 
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const bun = @import("bun");
+const Environment = bun.Environment;
+
 /// Returns the optimal static bit set type for the specified number
 /// of elements.  The returned type will perform no allocations,
 /// can be copied by value, and does not require deinitialization.
@@ -1573,6 +1578,8 @@ pub const Range = struct {
 
 // ---------------- Tests -----------------
 
+const testing = std.testing;
+
 fn testEql(empty: anytype, full: anytype, len: usize) !void {
     try testing.expect(empty.eql(empty));
     try testing.expect(full.eql(full));
@@ -1927,10 +1934,3 @@ fn testStaticBitSet(comptime Set: type, comptime Container: @Type(.enum_literal)
 
     try testPureBitSet(Set);
 }
-
-const bun = @import("bun");
-const Environment = bun.Environment;
-
-const std = @import("std");
-const testing = std.testing;
-const Allocator = std.mem.Allocator;