From 830648024264c021b76b1d67808286b606b03fba Mon Sep 17 00:00:00 2001
From: Jarred Sumner <jarred@jarredsumner.com>
Date: Mon, 19 Oct 2026 00:44:30 +0000
Subject: [PATCH 01/24] bun run --filter: use original-case basename for
 workspace dirs (#29941)

---
 src/resolver/lib.rs                   | 37 ++---------------
 test/cli/run/filter-workspace.test.ts | 60 +++++++++++++++++++++++++++
 2 files changed, 64 insertions(+), 33 deletions(-)

diff --git a/src/resolver/lib.rs b/src/resolver/lib.rs
index 40f158b9468e..466c2aa92824 100644
--- a/src/resolver/lib.rs
+++ b/src/resolver/lib.rs
@@ -1732,38 +1732,16 @@ pub mod dir_entry_accessor {
     }
 
     pub struct DirEntryIterResult {
-        pub(crate) name: DirEntryNameWrapper,
+        pub(crate) entry: bun_ptr::BackRef<Entry>,
         pub(crate) kind: bun_sys::FileKind,
         /// Resolver-cached real path of a symlink entry's target
         /// (`Interned::EMPTY` for non-symlinks).
         pub(crate) symlink_target: bun_ptr::Interned,
     }
 
-    pub(crate) struct DirEntryNameWrapper {
-        // BACKREF: borrowed slice into a `Box<[u8]>` key owned by
-        // `DirEntry.data: HashMap`. Valid only while the parent `DirEntry`
-        // is live and not regenerated by `read_directory`. Stored as
-        // [`bun_ptr::RawSlice`] (not `&'static [u8]`) per PORTING.md
-        // §Forbidden — the key is individually heap-allocated by the HashMap,
-        // not a BSS-arena slice, so minting a `'static` borrow via
-        // `from_raw_parts` would be a lifetime lie. `RawSlice` encapsulates
-        // the outlives-holder invariant so `slice()` is safe.
-        pub value: bun_ptr::RawSlice<u8>,
-    }
-
-    impl DirEntryNameWrapper {
-        #[inline]
-        fn slice(&self) -> &[u8] {
-            // BACKREF — see field comment. The GlobWalker consumes
-            // `name_slice()` before advancing the iterator or reopening the
-            // directory, so the pointee `Box<[u8]>` is still alive here.
-            self.value.slice()
-        }
-    }
-
     impl AccessorDirEntry for DirEntryIterResult {
         fn name_slice(&self) -> &[u8] {
-            self.name.slice()
+            self.entry.base()
         }
         fn kind(&self) -> bun_sys::FileKind {
             self.kind
@@ -1781,7 +1759,7 @@ pub mod dir_entry_accessor {
         #[inline]
         fn next(&mut self) -> Maybe<Option<DirEntryIterResult>> {
             if let Some(value) = &mut self.value {
-                let Some((key, val)) = value.next() else {
+                let Some((_, val)) = value.next() else {
                     return Ok(None);
                 };
                 // BACKREF: ARENA — `*mut Entry` points into the EntryStore
@@ -1806,15 +1784,8 @@ pub mod dir_entry_accessor {
                 // `Entry::kind` resolved through symlinks above; a non-empty
                 // cached realpath is what records the entry as a symlink.
                 let symlink_target = entry.cache().symlink;
-                // BACKREF: wrap the HashMap key's bytes in a `RawSlice`
-                // instead of fabricating `&'static [u8]` (PORTING.md §Forbidden).
-                // The key is a `Box<[u8]>` owned by `DirEntry.data` and valid
-                // until the next `read_directory` regeneration; `name_slice()`
-                // re-narrows the lifetime so it never escapes the iter result.
                 Ok(Some(DirEntryIterResult {
-                    name: DirEntryNameWrapper {
-                        value: bun_ptr::RawSlice::new(&**key),
-                    },
+                    entry,
                     kind: fskind,
                     symlink_target,
                 }))
diff --git a/test/cli/run/filter-workspace.test.ts b/test/cli/run/filter-workspace.test.ts
index 423eeead4645..9363f349d1b1 100644
--- a/test/cli/run/filter-workspace.test.ts
+++ b/test/cli/run/filter-workspace.test.ts
@@ -836,6 +836,66 @@ describe("bun", () => {
     expect(stderr).toContain("skipping this workspace package");
     expect(exitCode).toBe(0);
   });
+
+  // https://github.com/oven-sh/bun/issues/21670
+  describe("a workspace directory with an upper-case letter in its name", () => {
+    const member = (name: string) => ({
+      "package.json": JSON.stringify({ name, scripts: { build: `echo BUILD-${name}` } }),
+    });
+
+    test.concurrent.each([
+      {
+        entry: "a glob",
+        workspaces: ["packages/*"],
+        files: { packages: { Core: member("core"), lower: member("lower") } },
+      },
+      {
+        entry: "a literal path",
+        workspaces: ["packages/Core", "packages/lower"],
+        files: { packages: { Core: member("core"), lower: member("lower") } },
+      },
+      {
+        entry: "a nested glob",
+        workspaces: ["packages/*/*"],
+        files: { packages: { UPPER: { Inner: member("core") }, group: { lower: member("lower") } } },
+      },
+    ])("is found through $entry in workspaces", async ({ workspaces, files }) => {
+      using dir = tempDir("filter-upper-case-dir", {
+        ...files,
+        "package.json": JSON.stringify({ name: "root", private: true, workspaces }),
+      });
+
+      async function run(...selection: string[]) {
+        await using proc = Bun.spawn({
+          cmd: [bunExe(), "run", ...selection, "build"],
+          cwd: String(dir),
+          env: bunEnv,
+          stdout: "pipe",
+          stderr: "pipe",
+        });
+        const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+        return {
+          ran: [...new Set(stdout.match(/BUILD-\w+/g))].sort(),
+          errors: stderr.split("\n").filter(line => line.startsWith("error")),
+          exitCode,
+        };
+      }
+
+      const [all, everyWorkspace, byName, byPath] = await Promise.all([
+        run("--filter", "*"),
+        run("--workspaces"),
+        run("--filter", "lower"),
+        run("--filter", "./packages/**"),
+      ]);
+      const both = { ran: ["BUILD-core", "BUILD-lower"], errors: [], exitCode: 0 };
+      expect({ all, everyWorkspace, byName, byPath }).toEqual({
+        all: both,
+        everyWorkspace: both,
+        byName: { ran: ["BUILD-lower"], errors: [], exitCode: 0 },
+        byPath: both,
+      });
+    });
+  });
 });
 
 describe("selectors", () => {

From 16ece2e522d5a3dc09262e53806b8aa62a302ca7 Mon Sep 17 00:00:00 2001
From: Jarred Sumner <jarred@jarredsumner.com>
Date: Mon, 19 Oct 2026 00:44:36 +0000
Subject: [PATCH 02/24] dotenv: keep $ literal before a digit (#36030)

---
 src/dotenv/env_loader.rs |  6 ++++-
 test/cli/run/env.test.ts | 47 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 52 insertions(+), 1 deletion(-)

diff --git a/src/dotenv/env_loader.rs b/src/dotenv/env_loader.rs
index dc1e5546d9b9..3ced1d884eae 100644
--- a/src/dotenv/env_loader.rs
+++ b/src/dotenv/env_loader.rs
@@ -1109,6 +1109,10 @@ impl<'a> Parser<'a> {
         fn is_ident(b: u8) -> bool {
             matches!(b, b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9' | b'_')
         }
+        #[inline]
+        fn is_ident_start(b: u8) -> bool {
+            matches!(b, b'a'..=b'z' | b'A'..=b'Z' | b'_')
+        }
 
         let mut pos = 0;
         let mut changed = false;
@@ -1183,7 +1187,7 @@ impl<'a> Parser<'a> {
                 pos = close + 1;
                 continue;
             }
-            if is_ident(next) {
+            if is_ident_start(next) {
                 changed = true;
                 let key_start = pos + 1;
                 let mut k = key_start;
diff --git a/test/cli/run/env.test.ts b/test/cli/run/env.test.ts
index d2d1468ae41f..30dbfe40ab06 100644
--- a/test/cli/run/env.test.ts
+++ b/test/cli/run/env.test.ts
@@ -398,6 +398,53 @@ test.concurrent(".env escaped dollar sign", async () => {
   expect(stdout).toBe("foo $FOO");
 });
 
+test.concurrent(".env leaves $ literal when not followed by an identifier (issue #4994)", async () => {
+  // https://github.com/oven-sh/bun/issues/4994
+  // Expansion only fires on `$IDENT` (letter or underscore start) or `${...}`.
+  // A `$` followed by a digit, another `$`, `(`, `-`, or the end of the value
+  // stays literal, inside and outside quotes and inside a `:-` default.
+  const expected = {
+    ISSUE: "123$567",
+    P1: "price$5.00",
+    P2: "a$(b)c",
+    P3: "cost$-1",
+    P4: "$1abc",
+    P5: "end$",
+    P6: "pa$$",
+    P7: "$5.00",
+    P8: "hit$5",
+    P9: "hit$5",
+    P10: "$5",
+    P11: "123$567",
+    P12: "123$567",
+  };
+  using dir = tempDir("dotenv-literal-dollar", {
+    ".env": [
+      "ISSUE=123$567",
+      "P1=price$5.00",
+      "P2=a$(b)c",
+      "P3=cost$-1",
+      "P4=$1abc",
+      "P5=end$",
+      "P6=pa$$",
+      "P7=\\$5.00",
+      "SET=hit",
+      "P8=$SET$5",
+      "P9=${SET}$5",
+      "P10=${UNSET:-$5}",
+      'P11="123$567"',
+      "P12='123$567'",
+    ].join("\n"),
+    "index.ts":
+      `const keys = ${JSON.stringify(Object.keys(expected))};` +
+      "const out = {};" +
+      "for (const k of keys) out[k] = process.env[k];" +
+      "console.log(JSON.stringify(out));",
+  });
+  const { stdout } = await bunRun(`${dir}/index.ts`);
+  expect(JSON.parse(stdout)).toEqual(expected);
+});
+
 test.concurrent(".env doesnt crash with 159 bytes", async () => {
   using dir = tempDir("dotenv-159", {
     ".env":

From 6b0a25993dffe7ffc44597f8f2879e70f18ae6a6 Mon Sep 17 00:00:00 2001
From: Jarred Sumner <jarred@jarredsumner.com>
Date: Mon, 19 Oct 2026 00:44:41 +0000
Subject: [PATCH 03/24] Suggest bounded fd limits in the fd-exhaustion error
 hints (#37339)

---
 src/crash_handler/lib.rs               | 22 ++++++++--------
 test/cli/run/run-crash-handler.test.ts | 35 +++++++++++++++++++++++++-
 2 files changed, 45 insertions(+), 12 deletions(-)

diff --git a/src/crash_handler/lib.rs b/src/crash_handler/lib.rs
index 4ae24e90d6b9..decae93654f0 100644
--- a/src/crash_handler/lib.rs
+++ b/src/crash_handler/lib.rs
@@ -1282,21 +1282,21 @@ mod draft {
                 #[cfg(target_os = "macos")]
                 {
                     pretty_error!(
-                        "<r><red>error<r>: Your computer ran out of file descriptors <d>(<red>SystemFdQuotaExceeded<r><d>)<r>\n\n<d>Current limit: {}<r>\n\nTo fix this, try running:\n\n  <cyan>sudo launchctl limit maxfiles 2147483646<r>\n  <cyan>ulimit -n 2147483646<r>\n\nThat will only work until you reboot.\n",
+                        "<r><red>error<r>: Your computer ran out of file descriptors <d>(<red>SystemFdQuotaExceeded<r><d>)<r>\n\n<d>Current limit: {}<r>\n\nTo fix this, try running:\n\n  <cyan>sudo launchctl limit maxfiles 65536 200000<r>\n  <cyan>ulimit -n 65536<r>\n\nThat will only work until you reboot.\n",
                         bun_fmt::nullable_fallback(limit, b"<unknown>"),
                     );
                 }
                 #[cfg(target_os = "freebsd")]
                 {
                     pretty_error!(
-                        "\n<r><red>error<r>: Your computer ran out of file descriptors <d>(<red>SystemFdQuotaExceeded<r><d>)<r>\n\n<d>Current limit: {}<r>\n\nTo fix this, try running:\n\n  <cyan>sudo sysctl kern.maxfiles=2147483646 kern.maxfilesperproc=2147483646<r>\n  <cyan>ulimit -n 2147483646<r>\n\nTo persist across reboots, add to /etc/sysctl.conf and edit /etc/login.conf.\n",
+                        "\n<r><red>error<r>: Your computer ran out of file descriptors <d>(<red>SystemFdQuotaExceeded<r><d>)<r>\n\n<d>Current limit: {}<r>\n\nTo fix this, try running:\n\n  <cyan>sudo sysctl kern.maxfiles=200000 kern.maxfilesperproc=65536<r>\n  <cyan>ulimit -n 65536<r>\n\nTo persist across reboots, add to /etc/sysctl.conf and edit /etc/login.conf.\n",
                         bun_fmt::nullable_fallback(limit, b"<unknown>"),
                     );
                 }
                 #[cfg(not(any(target_os = "macos", target_os = "freebsd")))]
                 {
                     pretty_error!(
-                        "\n<r><red>error<r>: Your computer ran out of file descriptors <d>(<red>SystemFdQuotaExceeded<r><d>)<r>\n\n<d>Current limit: {}<r>\n\nTo fix this, try running:\n\n  <cyan>sudo echo -e \"\\nfs.file-max=2147483646\\n\" >> /etc/sysctl.conf<r>\n  <cyan>sudo sysctl -p<r>\n  <cyan>ulimit -n 2147483646<r>\n",
+                        "\n<r><red>error<r>: Your computer ran out of file descriptors <d>(<red>SystemFdQuotaExceeded<r><d>)<r>\n\n<d>Current limit: {}<r>\n\nTo fix this, try running:\n\n  <cyan>echo \"fs.file-max=2097152\" | sudo tee -a /etc/sysctl.conf<r>\n  <cyan>sudo sysctl -p<r>\n  <cyan>ulimit -n 65536<r>\n",
                         bun_fmt::nullable_fallback(limit, b"<unknown>"),
                     );
 
@@ -1304,7 +1304,7 @@ mod draft {
                         if !user.is_empty() {
                             let user = bstr::BStr::new(user);
                             pretty_error!(
-                                "\nIf that still doesn't work, you may need to add these lines to /etc/security/limits.conf:\n\n <cyan>{} soft nofile 2147483646<r>\n <cyan>{} hard nofile 2147483646<r>\n",
+                                "\nIf that still doesn't work, you may need to add these lines to /etc/security/limits.conf:\n\n <cyan>{} soft nofile 65536<r>\n <cyan>{} hard nofile 200000<r>\n",
                                 user,
                                 user,
                             );
@@ -1325,21 +1325,21 @@ mod draft {
                 #[cfg(target_os = "macos")]
                 {
                     pretty_error!(
-                        "\n<r><red>error<r>: bun ran out of file descriptors <d>(<red>ProcessFdQuotaExceeded<r><d>)<r>\n\n<d>Current limit: {}<r>\n\nTo fix this, try running:\n\n  <cyan>ulimit -n 2147483646<r>\n\nYou may also need to run:\n\n  <cyan>sudo launchctl limit maxfiles 2147483646<r>\n",
+                        "\n<r><red>error<r>: bun ran out of file descriptors <d>(<red>ProcessFdQuotaExceeded<r><d>)<r>\n\n<d>Current limit: {}<r>\n\nTo fix this, try running:\n\n  <cyan>ulimit -n 65536<r>\n\nYou may also need to run:\n\n  <cyan>sudo launchctl limit maxfiles 65536 200000<r>\n",
                         bun_fmt::nullable_fallback(limit, b"<unknown>"),
                     );
                 }
                 #[cfg(target_os = "freebsd")]
                 {
                     pretty_error!(
-                        "\n<r><red>error<r>: bun ran out of file descriptors <d>(<red>ProcessFdQuotaExceeded<r><d>)<r>\n\n<d>Current limit: {}<r>\n\nTo fix this, try running:\n\n  <cyan>ulimit -n 2147483646<r>\n  <cyan>sudo sysctl kern.maxfilesperproc=2147483646<r>\n",
+                        "\n<r><red>error<r>: bun ran out of file descriptors <d>(<red>ProcessFdQuotaExceeded<r><d>)<r>\n\n<d>Current limit: {}<r>\n\nTo fix this, try running:\n\n  <cyan>ulimit -n 65536<r>\n  <cyan>sudo sysctl kern.maxfilesperproc=65536<r>\n",
                         bun_fmt::nullable_fallback(limit, b"<unknown>"),
                     );
                 }
                 #[cfg(not(any(target_os = "macos", target_os = "freebsd")))]
                 {
                     pretty_error!(
-                        "\n<r><red>error<r>: bun ran out of file descriptors <d>(<red>ProcessFdQuotaExceeded<r><d>)<r>\n\n<d>Current limit: {}<r>\n\nTo fix this, try running:\n\n  <cyan>ulimit -n 2147483646<r>\n\nThat will only work for the current shell. To fix this for the entire system, run:\n\n  <cyan>sudo echo -e \"\\nfs.file-max=2147483646\\n\" >> /etc/sysctl.conf<r>\n  <cyan>sudo sysctl -p<r>\n",
+                        "\n<r><red>error<r>: bun ran out of file descriptors <d>(<red>ProcessFdQuotaExceeded<r><d>)<r>\n\n<d>Current limit: {}<r>\n\nTo fix this, try running:\n\n  <cyan>ulimit -n 65536<r>\n\nThat will only work for the current shell. To fix this for the entire system, run:\n\n  <cyan>echo \"fs.file-max=2097152\" | sudo tee -a /etc/sysctl.conf<r>\n  <cyan>sudo sysctl -p<r>\n",
                         bun_fmt::nullable_fallback(limit, b"<unknown>"),
                     );
 
@@ -1347,7 +1347,7 @@ mod draft {
                         if !user.is_empty() {
                             let user = bstr::BStr::new(user);
                             pretty_error!(
-                                "\nIf that still doesn't work, you may need to add these lines to /etc/security/limits.conf:\n\n <cyan>{} soft nofile 2147483646<r>\n <cyan>{} hard nofile 2147483646<r>\n",
+                                "\nIf that still doesn't work, you may need to add these lines to /etc/security/limits.conf:\n\n <cyan>{} soft nofile 65536<r>\n <cyan>{} hard nofile 200000<r>\n",
                                 user,
                                 user,
                             );
@@ -1370,7 +1370,7 @@ mod draft {
 
                 if limit.rlim_cur > 0 && limit.rlim_cur < (8192 * 2) {
                     pretty_error!(
-                        "\n<r><red>error<r>: An unknown error occurred, possibly due to low max file descriptors <d>(<red>Unexpected<r><d>)<r>\n\n<d>Current limit: {}<r>\n\nTo fix this, try running:\n\n  <cyan>ulimit -n 2147483646<r>\n",
+                        "\n<r><red>error<r>: An unknown error occurred, possibly due to low max file descriptors <d>(<red>Unexpected<r><d>)<r>\n\n<d>Current limit: {}<r>\n\nTo fix this, try running:\n\n  <cyan>ulimit -n 65536<r>\n",
                         limit.rlim_cur,
                     );
 
@@ -1380,7 +1380,7 @@ mod draft {
                             if !user.is_empty() {
                                 let user = bstr::BStr::new(user);
                                 pretty_error!(
-                                    "\nIf that still doesn't work, you may need to add these lines to /etc/security/limits.conf:\n\n <cyan>{} soft nofile 2147483646<r>\n <cyan>{} hard nofile 2147483646<r>\n",
+                                    "\nIf that still doesn't work, you may need to add these lines to /etc/security/limits.conf:\n\n <cyan>{} soft nofile 65536<r>\n <cyan>{} hard nofile 200000<r>\n",
                                     user,
                                     user,
                                 );
@@ -1390,7 +1390,7 @@ mod draft {
                     #[cfg(target_os = "macos")]
                     {
                         pretty_error!(
-                            "\nIf that still doesn't work, you may need to run:\n\n  <cyan>sudo launchctl limit maxfiles 2147483646<r>\n",
+                            "\nIf that still doesn't work, you may need to run:\n\n  <cyan>sudo launchctl limit maxfiles 65536 200000<r>\n",
                         );
                     }
                 } else {
diff --git a/test/cli/run/run-crash-handler.test.ts b/test/cli/run/run-crash-handler.test.ts
index 5657f420ca6b..54965b1af506 100644
--- a/test/cli/run/run-crash-handler.test.ts
+++ b/test/cli/run/run-crash-handler.test.ts
@@ -1,6 +1,6 @@
 import { crash_handler } from "bun:internal-for-testing";
 import { describe, expect, test } from "bun:test";
-import { bunEnv, bunExe, isDebug, isLinux, isPosix, isWindows, mergeWindowEnvs, tempDir } from "harness";
+import { bunEnv, bunExe, isDebug, isLinux, isMacOS, isPosix, isWindows, mergeWindowEnvs, tempDir } from "harness";
 import { rmSync } from "node:fs";
 import { constants as osConstants } from "node:os";
 import path from "path";
@@ -191,6 +191,39 @@ describe.if(isPosix)("cwd deleted before startup", () => {
   });
 });
 
+// The fd-exhaustion remediation hint must suggest bounded limits. It used to
+// print `ulimit -n 2147483646` (and `sudo launchctl limit maxfiles 2147483646`
+// on macOS, where a maxfiles limit that large makes every new terminal's
+// `login` iterate the fd table for minutes, and SIP blocks lowering it back
+// without a reboot). See #37337.
+test.if(isPosix)("fd limit hint suggests bounded values", async () => {
+  await using proc = Bun.spawn({
+    // The hint only prints when the current fd limit is low (< 16384); lower
+    // it in a wrapper shell so the check triggers deterministically.
+    cmd: [
+      "/bin/sh",
+      "-c",
+      `ulimit -n 8192 && exec "$@"`,
+      "--",
+      bunExe(),
+      path.join(import.meta.dir, "fixture-crash.js"),
+      "rootError",
+      "--debug-crash-handler-use-trace-string",
+    ],
+    env: noReportEnv,
+    stdio: ["ignore", "ignore", "pipe"],
+  });
+  const [stderr, exitCode] = await Promise.all([proc.stderr.text(), proc.exited]);
+
+  expect(stderr).toContain("possibly due to low max file descriptors");
+  expect(stderr).toContain("ulimit -n 65536");
+  if (isMacOS) {
+    expect(stderr).toContain("sudo launchctl limit maxfiles 65536 200000");
+  }
+  expect(stderr).not.toContain("2147483646");
+  expect(exitCode).not.toBe(0);
+});
+
 // Windows: the VEH handler must walk the stack from the fault CONTEXT record
 // (RtlVirtualUnwind), not from inside the handler. When the fault is in an
 // external DLL the old RtlCaptureStackBackTrace path could stop at

From 960fe301b419ed144c3d2c4b9d3c29c999c3fc4c Mon Sep 17 00:00:00 2001
From: Jarred Sumner <jarred@jarredsumner.com>
Date: Mon, 19 Oct 2026 00:44:49 +0000
Subject: [PATCH 04/24] cli: read the script from stdin for `node -` in node
 emulation (#38566)

---
 src/runtime/cli/run_command.rs | 15 +++++++++--
 test/cli/run/as-node.test.ts   | 47 ++++++++++++++++++++++++++++++++++
 2 files changed, 60 insertions(+), 2 deletions(-)

diff --git a/src/runtime/cli/run_command.rs b/src/runtime/cli/run_command.rs
index 9196a2c70e8d..6593676149f1 100644
--- a/src/runtime/cli/run_command.rs
+++ b/src/runtime/cli/run_command.rs
@@ -2999,8 +2999,9 @@ impl RunCommand {
         Self::boot_and_handle_error(ctx, &absolute_script_path, None)
     }
 
-    /// `bun run -` — read script from stdin into `ctx.runtime_options.eval`
-    /// and boot the VM with the synthetic `[stdin]` path.
+    /// `bun run -` / `node -` — read script from stdin into
+    /// `ctx.runtime_options.eval` and boot the VM with the synthetic `[stdin]`
+    /// path. `false` means stdin could not be read; the caller exits 1.
     fn exec_stdin(ctx: &mut ContextData) -> crate::Result<bool> {
         bun_core::scoped_log!(RUN_LOG, "Executing from stdin");
 
@@ -3141,6 +3142,16 @@ impl RunCommand {
             Self::exec_as_if_node_missing_script();
         }
 
+        // `node -` reads the script from stdin. `Arguments::parse` stopped at
+        // this positional, so everything after the `-` is already in
+        // `ctx.passthrough`; `exec_stdin` puts the `-` itself back in front.
+        if ctx.positionals[0].as_ref() == b"-" {
+            if Self::exec_stdin(ctx)? {
+                return Ok(());
+            }
+            Global::exit(1);
+        }
+
         // borrowck — `boot_and_handle_error` takes `&mut ctx`, so
         // dupe the positional out before the call.
         let filename: Box<[u8]> = ctx.positionals[0].clone();
diff --git a/test/cli/run/as-node.test.ts b/test/cli/run/as-node.test.ts
index 34ee77efd693..a0208c51ad53 100644
--- a/test/cli/run/as-node.test.ts
+++ b/test/cli/run/as-node.test.ts
@@ -111,4 +111,51 @@ describe("fake node cli", () => {
     expect(result.stderr.toString()).toContain("Missing script");
     expect(result.success).toBe(false);
   });
+
+  // `node -` runs the script piped to stdin. Like node, the `-` stays in
+  // process.argv[1] and everything after it is user argv, even when a file
+  // literally named `-` exists in cwd.
+  describe("node - runs the script from stdin", () => {
+    function nodeStdin(args: string[], script: string, files: Record<string, string> = {}) {
+      using temp = tempDir("fake-node", { "-": "console.log('fail: ran the file named -')", ...files });
+      const result = Bun.spawnSync([bunExe(), "--bun", "node", ...args], {
+        cwd: String(temp),
+        env: { ...bunEnv, NODE_ENV: undefined },
+        stdin: Buffer.from(script),
+      });
+      return {
+        stdout: result.stdout.toString("utf8"),
+        stderr: result.stderr.toString("utf8"),
+        exitCode: result.exitCode,
+      };
+    }
+
+    const logArgv = "console.log(JSON.stringify(process.argv.slice(1)))";
+    test.each([
+      { args: ["-"], argv: ["-"] },
+      { args: ["-", "a", "b"], argv: ["-", "a", "b"] },
+      { args: ["-", "--flag", "-x"], argv: ["-", "--flag", "-x"] },
+      { args: ["--", "-", "a"], argv: ["-", "a"] },
+    ])("node $args", ({ args, argv }) => {
+      const { stdout, stderr, exitCode } = nodeStdin(args, logArgv);
+      expect(stdout).toBe(JSON.stringify(argv) + "\n");
+      expect(stderr).toBe("");
+      expect(exitCode).toBe(0);
+    });
+
+    test("the stdin script's exit code is the process exit code", () => {
+      const { stdout, exitCode } = nodeStdin(["-"], "console.log('ran'); process.exitCode = 3");
+      expect(stdout).toBe("ran\n");
+      expect(exitCode).toBe(3);
+    });
+
+    test("--require preloads run before the stdin script", () => {
+      const { stdout, stderr, exitCode } = nodeStdin(["--require", "./pre.js", "-"], "console.log(globalThis.pre)", {
+        "pre.js": "globalThis.pre = 'preloaded'",
+      });
+      expect(stdout).toBe("preloaded\n");
+      expect(stderr).toBe("");
+      expect(exitCode).toBe(0);
+    });
+  });
 });

From cce7f7ced53e9d898a563392252cd6914662cc87 Mon Sep 17 00:00:00 2001
From: Jarred Sumner <jarred@jarredsumner.com>
Date: Mon, 19 Oct 2026 00:44:55 +0000
Subject: [PATCH 05/24] test: un-todo the process.env string coercion test on
 POSIX (#38864)

---
 test/cli/run/env.test.ts | 34 +++++++++++++++++++---------------
 1 file changed, 19 insertions(+), 15 deletions(-)

diff --git a/test/cli/run/env.test.ts b/test/cli/run/env.test.ts
index 30dbfe40ab06..e08c7692fab1 100644
--- a/test/cli/run/env.test.ts
+++ b/test/cli/run/env.test.ts
@@ -1270,21 +1270,25 @@ for (const shell of ["system", "bun"]) {
   });
 }
 
-const todoOnPosix = process.platform !== "win32" ? test.todo : test;
-todoOnPosix("setting process.env coerces the value to a string", () => {
-  // @ts-expect-error
-  process.env.SET_TO_TRUE = true;
-  let did_call = 0;
-  // @ts-expect-error
-  process.env.SET_TO_BUN = {
-    toString() {
-      did_call++;
-      return "bun!";
-    },
-  };
-  expect(process.env.SET_TO_TRUE).toBe("true");
-  expect(process.env.SET_TO_BUN).toBe("bun!");
-  expect(did_call).toBe(1);
+test("setting process.env coerces the value to a string", () => {
+  try {
+    // @ts-expect-error
+    process.env.SET_TO_TRUE = true;
+    let did_call = 0;
+    // @ts-expect-error
+    process.env.SET_TO_BUN = {
+      toString() {
+        did_call++;
+        return "bun!";
+      },
+    };
+    expect(process.env.SET_TO_TRUE).toBe("true");
+    expect(process.env.SET_TO_BUN).toBe("bun!");
+    expect(did_call).toBe(1);
+  } finally {
+    delete process.env.SET_TO_TRUE;
+    delete process.env.SET_TO_BUN;
+  }
 });
 
 test.concurrent("NODE_ENV=test loads .env.test even when .env.production exists", async () => {

From 868553d34bf261a68a40a8d45ec1c7f74795bfda Mon Sep 17 00:00:00 2001
From: Jarred Sumner <jarred@jarredsumner.com>
Date: Mon, 19 Oct 2026 00:45:04 +0000
Subject: [PATCH 06/24] crash handler: report failed Rust allocations as out of
 memory (#39635)

---
 src/crash_handler/lib.rs               |  61 ++++++++++--
 src/js/internal-for-testing.ts         |   1 +
 src/runtime/api/crash_handler_jsc.rs   |  16 +++
 test/cli/run/fixture-crash.js          |   2 +-
 test/cli/run/run-crash-handler.test.ts | 131 +++++++++++++++++--------
 5 files changed, 157 insertions(+), 54 deletions(-)

diff --git a/src/crash_handler/lib.rs b/src/crash_handler/lib.rs
index decae93654f0..9475e295161e 100644
--- a/src/crash_handler/lib.rs
+++ b/src/crash_handler/lib.rs
@@ -20,6 +20,7 @@
 // builds only. Declaring the feature where neither is compiled (Windows
 // release) trips `unused_features`.
 #![cfg_attr(any(not(windows), debug_assertions), feature(core_intrinsics))]
+#![feature(alloc_error_hook)]
 #![allow(internal_features)]
 #![warn(unused_must_use)]
 #[path = "CPUFeatures.rs"]
@@ -40,7 +41,9 @@ pub use error::{Error, Result};
 #[inline(never)]
 fn out_of_memory() -> ! {
     draft::crash_handler(
-        draft::CrashReason::OutOfMemory,
+        draft::CrashReason::OutOfMemory {
+            requested_bytes: None,
+        },
         draft::TraceSeed::BeginAddr(bun_core::return_address()),
     )
 }
@@ -639,7 +642,10 @@ mod draft {
         /// Either `main` returned an error, or somewhere else in the code a trace string is printed.
         ZigError(&'static [u8]),
 
-        OutOfMemory,
+        OutOfMemory {
+            /// `None` when the caller only has an `AllocError`.
+            requested_bytes: Option<usize>,
+        },
     }
 
     impl CrashReason {
@@ -662,7 +668,7 @@ mod draft {
                 | CrashReason::DatatypeMisalignment
                 | CrashReason::StackOverflow
                 | CrashReason::ZigError(_)
-                | CrashReason::OutOfMemory => libc::SIGABRT,
+                | CrashReason::OutOfMemory { .. } => libc::SIGABRT,
             }
         }
     }
@@ -691,7 +697,23 @@ mod draft {
                 CrashReason::ZigError(err_name) => {
                     write!(writer, "error.{}", bstr::BStr::new(err_name))
                 }
-                CrashReason::OutOfMemory => writer.write_str("Bun ran out of memory"),
+                CrashReason::OutOfMemory { requested_bytes } => write!(
+                    writer,
+                    "Bun ran out of memory{}",
+                    RequestedBytes(*requested_bytes)
+                ),
+            }
+        }
+    }
+
+    /// ` (failed to allocate N bytes)`, or nothing when the size is unknown.
+    struct RequestedBytes(Option<usize>);
+
+    impl fmt::Display for RequestedBytes {
+        fn fmt(&self, writer: &mut fmt::Formatter<'_>) -> fmt::Result {
+            match self.0 {
+                Some(bytes) => write!(writer, " (failed to allocate {bytes} bytes)"),
+                None => Ok(()),
             }
         }
     }
@@ -921,7 +943,7 @@ mod draft {
                         }
                     }
 
-                    if !matches!(reason, CrashReason::OutOfMemory) || debug_trace {
+                    if !matches!(reason, CrashReason::OutOfMemory { .. }) || debug_trace {
                         if enable_ansi_colors_stderr() {
                             if writer
                                 .write_all(&Output::pretty_fmt::<true>("<red>"))
@@ -1115,10 +1137,16 @@ mod draft {
                                 {
                                     abort();
                                 }
-                            } else if matches!(reason, CrashReason::OutOfMemory) {
-                                if writer.write_all(
-                                b"Bun has run out of memory.\n\nTo send a redacted crash report to Bun's team,\nplease file a GitHub issue using the link below:\n\n",
-                            ).is_err() { abort(); }
+                            } else if let CrashReason::OutOfMemory { requested_bytes } = reason {
+                                if write!(
+                                    writer,
+                                    "Bun has run out of memory{}.\n\nTo send a redacted crash report to Bun's team,\nplease file a GitHub issue using the link below:\n\n",
+                                    RequestedBytes(requested_bytes)
+                                )
+                                .is_err()
+                                {
+                                    abort();
+                                }
                             } else {
                                 if writer.write_all(
                                 b"Bun has crashed. This indicates a bug in Bun, not your code.\n\nTo send a redacted crash report to Bun's team,\nplease file a GitHub issue using the link below:\n\n",
@@ -1706,6 +1734,19 @@ mod draft {
         // this hook, a bare `panic!` would print the std
         // default hook + unwind with no trace string and no upload.
         std::panic::set_hook(Box::new(rust_panic_hook));
+        std::alloc::set_alloc_error_hook(rust_alloc_error_hook);
+    }
+
+    /// Not a null check in `GlobalAlloc`: `try_reserve` reports failure with null too. Must not allocate.
+    #[cold]
+    #[inline(never)]
+    fn rust_alloc_error_hook(layout: core::alloc::Layout) {
+        crash_handler(
+            CrashReason::OutOfMemory {
+                requested_bytes: Some(layout.size()),
+            },
+            TraceSeed::BeginAddr(debug::return_address()),
+        )
     }
 
     /// `std::panic` hook: emit the same trace-string + auto-report as the fatal
@@ -2680,7 +2721,7 @@ mod draft {
                 writer.write_all(err_name)?;
             }
 
-            CrashReason::OutOfMemory => writer.write_byte(b'9')?,
+            CrashReason::OutOfMemory { .. } => writer.write_byte(b'9')?,
 
             CrashReason::Abort => writer.write_byte(b'a')?,
             CrashReason::Trap(addr) => {
diff --git a/src/js/internal-for-testing.ts b/src/js/internal-for-testing.ts
index 4e31f23e7af1..a997d7d018b5 100644
--- a/src/js/internal-for-testing.ts
+++ b/src/js/internal-for-testing.ts
@@ -151,6 +151,7 @@ export const crash_handler = $rust("crash_handler.rs", "js_bindings.generate") a
   panic: () => void;
   rootError: () => void;
   outOfMemory: () => void;
+  allocError: () => void;
   abort: () => void;
   fastfail: () => void;
   trap: () => void;
diff --git a/src/runtime/api/crash_handler_jsc.rs b/src/runtime/api/crash_handler_jsc.rs
index e042f1124cf6..6c5234b45a34 100644
--- a/src/runtime/api/crash_handler_jsc.rs
+++ b/src/runtime/api/crash_handler_jsc.rs
@@ -24,6 +24,7 @@ pub(crate) mod js_bindings {
             ("panic", __jsc_host_js_panic),
             ("rootError", __jsc_host_js_root_error),
             ("outOfMemory", __jsc_host_js_out_of_memory),
+            ("allocError", __jsc_host_js_alloc_error),
             ("abort", __jsc_host_js_abort),
             ("fastfail", __jsc_host_js_fastfail),
             ("trap", __jsc_host_js_trap),
@@ -206,6 +207,21 @@ pub(crate) mod js_bindings {
         bun_core::out_of_memory();
     }
 
+    /// Fails a real infallible allocation; `outOfMemory` covers the explicit `AllocError` path.
+    #[bun_jsc::host_fn]
+    fn js_alloc_error(_global: &JSGlobalObject, _frame: &CallFrame) -> JsResult<JSValue> {
+        crash_handler::suppress_core_dumps_if_necessary();
+        // Above any 64-bit address space (null even with overcommit), below `isize::MAX` (no capacity panic).
+        const SIZE: usize = 1 << 62;
+        // ASAN's allocator aborts on an oversized request instead of returning null.
+        if Environment::ENABLE_ASAN {
+            std::alloc::handle_alloc_error(core::alloc::Layout::from_size_align(SIZE, 1).unwrap());
+        }
+        let buf: Vec<u8> = Vec::with_capacity(SIZE);
+        core::hint::black_box(buf);
+        Ok(JSValue::UNDEFINED)
+    }
+
     #[bun_jsc::host_fn]
     fn js_raise_ignoring_panic_handler(
         _global: &JSGlobalObject,
diff --git a/test/cli/run/fixture-crash.js b/test/cli/run/fixture-crash.js
index d44ba5bbc61d..332663c8c092 100644
--- a/test/cli/run/fixture-crash.js
+++ b/test/cli/run/fixture-crash.js
@@ -12,6 +12,6 @@ if (approach in crash_handler) {
   crash_handler[approach]();
 } else {
   console.error(
-    "usage: bun fixture-crash.js <segfault|segfaultInDll|panic|rootError|outOfMemory|abort|trap|raiseIgnoringPanicHandler>",
+    "usage: bun fixture-crash.js <segfault|segfaultInDll|panic|rootError|outOfMemory|allocError|abort|trap|raiseIgnoringPanicHandler>",
   );
 }
diff --git a/test/cli/run/run-crash-handler.test.ts b/test/cli/run/run-crash-handler.test.ts
index 54965b1af506..200deccb2644 100644
--- a/test/cli/run/run-crash-handler.test.ts
+++ b/test/cli/run/run-crash-handler.test.ts
@@ -15,6 +15,10 @@ const noReportEnv = { ...bunEnv, BUN_CRASH_REPORT_URL: "", BUN_ENABLE_CRASH_REPO
 // without it the fallback printer has no Rust symbol names to assert on.
 const hasSymbolizer = !!(Bun.which("llvm-symbolizer") || Bun.which("llvm-symbolizer-23"));
 
+// The allocation the `allocError` test hook requests (`js_alloc_error` in
+// src/runtime/api/crash_handler_jsc.rs). The crash report prints it.
+const allocErrorSize = 2n ** 62n;
+
 test.if(isDebug && isLinux && hasSymbolizer)(
   "crash trace starts at the crash site, not inside the crash handler",
   async () => {
@@ -44,6 +48,38 @@ test.if(isDebug && isLinux && hasSymbolizer)(
   60_000, // symbolizing the debug binary takes several seconds
 );
 
+// A failed infallible allocation (`Vec` growth, `Box::new`, ...) reaches std's
+// alloc error handler. Without the alloc error hook std prints "memory
+// allocation of N bytes failed" and calls abort(), so the report said
+// "abort() called" and its trace was seeded inside libc, where the frame
+// pointer walk stops after one frame. The hook reports it as out of memory,
+// with the requested size, and captures the trace while the allocating
+// frame is still on the stack.
+test.if(isDebug && isLinux && hasSymbolizer)(
+  "failed Rust allocation is reported as out of memory with the allocating frame in the trace",
+  async () => {
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), path.join(import.meta.dir, "fixture-crash.js"), "allocError"],
+      env: noReportEnv,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    // Header on stderr, symbolized frames on stdout (see the test above).
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+
+    expect(stderr).toContain(`panic(main thread): Bun ran out of memory (failed to allocate ${allocErrorSize} bytes)`);
+    expect(stderr).not.toContain("abort() called");
+    expect(stderr).not.toContain("memory allocation of");
+    expect(exitCode).not.toBe(0);
+
+    // The trace walks from the alloc error hook through std's handler into
+    // the test hook that made the allocation...
+    expect(stdout).toContain("js_alloc_error");
+    // ...and does not include the capture machinery.
+    expect(stdout).not.toContain("capture_stack_trace");
+  },
+  60_000, // symbolizing the debug binary takes several seconds
+);
+
 // `crash()` resets fatal-signal dispositions to SIG_DFL before re-raising so
 // that JS-registered listeners (`process.on("SIGABRT")` etc., installed by
 // npm's widely-used signal-exit package) cannot swallow the termination. A
@@ -99,6 +135,7 @@ describe.if(isPosix)("terminal signal reflects the crash cause", () => {
   test.each([
     ["panic", "SIGABRT"],
     ["outOfMemory", "SIGABRT"],
+    ["allocError", "SIGABRT"],
     ["segfault", "SIGSEGV"],
     ["abort", "SIGABRT"],
     ["trap", "SIGTRAP"],
@@ -119,6 +156,11 @@ describe.if(isPosix)("terminal signal reflects the crash cause", () => {
       expect(stderr).toContain("Segmentation fault at address");
     } else if (approach === "panic") {
       expect(stderr).toContain("invoked crashByPanic() handler");
+    } else if (approach === "outOfMemory") {
+      expect(stderr).toContain("Bun has run out of memory.");
+    } else if (approach === "allocError") {
+      expect(stderr).toContain(`Bun has run out of memory (failed to allocate ${allocErrorSize} bytes).`);
+      expect(stderr).not.toContain("abort() called");
     } else if (approach === "abort") {
       expect(stderr).toContain("abort() called");
     } else if (approach === "trap") {
@@ -616,52 +658,55 @@ describe.if(isPosix)("process.kill() aimed at the process itself is not reported
 });
 
 describe("automatic crash reporter", () => {
-  for (const approach of ["panic", "segfault", "outOfMemory"]) {
-    test(`${approach} should report`, async () => {
-      let sent = false;
-      const resolve_handler = Promise.withResolvers();
-
-      // Self host the crash report backend.
-      using server = Bun.serve({
-        port: 0,
-        fetch(request, server) {
-          expect(request.url).toEndWith("/ack");
-          sent = true;
-          resolve_handler.resolve();
-          return new Response("OK");
-        },
-      });
+  const crashed = "oh no: Bun has crashed. This indicates a bug in Bun, not your code";
+  // The uploaded URL is the trace string followed by "/ack". The trace string
+  // ends with the reason; both out-of-memory paths encode it as "9" (see
+  // encode_trace_string in src/crash_handler/lib.rs), which is what tells
+  // bun.report to classify the report as out of memory.
+  test.each([
+    ["panic", crashed, "/ack"],
+    ["segfault", crashed, "/ack"],
+    ["outOfMemory", "oh no: Bun has run out of memory.", "9/ack"],
+    ["allocError", `oh no: Bun has run out of memory (failed to allocate ${allocErrorSize} bytes).`, "9/ack"],
+  ])("%s should report", async (approach, expectedMessage, expectedUrlSuffix) => {
+    const reported = Promise.withResolvers<string>();
+
+    // Self host the crash report backend.
+    using server = Bun.serve({
+      port: 0,
+      fetch(request) {
+        reported.resolve(request.url);
+        return new Response("OK");
+      },
+    });
 
-      const proc = Bun.spawn({
-        cmd: [bunExe(), path.join(import.meta.dir, "fixture-crash.js"), approach],
-        env: mergeWindowEnvs([
-          bunEnv,
-          {
-            BUN_CRASH_REPORT_URL: server.url.toString(),
-            BUN_ENABLE_CRASH_REPORTING: "1",
-            GITHUB_ACTIONS: undefined,
-            CI: undefined,
-          },
-        ]),
-        stdio: ["ignore", "pipe", "pipe"],
-      });
-      const exitCode = await proc.exited;
-      const stderr = await proc.stderr.text();
-      console.log(stderr);
+    const proc = Bun.spawn({
+      cmd: [bunExe(), path.join(import.meta.dir, "fixture-crash.js"), approach],
+      env: mergeWindowEnvs([
+        bunEnv,
+        {
+          BUN_CRASH_REPORT_URL: server.url.toString(),
+          BUN_ENABLE_CRASH_REPORTING: "1",
+          GITHUB_ACTIONS: undefined,
+          CI: undefined,
+        },
+      ]),
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    const exitCode = await proc.exited;
+    const stderr = await proc.stderr.text();
+    console.log(stderr);
 
-      await resolve_handler.promise;
+    const reportedUrl = await reported.promise;
 
-      expect(exitCode).not.toBe(0);
-      expect(stderr).toContain(server.url.toString());
-      if (approach !== "outOfMemory") {
-        expect(stderr).toContain("oh no: Bun has crashed. This indicates a bug in Bun, not your code");
-      } else {
-        expect(stderr.toLowerCase()).toContain("out of memory");
-        expect(stderr.toLowerCase()).not.toContain("panic");
-      }
-      expect(sent).toBe(true);
-    });
-  }
+    expect(exitCode).not.toBe(0);
+    expect(stderr).toContain(server.url.toString());
+    expect(stderr).toContain(expectedMessage);
+    if (approach === "outOfMemory" || approach === "allocError") {
+      expect(stderr.toLowerCase()).not.toContain("panic");
+    }
+    expect(reportedUrl).toEndWith(expectedUrlSuffix);
+  });
 });
 
 test.if(isWindows)(

From 2feba7e17da5f6f2d93c1370cc9583467faf21a3 Mon Sep 17 00:00:00 2001
From: Jarred Sumner <jarred@jarredsumner.com>
Date: Mon, 19 Oct 2026 00:45:18 +0000
Subject: [PATCH 07/24] output: keep a bare `>` in pretty templates instead of
 dropping it (#40713)

---
 src/bun_core/output.rs          | 27 ++++++++--
 src/bun_core_macros/lib.rs      |  9 ++--
 src/clap_macros/lib.rs          |  7 +--
 src/runtime/cli/init_command.rs |  7 +--
 test/cli/bun.test.ts            | 24 ++++++++-
 test/cli/init/init.test.ts      | 96 +++++++++++++++++++++++++++++++++
 6 files changed, 153 insertions(+), 17 deletions(-)

diff --git a/src/bun_core/output.rs b/src/bun_core/output.rs
index 27f6012c8bc7..78f6f5d352fc 100644
--- a/src/bun_core/output.rs
+++ b/src/bun_core/output.rs
@@ -1934,9 +1934,6 @@ pub fn pretty_fmt_runtime(fmt: &[u8], is_enabled: bool) -> Vec<u8> {
                     }
                 }
             }
-            b'>' => {
-                i += 1;
-            }
             b'{' => {
                 while i < fmt.len() && fmt[i] != b'}' {
                     out.push(fmt[i]);
@@ -1954,6 +1951,10 @@ pub fn pretty_fmt_runtime(fmt: &[u8], is_enabled: bool) -> Vec<u8> {
                     i += 1;
                 }
                 let color_name = &fmt[start..i];
+                // Skip the tag's closing `>`. Any other `>` is text.
+                if i < fmt.len() {
+                    i += 1;
+                }
                 let color_str: &str = 'picker: {
                     if let Some(lit) = color_map::get(color_name) {
                         break 'picker lit;
@@ -2927,6 +2928,23 @@ mod pretty_fmt_tests {
         assert_eq!(pretty_fmt!("\\<folder\\>", false), "<folder>");
     }
 
+    #[test]
+    fn bare_closing_bracket_is_literal() {
+        // Only the `>` that closes a tag is markup.
+        assert_eq!(pretty_fmt!("-> {}", true), "-> {}");
+        assert_eq!(pretty_fmt!("-> {}", false), "-> {}");
+        assert_eq!(pretty_fmt!("<cyan>><r>", true), "\x1b[36m>\x1b[0m");
+        assert_eq!(pretty_fmt!("<cyan>><r>", false), ">");
+        assert_eq!(
+            pretty_fmt!("<cyan>echo x >> /etc/sysctl.conf<r>", false),
+            "echo x >> /etc/sysctl.conf"
+        );
+        assert_eq!(
+            pretty_fmt_runtime(b"<cyan>><r> a -> b", false),
+            b"> a -> b".as_slice()
+        );
+    }
+
     #[test]
     fn format_specs_with_angle_brackets_pass_through() {
         // `{:<16}` / `{:>.2}` contain `<`/`>` *inside* a format spec — the
@@ -3009,6 +3027,9 @@ mod pretty_fmt_tests {
         check!("<b>Usage<r>: <b><green>bun init<r> <cyan>[flags]<r> <blue>[\\<folder\\>]<r>\n");
         check!("<r><d>[<b>{d:>.2}ms<r><d>]<r>");
         check!("<r><red>error<r><d>:<r> ");
+        check!("<r><cyan>><r>   ");
+        check!("-> {}");
+        check!("  <cyan>sudo echo x >> /etc/sysctl.conf<r>\n");
         check!(
             "  <b><blue>link<r>      <d>[\\<package\\>]<r>          Register or link a local npm package\n"
         );
diff --git a/src/bun_core_macros/lib.rs b/src/bun_core_macros/lib.rs
index 352a3c61f11b..dc9739dedcb0 100644
--- a/src/bun_core_macros/lib.rs
+++ b/src/bun_core_macros/lib.rs
@@ -109,10 +109,6 @@ fn rewrite(fmt: &str, is_enabled: bool) -> Result<String, String> {
                     }
                 }
             }
-            b'>' => {
-                // stray closer — dropped
-                i += 1;
-            }
             b'{' => {
                 // copy `{ ... }` verbatim, optionally rewriting legacy specs
                 let start = i;
@@ -139,6 +135,10 @@ fn rewrite(fmt: &str, is_enabled: bool) -> Result<String, String> {
                     i += 1;
                 }
                 let name = &fmt[start..i];
+                // Skip the tag's closing `>`. Any other `>` is text.
+                if i < bytes.len() {
+                    i += 1;
+                }
                 let seq: &str = if let Some(c) = color_for(name) {
                     c
                 } else if name == "r" {
@@ -152,7 +152,6 @@ fn rewrite(fmt: &str, is_enabled: bool) -> Result<String, String> {
                 if is_enabled {
                     out.push_str(if is_reset { RESET } else { seq });
                 }
-                // trailing `>` consumed by the `'>'` arm next iteration
             }
             _ => {
                 // Preserve full UTF-8: push the char at this byte position.
diff --git a/src/clap_macros/lib.rs b/src/clap_macros/lib.rs
index 0969a83031f5..5e4c1512e10e 100644
--- a/src/clap_macros/lib.rs
+++ b/src/clap_macros/lib.rs
@@ -294,9 +294,6 @@ fn pretty_rewrite(fmt: &[u8], is_enabled: bool) -> Vec<u8> {
                     }
                 }
             }
-            b'>' => {
-                i += 1;
-            }
             b'{' => {
                 while i < fmt.len() && fmt[i] != b'}' {
                     out.push(fmt[i]);
@@ -314,6 +311,10 @@ fn pretty_rewrite(fmt: &[u8], is_enabled: bool) -> Vec<u8> {
                     i += 1;
                 }
                 let name = &fmt[start..i];
+                // Skip the tag's closing `>`. Any other `>` is text.
+                if i < fmt.len() {
+                    i += 1;
+                }
                 let seq: &str = if let Some(c) = color_for_bytes(name) {
                     c
                 } else if name == b"r" {
diff --git a/src/runtime/cli/init_command.rs b/src/runtime/cli/init_command.rs
index ac428b724a8c..c8fbf8a1d2aa 100644
--- a/src/runtime/cli/init_command.rs
+++ b/src/runtime/cli/init_command.rs
@@ -133,13 +133,10 @@ impl InitCommand {
                 if i == selected.to_index() {
                     if colors {
                         bun_core::pretty!("<r><cyan>❯<r>   ");
-                    } else {
-                        bun_core::pretty!("<r><cyan>><r>   ");
-                    }
-                    if colors {
                         Output::print(format_args!("\x1B[4m{}\x1B[24m\x1B[0K\n", option));
                     } else {
-                        Output::print(format_args!("    {}\x1B[0K\n", option));
+                        bun_core::pretty!("<r><cyan>><r>   ");
+                        Output::print(format_args!("{}\x1B[0K\n", option));
                     }
                 } else {
                     Output::print(format_args!("    {}\x1B[0K\n", option));
diff --git a/test/cli/bun.test.ts b/test/cli/bun.test.ts
index 736bfe37ab7d..a63c61987961 100644
--- a/test/cli/bun.test.ts
+++ b/test/cli/bun.test.ts
@@ -1,7 +1,7 @@
 import { spawnSync } from "bun";
 import { dlopen, FFIType } from "bun:ffi";
 import { describe, expect, test } from "bun:test";
-import { bunEnv, bunExe, isDebug, isMusl, isWindows, tempDir } from "harness";
+import { bunEnv, bunExe, isDebug, isLinux, isMusl, isWindows, tempDir } from "harness";
 import fs from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -175,6 +175,28 @@ describe("bun", () => {
       );
     });
   });
+
+  // `bun discord` runs the platform opener (`xdg-open` on Linux) and prints the
+  // URL when that fails. Linux only: an empty PATH makes `xdg-open` fail to
+  // resolve, while macOS spawns `/usr/bin/open` by absolute path and would
+  // open a browser.
+  describe.skipIf(!isLinux)("discord", () => {
+    test("prints the URL when the opener is not on PATH", async () => {
+      using emptyPath = tempDir("bun-discord-empty-path", {});
+      await using proc = Bun.spawn({
+        cmd: [bunExe(), "discord"],
+        env: { ...bunEnv, PATH: String(emptyPath) },
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+      const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+
+      expect(stdout).toBe("-> https://bun.com/discord\n");
+      expect(stderr).toBe("");
+      expect(exitCode).toBe(0);
+    });
+  });
+
   describe("getcompletes", () => {
     test("getcompletes should not panic and should not be empty", () => {
       const { stdout, exitCode } = spawnSync({
diff --git a/test/cli/init/init.test.ts b/test/cli/init/init.test.ts
index 113be9d6abcc..ff3ee799b165 100644
--- a/test/cli/init/init.test.ts
+++ b/test/cli/init/init.test.ts
@@ -143,6 +143,102 @@ const initEnv = { ...bunEnv, BUN_AGENT_RULE_DISABLED: "1" };
     expect(fs.existsSync(path.join(temp, "package.json"))).toBe(false);
   });
 
+  // Windows is skipped: ConPTY rewrites the child's output into its own escape
+  // sequences, so the raw rows cannot be compared.
+  test.skipIf(isWindows)("bun init template menu marks the selected row when colors are off", async () => {
+    await using temp = tempDir("bun-init-menu-no-color", {});
+
+    const received: string[] = [];
+    let eof = false;
+    let wake: (() => void) | null = null;
+    const decoder = new TextDecoder();
+    // bunEnv sets NO_COLOR=1, so the menu takes its no-color branch: an ASCII
+    // `>` in place of the colored `❯` and no underline on the selected row.
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "init"],
+      cwd: temp,
+      env: initEnv,
+      // An inline terminal is owned by the subprocess: when the child exits, the
+      // remaining output is drained and then `exit` fires. So `eof` means that
+      // no more output can arrive.
+      terminal: {
+        cols: 80,
+        rows: 24,
+        data(_term, chunk) {
+          received.push(decoder.decode(chunk, { stream: true }));
+          wake?.();
+        },
+        exit() {
+          eof = true;
+          wake?.();
+        },
+      },
+    });
+    await using terminal = proc.terminal!;
+
+    // Resolves with everything received so far, once `ready` accepts it.
+    // Fails at once, with that output, if the process exits first.
+    const waitFor = async (ready: (all: string) => boolean): Promise<string> => {
+      const deadline = Date.now() + 10_000;
+      while (true) {
+        const all = received.join("");
+        if (ready(all)) return all;
+        if (eof) {
+          throw new Error(`bun init exited before the expected output. Received:\n${JSON.stringify(all)}`);
+        }
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) {
+          throw new Error(`Timed out waiting for the menu. Received so far:\n${JSON.stringify(all)}`);
+        }
+        await new Promise<void>(resolve => {
+          const timer = setTimeout(resolve, remaining);
+          wake = () => {
+            clearTimeout(timer);
+            resolve();
+          };
+        });
+        wake = null;
+      }
+    };
+    // Every draw of the menu ends with "clear to end of screen", then the
+    // process blocks on stdin. So once the `count`-th one has arrived, the
+    // output is complete and stable.
+    const drawn = (count: number) => (all: string) => all.split("\x1b[0J").length > count;
+    // The menu is redrawn in place on every keypress (cursor up, then the three
+    // rows again). The last three non-empty lines are the current state.
+    const currentMenu = (all: string) =>
+      all
+        .replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "")
+        .split("\r\n")
+        .filter(Boolean)
+        .slice(-3);
+
+    expect(currentMenu(await waitFor(drawn(1)))).toMatchInlineSnapshot(`
+      [
+        ">   Blank",
+        "    React",
+        "    Library",
+      ]
+    `);
+
+    // Down arrow: the marker follows the selection.
+    terminal.write("\x1b[B");
+    expect(currentMenu(await waitFor(drawn(2)))).toMatchInlineSnapshot(`
+      [
+        "    Blank",
+        ">   React",
+        "    Library",
+      ]
+    `);
+
+    // Ctrl-C cancels the menu without creating a project.
+    terminal.write("\x03");
+    await waitFor(all => all.includes("Cancelled"));
+    const exitCode = await proc.exited;
+    expect(fs.existsSync(path.join(temp, "package.json"))).toBe(false);
+    expect(exitCode).toBe(0);
+  });
+
   test("bun init in folder", async () => {
     await using temp = tempDir("bun-init-in-folder", {
       "mydir": {

From 9301e3a86c0bb39fd6dfa16b598531d8dd71beab Mon Sep 17 00:00:00 2001
From: Jarred Sumner <jarred@jarredsumner.com>
Date: Mon, 19 Oct 2026 00:45:28 +0000
Subject: [PATCH 08/24] bun run: print the package.json parse error instead of
 "Script not found" (#41700)

---
 src/runtime/cli/run_command.rs   | 20 +++++++++++++++-
 test/cli/run/run_command.test.ts | 39 ++++++++++++++++++++++++++++++++
 2 files changed, 58 insertions(+), 1 deletion(-)

diff --git a/src/runtime/cli/run_command.rs b/src/runtime/cli/run_command.rs
index 6593676149f1..3fb8bb7ff204 100644
--- a/src/runtime/cli/run_command.rs
+++ b/src/runtime/cli/run_command.rs
@@ -2839,6 +2839,20 @@ impl RunCommand {
         }
 
         if log_errors {
+            // The resolver records a package.json that fails to load (a
+            // syntax error, an unreadable file) in `ctx.log` and returns a
+            // `DirInfo` without it.
+            //
+            // SAFETY: `ctx.log` set in `create_context_data` (single-threaded
+            // CLI startup), process-lifetime.
+            let log = unsafe { ctx.log() };
+            let has_log_errors = log.has_errors();
+            if has_log_errors {
+                let _ = log.print(std::ptr::from_mut::<bun_core::io::Writer>(
+                    Output::error_writer(),
+                ));
+            }
+
             if let Some((path, loader)) = resolved_to_unrunnable_file {
                 bun_core::pretty_error!(
                     "<r><red>error<r><d>:<r> <b>Cannot run \"{}\"<r>\n",
@@ -2867,7 +2881,11 @@ impl RunCommand {
                         "<r><red>error<r><d>:<r> <b>File not found \"<b>{}<r>\"",
                         bstr::BStr::new(target_name),
                     );
-                } else {
+                } else if !(has_log_errors && root_dir.enclosing_package_json.is_none()) {
+                    // With no usable package.json and an error that says
+                    // why, the error is the message. "Script not found"
+                    // would claim the script is absent from a file that
+                    // did not load.
                     pretty_errorln!(
                         "<r><red>error<r><d>:<r> <b>Script not found \"<b>{}<r>\"",
                         bstr::BStr::new(target_name),
diff --git a/test/cli/run/run_command.test.ts b/test/cli/run/run_command.test.ts
index 90e59c3349d1..1190b3c3ba23 100644
--- a/test/cli/run/run_command.test.ts
+++ b/test/cli/run/run_command.test.ts
@@ -40,6 +40,45 @@ describe("bun", () => {
     expect(stderr.toString()).toMatch(/Script not found/);
     expect(exitCode).toBe(1);
   });
+
+  test("a package.json that fails to parse reports the parse error, not 'Script not found'", () => {
+    using dir = tempDir("broken-package-json", {
+      "package.json": `{"name": "p", "scripts": {"s": "echo hi"`,
+    });
+    const { exitCode, stdout, stderr } = spawnSync({
+      cwd: String(dir),
+      cmd: [bunExe(), "run", "s"],
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(stdout.toString()).toBeEmpty();
+    const err = stderr.toString();
+    expect(err).toContain(`Expected "}" but found end of file`);
+    expect(err).toContain(join(String(dir), "package.json") + ":1:40");
+    expect(err).not.toContain("Script not found");
+    expect(exitCode).toBe(1);
+  });
+
+  test("a package.json that fails to parse in an ancestor is printed before 'Script not found'", () => {
+    using dir = tempDir("broken-ancestor-package-json", {
+      "package.json": `{"name": "top", "private": tru`,
+      "a/b/package.json": JSON.stringify({ name: "deep", scripts: { s: "echo hi" } }),
+    });
+    const { exitCode, stdout, stderr } = spawnSync({
+      cwd: join(String(dir), "a", "b"),
+      cmd: [bunExe(), "run", "nope"],
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(stdout.toString()).toBeEmpty();
+    const err = stderr.toString();
+    expect(err).toContain("Unexpected tru");
+    expect(err).toContain(join(String(dir), "package.json") + ":1:28");
+    expect(err).toContain('Script not found "nope"');
+    expect(exitCode).toBe(1);
+  });
 });
 
 // A working directory can be PATH_MAX - 1 bytes long. A file in it whose own path no longer fits a path buffer

From f7f75a617da197bfd7f28a366e64f6b63b719693 Mon Sep 17 00:00:00 2001
From: Jarred Sumner <jarred@jarredsumner.com>
Date: Mon, 19 Oct 2026 00:45:37 +0000
Subject: [PATCH 09/24] Do not forward the inherited IPC channel to spawned
 scripts and tools (#41739)

---
 src/bun_core/env_var.rs                     |  2 +
 src/dotenv/env_loader.rs                    | 17 +++++++
 src/jsc/VirtualMachine.rs                   | 30 +++++-------
 src/runtime/cli/run_command.rs              | 12 +++++
 test/js/bun/spawn/ipc-channel-scrub.test.ts | 51 +++++++++++++++++++++
 5 files changed, 93 insertions(+), 19 deletions(-)
 create mode 100644 test/js/bun/spawn/ipc-channel-scrub.test.ts

diff --git a/src/bun_core/env_var.rs b/src/bun_core/env_var.rs
index 2c8b1a99f387..3f65e1cc2ca9 100644
--- a/src/bun_core/env_var.rs
+++ b/src/bun_core/env_var.rs
@@ -178,6 +178,8 @@ new!(pub JENKINS_URL: string, "JENKINS_URL", {});
 new!(pub MI_VERBOSE: boolean, "MI_VERBOSE", { default: false });
 new!(pub NO_COLOR: boolean, "NO_COLOR", { default: false });
 new!(pub NODE_CHANNEL_FD: string, "NODE_CHANNEL_FD", {});
+// "advanced" (structured clone) or "json" for the channel named by NODE_CHANNEL_FD.
+new!(pub NODE_CHANNEL_SERIALIZATION_MODE: string, "NODE_CHANNEL_SERIALIZATION_MODE", {});
 // A string, not a boolean: node suppresses warnings only when the value is
 // exactly "1" (lib/internal/process/pre_execution.js).
 new!(pub NODE_NO_WARNINGS: string, "NODE_NO_WARNINGS", {});
diff --git a/src/dotenv/env_loader.rs b/src/dotenv/env_loader.rs
index 3ced1d884eae..9e7a680c79f0 100644
--- a/src/dotenv/env_loader.rs
+++ b/src/dotenv/env_loader.rs
@@ -162,6 +162,18 @@ static NODE_PATH_TO_USE_SET_ONCE: bun_core::RwLock<Option<Box<[u8]>>> = bun_core
 // PORTING.md §Concurrency: OnceLock — set once from CLI flag, read many.
 pub static HAS_NO_CLEAR_SCREEN_CLI_FLAG: OnceLock<bool> = OnceLock::new();
 
+/// Compares like [`HashTable`] keys: ASCII case-insensitive on Windows.
+fn is_ipc_channel_key(key: &[u8]) -> bool {
+    const KEYS: [&[u8]; 2] = [b"NODE_CHANNEL_FD", b"NODE_CHANNEL_SERIALIZATION_MODE"];
+    KEYS.iter().any(|&k| {
+        if cfg!(windows) {
+            strings::eql_case_insensitive_ascii(key, k, true)
+        } else {
+            strings::eql(key, k)
+        }
+    })
+}
+
 impl Loader {
     /// Shared "empty-ish" predicate for proxy env vars: an unset/empty value,
     /// or a literal empty-quote pair left over from shell `export FOO=""` /
@@ -569,6 +581,11 @@ impl Loader {
                 let key = &env[..i as usize];
                 let value = &env[i as usize + 1..];
                 if !key.is_empty() {
+                    // Our inherited IPC channel is not for children spawned from
+                    // this env (Node drops these too); `bun run` re-adds them.
+                    if is_ipc_channel_key(key) {
+                        continue;
+                    }
                     self.map.put(key, value)?;
                 }
             } else {
diff --git a/src/jsc/VirtualMachine.rs b/src/jsc/VirtualMachine.rs
index 7f98053db4e7..65f0ebc5f6f0 100644
--- a/src/jsc/VirtualMachine.rs
+++ b/src/jsc/VirtualMachine.rs
@@ -4315,7 +4315,7 @@ impl VirtualMachine {
         // `&'static mut Loader` is independent of `&self`, so `map` may be held
         // across the `&mut self` writes below.
         let env = self.transpiler.env_mut();
-        let map = &mut env.map;
+        let map = &env.map;
 
         ensure_source_code_printer();
         // The runtime VM owns the printer from here on — even if a macro had
@@ -4332,23 +4332,15 @@ impl VirtualMachine {
             self.transpiler_store.enabled = false;
         }
 
-        if let Some(idx) = map.map.get_index(b"NODE_CHANNEL_FD") {
-            let (_, kv) = map.map.swap_remove_at(idx);
-            let fd_s = kv.value;
-            let advanced = map
-                .map
-                .get_index(b"NODE_CHANNEL_SERIALIZATION_MODE")
-                .map(|i| map.map.swap_remove_at(i).1)
-                .is_some_and(|v| &v.value[..] == b"advanced");
-            // Accept only
-            // non-negative values that fit in i31 (i.e. `0..=i32::MAX`).
-            // Parsing as `u32` then `as i32` would silently wrap values in
-            // `2^31..2^32` to a negative fd instead of taking the warn branch.
-            // The channel belongs to the process (its main thread). A worker
-            // sees the same inherited variables but must not open a second
-            // endpoint over the same fd (Node: no process.send() in workers).
-            if self.is_main_thread() {
-                match bun_core::fmt::parse_int::<i32>(&fd_s, 10)
+        // Not in `map`: `Loader::load_process` drops it so children don't inherit
+        // the channel. Main thread only (Node: no process.send() in workers).
+        if self.is_main_thread() {
+            if let Some(fd_s) = bun_core::env_var::NODE_CHANNEL_FD.get() {
+                let advanced = bun_core::env_var::NODE_CHANNEL_SERIALIZATION_MODE
+                    .get()
+                    .is_some_and(|v| bun_core::strings::eql(v, b"advanced"));
+                // i32, not u32-then-cast: `2^31..` must warn, not wrap negative.
+                match bun_core::fmt::parse_int::<i32>(fd_s, 10)
                     .ok()
                     .filter(|&n| n >= 0)
                 {
@@ -4360,7 +4352,7 @@ impl VirtualMachine {
                     }
                     None => bun_core::warn!(
                         "Failed to parse IPC channel number '{}'",
-                        bstr::BStr::new(&fd_s[..])
+                        bstr::BStr::new(fd_s)
                     ),
                 }
             }
diff --git a/src/runtime/cli/run_command.rs b/src/runtime/cli/run_command.rs
index 3fb8bb7ff204..f990e9bf607a 100644
--- a/src/runtime/cli/run_command.rs
+++ b/src/runtime/cli/run_command.rs
@@ -437,6 +437,18 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
         #[cfg(windows)]
         let ipc_fd: Option<bun_sys::Fd> = None; // TODO: implement on Windows
 
+        // `Loader::load_process` drops these; a package script inherits the
+        // channel on purpose (#11132), so restore them alongside `ipc_fd`.
+        #[cfg(not(windows))]
+        if ipc_fd.is_some() {
+            if let Some(fd_s) = bun_core::env_var::NODE_CHANNEL_FD.get() {
+                env.map.put(b"NODE_CHANNEL_FD", fd_s)?;
+            }
+            if let Some(mode) = bun_core::env_var::NODE_CHANNEL_SERIALIZATION_MODE.get() {
+                env.map.put(b"NODE_CHANNEL_SERIALIZATION_MODE", mode)?;
+            }
+        }
+
         // TODO: remember to free this when we add --filter or --concurrent
         // in the meantime we don't need to free it.
         let envp = env.map.create_null_delimited_env_map()?;
diff --git a/test/js/bun/spawn/ipc-channel-scrub.test.ts b/test/js/bun/spawn/ipc-channel-scrub.test.ts
new file mode 100644
index 000000000000..962d01247bf7
--- /dev/null
+++ b/test/js/bun/spawn/ipc-channel-scrub.test.ts
@@ -0,0 +1,51 @@
+import { expect, test } from "bun:test";
+import { bunEnv, bunExe, isWindows, tempDir } from "harness";
+
+// A bun CLI process that inherits an IPC channel (NODE_CHANNEL_FD) must not
+// forward that channel to the scripts and tools it spawns, the way Node sets
+// the channel fd close-on-exec and deletes the variables before it spawns.
+//
+// The grandchild is a POSIX shell, not bun or node: bun and node remove
+// NODE_CHANNEL_FD from `process.env` while they adopt the channel, so only a
+// shell reports the raw inherited value.
+const SHOW_CHANNEL = [
+  "#!/bin/sh",
+  `printf 'NODE_CHANNEL_FD=[%s]\\n' "\${NODE_CHANNEL_FD:-}"`,
+  `printf 'NODE_CHANNEL_SERIALIZATION_MODE=[%s]\\n' "\${NODE_CHANNEL_SERIALIZATION_MODE:-}"`,
+  "",
+].join("\n");
+
+const NO_CHANNEL = "NODE_CHANNEL_FD=[]\nNODE_CHANNEL_SERIALIZATION_MODE=[]\n";
+
+// Spawn `bun <args>` with an IPC channel (`ipc` makes Bun.spawn create one and
+// set NODE_CHANNEL_FD for the direct child) and report what the grandchild saw.
+async function runWithChannel(args: string[], cwd: string) {
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), ...args],
+    env: bunEnv,
+    cwd,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+    ipc() {},
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+  return { stdout, stderr, exitCode };
+}
+
+test.concurrent.skipIf(isWindows)("bun exec does not forward the inherited IPC channel", async () => {
+  using dir = tempDir("ipc-scrub-exec", { "show.sh": SHOW_CHANNEL });
+  const { stdout, stderr, exitCode } = await runWithChannel(["exec", "sh show.sh"], String(dir));
+  expect(stdout).toBe(NO_CHANNEL);
+  expect({ stderr, exitCode }).toEqual({ stderr: "", exitCode: 0 });
+});
+
+test.concurrent.skipIf(isWindows)("bun run --shell=bun does not forward the inherited IPC channel", async () => {
+  using dir = tempDir("ipc-scrub-bunshell", {
+    "package.json": JSON.stringify({ name: "x", version: "1.0.0", scripts: { show: "sh show.sh" } }),
+    "show.sh": SHOW_CHANNEL,
+  });
+  const { stdout, stderr, exitCode } = await runWithChannel(["run", "--silent", "--shell=bun", "show"], String(dir));
+  expect(stdout).toBe(NO_CHANNEL);
+  expect({ stderr, exitCode }).toEqual({ stderr: "", exitCode: 0 });
+});

From 82e6cec4ef67a7606810d0a4b64a108826146502 Mon Sep 17 00:00:00 2001
From: Jarred Sumner <jarred@jarredsumner.com>
Date: Mon, 19 Oct 2026 00:45:42 +0000
Subject: [PATCH 10/24] cli: fix the `--no-module-preload` help text and two
 bunfig error messages (#42967)

---
 src/bunfig/bunfig.rs                     |  6 +--
 src/clap_macros/lib.rs                   | 53 +++++++++++-------------
 src/runtime/cli/Arguments.rs             |  2 +-
 test/cli/bun.test.ts                     | 16 +++++++
 test/config/bunfig/bunfig-errors.test.ts | 45 ++++++++++++++++++++
 5 files changed, 90 insertions(+), 32 deletions(-)

diff --git a/src/bunfig/bunfig.rs b/src/bunfig/bunfig.rs
index b92f66a06a3f..23f39aa35756 100644
--- a/src/bunfig/bunfig.rs
+++ b/src/bunfig/bunfig.rs
@@ -769,7 +769,7 @@ impl<'a> Parser<'a, '_> {
                             None => {
                                 self.add_error(
                                     auto_install_expr.loc,
-                                    b"Invalid auto install setting, must be one of true, false, or \"force\" \"fallback\" \"disable\"",
+                                    b"Invalid auto install setting, must be one of true, false, \"auto\", \"force\", \"fallback\", or \"disable\"",
                                 )?;
                                 return Ok(());
                             }
@@ -783,7 +783,7 @@ impl<'a> Parser<'a, '_> {
                     } else {
                         self.add_error(
                             auto_install_expr.loc,
-                            b"Invalid auto install setting, must be one of true, false, or \"force\" \"fallback\" \"disable\"",
+                            b"Invalid auto install setting, must be one of true, false, \"auto\", \"force\", \"fallback\", or \"disable\"",
                         )?;
                         return Ok(());
                     }
@@ -797,7 +797,7 @@ impl<'a> Parser<'a, '_> {
                     } else {
                         self.add_error(
                             prefer_expr.loc,
-                            b"Invalid prefer setting, must be one of online or offline",
+                            b"Invalid prefer setting, must be one of \"online\", \"offline\", or \"latest\"",
                         )?;
                     }
                 }
diff --git a/src/clap_macros/lib.rs b/src/clap_macros/lib.rs
index 5e4c1512e10e..7699358ee6a0 100644
--- a/src/clap_macros/lib.rs
+++ b/src/clap_macros/lib.rs
@@ -265,14 +265,14 @@ fn byte_str_b(s: &[u8]) -> LitByteStr {
     LitByteStr::new(s, Span::call_site())
 }
 
-/// 1:1 port of `bun_core::output::pretty_fmt_runtime` — rewrites Bun's `<tag>`
+/// Port of `bun_core::output::pretty_fmt_runtime` — rewrites Bun's `<tag>`
 /// colour markup to ANSI escape sequences when `is_enabled`, or strips it when
 /// not. Run here at macro-expansion time with `is_enabled = false` so each param
 /// description's tag-stripped form (`Help::msg_plain`) is a `const` byte literal
 /// in rodata. The ANSI form is *not* baked in — it is rare (only `bun --help` on
 /// a colour TTY) and would otherwise roughly triple the help-string rodata, so
 /// `bun_clap::pretty_help_desc` derives it from `Help::msg` on demand instead.
-fn pretty_rewrite(fmt: &[u8], is_enabled: bool) -> Vec<u8> {
+fn pretty_rewrite(fmt: &[u8], is_enabled: bool) -> Result<Vec<u8>, String> {
     use bun_output_tags::{RESET, color_for_bytes};
     let mut out: Vec<u8> = Vec::with_capacity(fmt.len() * 2);
     let mut i = 0usize;
@@ -321,12 +321,10 @@ fn pretty_rewrite(fmt: &[u8], is_enabled: bool) -> Vec<u8> {
                     is_reset = true;
                     ""
                 } else {
-                    // Unknown tag: `pretty_fmt_runtime` (the path this replaces)
-                    // drops it silently. Match
-                    // the lenient runtime behaviour — a compile error would be
-                    // stricter than what shipped, and param specs don't carry
-                    // unknown tags anyway.
-                    ""
+                    return Err(format!(
+                        "`<{}>` in the help text is not a colour tag and would be dropped from --help; write `\\\\<` and `\\\\>` for literal angle brackets",
+                        name.escape_ascii()
+                    ));
                 };
                 if is_enabled {
                     out.extend_from_slice(if is_reset {
@@ -342,15 +340,15 @@ fn pretty_rewrite(fmt: &[u8], is_enabled: bool) -> Vec<u8> {
             }
         }
     }
-    out
+    Ok(out)
 }
 
-fn emit_param(krate: &Path, p: &Param) -> TokenStream2 {
+fn emit_param(krate: &Path, p: &Param) -> Result<TokenStream2, String> {
     let msg = byte_str(&p.id.msg);
     // Precompute only the tag-stripped form (the non-TTY help path needs it ready
     // without a TTY check); the ANSI form is derived lazily from `msg` by
     // `bun_clap::pretty_help_desc`, so it stays out of rodata.
-    let msg_plain = byte_str_b(&pretty_rewrite(p.id.msg.as_bytes(), false));
+    let msg_plain = byte_str_b(&pretty_rewrite(p.id.msg.as_bytes(), false)?);
     let value = byte_str(&p.id.value);
 
     let short = match p.names.short {
@@ -386,7 +384,7 @@ fn emit_param(krate: &Path, p: &Param) -> TokenStream2 {
         Values::OneOptional => quote! { #krate::Values::OneOptional },
     };
 
-    quote! {
+    Ok(quote! {
         #krate::Param::<#krate::Help> {
             id: #krate::Help {
                 msg: #msg,
@@ -400,7 +398,7 @@ fn emit_param(krate: &Path, p: &Param) -> TokenStream2 {
             },
             takes_value: #takes_value,
         }
-    }
+    })
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -423,17 +421,21 @@ impl Parse for ParseParamInput {
     }
 }
 
+/// One param spec literal → const `Param<Help>` literal, or a compile error at the literal.
+fn expand_param(krate: &Path, lit: &LitStr, macro_name: &str) -> syn::Result<TokenStream2> {
+    let line = lit.value();
+    let error = |msg: &str| syn::Error::new(lit.span(), format!("{macro_name}: {msg}"));
+    let param = parse_param(line.as_bytes()).map_err(|e| error(e.msg()))?;
+    emit_param(krate, &param).map_err(|msg| error(&msg))
+}
+
 /// `__parse_param_impl!($crate, "…")` → const `Param<Help>` literal.
 #[proc_macro]
 pub fn __parse_param_impl(input: TokenStream) -> TokenStream {
     let ParseParamInput { krate, lit } = parse_macro_input!(input as ParseParamInput);
-    let line = lit.value();
-    match parse_param(line.as_bytes()) {
-        Ok(p) => emit_param(&krate, &p).into(),
-        Err(e) => syn::Error::new(lit.span(), format!("parse_param!: {}", e.msg()))
-            .to_compile_error()
-            .into(),
-    }
+    expand_param(&krate, &lit, "parse_param!")
+        .unwrap_or_else(|e| e.to_compile_error())
+        .into()
 }
 
 struct ParseParamsInput {
@@ -457,14 +459,9 @@ pub fn __parse_params_impl(input: TokenStream) -> TokenStream {
 
     let mut items = Vec::with_capacity(lits.len());
     for lit in &lits {
-        let line = lit.value();
-        match parse_param(line.as_bytes()) {
-            Ok(p) => items.push(emit_param(&krate, &p)),
-            Err(e) => {
-                return syn::Error::new(lit.span(), format!("parse_params!: {}", e.msg()))
-                    .to_compile_error()
-                    .into();
-            }
+        match expand_param(&krate, lit, "parse_params!") {
+            Ok(item) => items.push(item),
+            Err(e) => return e.to_compile_error().into(),
         }
     }
 
diff --git a/src/runtime/cli/Arguments.rs b/src/runtime/cli/Arguments.rs
index d2a105468ec6..ab9c5b07e06b 100644
--- a/src/runtime/cli/Arguments.rs
+++ b/src/runtime/cli/Arguments.rs
@@ -486,7 +486,7 @@ pub(crate) const BUILD_ONLY_PARAMS: &[ParamType] = concat_params!(
             "--no-split-require               With --splitting and --target bun: keep a require()'d ESM file in the calling chunk instead of emitting a chunk loaded at the call"
         ),
         parse_param!(
-            "--no-module-preload              With --splitting and --target browser: don't emit <link rel=modulepreload> for the chunks an entry or import() loads"
+            "--no-module-preload              With --splitting and --target browser: don't emit \\<link rel=modulepreload\\> for the chunks an entry or import() loads"
         ),
         parse_param!(
             "--min-chunk-size <INT>           With --splitting, also fold side-effect-free chunks smaller than this many source bytes into a chunk more entry points load. Default: 0 (off); 16384 is a good value for browser builds"
diff --git a/test/cli/bun.test.ts b/test/cli/bun.test.ts
index a63c61987961..eefd93179321 100644
--- a/test/cli/bun.test.ts
+++ b/test/cli/bun.test.ts
@@ -462,6 +462,7 @@ describe("bun", () => {
       ["test", "--rerun-each", "Re-run each test file <NUMBER> times"],
       ["test", "--bail", "Exit the test suite after <NUMBER> failures"],
       ["build", "--allow-unresolved", "Use '<empty>' for opaque specifiers"],
+      ["build", "--no-module-preload", "don't emit <link rel=modulepreload> for the chunks"],
       ["add", "-F, --filter", "Add the package(s) to the matching workspaces instead of the current package"],
       ["add", "--catalog", 'depend on it as "catalog:" (use --catalog=NAME for a named catalog)'],
       ["remove", "-F, --filter", "Remove the package(s) from the matching workspaces instead of the current package"],
@@ -494,6 +495,21 @@ describe("bun", () => {
       expect(out).not.toContain("<blue>");
       expect(exitCode).toBe(0);
     });
+
+    // With colors on, a flag description goes through the runtime markup pass, not the build-time one.
+    test("bun build --help keeps <link rel=modulepreload> with FORCE_COLOR=1", async () => {
+      await using proc = Bun.spawn({
+        cmd: [bunExe(), "build", "--help"],
+        env: { ...bunEnv, NO_COLOR: undefined, FORCE_COLOR: "1" },
+        stderr: "pipe",
+      });
+      const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+      const line = (stdout + stderr).split(/\r?\n/).find(l => l.includes("--no-module-preload")) ?? "";
+      // The cyan flag name proves that colors are on, so the runtime pass wrote this line.
+      expect(line).toContain("\x1b[36m--no-module-preload\x1b[0m");
+      expect(line).toContain("don't emit <link rel=modulepreload> for the chunks");
+      expect(exitCode).toBe(0);
+    });
   });
 
   describe("--help lists package manager commands and examples", () => {
diff --git a/test/config/bunfig/bunfig-errors.test.ts b/test/config/bunfig/bunfig-errors.test.ts
index e1581e953929..4dc71148896a 100644
--- a/test/config/bunfig/bunfig-errors.test.ts
+++ b/test/config/bunfig/bunfig-errors.test.ts
@@ -33,6 +33,51 @@ describe.concurrent("bunfig.toml type-mismatch error messages", () => {
   });
 });
 
+describe.concurrent("bunfig.toml invalid-value error messages name every accepted value", () => {
+  const settings: [key: string, accepted: string[], expected: string][] = [
+    [
+      "prefer",
+      [`"online"`, `"offline"`, `"latest"`],
+      `Invalid prefer setting, must be one of "online", "offline", or "latest"`,
+    ],
+    [
+      "auto",
+      [`true`, `false`, `"auto"`, `"force"`, `"fallback"`, `"disable"`],
+      `Invalid auto install setting, must be one of true, false, "auto", "force", "fallback", or "disable"`,
+    ],
+  ];
+
+  async function runWithInstallSetting(key: string, value: string) {
+    using dir = tempDir("bunfig-invalid-value", {
+      "bunfig.toml": `[install]\n${key} = ${value}\n`,
+    });
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "-e", "console.log('ran')"],
+      env: bunEnv,
+      cwd: String(dir),
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    return { stdout, stderr, exitCode };
+  }
+
+  test.each(settings)('install.%s = "bogus"', async (key, accepted, expected) => {
+    const { stdout, stderr, exitCode } = await runWithInstallSetting(key, `"bogus"`);
+    const errorLine = stderr.split("\n").find(l => l.startsWith("error:")) ?? stderr;
+    expect(errorLine).toBe(`error: ${expected}`);
+    // The message names every value that the next test shows bun accepts.
+    expect(accepted.filter(value => !expected.includes(value))).toEqual([]);
+    expect(stdout).toBe("");
+    expect(exitCode).not.toBe(0);
+  });
+
+  const acceptedCases = settings.flatMap(([key, accepted]) => accepted.map((value): [string, string] => [key, value]));
+  test.each(acceptedCases)("install.%s = %s is accepted", async (key, value) => {
+    expect(await runWithInstallSetting(key, value)).toEqual({ stdout: "ran\n", stderr: "", exitCode: 0 });
+  });
+});
+
 // bun builds every config path in a stack buffer of MAX_PATH_BYTES (the platform's
 // PATH_MAX, see bun_core), so the longest path it can hold is MAX_PATH_BYTES - 1
 // bytes plus the NUL terminator. Paths that do not fit used to overflow the buffer

From 96ffb6722787d7cee77395e908de05e4771d866a Mon Sep 17 00:00:00 2001
From: Jarred Sumner <jarred@jarredsumner.com>
Date: Mon, 19 Oct 2026 00:45:46 +0000
Subject: [PATCH 11/24] bun run: do not look for a system shell when
 --shell=bun runs the script (#43231)

---
 src/crash_handler/lib.rs       |   5 +
 src/runtime/cli/run_command.rs |  14 ++-
 test/cli/run/hide-paths.c      | 216 +++++++++++++++++++++++++++++++++
 test/cli/run/run-shell.test.ts |  89 +++++++++++++-
 4 files changed, 317 insertions(+), 7 deletions(-)
 create mode 100644 test/cli/run/hide-paths.c

diff --git a/src/crash_handler/lib.rs b/src/crash_handler/lib.rs
index 9475e295161e..95f7eb4d00bd 100644
--- a/src/crash_handler/lib.rs
+++ b/src/crash_handler/lib.rs
@@ -1444,6 +1444,11 @@ mod draft {
         } else if name == b"MissingPackageJSON" {
             err_generic!("Bun could not find a package.json file to install from");
             bun_core::note!("Run \"bun init\" to initialize a project");
+        } else if name == b"MissingShell" {
+            err_generic!("Bun could not find a system shell (bash, sh, or zsh) to run this script");
+            bun_core::note!(
+                "To use Bun's built-in shell, pass --shell=bun to \"bun run\" or set shell = \"bun\" under [run] in bunfig.toml"
+            );
         } else {
             // The macros need
             // `:literal`, so branch on the const and call separately.
diff --git a/src/runtime/cli/run_command.rs b/src/runtime/cli/run_command.rs
index f990e9bf607a..d53c5853c48a 100644
--- a/src/runtime/cli/run_command.rs
+++ b/src/runtime/cli/run_command.rs
@@ -319,9 +319,13 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
         use_system_shell: bool,
         shell_path: Option<&[u8]>,
     ) -> crate::Result<()> {
-        let shell_search_path = shell_path.unwrap_or_else(|| env.get(b"PATH").unwrap_or(b""));
-        let shell_bin =
-            Self::find_shell(shell_search_path, cwd).ok_or(crate::Error::MissingShell)?;
+        // `--shell=bun` must work on an image that has no system shell.
+        let shell_bin = if use_system_shell {
+            let shell_search_path = shell_path.unwrap_or_else(|| env.get(b"PATH").unwrap_or(b""));
+            Some(Self::find_shell(shell_search_path, cwd).ok_or(crate::Error::MissingShell)?)
+        } else {
+            None
+        };
         env.map
             .put(b"npm_lifecycle_event", name)
             .expect("unreachable");
@@ -368,7 +372,7 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
             Output::flush();
         }
 
-        if !use_system_shell {
+        let Some(shell_bin) = shell_bin else {
             // SAFETY: `MiniEventLoop` stores `env` as a raw `*mut`; the loader
             // outlives the call (process-lifetime in `configure_env_for_run`).
             let mini = bun_event_loop::MiniEventLoop::init_global(
@@ -412,7 +416,7 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
                 Global::exit(code as u32);
             }
             return Ok(());
-        }
+        };
 
         use crate::api::bun_process::{Status as SpawnStatus, sync};
 
diff --git a/test/cli/run/hide-paths.c b/test/cli/run/hide-paths.c
new file mode 100644
index 000000000000..ff11b335c710
--- /dev/null
+++ b/test/cli/run/hide-paths.c
@@ -0,0 +1,216 @@
+// Test helper: run a command with some paths made to look absent.
+//
+//   hide-paths /bin/sh /bin/bash -- bun run start
+//
+// A mount namespace needs privileges that CI does not have. This uses seccomp
+// user notification instead: the child's path syscalls stop in the kernel, the
+// parent reads the path from the child's memory, and answers ENOENT for a
+// hidden path (the path itself or anything below it) or lets the syscall
+// continue. Exit code 77 means the kernel or the sandbox does not allow this.
+// The path check is racy by design, which does not matter for a test.
+#define _GNU_SOURCE
+#include <errno.h>
+#include <linux/audit.h>
+#include <linux/filter.h>
+#include <linux/seccomp.h>
+#include <poll.h>
+#include <signal.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/prctl.h>
+#include <sys/socket.h>
+#include <sys/syscall.h>
+#include <sys/uio.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#define SKIP 77
+
+#if defined(__x86_64__)
+#define HP_AUDIT_ARCH AUDIT_ARCH_X86_64
+#elif defined(__aarch64__)
+#define HP_AUDIT_ARCH AUDIT_ARCH_AARCH64
+#else
+#define HP_AUDIT_ARCH 0
+#endif
+
+// Linux 5.0 (listener) and 5.5 (continue). Declared here so that older kernel
+// headers still compile; an older kernel answers EINVAL and the helper skips.
+struct hp_notif { uint64_t id; uint32_t pid; uint32_t flags; struct seccomp_data data; };
+struct hp_notif_resp { uint64_t id; int64_t val; int32_t error; uint32_t flags; };
+struct hp_notif_sizes { uint16_t notif, resp, data; };
+#define HP_NEW_LISTENER (1UL << 3)
+#define HP_GET_NOTIF_SIZES 3
+#define HP_CONTINUE (1UL << 0)
+#define HP_NOTIF_RECV _IOWR('!', 0, struct hp_notif)
+#define HP_NOTIF_SEND _IOWR('!', 1, struct hp_notif_resp)
+#ifndef SECCOMP_RET_USER_NOTIF
+#define SECCOMP_RET_USER_NOTIF 0x7fc00000U
+#endif
+#ifndef __NR_faccessat2
+#define __NR_faccessat2 439
+#endif
+#ifndef __NR_openat2
+#define __NR_openat2 437
+#endif
+
+// Syscalls that take the path in args[0], then those that take it in args[1].
+static const int path_arg0[] = {
+#ifdef __NR_open
+  __NR_open, __NR_stat, __NR_lstat, __NR_readlink, __NR_access,
+#endif
+  __NR_execve,
+};
+static const int path_arg1[] = {
+  __NR_openat, __NR_openat2, __NR_newfstatat, __NR_statx, __NR_readlinkat, __NR_faccessat, __NR_faccessat2, __NR_execveat,
+};
+#define N0 ((int)(sizeof(path_arg0) / sizeof(path_arg0[0])))
+#define N1 ((int)(sizeof(path_arg1) / sizeof(path_arg1[0])))
+
+static int install_filter(void) {
+  struct sock_filter f[N0 + N1 + 6];
+  int n = 0, total = N0 + N1;
+  f[n++] = (struct sock_filter)BPF_STMT(BPF_LD | BPF_W | BPF_ABS, offsetof(struct seccomp_data, arch));
+  f[n++] = (struct sock_filter)BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, HP_AUDIT_ARCH, 1, 0);
+  f[n++] = (struct sock_filter)BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW);
+  f[n++] = (struct sock_filter)BPF_STMT(BPF_LD | BPF_W | BPF_ABS, offsetof(struct seccomp_data, nr));
+  for (int i = 0; i < total; i++) {
+    int nr = i < N0 ? path_arg0[i] : path_arg1[i - N0];
+    // On a match, jump over the remaining compares and the ALLOW to the NOTIF return.
+    f[n++] = (struct sock_filter)BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, nr, total - i, 0);
+  }
+  f[n++] = (struct sock_filter)BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW);
+  f[n++] = (struct sock_filter)BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_USER_NOTIF);
+  struct sock_fprog prog = {.len = (unsigned short)n, .filter = f};
+  return (int)syscall(__NR_seccomp, SECCOMP_SET_MODE_FILTER, HP_NEW_LISTENER, &prog);
+}
+
+static int send_fd(int sock, int fd) {
+  char control[CMSG_SPACE(sizeof(int))] = {0}, byte = 0;
+  struct iovec io = {.iov_base = &byte, .iov_len = 1};
+  struct msghdr msg = {.msg_iov = &io, .msg_iovlen = 1, .msg_control = control, .msg_controllen = sizeof(control)};
+  struct cmsghdr *c = CMSG_FIRSTHDR(&msg);
+  c->cmsg_level = SOL_SOCKET;
+  c->cmsg_type = SCM_RIGHTS;
+  c->cmsg_len = CMSG_LEN(sizeof(int));
+  memcpy(CMSG_DATA(c), &fd, sizeof(int));
+  return sendmsg(sock, &msg, 0) < 0 ? -1 : 0;
+}
+
+static int recv_fd(int sock) {
+  char control[CMSG_SPACE(sizeof(int))] = {0}, byte;
+  struct iovec io = {.iov_base = &byte, .iov_len = 1};
+  struct msghdr msg = {.msg_iov = &io, .msg_iovlen = 1, .msg_control = control, .msg_controllen = sizeof(control)};
+  if (recvmsg(sock, &msg, 0) <= 0) return -1;
+  struct cmsghdr *c = CMSG_FIRSTHDR(&msg);
+  if (!c) return -1;
+  int fd;
+  memcpy(&fd, CMSG_DATA(c), sizeof(int));
+  return fd;
+}
+
+static int is_hidden(const char *path, char **hidden, int count) {
+  for (int i = 0; i < count; i++) {
+    size_t len = strlen(hidden[i]);
+    if (strncmp(path, hidden[i], len) == 0 && (path[len] == 0 || path[len] == '/')) return 1;
+  }
+  return 0;
+}
+
+// Reads the NUL-terminated path at `addr` in the child. Returns 0, or -1 if the read is not permitted.
+static int read_path(pid_t pid, uint64_t addr, char *out, size_t cap) {
+  out[0] = 0;
+  if (!addr) return 0;
+  // Do not cross into the next page unless the string does: it may be unmapped.
+  size_t first = 4096 - (size_t)(addr & 4095);
+  if (first > cap - 1) first = cap - 1;
+  struct iovec local = {.iov_base = out, .iov_len = first};
+  struct iovec remote = {.iov_base = (void *)(uintptr_t)addr, .iov_len = first};
+  ssize_t got = process_vm_readv(pid, &local, 1, &remote, 1, 0);
+  if (got < 0) return errno == EPERM || errno == ENOSYS ? -1 : 0;
+  if (memchr(out, 0, (size_t)got) == NULL && (size_t)got < cap - 1) {
+    local.iov_base = out + got;
+    remote.iov_base = (void *)(uintptr_t)(addr + (uint64_t)got);
+    local.iov_len = remote.iov_len = cap - 1 - (size_t)got;
+    ssize_t more = process_vm_readv(pid, &local, 1, &remote, 1, 0);
+    got += more > 0 ? more : 0;
+  }
+  out[got] = 0;
+  return 0;
+}
+
+int main(int argc, char **argv) {
+  int sep = 0;
+  for (int i = 1; i < argc && !sep; i++)
+    if (strcmp(argv[i], "--") == 0) sep = i;
+  if (sep < 2 || sep + 1 >= argc) {
+    fprintf(stderr, "usage: %s <hidden path>... -- <command> [args...]\n", argv[0]);
+    return 2;
+  }
+  if (HP_AUDIT_ARCH == 0) return SKIP;
+
+  int pair[2];
+  if (socketpair(AF_UNIX, SOCK_STREAM, 0, pair) != 0) return SKIP;
+  pid_t child = fork();
+  if (child < 0) return SKIP;
+  if (child == 0) {
+    close(pair[0]);
+    if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) != 0) _exit(SKIP);
+    int listener = install_filter();
+    if (listener < 0 || send_fd(pair[1], listener) != 0) _exit(SKIP);
+    close(listener);
+    close(pair[1]);
+    execvp(argv[sep + 1], argv + sep + 1);
+    perror("execvp");
+    _exit(127);
+  }
+  close(pair[1]);
+  int listener = recv_fd(pair[0]);
+  close(pair[0]);
+
+  struct hp_notif_sizes sizes = {0};
+  if (listener < 0 || syscall(__NR_seccomp, HP_GET_NOTIF_SIZES, 0, &sizes) != 0) {
+    kill(child, SIGKILL);
+    return SKIP;
+  }
+  size_t notif_size = sizes.notif > sizeof(struct hp_notif) ? sizes.notif : sizeof(struct hp_notif);
+  size_t resp_size = sizes.resp > sizeof(struct hp_notif_resp) ? sizes.resp : sizeof(struct hp_notif_resp);
+  struct hp_notif *req = malloc(notif_size);
+  struct hp_notif_resp *resp = malloc(resp_size);
+
+  for (;;) {
+    struct pollfd pfd = {.fd = listener, .events = POLLIN};
+    int ready = poll(&pfd, 1, 100);
+    if (ready < 0 && errno != EINTR) break;
+    if (ready <= 0 || !(pfd.revents & POLLIN)) {
+      int status;
+      if (waitpid(child, &status, WNOHANG) == child)
+        return WIFSIGNALED(status) ? 128 + WTERMSIG(status) : WEXITSTATUS(status);
+      continue;
+    }
+    memset(req, 0, notif_size);
+    if (ioctl(listener, HP_NOTIF_RECV, req) != 0) {
+      if (errno == EINTR || errno == ENOENT) continue;
+      break;
+    }
+    int index = 1;
+    for (int i = 0; i < N0; i++)
+      if (path_arg0[i] == req->data.nr) index = 0;
+    char path[4096];
+    if (read_path((pid_t)req->pid, req->data.args[index], path, sizeof(path)) != 0) break;
+
+    memset(resp, 0, resp_size);
+    resp->id = req->id;
+    if (is_hidden(path, argv + 1, sep - 1)) resp->error = -ENOENT;
+    else resp->flags = HP_CONTINUE;
+    if (ioctl(listener, HP_NOTIF_SEND, resp) != 0 && errno != ENOENT) break;
+  }
+  // The kernel or the sandbox refused a step. Do not report a result.
+  kill(child, SIGKILL);
+  waitpid(child, NULL, 0);
+  return SKIP;
+}
diff --git a/test/cli/run/run-shell.test.ts b/test/cli/run/run-shell.test.ts
index 4d2778abb7cd..44214f99e781 100644
--- a/test/cli/run/run-shell.test.ts
+++ b/test/cli/run/run-shell.test.ts
@@ -1,6 +1,7 @@
-import { describe, expect, test } from "bun:test";
+import { afterAll, describe, expect, test } from "bun:test";
+import { spawnSync } from "child_process";
 import { chmodSync, mkdirSync } from "fs";
-import { bunEnv, bunExe, isWindows, tempDir, tmpdirSync } from "harness";
+import { bunEnv, bunExe, isLinux, isWindows, tempDir, tmpdirSync } from "harness";
 import { join } from "path";
 
 describe.concurrent("run-shell", () => {
@@ -80,3 +81,87 @@ test.skipIf(isWindows)(
     expect(exitCode).toBe(0);
   },
 );
+
+// hide-paths.c makes chosen paths look absent (seccomp user notification). `bin` is the helper,
+// `skip` means this host cannot use it (no cc, missing headers, a kernel or sandbox that refuses
+// the filter), `error` is a compile failure of the helper itself.
+const hidePaths: { bin: string } | { skip: true } | { error: string } = (() => {
+  if (!isLinux) return { skip: true };
+  const dir = tempDir("hide-paths", {});
+  const result = ((): typeof hidePaths => {
+    const bin = join(String(dir), "hide-paths");
+    const compile = spawnSync("cc", ["-O0", "-o", bin, join(import.meta.dir, "hide-paths.c")], { stdio: "pipe" });
+    if ((compile.error as NodeJS.ErrnoException | undefined)?.code === "ENOENT") return { skip: true };
+    if (compile.status !== 0) {
+      const stderr = compile.stderr?.toString() ?? "";
+      // A missing header or libc means this host cannot build C. Anything else is a bug in the helper.
+      return stderr.includes("No such file or directory") ? { skip: true } : { error: stderr };
+    }
+    // Probe: the helper runs itself with no arguments, which prints the usage and exits 2. 77 means skip.
+    return spawnSync(bin, ["/hide-paths-probe", "--", bin], { stdio: "pipe" }).status === 2 ? { bin } : { skip: true };
+  })();
+  // The tests need the binary until the file ends. Every other outcome is done with the directory now.
+  if ("bin" in result) afterAll(() => dir[Symbol.dispose]());
+  else dir[Symbol.dispose]();
+  return result;
+})();
+
+// A FROM-scratch or distroless image has no /bin/sh. `--shell=bun` must not need one. Every path
+// that the shell lookup probes looks absent, and PATH points at an empty directory.
+describe.skipIf("skip" in hidePaths)("bun run on a system with no shell", () => {
+  // Keep in sync with HARDCODED_POPULAR_ONES in src/runtime/cli/run_command.rs.
+  const shellPaths = [
+    "/bin/bash",
+    "/usr/bin/bash",
+    "/usr/local/bin/bash",
+    "/bin/sh",
+    "/usr/bin/sh",
+    "/usr/bin/zsh",
+    "/usr/local/bin/zsh",
+    "/system/bin/sh",
+  ];
+
+  async function runWithoutShells(files: Record<string, string>, args: string[]) {
+    using dir = tempDir("run-no-shell", {
+      "package.json": JSON.stringify({
+        name: "no-shell-fixture",
+        version: "1.0.0",
+        scripts: { prestart: "echo pre", start: "echo started", poststart: "echo post" },
+      }),
+      "empty-path/.keep": "",
+      ...files,
+    });
+    if ("error" in hidePaths) throw new Error("failed to compile hide-paths.c:\n" + hidePaths.error);
+    await using proc = Bun.spawn({
+      cmd: [(hidePaths as { bin: string }).bin, ...shellPaths, "--", bunExe(), "run", ...args],
+      env: { ...bunEnv, PATH: join(String(dir), "empty-path") },
+      cwd: String(dir),
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    return { stdout, stderr, exitCode };
+  }
+
+  test.concurrent("--shell=bun runs the pre, main and post scripts", async () => {
+    const { stdout, exitCode } = await runWithoutShells({}, ["--shell=bun", "start"]);
+    expect(stdout).toBe("pre\nstarted\npost\n");
+    expect(exitCode).toBe(0);
+  });
+
+  test.concurrent('bunfig [run] shell = "bun" runs the scripts', async () => {
+    const { stdout, exitCode } = await runWithoutShells({ "bunfig.toml": '[run]\nshell = "bun"\n' }, ["start"]);
+    expect(stdout).toBe("pre\nstarted\npost\n");
+    expect(exitCode).toBe(0);
+  });
+
+  test.concurrent("the system shell reports what is missing and how to continue", async () => {
+    const { stdout, stderr, exitCode } = await runWithoutShells({}, ["start"]);
+    expect(stderr).toBe(
+      "error: Bun could not find a system shell (bash, sh, or zsh) to run this script\n" +
+        'note: To use Bun\'s built-in shell, pass --shell=bun to "bun run" or set shell = "bun" under [run] in bunfig.toml\n',
+    );
+    expect(stdout).toBe("");
+    expect(exitCode).toBe(1);
+  });
+});

From 0e0b3a85ae0bfb8f66268db28b4a6bfe7a3ee4c5 Mon Sep 17 00:00:00 2001
From: Jarred Sumner <jarred@jarredsumner.com>
Date: Mon, 19 Oct 2026 00:45:50 +0000
Subject: [PATCH 12/24] run: run a package once when two "workspaces" entries
 match it (#43357)

---
 src/runtime/cli/filter_arg.rs         |  6 +++
 test/cli/run/filter-workspace.test.ts | 56 +++++++++++++++++++++++++++
 2 files changed, 62 insertions(+)

diff --git a/src/runtime/cli/filter_arg.rs b/src/runtime/cli/filter_arg.rs
index 82f282c8811d..a9045de7265e 100644
--- a/src/runtime/cli/filter_arg.rs
+++ b/src/runtime/cli/filter_arg.rs
@@ -2,6 +2,7 @@ use core::ptr::NonNull;
 
 use bstr::BStr;
 use bun_ast::{self, ExprData, Log};
+use bun_collections::StringHashMap;
 use bun_core::Global;
 use bun_core::Output;
 use bun_core::{ZStr, strings};
@@ -183,7 +184,12 @@ pub(crate) fn select_packages(
 
     let mut iter = PackageFilterIterator::init(&glob_patterns, &negated, &root_dir)?;
     let mut discovered: Vec<WorkspacePackage> = Vec::new();
+    // Each "workspaces" entry is walked on its own, so two entries can yield the same path.
+    let mut seen_paths: StringHashMap<()> = StringHashMap::default();
     while let Some(package_json_path) = iter.next()? {
+        if seen_paths.get_or_put(&package_json_path)?.found_existing {
+            continue;
+        }
         let dir = strings::without_trailing_slash(resolve_path::dirname::<platform::Auto>(
             &package_json_path,
         ));
diff --git a/test/cli/run/filter-workspace.test.ts b/test/cli/run/filter-workspace.test.ts
index 9363f349d1b1..99c209b09d45 100644
--- a/test/cli/run/filter-workspace.test.ts
+++ b/test/cli/run/filter-workspace.test.ts
@@ -898,6 +898,62 @@ describe("bun", () => {
   });
 });
 
+describe.concurrent('"workspaces" entries that match the same package', () => {
+  function fixture(workspaces: string[] | { packages: string[] }) {
+    return tempDir("filter-workspaces-overlap", {
+      packages: {
+        app: { "package.json": JSON.stringify({ name: "app", scripts: { build: "echo ran-app" } }) },
+        legacy: { "package.json": JSON.stringify({ name: "legacy", scripts: { build: "echo ran-legacy" } }) },
+      },
+      "package.json": JSON.stringify({ name: "root", private: true, workspaces }),
+    });
+  }
+
+  // `ran` has one element per script run, so a package that runs twice is listed twice.
+  async function run(cwd: string, args: string[]) {
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "run", ...args, "build"],
+      cwd,
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    return { ran: (stdout.match(/ran-\w+/g) ?? []).sort(), stderr, exitCode };
+  }
+
+  test.each([
+    ["a glob and a path", ["packages/*", "packages/legacy"]],
+    ["two globs", ["packages/*", "packages/l*"]],
+    ["one path written two ways", ["packages/app", "packages/legacy", "./packages/legacy/"]],
+    ['the { "packages": [...] } form', { packages: ["packages/*", "packages/legacy"] }],
+  ])("%s: each package runs once", async (_, workspaces) => {
+    using dir = fixture(workspaces);
+    const { ran, exitCode } = await run(String(dir), ["--filter", "*"]);
+    expect({ ran, exitCode }).toEqual({ ran: ["ran-app", "ran-legacy"], exitCode: 0 });
+  });
+
+  test.each([[["--workspaces"]], [["--parallel", "--workspaces"]], [["--sequential", "--filter", "*"]]])(
+    "%j runs each package once",
+    async args => {
+      using dir = fixture(["packages/*", "packages/legacy"]);
+      const { ran, exitCode } = await run(String(dir), args);
+      expect({ ran, exitCode }).toEqual({ ran: ["ran-app", "ran-legacy"], exitCode: 0 });
+    },
+  );
+
+  test("a package.json that fails to parse is reported once", async () => {
+    using dir = fixture(["packages/*", "packages/legacy"]);
+    await Bun.write(join(String(dir), "packages", "legacy", "package.json"), "this is { not valid json");
+    const { ran, stderr, exitCode } = await run(String(dir), ["--filter", "*"]);
+    expect({ ran, warnings: stderr.split("skipping this workspace package").length - 1, exitCode }).toEqual({
+      ran: ["ran-app"],
+      warnings: 1,
+      exitCode: 0,
+    });
+  });
+});
+
 describe("selectors", () => {
   test("'foo...' runs foo and the workspaces it depends on", () => {
     runInCwdSuccess({

From bfb8d14dddbb36f34b194956b7b4c8fca83c14c1 Mon Sep 17 00:00:00 2001
From: Jarred Sumner <jarred@jarredsumner.com>
Date: Mon, 19 Oct 2026 00:45:54 +0000
Subject: [PATCH 13/24] docs: describe where bun build --compile --asset mounts
 a file or directory (#44065)

---
 docs/bundler/executables.mdx | 4 ++--
 packages/bun-types/bun.d.ts  | 7 ++++---
 src/runtime/cli/Arguments.rs | 2 +-
 3 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/docs/bundler/executables.mdx b/docs/bundler/executables.mdx
index a05760ff47be..dfa286d45f38 100644
--- a/docs/bundler/executables.mdx
+++ b/docs/bundler/executables.mdx
@@ -897,7 +897,7 @@ If you're using `@mapbox/node-pre-gyp` or similar tools, require the `.node` fil
 
 ### Embed directories
 
-Use `--asset` (or `compile.assets` in the JavaScript API) to embed a file or directory tree into the executable under its original relative path. The embedded files live under `import.meta.dir` at runtime and are reachable via `node:fs` (`existsSync`, `statSync`, `readdirSync`, `readFileSync`) and `Bun.file()`.
+Use `--asset` (or `compile.assets` in the JavaScript API) to embed a file or directory tree into the executable. Bun mounts each asset under its basename, next to the entry point: `--asset ./build/client` lands at `path.join(import.meta.dir, "client")`, and `--asset ./config/app.json` at `path.join(import.meta.dir, "app.json")`. The leading directories of the path you pass are dropped, and a directory keeps its internal tree. The embedded files are reachable via `node:fs` (`existsSync`, `statSync`, `readdirSync`, `readFileSync`) and `Bun.file()`.
 
 <Tabs>
   <Tab title="CLI">
@@ -931,7 +931,7 @@ for (const entry of fs.readdirSync(publicDir, { withFileTypes: true })) {
 const html = await Bun.file(path.join(publicDir, "index.html")).text();
 ```
 
-Pass `--asset` multiple times to embed several directories (for example `--asset ./client --asset ./prerendered` for a SvelteKit build). Bun embeds only regular files; it skips symlinks and empty subdirectories inside the tree.
+Pass `--asset` multiple times to embed several directories (for example `--asset ./client --asset ./prerendered` for a SvelteKit build). Two assets with the same basename are merged into one directory (`--asset a/b --asset x/b` both land under `b/`). Two files that resolve to the same embedded path are an error. Bun embeds only regular files; it skips symlinks and empty subdirectories inside the tree.
 
 You can also embed individual files via the `with { type: "file" }` import attribute or, for files that use the `file` loader (images, fonts, and so on) as well as `.wasm` and `.node` files, by adding them as extra entry points. Bun renames imported assets according to `--asset-naming` (default `[name]-[hash].[ext]`):
 
diff --git a/packages/bun-types/bun.d.ts b/packages/bun-types/bun.d.ts
index 5379ed670831..5ecff8c3a09d 100644
--- a/packages/bun-types/bun.d.ts
+++ b/packages/bun-types/bun.d.ts
@@ -3740,9 +3740,10 @@ declare module "bun" {
     executablePath?: string;
     outfile?: string;
     /**
-     * Files or directories to embed into the executable under their original
-     * relative paths. At runtime they are reachable via `node:fs` and
-     * `Bun.file()` relative to `import.meta.dir`.
+     * Files or directories to embed into the executable. Each one is mounted
+     * under its basename, next to the entry point: `"./build/client"` lands at
+     * `path.join(import.meta.dir, "client")`. At runtime the files are
+     * reachable via `node:fs` and `Bun.file()`.
      *
      * Equivalent CLI flag: `--asset` (repeatable)
      */
diff --git a/src/runtime/cli/Arguments.rs b/src/runtime/cli/Arguments.rs
index ab9c5b07e06b..664e7127915d 100644
--- a/src/runtime/cli/Arguments.rs
+++ b/src/runtime/cli/Arguments.rs
@@ -440,7 +440,7 @@ pub(crate) const BUILD_ONLY_PARAMS: &[ParamType] = concat_params!(
             "--compile-executable-path <STR>  Path to a Bun executable to use for cross-compilation instead of downloading"
         ),
         parse_param!(
-            "--asset <STR>...                 Embed a file or directory into the compiled executable, preserving its relative path (requires --compile)"
+            "--asset <STR>...                 Embed a file or directory into the compiled executable under its basename, next to the entry point (requires --compile)"
         ),
         parse_param!("--bytecode                       Use a bytecode cache"),
         parse_param!(

From 5df28e492603afd28e828debb4f2bafab2f57bb6 Mon Sep 17 00:00:00 2001
From: Jarred Sumner <jarred@jarredsumner.com>
Date: Mon, 19 Oct 2026 00:45:58 +0000
Subject: [PATCH 14/24] cli: read `--conditions` for every command, so node
 emulation applies it (#44611)

---
 src/runtime/cli/Arguments.rs | 13 +++----------
 test/cli/run/as-node.test.ts | 26 ++++++++++++++++++++++++++
 2 files changed, 29 insertions(+), 10 deletions(-)

diff --git a/src/runtime/cli/Arguments.rs b/src/runtime/cli/Arguments.rs
index 664e7127915d..653b9dcf3cd2 100644
--- a/src/runtime/cli/Arguments.rs
+++ b/src/runtime/cli/Arguments.rs
@@ -1032,16 +1032,9 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
 
     ctx.passthrough = slice_to_owned(args.remaining());
 
-    if matches!(
-        cmd,
-        CommandTag::AutoCommand
-            | CommandTag::RunCommand
-            | CommandTag::BuildCommand
-            | CommandTag::TestCommand
-    ) {
-        if !args.options(b"--conditions").is_empty() {
-            opts.conditions = slice_to_owned(args.options(b"--conditions"));
-        }
+    // Declared in both RUNTIME_PARAMS_ and BUILD_ONLY_PARAMS, so every table has it.
+    if !args.options(b"--conditions").is_empty() {
+        opts.conditions = slice_to_owned(args.options(b"--conditions"));
     }
 
     // runtime commands
diff --git a/test/cli/run/as-node.test.ts b/test/cli/run/as-node.test.ts
index a0208c51ad53..29e5766df601 100644
--- a/test/cli/run/as-node.test.ts
+++ b/test/cli/run/as-node.test.ts
@@ -97,6 +97,32 @@ describe("fake node cli", () => {
     );
   });
 
+  describe("--conditions", () => {
+    const files = {
+      "node_modules/condpkg/package.json": JSON.stringify({
+        name: "condpkg",
+        exports: { ".": { custom: "./custom.js", default: "./default.js" } },
+      }),
+      "node_modules/condpkg/custom.js": "module.exports = 'custom';",
+      "node_modules/condpkg/default.js": "module.exports = 'default';",
+      "require.cjs": "console.log(require('condpkg'));",
+      "import.mjs": `
+        import value from "condpkg";
+        import { createRequire } from "node:module";
+        console.log(value, createRequire(import.meta.url)("condpkg"));
+      `,
+    };
+    test.each([
+      [["--conditions=custom", "require.cjs"], "custom"],
+      [["--conditions", "custom", "require.cjs"], "custom"],
+      [["--conditions=custom", "import.mjs"], "custom custom"],
+      [["require.cjs"], "default"],
+    ])("node %j", (args, expected) => {
+      using temp = tempDir("fake-node", files);
+      expect(fakeNodeRun(temp, args)).toEqual({ stdout: expected, stderr: "" });
+    });
+  });
+
   // Bare `node` now matches Node.js: a TTY stdin enters the REPL, a
   // non-TTY stdin (pipe) prints "Missing script". fakeNodeRun's default
   // stdin is platform-dependent (Windows may inherit a console), so pin

From d373fc5ff70d3977837b73c4e61181fc583076c0 Mon Sep 17 00:00:00 2001
From: Jarred Sumner <jarred@jarredsumner.com>
Date: Mon, 19 Oct 2026 00:46:02 +0000
Subject: [PATCH 15/24] bun patch --help: add --commit to the custom patches
 directory example (#45417)

---
 completions/bun-cli.json                      |  2 +-
 .../PackageManager/CommandLineArguments.rs    |  2 +-
 test/cli/install/bun-patch.test.ts            | 51 +++++++++++++++++++
 3 files changed, 53 insertions(+), 2 deletions(-)

diff --git a/completions/bun-cli.json b/completions/bun-cli.json
index e89d30390121..6711e639136e 100644
--- a/completions/bun-cli.json
+++ b/completions/bun-cli.json
@@ -3885,7 +3885,7 @@
       "examples": [
         "bun patch jquery",
         "bun patch --commit 'node_modules/jquery'",
-        "bun patch --patches-dir 'my-patches' 'node_modules/jquery'"
+        "bun patch --commit --patches-dir 'my-patches' 'node_modules/jquery'"
       ],
       "usage": "Usage: bun patch [flags or options] <package>@<version>",
       "documentationUrl": "https://bun.com/docs/install/patch.",
diff --git a/src/install/PackageManager/CommandLineArguments.rs b/src/install/PackageManager/CommandLineArguments.rs
index aac18351dfa9..c765f8b5b3a0 100644
--- a/src/install/PackageManager/CommandLineArguments.rs
+++ b/src/install/PackageManager/CommandLineArguments.rs
@@ -1047,7 +1047,7 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/update<r>.
   <b><green>bun patch --commit 'node_modules/jquery'<r>
 
   <d>Generate a patch file in a custom directory for changes made to jquery<r>
-  <b><green>bun patch --patches-dir 'my-patches' 'node_modules/jquery'<r>
+  <b><green>bun patch --commit --patches-dir 'my-patches' 'node_modules/jquery'<r>
 
 Full documentation is available at <magenta>https://bun.com/docs/install/patch<r>.
 ",
diff --git a/test/cli/install/bun-patch.test.ts b/test/cli/install/bun-patch.test.ts
index 10203f1bc209..a12b81848d93 100644
--- a/test/cli/install/bun-patch.test.ts
+++ b/test/cli/install/bun-patch.test.ts
@@ -201,6 +201,57 @@ describe.concurrent("error messages", () => {
   });
 });
 
+// Each example is run as the help prints it, in a project where `jquery` is an alias of a stand-in.
+describe.concurrent("the examples in 'bun patch --help'", () => {
+  test.each([
+    ["Generate a patch file for changes made to jquery", "patches"],
+    ["Generate a patch file in a custom directory for changes made to jquery", "my-patches"],
+  ])("%s", async (commitExample, patchesDir) => {
+    await using project = await installedProject({ dependencies: { jquery: "npm:no-deps@1.0.0" } });
+    const { dir, env } = project;
+    const indexJs = join(dir, "node_modules", "jquery", "index.js");
+    const help = (await bunOk(dir, env, "patch", "--help")).split(/\r?\n/).map(line => line.trim());
+
+    /** Runs the command that the help prints under `description`, without the quotes a shell removes. */
+    async function runExample(description: string) {
+      expect(help).toContain(description);
+      const [bun, ...args] = help[help.indexOf(description) + 1].split(" ");
+      expect(bun).toBe("bun");
+      await bunOk(dir, env, ...args.map(arg => arg.replace(/^'(.*)'$/, "$1")));
+    }
+
+    await runExample("Prepare jquery for patching");
+    await Bun.write(indexJs, patched);
+    await runExample(commitExample);
+
+    expect({
+      patchedDependencies: (await Bun.file(join(dir, "package.json")).json()).patchedDependencies,
+      patchFile: existsSync(join(dir, patchesDir, "no-deps@1.0.0.patch")),
+      indexJs: await Bun.file(indexJs).text(),
+    }).toEqual({
+      patchedDependencies: { "no-deps@1.0.0": `${patchesDir}/no-deps@1.0.0.patch` },
+      patchFile: true,
+      indexJs: patched,
+    });
+    expect(await Bun.file(join(dir, patchesDir, "no-deps@1.0.0.patch")).text()).toMatchInlineSnapshot(`
+      "diff --git a/index.js b/index.js
+      index bb9c6f6876154493527577cd78279aa6bb686ebb..486c735f2b33e6d1beb1de227b99684124172cb9 100644
+      --- a/index.js
+      +++ b/index.js
+      @@ -1,7 +1 @@
+      -module.exports = require(\`./package.json\`);
+      -
+      -for (const key of [\`dependencies\`, \`devDependencies\`, \`peerDependencies\`]) {
+      -  for (const dep of Object.keys(module.exports[key] || {})) {
+      -    module.exports[key][dep] = require(dep);
+      -  }
+      -}
+      +module.exports = 'patched';
+      "
+    `);
+  });
+});
+
 // `bun patch` identifies packages by `name@label`, where a tarball package's label is
 // the spec it was installed from. These labels used to be formatted into 1024 byte
 // stack buffers (512 bytes in the installer itself), so a long enough spec crashed

From b941e92b9987facd19ccc265e9f8c479fdd5c320 Mon Sep 17 00:00:00 2001
From: Jarred Sumner <jarred@jarredsumner.com>
Date: Mon, 19 Oct 2026 00:46:07 +0000
Subject: [PATCH 16/24] Wake the event loop from the bun test --parallel and
 REPL signal handlers (#45756)

---
 src/runtime/cli/repl.rs                      | 24 ++++--
 src/runtime/cli/test/parallel/Coordinator.rs | 37 +++++++--
 src/runtime/cli/test/parallel/runner.rs      | 10 ++-
 test/cli/test/parallel-signal.test.ts        | 87 ++++++++++++++++++++
 test/js/bun/repl/repl.test.ts                | 21 +++++
 5 files changed, 162 insertions(+), 17 deletions(-)
 create mode 100644 test/cli/test/parallel-signal.test.ts

diff --git a/src/runtime/cli/repl.rs b/src/runtime/cli/repl.rs
index 99f8a2f90f1e..ca00b44d6226 100644
--- a/src/runtime/cli/repl.rs
+++ b/src/runtime/cli/repl.rs
@@ -1085,6 +1085,8 @@ impl<'a> Repl<'a> {
 
         #[cfg(unix)]
         {
+            SIGINT_WAKES.store(bun_uws::Loop::get(), core::sync::atomic::Ordering::Release);
+
             // Switch to normal terminal mode (has ISIG) so Ctrl+C generates SIGINT
             let _ = self
                 .tty_state
@@ -2845,17 +2847,29 @@ impl<'a> Drop for Repl<'a> {
     }
 }
 
-/// The REPL is waiting on a promise and wants SIGINT to cut the wait short (async-signal-safe: atomics only).
+/// The REPL is waiting on a promise and wants SIGINT to cut the wait short.
 static SIGINT_ARMED: core::sync::atomic::AtomicBool = core::sync::atomic::AtomicBool::new(false);
-/// A SIGINT arrived during such a wait: stop waiting (the signal itself interrupts the loop's poll). Not a
-/// VM stop — the VM stays usable.
+/// A SIGINT arrived during such a wait: stop waiting. Not a VM stop — the VM stays usable.
 static SIGINT_DURING_WAIT: core::sync::atomic::AtomicBool =
     core::sync::atomic::AtomicBool::new(false);
+/// The loop that wait parks in. The poll retries on EINTR, so the signal does not end it:
+/// `sigint_handler` wakes it.
+#[cfg(unix)]
+static SIGINT_WAKES: core::sync::atomic::AtomicPtr<bun_uws::Loop> =
+    core::sync::atomic::AtomicPtr::new(core::ptr::null_mut());
 
+/// Async-signal-safe: atomics and one write to the loop's wakeup fd.
 #[cfg(unix)]
 extern "C" fn sigint_handler(_: c_int) {
-    if SIGINT_ARMED.load(core::sync::atomic::Ordering::Acquire) {
-        SIGINT_DURING_WAIT.store(true, core::sync::atomic::Ordering::Release);
+    use core::sync::atomic::Ordering;
+    if SIGINT_ARMED.load(Ordering::Acquire) {
+        SIGINT_DURING_WAIT.store(true, Ordering::Release);
+        let loop_ = SIGINT_WAKES.load(Ordering::Acquire);
+        if !loop_.is_null() {
+            // SAFETY: the loop is process-lifetime, and the raw extern is the
+            // thread-safe entry point (no `&mut Loop` formed off the main thread).
+            unsafe { bun_uws::us_wakeup_loop(loop_) };
+        }
     }
 }
 
diff --git a/src/runtime/cli/test/parallel/Coordinator.rs b/src/runtime/cli/test/parallel/Coordinator.rs
index 25e1a381ad91..93348a1feadc 100644
--- a/src/runtime/cli/test/parallel/Coordinator.rs
+++ b/src/runtime/cli/test/parallel/Coordinator.rs
@@ -7,7 +7,7 @@
 use core::ffi::c_void;
 #[cfg(unix)]
 use core::mem::MaybeUninit;
-use core::sync::atomic::{AtomicI32, Ordering};
+use core::sync::atomic::{AtomicI32, AtomicPtr, Ordering};
 use std::io::Write as _;
 
 use bun_core::strings;
@@ -1035,17 +1035,33 @@ fn describe_status<'b>(buf: &'b mut [u8; 32], status: &SpawnStatus) -> &'b [u8]
     }
 }
 
-/// Coordinator-side SIGINT/SIGTERM handling. The signal handler only sets a
-/// flag; `Coordinator::drive` checks it and tears down workers itself so we
-/// don't do non-signal-safe work in the handler. Linux PDEATHSIG and the
-/// Windows Job Object are the safety net for when the coordinator can't run
-/// this (SIGKILL).
+/// Coordinator-side SIGINT/SIGTERM handling. The handler records the signal
+/// and wakes the loop; `Coordinator::drive` checks it and tears down workers
+/// itself so we don't do non-signal-safe work in the handler. Linux PDEATHSIG
+/// and the Windows Job Object are the safety net for when the coordinator
+/// can't run this (SIGKILL).
 pub(crate) mod abort_handler {
     use super::*;
 
     /// The signal that asked for the abort, or 0. Windows console events count as SIGINT.
     pub(crate) static ABORT_SIGNAL: AtomicI32 = AtomicI32::new(0);
 
+    /// The loop `Coordinator::drive` ticks. Set by `install`, cleared by `uninstall`.
+    static LOOP: AtomicPtr<bun_uws::Loop> = AtomicPtr::new(core::ptr::null_mut());
+
+    /// Signal context on POSIX; the console control thread on Windows. The
+    /// poll retries on EINTR, so without the wakeup `drive` reads the flag
+    /// only when something else ends the poll.
+    fn request_abort(signal: i32) {
+        ABORT_SIGNAL.store(signal, Ordering::Release);
+        let loop_ = LOOP.load(Ordering::Acquire);
+        if !loop_.is_null() {
+            // SAFETY: the loop is process-lifetime, and the raw extern is the
+            // thread-safe entry point (no `&mut Loop` formed off the main thread).
+            unsafe { bun_uws::us_wakeup_loop(loop_) };
+        }
+    }
+
     // PORTING.md §Global mutable state: written once in `install()` (single
     // call site), read once in `uninstall()`. RacyCell — `sigaction` is POD,
     // no concurrent access.
@@ -1058,7 +1074,7 @@ pub(crate) mod abort_handler {
 
     #[cfg(unix)]
     extern "C" fn posix_handler(sig: i32, _: *const libc::siginfo_t, _: *const c_void) {
-        ABORT_SIGNAL.store(sig, Ordering::Release);
+        request_abort(sig);
     }
 
     #[cfg(windows)]
@@ -1068,7 +1084,7 @@ pub(crate) mod abort_handler {
         use bun_sys::windows;
         match ctrl {
             windows::CTRL_C_EVENT | windows::CTRL_BREAK_EVENT | windows::CTRL_CLOSE_EVENT => {
-                ABORT_SIGNAL.store(libc::SIGINT, Ordering::Release);
+                request_abort(libc::SIGINT);
                 windows::TRUE
             }
             _ => windows::FALSE,
@@ -1086,7 +1102,9 @@ pub(crate) mod abort_handler {
         }
     }
 
-    pub(crate) fn install() -> Guard {
+    /// `loop_` is the loop `Coordinator::drive` ticks.
+    pub(crate) fn install(loop_: *mut bun_uws::Loop) -> Guard {
+        LOOP.store(loop_, Ordering::Release);
         #[cfg(unix)]
         {
             // SAFETY: signal handler installation; PREV_* are written before
@@ -1146,5 +1164,6 @@ pub(crate) mod abort_handler {
                 bun_sys::windows::FALSE,
             );
         }
+        LOOP.store(core::ptr::null_mut(), Ordering::Release);
     }
 }
diff --git a/src/runtime/cli/test/parallel/runner.rs b/src/runtime/cli/test/parallel/runner.rs
index 0272a3d8a68b..a8bf832b7208 100644
--- a/src/runtime/cli/test/parallel/runner.rs
+++ b/src/runtime/cli/test/parallel/runner.rs
@@ -192,7 +192,13 @@ pub(crate) fn run_as_coordinator(
         windows_job: Coordinator::create_windows_kill_on_close_job(),
     };
 
-    let _abort_guard = abort_handler::install();
+    // SAFETY: event_loop pointer is valid while vm lives.
+    let uws_loop = unsafe {
+        let event_loop = (*vm_ptr).event_loop();
+        (*event_loop).ensure_waker();
+        (*event_loop).usockets_loop()
+    };
+    let _abort_guard = abort_handler::install(uws_loop);
 
     // Patch the Worker→Coordinator backref now that `coord`'s address is fixed.
     // Access workers through `coord.workers` to avoid a second &mut on the Vec.
@@ -210,8 +216,6 @@ pub(crate) fn run_as_coordinator(
         }
     }
 
-    // SAFETY: event_loop pointer is valid while vm lives.
-    unsafe { (*(*vm_ptr).event_loop()).ensure_waker() };
     // SAFETY: see vm_ptr note above.
     unsafe { &*vm_ptr }.run_with_api_lock(|| coord.drive());
     coord.end_group();
diff --git a/test/cli/test/parallel-signal.test.ts b/test/cli/test/parallel-signal.test.ts
new file mode 100644
index 000000000000..750e484e0492
--- /dev/null
+++ b/test/cli/test/parallel-signal.test.ts
@@ -0,0 +1,87 @@
+// Kept separate from parallel.test.ts for the reason parallel-startup-failure.test.ts gives:
+// file-level pass/fail is what the surrounding tooling checks, and that file has cases that
+// depend on how fast a debug build starts its workers.
+
+import { expect, test } from "bun:test";
+import { readFileSync } from "fs";
+import { bunEnv, bunExe, isLinux, isWindows, tempDir } from "harness";
+
+// With every worker in the middle of a file, nothing arrives on the coordinator's loop, and the
+// poll it waits in is not ended by a signal: it retries on EINTR. A handler that only records
+// the signal is then acted on when something else turns the loop, which on Linux shows as the
+// coordinator's voluntary context switches. Wait for such a turn to pass, so that the signal
+// lands at the start of a quiet period and not just before the next turn.
+async function waitForCoordinatorToPark(pid: number) {
+  const switches = () =>
+    Number(/voluntary_ctxt_switches:\s+(\d+)/.exec(readFileSync(`/proc/${pid}/status`, "utf8"))![1]);
+  const deadline = Date.now() + 3000;
+  const before = switches();
+  while (switches() === before && Date.now() < deadline) await Bun.sleep(1);
+  let last = switches();
+  let quietSince = Date.now();
+  while (Date.now() - quietSince < 100 && Date.now() < deadline) {
+    await Bun.sleep(1);
+    const now = switches();
+    if (now !== last) {
+      last = now;
+      quietSince = Date.now();
+    }
+  }
+}
+
+test.skipIf(isWindows).concurrent.each([
+  ["SIGTERM", 143],
+  ["SIGINT", 130],
+] as const)(
+  "--parallel: the coordinator acts on %s at once while every worker is mid-file",
+  async (signal, code) => {
+    const fixture = `
+      import { test } from "bun:test";
+      import { appendFileSync } from "fs";
+      test("slow", async () => {
+        appendFileSync(process.env.PIDS, process.pid + "\\n");
+        await Bun.sleep(60000);
+      });
+    `;
+    using dir = tempDir("parallel-signal", { "a.test.ts": fixture, "b.test.ts": fixture });
+    const pids = String(dir) + "/pids.txt";
+
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "test", "--parallel=2", "--parallel-delay=0"],
+      env: { ...bunEnv, PIDS: pids },
+      cwd: String(dir),
+      stdout: "ignore",
+      stderr: "pipe",
+    });
+
+    const workersRunning = () => {
+      try {
+        return readFileSync(pids, "utf8").split("\n").filter(Boolean).length;
+      } catch {
+        return 0;
+      }
+    };
+    while (workersRunning() < 2 && proc.exitCode === null) await Bun.sleep(10);
+    expect(workersRunning()).toBe(2);
+    if (isLinux) await waitForCoordinatorToPark(proc.pid);
+
+    // "Interrupted" is the first thing the coordinator prints once it has seen the signal. The
+    // time up to that leaves out how long the processes take to go away.
+    const stderr = proc.stderr.getReader();
+    const decoder = new TextDecoder();
+    let seen = "";
+    const start = performance.now();
+    proc.kill(signal);
+    while (!seen.includes("Interrupted")) {
+      const { value, done } = await stderr.read();
+      if (done) break;
+      seen += decoder.decode(value, { stream: true });
+    }
+    const reactedAfterMs = performance.now() - start;
+
+    expect(seen).toContain("Interrupted");
+    expect(reactedAfterMs).toBeLessThan(500);
+    expect(await proc.exited).toBe(code);
+  },
+  30_000,
+);
diff --git a/test/js/bun/repl/repl.test.ts b/test/js/bun/repl/repl.test.ts
index 5947a8d30a3f..13b4290ce69a 100644
--- a/test/js/bun/repl/repl.test.ts
+++ b/test/js/bun/repl/repl.test.ts
@@ -1079,6 +1079,27 @@ describe.todoIf(isWindows).concurrent("Bun REPL (Terminal)", () => {
     });
   });
 
+  // The poll that the REPL waits in for a promise is not ended by a signal: it retries on
+  // EINTR. The timer keeps the loop parked in that poll, and the idle GC timer is off so that
+  // nothing else ends it.
+  test("SIGINT interrupts an await while the event loop is parked", async () => {
+    await withTerminalRepl(
+      async ({ send, waitFor, proc }) => {
+        // "parked" is printed from inside the wait, when the REPL's SIGINT handler is installed.
+        // The echo of this line does not contain the word.
+        send(
+          "await new Promise(() => { setTimeout(() => console.log('par' + 'ked'), 1); setTimeout(() => {}, 600000); })\n",
+        );
+        await waitFor("parked");
+        proc.kill("SIGINT");
+        await waitFor(/\u276f|> /);
+        send("1 + 1\n");
+        await waitFor("2");
+      },
+      { env: { BUN_GC_TIMER_DISABLE: "1" } },
+    );
+  });
+
   test("require works in terminal", async () => {
     await withTerminalRepl(async ({ send, waitFor }) => {
       send("typeof require\n");

From 28a2f1ae95d134ef76a28ee792e7b71bd08f79d0 Mon Sep 17 00:00:00 2001
From: Jarred Sumner <jarred@jarredsumner.com>
Date: Mon, 19 Oct 2026 00:46:11 +0000
Subject: [PATCH 17/24] macros: give each parse-worker macro VM its own env
 loader (#45960)

---
 src/dotenv/env_loader.rs                   |  15 +++
 src/js_parser_jsc/Macro.rs                 |  13 ++-
 src/jsc/VirtualMachine.rs                  |   6 +
 src/runtime/jsc_hooks.rs                   |  22 +++-
 test/bundler/transpiler/macro-test.test.ts | 122 +++++++++++++++++++++
 5 files changed, 173 insertions(+), 5 deletions(-)

diff --git a/src/dotenv/env_loader.rs b/src/dotenv/env_loader.rs
index 9e7a680c79f0..dd6a969344ac 100644
--- a/src/dotenv/env_loader.rs
+++ b/src/dotenv/env_loader.rs
@@ -567,6 +567,21 @@ impl Loader {
         })
     }
 
+    /// A copy for a VM on another thread: the map plus the record of what the
+    /// source already loaded (process env, default and explicit `.env` files).
+    /// The copy reads only the files the source skipped, into its own map.
+    pub fn clone_loaded(&self) -> Result<Loader, AllocError> {
+        Ok(Loader {
+            map: self.map.clone_with_allocator()?,
+            default_files_loaded: self.default_files_loaded,
+            custom_files_loaded: self.custom_files_loaded.clone()?,
+            quiet: self.quiet,
+            did_load_process: self.did_load_process,
+            reject_unauthorized: Cell::new(None),
+            aws_credentials: None,
+        })
+    }
+
     pub fn load_process(&mut self) -> Result<(), AllocError> {
         if self.did_load_process {
             return Ok(());
diff --git a/src/js_parser_jsc/Macro.rs b/src/js_parser_jsc/Macro.rs
index a48a00f5f9e0..b7918323713b 100644
--- a/src/js_parser_jsc/Macro.rs
+++ b/src/js_parser_jsc/Macro.rs
@@ -442,10 +442,21 @@ impl Macro {
             // JSC needs to be initialized if building from CLI
             jsc::initialize(jsc::InitializeOptions::default());
 
+            // `env` is the build's loader. Every parse thread shares it, and the
+            // build thread reads it while this thread parses. This VM's transpiler
+            // loads `.env` files into its loader, so it gets a copy, owned by the VM.
+            // SAFETY: `env` comes from `MacroContext.env`, the transpiler's loader,
+            // which is live for the whole build. The bundler does not write it
+            // while parse tasks run.
+            let owned_env_loader = match unsafe { env.as_ref() } {
+                Some(env) => Some(Box::new(env.clone_loaded()?)),
+                None => None,
+            };
+
             let _vm = VirtualMachine::init(VirtualMachineInitOptions {
                 transform_options,
                 log: Some(NonNull::from(&mut *log)),
-                env_loader: NonNull::new(env),
+                owned_env_loader,
                 is_main_thread: false,
                 ..Default::default()
             })?;
diff --git a/src/jsc/VirtualMachine.rs b/src/jsc/VirtualMachine.rs
index 65f0ebc5f6f0..db9bbe3804a0 100644
--- a/src/jsc/VirtualMachine.rs
+++ b/src/jsc/VirtualMachine.rs
@@ -93,6 +93,11 @@ pub struct InitOptions {
     /// `RuntimeHooks::init_runtime_state` so the high-tier `Transpiler::init`
     /// reuses the caller's env loader.
     pub env_loader: Option<NonNull<bun_dotenv::Loader>>,
+    /// An env loader the VM owns, for a VM whose caller's loader belongs to
+    /// another thread (a parse-worker macro VM copies the build's loader).
+    /// The VM's transpiler uses it in place of `env_loader`, and the VM's
+    /// runtime state frees it on teardown.
+    pub owned_env_loader: Option<Box<bun_dotenv::Loader>>,
     pub graph: Option<&'static dyn bun_resolver::StandaloneModuleGraph>,
     /// `--install=...`; the resolver needs it before `configure_linker()` caches package.json.
     pub global_cache: bun_options_types::global_cache::GlobalCache,
@@ -119,6 +124,7 @@ impl Default for InitOptions {
             debugger: Default::default(),
             log: None,
             env_loader: None,
+            owned_env_loader: None,
             graph: None,
             global_cache: bun_options_types::global_cache::GlobalCache::disable,
             smol: false,
diff --git a/src/runtime/jsc_hooks.rs b/src/runtime/jsc_hooks.rs
index 5e6e7e37adbc..b9ba6310cbbb 100644
--- a/src/runtime/jsc_hooks.rs
+++ b/src/runtime/jsc_hooks.rs
@@ -84,6 +84,10 @@ pub(crate) struct RuntimeState {
     /// leaked per-VM (PORTING.md §Forbidden: leaking only for true
     /// process-lifetime singletons via `OnceLock`, which a per-VM arena is not).
     pub(crate) transpiler_arena: Box<bun_alloc::Arena>,
+    /// The env loader `vm.transpiler` points at when the VM owns its own
+    /// (`InitOptions::owned_env_loader`). `None` when the transpiler shares
+    /// the caller's loader. Freed with the state, after the VM.
+    pub(crate) owned_env_loader: Option<Box<bun_dotenv::Loader>>,
     /// `vm.body_value_pool` — pooled storage for `Body.Value`
     /// (`Request.body` payloads).
     /// Boxed because `HiveAllocator` is `Fallback<HiveRef<Body::Value, 256>, 256>`
@@ -351,6 +355,7 @@ unsafe fn init_runtime_state(
         // allocations use the same heap as the global allocator and skip the
         // `mi_heap_new`/`mi_heap_destroy` pair.
         transpiler_arena: Box::new(bun_alloc::Arena::borrowing_default()),
+        owned_env_loader: opts.owned_env_loader.take(),
         body_value_pool: {
             // `Box::new(ManuallyDrop::new(HiveAllocator::init()))` still builds the
             // ~100 KB pool in a stack temporary before moving it into the box (see
@@ -418,10 +423,19 @@ unsafe fn init_runtime_state(
         // `Transpiler` (reclaimed in `deinit_runtime_state` after the VM —
         // and hence `vm.transpiler` — is done).
         let arena: &'static bun_alloc::Arena = unsafe { &*(*state).transpiler_arena };
-        // Forward `opts.env_loader` so the VM
-        // shares the caller's `DotEnv.Loader` (e.g. `bun test` writes
-        // `NODE_ENV=test` into it after init).
-        match bun_bundler::Transpiler::init(arena, log, args, opts.env_loader.map(|p| p.as_ptr())) {
+        // The VM's own loader when it has one. Otherwise forward
+        // `opts.env_loader` so the VM shares the caller's `DotEnv.Loader`
+        // (e.g. `bun test` writes `NODE_ENV=test` into it after init).
+        // SAFETY: `state` is the unique freshly-boxed `RuntimeState`; the
+        // inner `Box<Loader>` payload is heap-stable and, like the arena,
+        // outlives the `Transpiler`.
+        let env_loader: Option<*mut bun_dotenv::Loader> = unsafe {
+            match (*state).owned_env_loader.as_deref_mut() {
+                Some(owned) => Some(ptr::from_mut(owned)),
+                None => opts.env_loader.map(|p| p.as_ptr()),
+            }
+        };
+        match bun_bundler::Transpiler::init(arena, log, args, env_loader) {
             Ok(transpiler) => {
                 // SAFETY: `vm` is the unique freshly-boxed VM; `transpiler`
                 // field is zero-init'd uninhabited memory (never dropped).
diff --git a/test/bundler/transpiler/macro-test.test.ts b/test/bundler/transpiler/macro-test.test.ts
index 4b5254346695..58ee6f1440d6 100644
--- a/test/bundler/transpiler/macro-test.test.ts
+++ b/test/bundler/transpiler/macro-test.test.ts
@@ -625,3 +625,125 @@ describe("--no-macros", () => {
     expect(existsSync(path.join(String(dir), "MACRO_RAN"))).toBe(true);
   });
 });
+
+// Each parse-worker thread creates its own macro VM at its first macro call. The VM's transpiler
+// loads the `.env` files of the cwd into the VM's env loader, so the macro's `process.env` sees
+// them. That loader used to be the build's own loader, shared by every worker thread.
+describe("the macro VM's env loader is its own", () => {
+  const macroModules = 8;
+  const files: Record<string, string> = {
+    ".env": Array.from({ length: 5000 }, (_, i) => `VAR_${i}=value_number_${i}`).join("\n") + "\n",
+    "macro.ts": `export function value(name: string) {\n  return name;\n}\n`,
+    "entry.ts":
+      Array.from({ length: macroModules }, (_, i) => `import m${i} from "./m${i}.ts";`).join("\n") +
+      `\nconsole.log(${Array.from({ length: macroModules }, (_, i) => `m${i}`).join(", ")});\n`,
+  };
+  for (let i = 0; i < macroModules; i++) {
+    files[`m${i}.ts`] = `import { value } from "./macro.ts" with { type: "macro" };\nexport default value("m${i}");\n`;
+  }
+
+  // Several worker threads load the same `.env` into one map at the same time. A few builds at
+  // once, each with a fixed pool of eight threads, make the overlap likely in every environment.
+  test("bun build with several macro modules and a .env does not crash", async () => {
+    using dir = tempDir("macro-env-loader-race", files);
+    const builds = 4;
+    const results = await Promise.all(
+      Array.from({ length: builds }, async (_, i) => {
+        await using proc = Bun.spawn({
+          cmd: [bunExe(), "build", "./entry.ts", "--target=bun", "--outdir", `out${i}`],
+          env: { ...bunEnv, UV_THREADPOOL_SIZE: "8" },
+          cwd: String(dir),
+          stdout: "pipe",
+          stderr: "pipe",
+        });
+        const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+        return { stderr, exitCode };
+      }),
+    );
+    expect(results).toEqual(results.map(() => ({ stderr: "", exitCode: 0 })));
+    for (let i = 0; i < builds; i++) {
+      const out = await Bun.file(path.join(String(dir), `out${i}`, "entry.js")).text();
+      for (let m = 0; m < macroModules; m++) {
+        expect(out).toContain(`var m${m}_default = "m${m}";`);
+      }
+    }
+  }, 60_000);
+
+  // `bun build` without `--env` does not read `.env`. The macro VM reads it for its own
+  // `process.env`, and that read must not change what the build's resolver sees.
+  test.concurrent("a macro's .env load does not reach the build's resolver", async () => {
+    using dir = tempDir("macro-env-loader-isolated", {
+      "vendor/dep/index.ts": `export const dep = "from NODE_PATH";\n`,
+      "macro.ts": `export function value(name: string) {\n  return name;\n}\n`,
+      "with-macro.ts": `import { value } from "./macro.ts" with { type: "macro" };\nimport { dep } from "dep";\nconsole.log(value("a"), dep);\n`,
+      "without-macro.ts": `import { dep } from "dep";\nconsole.log("b", dep);\n`,
+    });
+    await Bun.write(path.join(String(dir), ".env"), `NODE_PATH=${path.join(String(dir), "vendor")}\n`);
+    const build = async (entry: string) => {
+      await using proc = Bun.spawn({
+        cmd: [bunExe(), "build", entry, "--target=bun"],
+        env: bunEnv,
+        cwd: String(dir),
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+      const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+      return {
+        resolved: stdout.includes("from NODE_PATH"),
+        unresolved: stderr.includes('Could not resolve: "dep"'),
+        exitCode,
+      };
+    };
+    const [withMacro, withoutMacro] = await Promise.all([build("./with-macro.ts"), build("./without-macro.ts")]);
+    expect(withoutMacro).toEqual({ resolved: false, unresolved: true, exitCode: 1 });
+    expect(withMacro).toEqual(withoutMacro);
+  });
+
+  test.concurrent("a macro reads .env through its own loader", async () => {
+    using dir = tempDir("macro-env-loader-reads-dotenv", {
+      ".env": "FROM_DOTENV=hello\n",
+      "macro.ts": `export function fromDotenv() {\n  return process.env.FROM_DOTENV ?? "unset";\n}\n`,
+      "entry.ts": `import { fromDotenv } from "./macro.ts" with { type: "macro" };\nconsole.log(fromDotenv());\n`,
+    });
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "build", "./entry.ts", "--target=bun"],
+      env: bunEnv,
+      cwd: String(dir),
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    expect({ lastLine: stdout.trim().split("\n").pop(), exitCode }).toEqual({
+      lastLine: `console.log("hello");`,
+      exitCode: 0,
+    });
+  });
+
+  // The copy carries the record of what the program's loader already read. `Bun.build()` in a
+  // program that loaded `.env` at start does not read it again.
+  test.concurrent("Bun.build() gives the macro VM a copy of the program's env", async () => {
+    using dir = tempDir("macro-env-loader-build-api", {
+      ".env": "FROM_DOTENV=hello\n",
+      "macro.ts": `export function vars() {\n  return [process.env.FROM_DOTENV ?? "unset", process.env.ADDED_AFTER_START ?? "unset"].join(",");\n}\n`,
+      "entry.ts": `import { vars } from "./macro.ts" with { type: "macro" };\nconsole.log(vars());\n`,
+      "build.ts": `
+        import { appendFileSync } from "node:fs";
+        appendFileSync(".env", "ADDED_AFTER_START=yes\\n");
+        const result = await Bun.build({ entrypoints: ["./entry.ts"], target: "bun" });
+        console.log(await result.outputs[0].text());
+      `,
+    });
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "run", "build.ts"],
+      env: bunEnv,
+      cwd: String(dir),
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    expect({ lastLine: stdout.trim().split("\n").pop(), exitCode }).toEqual({
+      lastLine: `console.log("hello,unset");`,
+      exitCode: 0,
+    });
+  });
+});

From 10e06565f1b6e5076376183d4533f5d887b47246 Mon Sep 17 00:00:00 2001
From: Jarred Sumner <jarred@jarredsumner.com>
Date: Mon, 19 Oct 2026 01:53:08 +0000
Subject: [PATCH 18/24] cli: port the rest of the chosen pull requests

---
 Cargo.lock                                    |   2 +-
 completions/bun.bash                          | 107 ++--
 completions/bun.fish                          |  28 +-
 completions/bun.zsh                           |   8 +-
 docs/bundler/esbuild.mdx                      |   2 +-
 docs/bundler/executables.mdx                  |   2 +-
 docs/bundler/index.mdx                        |   2 +-
 docs/pm/filter.mdx                            |   3 +
 docs/runtime/bunfig.mdx                       |  46 +-
 docs/runtime/environment-variables.mdx        |   2 +
 docs/runtime/index.mdx                        |   4 +-
 docs/runtime/jsx.mdx                          |   2 +-
 docs/runtime/templating/init.mdx              |   2 +-
 docs/test/configuration.mdx                   |  24 +
 docs/test/discovery.mdx                       |   9 +
 docs/test/parallel.mdx                        |  10 +-
 src/bun_core/Progress.rs                      |   4 +-
 src/bun_core/output.rs                        |  19 +-
 src/bun_core/util.rs                          |  20 +
 src/bundler/options.rs                        |   6 +-
 src/bundler/transpiler.rs                     |  10 +
 src/bunfig/Cargo.toml                         |   1 +
 src/bunfig/arguments.rs                       |  96 +++-
 src/bunfig/bunfig.rs                          | 230 ++++++---
 src/clap/comptime.rs                          |   9 +
 src/clap/lib.rs                               |   7 +-
 src/clap/streaming.rs                         |   4 +
 src/crash_handler/lib.rs                      |   2 +-
 src/dotenv/env_loader.rs                      | 123 +++--
 src/dotenv/lib.rs                             |   4 +-
 src/glob/lib.rs                               |  13 +
 src/install/PackageManager.rs                 |  19 +-
 .../PackageManagerDirectories.rs              |   1 -
 src/install/PackageManager/ProgressStrings.rs |   1 -
 .../PackageManager/install_with_manager.rs    |   1 -
 src/install/hoisted_install.rs                |   1 -
 src/install/isolated_install.rs               |   1 -
 src/install/lockfile/Package.rs               |   6 +-
 src/jsc/VirtualMachine.rs                     |  21 +-
 src/options_types/context.rs                  |  52 ++
 src/options_types/jsx.rs                      |   3 +
 src/options_types/schema.rs                   |   6 +-
 src/resolver/resolver.rs                      |   7 +-
 src/runtime/api/BunObject.rs                  |   6 +
 src/runtime/api/JSBundler.rs                  |   7 +-
 src/runtime/cli/Arguments.rs                  |  90 +++-
 src/runtime/cli/build_command.rs              |   3 +-
 src/runtime/cli/bunx_command.rs               |   8 +-
 src/runtime/cli/create_command.rs             |  89 +---
 src/runtime/cli/filter_arg.rs                 |  89 +++-
 src/runtime/cli/filter_run.rs                 | 138 +----
 src/runtime/cli/init_command.rs               | 471 ++++--------------
 src/runtime/cli/lint_command.rs               |   4 +-
 src/runtime/cli/mod.rs                        | 137 +++--
 src/runtime/cli/multi_run.rs                  |  95 ++--
 src/runtime/cli/pack_command.rs               |   1 -
 src/runtime/cli/pm_trusted_command.rs         |   1 -
 src/runtime/cli/run_command.rs                | 301 ++++++-----
 src/runtime/cli/test/Scanner.rs               |  14 +-
 src/runtime/cli/test/parallel/Coordinator.rs  |  17 +-
 src/runtime/cli/test/parallel/Frame.rs        |   3 +
 src/runtime/cli/test/parallel/runner.rs       |  27 +-
 src/runtime/cli/test_command.rs               |  40 +-
 src/runtime/cli/upgrade_command.rs            |  22 +-
 src/runtime/node/node_process.rs              |  17 +-
 src/spawn/Cargo.toml                          |   1 -
 src/spawn/lib.rs                              |   2 +-
 src/spawn/process.rs                          |   4 +-
 src/spawn_sys/spawn_process.rs                |   1 +
 src/sys/lib.rs                                |  15 +
 test/bundler/bun-build-api.test.ts            |  18 +-
 test/bundler/bundler_compile_autoload.test.ts |  29 ++
 test/bundler/bundler_jsx.test.ts              |  32 ++
 test/bundler/bundler_minify.test.ts           |  40 +-
 test/bundler/cli.test.ts                      |  17 +
 test/bundler/compile-argv.test.ts             |  30 ++
 .../transpiler/jsx-tsconfig-react-jsx.test.ts |  21 +
 test/cli/bun.test.ts                          | 224 +++++++++
 test/cli/bunfig-test-options.test.ts          | 212 +++++++-
 test/cli/hot/hot.test.ts                      |  42 +-
 test/cli/init/init.test.ts                    | 188 ++++++-
 test/cli/install/bun-create.test.ts           |  16 +
 test/cli/install/bun-install.test.ts          |  43 +-
 test/cli/install/bun-run-bunfig.test.ts       | 175 ++++++-
 test/cli/install/bun-run.test.ts              |  96 +++-
 test/cli/install/bun-upgrade.test.ts          |  22 +
 test/cli/install/bunx.test.ts                 |  82 +++
 test/cli/run/as-node.test.ts                  |  22 +-
 test/cli/run/env.test.ts                      |  79 +++
 test/cli/run/filter-workspace.test.ts         | 459 +++++++++++++----
 test/cli/run/if-present.test.ts               |  30 +-
 test/cli/run/multi-run.test.ts                |  55 ++
 test/cli/run/no-envfile.test.ts               | 105 +++-
 test/cli/run/run-autoinstall.test.ts          |  10 +-
 test/cli/run/run-eval.test.ts                 |  64 +++
 test/cli/run/run-extensionless.test.ts        |  22 +-
 test/cli/run/run_command.test.ts              |  60 +++
 test/cli/test/coverage.test.ts                |  32 ++
 test/cli/test/parallel.test.ts                |  41 ++
 test/cli/test/test-changed.test.ts            |  18 +
 test/cli/watch/watch.test.ts                  | 122 ++++-
 test/config/bunfig/preload.test.ts            | 103 +++-
 test/js/bun/resolve/resolve.test.ts           | 109 ++++
 test/js/bun/spawn/spawn.test.ts               |  21 +
 test/js/junit-reporter/junit.test.js          |  22 +
 test/js/node/process/process.test.js          |  16 +
 test/js/web/console/console-log.test.ts       |  31 +-
 107 files changed, 3995 insertions(+), 1236 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 91c05b2f032f..7348df1f830c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -304,6 +304,7 @@ dependencies = [
  "bun_clap",
  "bun_collections",
  "bun_core",
+ "bun_glob",
  "bun_install_types",
  "bun_io",
  "bun_options_types",
@@ -1770,7 +1771,6 @@ dependencies = [
  "bun_alloc",
  "bun_analytics",
  "bun_core",
- "bun_crash_handler",
  "bun_dispatch",
  "bun_errno",
  "bun_event_loop",
diff --git a/completions/bun.bash b/completions/bun.bash
index e512a7ff1bf5..7f4898d29757 100644
--- a/completions/bun.bash
+++ b/completions/bun.bash
@@ -1,17 +1,19 @@
-#/usr/bin/env bash
-
+# adds the directories, and the files that match the pattern
 _file_arguments() {
-    local extensions="${1}"
-    local reset=$(shopt -p globstar)
-    shopt -s globstar
+    local pattern="${1}";
+    local file;
 
-    if [[ -z "${cur_word}" ]]; then
-        COMPREPLY=( $(compgen -fG -X "${extensions}" -- "${cur_word}") );
-    else
-        COMPREPLY=( $(compgen -f -X "${extensions}" -- "${cur_word}") );
-    fi
+    for file in $(compgen -f -- "${cur_word}"); do
+        if [[ -d "${file}" ]]; then
+            # a subcommand goes before a directory of the same name: `bun te<TAB>` gives `bun test `
+            [[ " ${COMPREPLY[*]} " == *" ${file} "* ]] || COMPREPLY+=( "${file}/" );
+        elif [[ "${file}" == ${pattern} ]]; then
+            COMPREPLY+=( "${file}" );
+        fi
+    done
 
-    $reset
+    # no space after a directory, so that the next <TAB> lists what is in it
+    [[ "${#COMPREPLY[@]}" -eq 1 && "${COMPREPLY[0]}" == */ ]] && compopt -o nospace 2>/dev/null;
 }
 
 _long_short_completion() {
@@ -69,17 +71,6 @@ _read_scripts_in_package_json() {
             [[ -n "${keep}" ]] && filtered_reply+=( "${reply_word}" );
         done
         COMPREPLY=( "${filtered_reply[@]}" );
-        replaced_script="${prev}";
-    }
-}
-
-
-_subcommand_comp_reply() {
-    local cur_word="${1}"
-    local sub_commands="${2}"
-    local regexp_subcommand="^[dbcriauh]";
-    [[ "${prev}" =~ ${regexp_subcommand} ]] && {
-        COMPREPLY+=( $(compgen -W "${sub_commands}" -- "${cur_word}") );
     }
 }
 
@@ -90,9 +81,10 @@ _bun_completions() {
     declare -A PM_OPTIONS;
 
     local SUBCOMMANDS="dev bun create run install add remove upgrade completions discord help init pm x test repl update audit dedupe prune outdated publish link unlink build check lint fmt";
+    local RUNNABLE_FILES="*.@(js|mjs|cjs|ts|mts|cts|jsx|tsx|wasm|html)";
 
-    GLOBAL_OPTIONS[LONG_OPTIONS]="--use --cwd --bunfile --server-bunfile --config --disable-react-fast-refresh --disable-hmr --env-file --extension-order --jsx-factory --jsx-fragment --extension-order --jsx-factory --jsx-fragment --jsx-import-source --jsx-production --jsx-runtime --main-fields --no-summary --version --platform --public-dir --tsconfig-override --define --external --help --inject --loader --origin --port";
-    GLOBAL_OPTIONS[SHORT_OPTIONS]="-c -v -d -e -h -i -l -u -p";
+    GLOBAL_OPTIONS[LONG_OPTIONS]="--use --cwd --bunfile --server-bunfile --config --disable-react-fast-refresh --disable-hmr --env-file --extension-order --jsx-factory --jsx-fragment --extension-order --jsx-factory --jsx-fragment --jsx-import-source --jsx-production --jsx-runtime --main-fields --no-summary --version --platform --public-dir --tsconfig-override --define --external --help --inject --loader --origin --port --hot --watch --no-clear-screen --smol --bun --silent --preload --require --import --inspect --inspect-brk --inspect-wait";
+    GLOBAL_OPTIONS[SHORT_OPTIONS]="-c -v -d -e -h -i -l -u -p -b -r";
 
     PACKAGE_OPTIONS[ADD_OPTIONS_LONG]="--development --optional --peer --save-prod --catalog --filter";
     PACKAGE_OPTIONS[ADD_OPTIONS_SHORT]="-d -F";
@@ -116,13 +108,26 @@ _bun_completions() {
     local cur_word="${COMP_WORDS[${COMP_CWORD}]}";
     local prev="${COMP_WORDS[$(( COMP_CWORD - 1 ))]}";
 
+    # the subcommand or file: the first word that is not a flag or the value of one (`bun --hot run`, `bun --cwd dir run`)
+    local first_word="" i;
+    for (( i=1; i < COMP_CWORD; i++ )); do
+        case "${COMP_WORDS[i]}" in
+            # readline splits `--flag=value` and `K:V` at the `=` and the `:`
+            =|:) (( i++ ));;
+            --cwd|--env-file|--preload|--require|--import|--filter|--define|--loader|--port|--conditions|--tsconfig-override|-r|-F|-d|-l)
+                (( i++ )); [[ "${COMP_WORDS[i]}" == "=" ]] && (( i++ ));;
+            -*) ;;
+            *) first_word="${COMP_WORDS[i]}"; break;;
+        esac
+    done
+
     case "${prev}" in
         help|--help|-h|-v|--version) return;;
-        -c|--config)      _file_arguments "!*.toml" && return;;
-        --bunfile)        _file_arguments "!*.bun" && return;;
-        --server-bunfile) _file_arguments "!*.server.bun" && return;;
+        -c|--config)      _file_arguments "*.toml"; return;;
+        --bunfile)        _file_arguments "*.bun"; return;;
+        --server-bunfile) _file_arguments "*.server.bun"; return;;
         --backend)
-            case "${COMP_WORDS[1]}" in
+            case "${first_word}" in
                 a|add|remove|rm|install|i|dedupe|update|up)
                     COMPREPLY=( $(compgen -W "clonefile copyfile hardlink clonefile_each_dir symlink" -- "${cur_word}") );
                     ;;
@@ -132,7 +137,7 @@ _bun_completions() {
             COMPREPLY=( $(compgen -W "dev optional peer" -- "${cur_word}") );
             return;;
         -F|--filter)
-            case "${COMP_WORDS[1]}" in
+            case "${first_word}" in
                 a|add|remove|rm|i|install|prune|update|up) return;;
             esac
             ;;
@@ -159,8 +164,8 @@ _bun_completions() {
             return;;
     esac
 
-    case "${COMP_WORDS[1]}" in
-        help|completions|--help|-h|-v|--version) return;;
+    case "${first_word}" in
+        help|completions) return;;
         add|a)
             _long_short_completion \
                 "${PACKAGE_OPTIONS[ADD_OPTIONS_LONG]} ${PACKAGE_OPTIONS[ADD_OPTIONS_SHORT]} ${PACKAGE_OPTIONS[SHARED_OPTIONS_LONG]} ${PACKAGE_OPTIONS[SHARED_OPTIONS_SHORT]}" \
@@ -219,45 +224,31 @@ _bun_completions() {
             COMPREPLY=( $(compgen -W "--help -h --eval -e --print -p --preload -r --smol --config -c --cwd --env-file --no-env-file" -- "${cur_word}") );
             return;;
         run)
-            _file_arguments "!(*.@(js|ts|jsx|tsx|mjs|cjs)?($|))";
-            COMPREPLY+=( $(compgen -W "--version --cwd --help --silent -v -h" -- "${cur_word}" ) );
             _read_scripts_in_package_json;
+            COMPREPLY+=( $(compgen -W "--version --cwd --help --silent -v -h" -- "${cur_word}" ) );
+            _file_arguments "${RUNNABLE_FILES}";
             return;;
         pm)
             _long_short_completion \
                 "${PM_OPTIONS[LONG_OPTIONS]} ${PM_OPTIONS[SHORT_OPTIONS]}";
             COMPREPLY+=( $(compgen -W "bin ls licenses cache hash hash-print hash-string" -- "${cur_word}") );
             return;;
-        *)
-            local replaced_script;
+        "")
             _long_short_completion \
                 "${GLOBAL_OPTIONS[*]}" \
                 "${GLOBAL_OPTIONS[SHORT_OPTIONS]}"
-
-            _read_scripts_in_package_json;
-            _subcommand_comp_reply "${cur_word}" "${SUBCOMMANDS}";
-
-            # determine if completion should be continued
-            # when the current word is an empty string
-            # the previous word is not part of the allowed completion
-            # the previous word is not an argument to the last two option
-            [[ -z "${cur_word}" ]] && {
-                local prev_in_reply="";
-                local reply_word;
-                for reply_word in "${COMPREPLY[@]}"; do
-                    [[ "${reply_word}" == "${prev}" ]] && { prev_in_reply=1; break; };
-                done
-                [[ -z "${prev_in_reply}" ]] && {
-                    local re_prev_prev="(^| )${COMP_WORDS[(( COMP_CWORD - 2 ))]}($| )";
-                    local global_option_with_extra_args="--bunfile --server-bunfile --config --port --cwd --public-dir --jsx-runtime --platform --loader";
-                    [[
-                        ( -n "${replaced_script}" && "${replaced_script}" == "${prev}" ) || \
-                            ( "${global_option_with_extra_args}" =~ ${re_prev_prev} )
-                    ]] && return;
-                    unset COMPREPLY;
-                }
+            [[ "${cur_word}" != -* ]] && {
+                _read_scripts_in_package_json;
+                COMPREPLY+=( $(compgen -W "${SUBCOMMANDS}" -- "${cur_word}") );
+                _file_arguments "${RUNNABLE_FILES}";
             }
             return;;
+        *)
+            _long_short_completion \
+                "${GLOBAL_OPTIONS[*]}" \
+                "${GLOBAL_OPTIONS[SHORT_OPTIONS]}"
+            [[ "${cur_word}" != -* ]] && _file_arguments "*";
+            return;;
     esac
 
 }
diff --git a/completions/bun.fish b/completions/bun.fish
index 2993fd63b061..79957667ecb5 100644
--- a/completions/bun.fish
+++ b/completions/bun.fish
@@ -38,6 +38,7 @@ set -l bun_install_boolean_flags_descriptions "Write a yarn.lock file (yarn v1)"
 set -l bun_builtin_cmds_without_run dev create help bun upgrade discord install remove add update audit dedupe prune publish init pm x repl check lint fmt
 # The package manager commands and `bun x` reject a flag they do not have.
 set -l bun_builtin_cmds_accepting_flags create help bun upgrade discord run init
+set -l bun_cmds_without_files create c help upgrade discord install i ci add a remove rm update up audit dedupe prune pm x repl link unlink outdated why info exec completions
 
 function __bun_complete_bins_scripts --inherit-variable bun_builtin_cmds_without_run -d "Emit bun completions for bins and scripts"
     # Do nothing if we already have a builtin subcommand,
@@ -79,6 +80,9 @@ complete -e -c bun
 # Dynamically emit scripts and binaries
 complete -c bun -f -a "(__bun_complete_bins_scripts)"
 
+# Complete files for `bun <file>`, `bun run <file>`, `bun test <file>` and the arguments of a script.
+complete -c bun -n "not __fish_seen_subcommand_from $bun_cmds_without_files" -F
+
 # Complete flags if we have no subcommand or a flag-friendly one.
 set -l flag_applies "__fish_use_subcommand; or __fish_seen_subcommand_from $bun_builtin_cmds_accepting_flags"
 complete -c bun \
@@ -92,7 +96,29 @@ complete -c bun \
 complete -c bun \
 	-n $flag_applies --no-files -l 'use' -r -d 'Use a framework (ex: next)'
 complete -c bun \
-	-n $flag_applies --no-files -l 'hot' -r -d 'Enable hot reloading in Bun\'s JavaScript runtime'
+	-n $flag_applies --no-files -l 'hot' -d 'Enable hot reloading in Bun\'s JavaScript runtime'
+complete -c bun \
+	-n $flag_applies --no-files -l 'watch' -d 'Automatically restart the process on file change'
+complete -c bun \
+	-n $flag_applies --no-files -l 'no-clear-screen' -d 'Disable clearing the terminal screen on reload when --hot or --watch is enabled'
+complete -c bun \
+	-n $flag_applies --no-files -l 'smol' -d 'Use less memory, but run garbage collection more often'
+complete -c bun \
+	-n $flag_applies --no-files -s 'b' -l 'bun' -d 'Force a script or package to use Bun\'s runtime instead of Node.js'
+complete -c bun \
+	-n $flag_applies --no-files -l 'silent' -d 'Don\'t print the script command'
+complete -c bun \
+	-n $flag_applies --no-files -l 'inspect' -d 'Activate Bun\'s debugger'
+complete -c bun \
+	-n $flag_applies --no-files -l 'inspect-brk' -d 'Activate Bun\'s debugger, set breakpoint on first line of code and wait'
+complete -c bun \
+	-n $flag_applies --no-files -l 'inspect-wait' -d 'Activate Bun\'s debugger, wait for a connection before executing'
+complete -c bun \
+	-n $flag_applies -s 'r' -l 'preload' -r -d 'Import a module before other modules are loaded'
+complete -c bun \
+	-n $flag_applies -l 'cwd' -r -d 'Absolute path to resolve files & entry points from'
+complete -c bun \
+	-n $flag_applies -l 'env-file' -r -d 'Load environment variables from the specified file(s)'
 
 # Complete dev and create as first subcommand.
 complete -c bun \
diff --git a/completions/bun.zsh b/completions/bun.zsh
index 3c3b27e60f55..055e6b103b67 100644
--- a/completions/bun.zsh
+++ b/completions/bun.zsh
@@ -1145,7 +1145,7 @@ _bun() {
             'help\:"Show all supported flags and commands" '
         )
         main_commands=($main_commands)
-        _alternative "$scripts" "args:command:(($main_commands))" "files:files:compadd -a files_list"
+        _alternative "$scripts" "args:command:(($main_commands))" "files:files:compadd -a files_list" "globbed-files:file:_files -g '*.(js|mjs|cjs|ts|mts|cts|jsx|tsx|wasm|html)'"
 
         ;;
     args)
@@ -1375,6 +1375,10 @@ _bun() {
                 ;;
             esac
 
+            ;;
+        *)
+            _files
+
             ;;
         esac
 
@@ -1394,7 +1398,7 @@ _bun_run_param_script_completion() {
 
     _alternative "scripts:scripts:compadd -a scripts_list"
     _alternative "bin:bin:compadd -a bins"
-    _alternative "files:file:_files -g '*.(js|ts|jsx|tsx|wasm)'"
+    _alternative "files:file:_files -g '*.(js|mjs|cjs|ts|mts|cts|jsx|tsx|wasm|html)'"
 }
 
 _bun_link_param_package_completion() {
diff --git a/docs/bundler/esbuild.mdx b/docs/bundler/esbuild.mdx
index 39ccc51a9630..fcb5798e510b 100644
--- a/docs/bundler/esbuild.mdx
+++ b/docs/bundler/esbuild.mdx
@@ -89,7 +89,7 @@ In Bun's CLI, boolean flags like `--minify` take no argument. Flags that take on
 | `--minify-syntax`      | `--minify-syntax`          |                                                                                                                                                                                                                                                                                                                                    |
 | `--out-extension`      | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                      |
 | `--outbase`            | `--root`                   |                                                                                                                                                                                                                                                                                                                                    |
-| `--preserve-symlinks`  | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                      |
+| `--preserve-symlinks`  | `--preserve-symlinks`      | Applies to imports. An entry point that is a symlink is still resolved to its target                                                                                                                                                                                                                                               |
 | `--public-path`        | `--public-path`            |                                                                                                                                                                                                                                                                                                                                    |
 | `--pure`               | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                      |
 | `--reserve-props`      | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                      |
diff --git a/docs/bundler/executables.mdx b/docs/bundler/executables.mdx
index dfa286d45f38..58b3318de046 100644
--- a/docs/bundler/executables.mdx
+++ b/docs/bundler/executables.mdx
@@ -445,7 +445,7 @@ BUN_OPTIONS="--smol --cpu-prof-md" ./myapp
 
 ## Automatic config loading
 
-Standalone executables can automatically load configuration files from the directory where they are run. By default:
+Standalone executables can automatically load configuration files from the directory where they are run. They do not search parent directories. By default:
 
 - **`tsconfig.json`** and **`package.json`** loading is **disabled** — these are typically only needed at development time, and the bundler already uses them when compiling
 - **`.env`** and **`bunfig.toml`** loading is **enabled** — these often contain runtime configuration that may vary per deployment
diff --git a/docs/bundler/index.mdx b/docs/bundler/index.mdx
index dcbed53d79c0..9ce0fbb211f1 100644
--- a/docs/bundler/index.mdx
+++ b/docs/bundler/index.mdx
@@ -1200,7 +1200,7 @@ A map of global identifiers to be replaced at build time. Keys of this object ar
 
 ### loader
 
-A map of file extensions to built-in loader names. Use this to customize how certain files are loaded.
+A map of file extensions to built-in loader names. Use this to customize how certain files are loaded. The empty extension (`""`, or `--loader :tsx` on the command line) is for files that have none.
 
 <Tabs>
   <Tab title="JavaScript">
diff --git a/docs/pm/filter.mdx b/docs/pm/filter.mdx
index ec8a989f959a..e40162067d47 100644
--- a/docs/pm/filter.mdx
+++ b/docs/pm/filter.mdx
@@ -159,6 +159,9 @@ bun run --parallel --no-exit-on-error --filter '*' test
 
 # Run multiple scripts across all packages
 bun run --parallel --filter '*' build lint
+
+# Pass arguments to every script: each one runs as "<script> --watch"
+bun run --parallel --filter '*' build -- --watch
 ```
 
 Bun prefixes each line of output with the package and script name (`pkg-a:build | ...`). Without `--filter`/`--workspaces`, the prefix is only the script name (`build | ...`). When a package's `package.json` has no `name` field, Bun uses the relative path from the workspace root instead.
diff --git a/docs/runtime/bunfig.mdx b/docs/runtime/bunfig.mdx
index da129da129b9..44cc30e9d89d 100644
--- a/docs/runtime/bunfig.mdx
+++ b/docs/runtime/bunfig.mdx
@@ -11,6 +11,8 @@ Bun relies on pre-existing configuration files like `package.json` and `tsconfig
 
 Put `bunfig.toml` in your project root, alongside your `package.json`.
 
+`bun <file>`, `bun run`, `bun test`, and `bun build` read the `bunfig.toml` in the working directory. If there is none, they read the nearest one in a parent directory of the same project. The search stops at the directory of the nearest `package.json`, or at the workspace root whose `workspaces` lists that directory. Bun reads only one of these files and does not merge them. It does not search parent directories when the working directory is inside `node_modules`.
+
 To configure Bun's package manager globally, you can also create a `.bunfig.toml` file at one of the following paths:
 
 - `$HOME/.bunfig.toml`
@@ -36,6 +38,8 @@ An array of scripts/plugins to execute before running a file or script.
 preload = ["./preload.ts"]
 ```
 
+Relative paths are relative to the directory of the `bunfig.toml` that Bun found. With `--config`, they are relative to the working directory.
+
 ### `jsx`
 
 Configure how Bun handles JSX. You can also set these fields in the `compilerOptions` of your `tsconfig.json`, but `bunfig.toml` supports them for non-TypeScript projects.
@@ -47,11 +51,19 @@ jsxFragment = "Fragment"
 jsxImportSource = "react"
 ```
 
-Refer to the tsconfig docs for more information on these fields.
+`jsx` accepts three values, in upper or lower case. Any other value, such as `"preserve"`, is a configuration error.
+
+| `jsx`            | Transform                                                     |
+| ---------------- | ------------------------------------------------------------- |
+| `"react"`        | Classic: `React.createElement`, or `jsxFactory` when set      |
+| `"react-jsx"`    | Automatic: `jsx` from `react/jsx-runtime`                     |
+| `"react-jsxdev"` | Automatic, development: `jsxDEV` from `react/jsx-dev-runtime` |
+
+Refer to the tsconfig docs for more information on these fields. `jsxFragment` is the `bunfig.toml` name for `jsxFragmentFactory`.
 
 - [`jsx`](https://www.typescriptlang.org/tsconfig#jsx)
 - [`jsxFactory`](https://www.typescriptlang.org/tsconfig#jsxFactory)
-- [`jsxFragment`](https://www.typescriptlang.org/tsconfig#jsxFragment)
+- [`jsxFragment`](https://www.typescriptlang.org/tsconfig#jsxFragmentFactory)
 - [`jsxImportSource`](https://www.typescriptlang.org/tsconfig#jsxImportSource)
 
 ### `smol`
@@ -91,6 +103,8 @@ Configure how Bun maps file extensions to [loaders](/bundler/loaders). Use this
 [loader]
 # when a .bagel file is imported, treat it like a tsx file
 ".bagel" = "tsx"
+# the empty extension is for files that have none
+"" = "ts"
 ```
 
 Bun supports the following loaders:
@@ -178,7 +192,7 @@ The `[test]` section of `bunfig.toml` configures the test runner.
 
 ### `test.root`
 
-The root directory to run tests from. Default `.`.
+The root directory to run tests from, relative to the working directory. Default `.`.
 
 ```toml title="bunfig.toml" icon="settings"
 [test]
@@ -205,6 +219,28 @@ pathIgnorePatterns = ["vendor/**", "submodules/**", "fixtures/**"]
 
 Equivalent CLI flag: `--path-ignore-patterns`. CLI flags override the `bunfig.toml` value entirely.
 
+### `test.filePatterns`
+
+Choose which files are test files with glob patterns: a string or an array of strings. The patterns replace the default rule, which takes every file whose name ends in `.test`, `_test`, `.spec` or `_spec` before its extension.
+
+```toml title="bunfig.toml" icon="settings"
+[test]
+filePatterns = ["**/*.itest.ts", "**/__tests__/*.unit.tsx"]
+```
+
+Each pattern is matched against the file's path relative to the project root, like `pathIgnorePatterns`. `*` does not cross a `/`, so use `**/*.itest.ts` to match at any depth. A pattern that starts with `!` excludes what it matches. Only files with a JavaScript or TypeScript extension are considered. A filter such as `bun test nested` still narrows the set, `pathIgnorePatterns` still excludes from it, and a file passed by path (`bun test ./b.test.ts`) runs whether or not it matches.
+
+### `test.isolate`
+
+Run each test file in a fresh global object, like `--isolate`. Default `false`.
+
+```toml title="bunfig.toml" icon="settings"
+[test]
+isolate = true
+```
+
+The `--no-isolate` CLI flag overrides this setting. See [`--isolate`](/test/parallel#--isolate).
+
 ### `test.smol`
 
 Same as the top-level `smol` field, but only applies to `bun test`.
@@ -383,6 +419,8 @@ Enable the dots reporter, which prints one dot per test. Default `false`.
 dots = true
 ```
 
+Equivalent CLI flag: `--dots`.
+
 #### `test.reporter.junit`
 
 Enable JUnit XML reporting and specify the output file path.
@@ -392,7 +430,7 @@ Enable JUnit XML reporting and specify the output file path.
 junit = "test-results.xml"
 ```
 
-CI systems and other tools can consume the report.
+CI systems and other tools can consume the report. The `--reporter-outfile` CLI flag overrides the output file path.
 
 ## Linter
 
diff --git a/docs/runtime/environment-variables.mdx b/docs/runtime/environment-variables.mdx
index d9ef390c6e4e..f7cfad3693ad 100644
--- a/docs/runtime/environment-variables.mdx
+++ b/docs/runtime/environment-variables.mdx
@@ -106,6 +106,8 @@ env = false
 
 Files passed with `--env-file` still load even when default loading is disabled.
 
+The setting applies to the whole process. [`Bun.build()`](/bundler) and its [macros](/bundler/macros), [HTML routes](/bundler/fullstack), and [`Worker`](/runtime/workers) threads also get no value from a default `.env` file.
+
 When invoked as `node` (for example via `bun --bun`, `bunx --bun`, or a `node` symlink pointing at Bun), Bun disables automatic `.env` loading to match Node.js. This lets tools with their own mode-aware `.env` resolution, such as Vite's `loadEnv`, pick the correct `.env.{mode}` file instead of seeing Bun's pre-populated values as shell-set overrides. Bun still honors explicit `--env-file` arguments.
 
 ---
diff --git a/docs/runtime/index.mdx b/docs/runtime/index.mdx
index fbf58dd8c34b..9aebe939b067 100644
--- a/docs/runtime/index.mdx
+++ b/docs/runtime/index.mdx
@@ -223,7 +223,9 @@ When a `package.json` script and a file have the same name, `bun run` prefers th
 1. `package.json` scripts: `bun run build`
 2. Source files: `bun run src/main.js`
 3. Binaries from project packages: `bun add eslint && bun run eslint`
-4. (`bun run` only) System commands: `bun run ls`
+4. (`bun run` only, and not with `--if-present`) System commands: `bun run ls`
+
+If the nearest `package.json` has a syntax error, `bun run` does not use the scripts of a `package.json` in a parent directory. If the other steps find nothing to run, it prints the syntax error and exits with code 1, also with `--if-present`.
 
 ---
 
diff --git a/docs/runtime/jsx.mdx b/docs/runtime/jsx.mdx
index 6b34752c94e1..96118afddbea 100644
--- a/docs/runtime/jsx.mdx
+++ b/docs/runtime/jsx.mdx
@@ -19,7 +19,7 @@ console.log(<Component message="Hello world!" />);
 
 ## Configuration
 
-Bun reads your `tsconfig.json` or `jsconfig.json` to determine how to perform the JSX transform internally. If you'd rather not use either, you can set the same options in [`bunfig.toml`](/runtime/bunfig).
+Bun reads your `tsconfig.json` or `jsconfig.json` to determine how to perform the JSX transform internally. If you'd rather not use either, you can set the same options in [`bunfig.toml`](/runtime/bunfig#jsx). There, `jsx` accepts only `react`, `react-jsx`, and `react-jsxdev`, and `jsxFragmentFactory` is named `jsxFragment`.
 
 Bun respects the following compiler options.
 
diff --git a/docs/runtime/templating/init.mdx b/docs/runtime/templating/init.mdx
index 926ac0514954..c852e8efab70 100644
--- a/docs/runtime/templating/init.mdx
+++ b/docs/runtime/templating/init.mdx
@@ -31,7 +31,7 @@ Press `enter` to accept the default answer for each prompt, or pass the `-y` fla
 
 ---
 
-`bun init` infers settings with sane defaults and is non-destructive when run multiple times.
+`bun init` infers settings with sane defaults and is non-destructive when run multiple times. If a `package.json` exists but cannot be parsed, `bun init` leaves it unchanged and exits with an error.
 
 <Frame>
   ![Demo](https://user-images.githubusercontent.com/709451/183006613-271960a3-ff22-4f7c-83f5-5e18f684c836.gif)
diff --git a/docs/test/configuration.mdx b/docs/test/configuration.mdx
index 865efdf24f23..1339a342e763 100644
--- a/docs/test/configuration.mdx
+++ b/docs/test/configuration.mdx
@@ -138,6 +138,21 @@ pathIgnorePatterns = [
   Command-line `--path-ignore-patterns` flags override the `bunfig.toml` value entirely. Bun does not merge the two.
 </Note>
 
+### File Patterns
+
+`filePatterns` replaces the default test file rule (a name that ends in `.test`, `_test`, `.spec` or `_spec` before its extension) with your own glob patterns.
+
+```toml title="bunfig.toml" icon="settings"
+[test]
+# Single pattern
+filePatterns = "**/*.itest.ts"
+
+# Multiple patterns
+filePatterns = ["**/*.dom.test.tsx", "**/__tests__/*.unit.ts"]
+```
+
+Each pattern is matched against the file's path relative to the project root, like `pathIgnorePatterns`. `*` does not cross a `/`, so `*.itest.ts` matches only in the project root and `**/*.itest.ts` matches at any depth. A pattern that starts with `!` excludes what it matches. Only files with a JavaScript or TypeScript extension are considered. Filters and `pathIgnorePatterns` still apply, and a file passed by path runs whether or not it matches. With `coverageSkipTestFiles`, coverage also skips the files that match.
+
 ## Reporters
 
 ### JUnit Reporter
@@ -204,6 +219,15 @@ Use it in memory-constrained environments, such as CI runners, or for large test
 
 ## Test execution
 
+### isolate
+
+Run each test file in a fresh global object, like [`--isolate`](/test/parallel#--isolate). Default `false`. `--no-isolate` on the command line overrides it.
+
+```toml title="bunfig.toml" icon="settings"
+[test]
+isolate = true
+```
+
 ### concurrentTestGlob
 
 Run test files matching a glob pattern with concurrent test execution enabled.
diff --git a/docs/test/discovery.mdx b/docs/test/discovery.mdx
index f135e1cf88e7..bf9a43966870 100644
--- a/docs/test/discovery.mdx
+++ b/docs/test/discovery.mdx
@@ -82,6 +82,15 @@ By default, Bun looks for test files starting from the current working directory
 root = "src"  # Only scan for tests in the src directory
 ```
 
+### Changing the File Patterns
+
+To name test files in another way, set [`filePatterns`](/test/configuration#file-patterns) in `bunfig.toml`. The patterns replace the default ones:
+
+```toml title="bunfig.toml" icon="settings"
+[test]
+filePatterns = ["**/*.itest.ts"]
+```
+
 ## Execution Order
 
 Tests run in the following order:
diff --git a/docs/test/parallel.mdx b/docs/test/parallel.mdx
index ee82ae508ad0..47119910ae23 100644
--- a/docs/test/parallel.mdx
+++ b/docs/test/parallel.mdx
@@ -59,7 +59,15 @@ Flags that affect how tests execute (`--timeout`, `--preload`, `--define`, `--co
 
 The coordinator merges coverage, JUnit XML and snapshot writes, so `--parallel --coverage --reporter=junit --reporter-outfile=junit.xml` produces one report.
 
-If a worker crashes (a test calls `process.exit`), the coordinator reports the file that worker was running as failed, and a replacement worker picks up the remaining files. A crash from a fatal signal aborts the whole run, so later passing files can't mask it. With a single effective worker (`--parallel=1`, or a suite with one test file), `bun test` runs the files in the main process, so `process.exit` ends the run with that exit code.
+### Crashes and interrupts
+
+If a worker dies in the middle of a file, the coordinator reports that file as failed, and a replacement worker picks up the remaining files. A test that calls `process.exit` ends its worker this way. So does a signal such as `SIGKILL` or `SIGTERM`.
+
+A crash signal aborts the whole run instead, so later passing files can't mask the crash. The crash signals are `SIGSEGV`, `SIGABRT`, `SIGBUS`, `SIGILL`, `SIGFPE`, `SIGTRAP` and `SIGSYS`.
+
+If `SIGINT` (Ctrl+C) or `SIGTERM` interrupts the run, the coordinator stops every worker and the processes their tests spawned. It lists the files that were still running and the files that had not started. Then it exits with 128 + the signal number: `130` for `SIGINT`, `143` for `SIGTERM`.
+
+With a single effective worker (`--parallel=1`, or a suite with one test file), `bun test` runs the files in the main process, so `process.exit` ends the run with that exit code.
 
 ### When `--parallel` helps, and when it doesn't
 
diff --git a/src/bun_core/Progress.rs b/src/bun_core/Progress.rs
index 44588bf6af5e..8e8df0570126 100644
--- a/src/bun_core/Progress.rs
+++ b/src/bun_core/Progress.rs
@@ -347,9 +347,9 @@ impl Progress {
     pub fn start(&mut self, name: &'static [u8], estimated_total_items: usize) -> &mut Node {
         let stderr = File::stderr();
         self.terminal = None;
-        if stderr.supports_ansi_escape_codes() {
+        self.supports_ansi_escape_codes = stderr.supports_ansi_escape_codes();
+        if self.supports_ansi_escape_codes {
             self.terminal = Some(stderr);
-            self.supports_ansi_escape_codes = true;
         } else {
             #[cfg(windows)]
             if stderr.is_tty() {
diff --git a/src/bun_core/output.rs b/src/bun_core/output.rs
index 78f6f5d352fc..5e0c8c1e9812 100644
--- a/src/bun_core/output.rs
+++ b/src/bun_core/output.rs
@@ -843,6 +843,17 @@ pub fn is_stderr_tty() -> bool {
     stdio_tty_flag(2)
 }
 
+/// Whether stdout takes cursor and clear codes. `FORCE_COLOR` turns colors on for a pipe too.
+#[inline]
+pub fn is_stdout_ansi_terminal() -> bool {
+    is_stdout_tty() && enable_ansi_colors_stdout()
+}
+/// See [`is_stdout_ansi_terminal`].
+#[inline]
+pub fn is_stderr_ansi_terminal() -> bool {
+    is_stderr_tty() && enable_ansi_colors_stderr()
+}
+
 pub fn is_github_action() -> bool {
     if env_var::GITHUB_ACTIONS.get().unwrap_or(false) {
         // Do not print github annotations for AI agents because that wastes the context window.
@@ -1005,8 +1016,8 @@ pub fn writer_buffered() -> &'static mut io::Writer {
 }
 
 pub fn reset_terminal() {
-    let stderr = ENABLE_ANSI_COLORS_STDERR.load(Ordering::Relaxed);
-    let stdout = ENABLE_ANSI_COLORS_STDOUT.load(Ordering::Relaxed);
+    let stderr = is_stderr_ansi_terminal();
+    let stdout = is_stdout_ansi_terminal();
     if !stderr && !stdout {
         return;
     }
@@ -1026,10 +1037,10 @@ pub fn reset_terminal_all() {
         return;
     }
     SOURCE.with_borrow_mut(|s| {
-        if ENABLE_ANSI_COLORS_STDERR.load(Ordering::Relaxed) {
+        if is_stderr_ansi_terminal() {
             let _ = s.error_stream().write_all(b"\x1B[2J\x1B[3J\x1B[H");
         }
-        if ENABLE_ANSI_COLORS_STDOUT.load(Ordering::Relaxed) {
+        if is_stdout_ansi_terminal() {
             let _ = s.stream().write_all(b"\x1B[2J\x1B[3J\x1B[H");
         }
     });
diff --git a/src/bun_core/util.rs b/src/bun_core/util.rs
index 60506629c378..540147bc13ca 100644
--- a/src/bun_core/util.rs
+++ b/src/bun_core/util.rs
@@ -4566,6 +4566,24 @@ pub mod spawn_ffi {
     }
 }
 
+/// Call before a spawn: under an inherited `SIG_IGN` on SIGCHLD the kernel reaps the child and `waitpid` fails with ECHILD.
+#[cfg(unix)]
+pub fn keep_children_waitable() {
+    static ONCE: std::sync::Once = std::sync::Once::new();
+    ONCE.call_once(|| {
+        // SAFETY: `current` is a valid out-param, and with `SIG_DFL` a valid disposition.
+        unsafe {
+            let mut current: libc::sigaction = crate::ffi::zeroed();
+            if libc::sigaction(libc::SIGCHLD, core::ptr::null(), &raw mut current) == 0
+                && current.sa_sigaction == libc::SIG_IGN
+            {
+                current.sa_sigaction = libc::SIG_DFL;
+                libc::sigaction(libc::SIGCHLD, &raw const current, core::ptr::null_mut());
+            }
+        }
+    });
+}
+
 /// Stdin disposition for [`spawn_sync_inherit`] / [`spawn_sync_inherit_no_stdin`].
 /// The `Ignore` case wires fd 0 to `/dev/null` (`NUL` on Windows) so the
 /// child never blocks on a TTY read.
@@ -4595,6 +4613,8 @@ fn spawn_sync_inherit_impl(
         return Err(crate::CrateError::FileNotFound);
     }
     #[cfg(unix)]
+    keep_children_waitable();
+    #[cfg(unix)]
     // SAFETY: argv strings are owned `ZBox`es (NUL-terminated) kept alive in
     // `cargs` for the duration of the spawn; `ptrs`/`environ` are null-
     // terminated `*const c_char` arrays as required by `posix_spawn_bun` /
diff --git a/src/bundler/options.rs b/src/bundler/options.rs
index ac49bb525032..afd9d6b3ea3c 100644
--- a/src/bundler/options.rs
+++ b/src/bundler/options.rs
@@ -1759,7 +1759,7 @@ impl<'a> BundleOptions<'a> {
             origin: bun_url::OwnedURL::from_href(Box::default()),
             output_dir_handle: None,
             root_dir: Box::default(),
-            preserve_symlinks: false,
+            preserve_symlinks: transform.preserve_symlinks.unwrap_or(false),
             preserve_extensions: false,
             production: false,
             output_format: Format::Esm,
@@ -1849,7 +1849,8 @@ impl<'a> BundleOptions<'a> {
             opts.env.files = transform.env_files.clone().into_boxed_slice();
         }
 
-        opts.env.disable_default_env_files = transform.disable_default_env_files;
+        opts.env.disable_default_env_files =
+            transform.disable_default_env_files || transform.skip_default_env_files;
 
         if let Some(origin) = &transform.origin {
             // ownership — `URL<'_>` borrows its input; `OwnedURL` owns the href and
@@ -1860,6 +1861,7 @@ impl<'a> BundleOptions<'a> {
         if let Some(jsx_opts) = &transform.jsx {
             opts.jsx = jsx::Pragma::from_api(jsx_opts.clone());
         }
+        opts.jsx.side_effects |= transform.jsx_side_effects;
 
         if !transform.extension_order.is_empty() {
             opts.extension_order.default.default = transform
diff --git a/src/bundler/transpiler.rs b/src/bundler/transpiler.rs
index a496e8e35ad5..b059230cf8cc 100644
--- a/src/bundler/transpiler.rs
+++ b/src/bundler/transpiler.rs
@@ -617,6 +617,8 @@ impl<'a> Transpiler<'a> {
                     // If we don't explicitly pass JSX, try to get it from the root tsconfig
                     if self.options.transform_options.jsx.is_none() {
                         self.options.jsx = jsx_pragma_from_resolver(&tsconfig.jsx);
+                        self.options.jsx.side_effects =
+                            self.options.transform_options.jsx_side_effects;
                     }
                     self.options.emit_decorator_metadata = tsconfig.emit_decorator_metadata;
                     self.options.experimental_decorators = tsconfig.experimental_decorators;
@@ -642,6 +644,14 @@ impl<'a> Transpiler<'a> {
         // for the duration of this call.
         let env: &mut dot_env::Loader = self.env_mut();
 
+        // A later `Bun.build`, macro VM or HTML route comes here with default options.
+        if self.options.transform_options.disable_default_env_files
+            // A standalone executable replaces this one with the flag it was compiled with.
+            && self.options.env.disable_default_env_files
+        {
+            dot_env::disable_default_files();
+        }
+
         match self.options.env.behavior {
             DotEnvBehavior::prefix
             | DotEnvBehavior::load_all
diff --git a/src/bunfig/Cargo.toml b/src/bunfig/Cargo.toml
index 7563baa5eace..7c28630a0926 100644
--- a/src/bunfig/Cargo.toml
+++ b/src/bunfig/Cargo.toml
@@ -23,6 +23,7 @@ bun_bundler.workspace = true
 bun_clap.workspace = true
 bun_collections.workspace = true
 bun_core.workspace = true
+bun_glob.workspace = true
 bun_analytics.workspace = true
 bun_install_types.workspace = true
 bun_parsers.workspace = true
diff --git a/src/bunfig/arguments.rs b/src/bunfig/arguments.rs
index 08abed8e9609..ba4e71df3a82 100644
--- a/src/bunfig/arguments.rs
+++ b/src/bunfig/arguments.rs
@@ -6,7 +6,7 @@
 use bstr::BStr;
 use bun_bundler::options;
 use bun_core::ZStr;
-use bun_core::{self, Global, Output, env_var};
+use bun_core::{self, Global, Output, env_var, strings};
 use bun_options_types::command_tag::{ALWAYS_LOADS_CONFIG, Tag as CommandTag};
 use bun_options_types::context::Context;
 use bun_options_types::schema::api;
@@ -81,6 +81,8 @@ enum ConfigFile {
     User,
     /// `./bunfig.toml`
     Project,
+    /// See [`find_config_above`].
+    ProjectAbove,
     /// `--config`
     Named,
 }
@@ -136,7 +138,80 @@ fn load_bunfig(
         log: log_ptr,
         level: original_level,
     };
-    Bunfig::parse(cmd, &source, file == ConfigFile::Project, ctx, tool, counts)
+    let is_above_cwd = file == ConfigFile::ProjectAbove;
+    let is_project_file = is_above_cwd || file == ConfigFile::Project;
+    Bunfig::parse(
+        cmd,
+        &source,
+        is_project_file,
+        is_above_cwd,
+        ctx,
+        tool,
+        counts,
+    )
+}
+
+/// Whether the package.json in `root` lists `dir`, which is below `root`, as a workspace. `None` if it has no `workspaces`.
+fn lists_workspace(root: &[u8], dir: &[u8], buf: &mut PathBuffer) -> Option<bool> {
+    let path = join_config_path(root, b"package.json", buf)?;
+    let source = bun_ast::to_source(path, Default::default()).ok()?;
+    bun_ast::stmt::data::Store::create();
+    bun_ast::expr::data::Store::create();
+    let _store_reset = bun_ast::StoreResetGuard::new();
+    let mut log = bun_ast::Log::init();
+    let Ok(json) = bun_parsers::json::ParsedJson::parse_package_json(&source, &mut log) else {
+        return Some(false);
+    };
+    let workspaces = json.root.get(b"workspaces")?;
+    let patterns = workspaces.get(b"packages").unwrap_or(workspaces);
+    let bun_ast::ExprData::EArrayJSON(patterns) = patterns.data else {
+        return Some(false);
+    };
+    let dir = bun_paths::string_paths::without_leading_path_separator(&dir[root.len()..]);
+    let patterns = patterns.get().items().iter().filter_map(|it| match it {
+        bun_ast::E::JsonValue::String(pattern) => Some(pattern.slice()),
+        _ => None,
+    });
+    Some(bun_glob::any_matches(patterns.map(|pattern| {
+        let pattern = strings::remove_leading_dot_slash(pattern);
+        bun_glob::r#match(strings::without_trailing_slash(pattern), dir)
+    })))
+}
+
+/// The nearest bunfig.toml above `cwd` that is in the same project: not above the nearest package.json, or the workspace root that lists it.
+fn find_config_above<'buf>(cwd: &[u8], buf: &'buf mut PathBuffer) -> Option<&'buf ZStr> {
+    // A dependency's scripts and a compiled executable are not part of the project they run in.
+    if StandaloneModuleGraph::get_ref().is_some()
+        || bun_paths::string_paths::path_contains_node_modules_folder(cwd)
+    {
+        return None;
+    }
+    let mut config_dir = cwd;
+    loop {
+        config_dir = bun_core::dirname(config_dir)?;
+        if bun_sys::exists_z(join_config_path(config_dir, b"bunfig.toml", buf)?)
+            && !bun_sys::is_shared_directory(config_dir)
+        {
+            break;
+        }
+    }
+    let mut root = cwd;
+    while !bun_sys::exists_z(join_config_path(root, b"package.json", buf)?) {
+        root = bun_core::dirname(root)?;
+    }
+    if config_dir.len() < root.len() {
+        let package_dir = root;
+        loop {
+            root = bun_core::dirname(root)?;
+            if let Some(is_listed) = lists_workspace(root, package_dir, buf) {
+                if !is_listed || config_dir.len() < root.len() {
+                    return None;
+                }
+                break;
+            }
+        }
+    }
+    join_config_path(config_dir, b"bunfig.toml", buf)
 }
 
 /// The user's own file, once.
@@ -237,6 +312,23 @@ fn load_config_path_for_tool(
     } else {
         ConfigFile::Named
     };
+    let looks_above = matches!(
+        cmd,
+        CommandTag::AutoCommand
+            | CommandTag::RunCommand
+            | CommandTag::TestCommand
+            | CommandTag::BuildCommand
+    );
+    let mut buf = bun_paths::path_buffer_pool::get();
+    if auto_loaded
+        && looks_above
+        && !bun_sys::exists_z(config_path)
+        && let Some(cwd) = ctx.args.absolute_working_dir.as_deref()
+        && let Some(above) = find_config_above(cwd, &mut buf)
+    {
+        let file = ConfigFile::ProjectAbove;
+        return load_bunfig(cmd, file, above, ctx, tool, Counts::Everything);
+    }
     load_bunfig(cmd, file, config_path, ctx, tool, Counts::Everything)
 }
 
diff --git a/src/bunfig/bunfig.rs b/src/bunfig/bunfig.rs
index 23f39aa35756..0e162de12dc6 100644
--- a/src/bunfig/bunfig.rs
+++ b/src/bunfig/bunfig.rs
@@ -153,6 +153,8 @@ struct Parser<'a, 'tool> {
     /// True for `./bunfig.toml`, which comes with the project. False for the user's own file and
     /// for `--config`.
     is_project_file: bool,
+    /// True for a project file that was found above the working directory. Its `preload` paths are relative to it.
+    is_above_cwd: bool,
     /// Reads `[lint]` and `[fmt]`.
     tool: Option<&'a mut crate::ToolReader<'tool>>,
     counts: Counts,
@@ -259,24 +261,29 @@ impl<'a> Parser<'a, '_> {
         Ok(())
     }
 
+    fn preload_path(&self, path: Box<[u8]>) -> Box<[u8]> {
+        if !self.is_above_cwd || bun_paths::is_package_path(&path) {
+            return path;
+        }
+        self.install_path(&path)
+    }
+
     fn load_preload(&mut self, expr: &Expr) -> crate::Result<()> {
+        let mut preloads: Vec<Box<[u8]>> = Vec::new();
         match &expr.data {
             ExprData::EArray(array) => {
-                let items = array.items.slice();
-                let mut preloads: Vec<Box<[u8]>> = Vec::with_capacity(items.len());
-                for item in items {
+                for item in array.items.slice() {
                     self.expect_string(item)?;
                     if let ExprData::EString(s) = &item.data {
                         if s.len() > 0 {
-                            preloads.push(estring_to_owned(s, self.bump));
+                            preloads.push(self.preload_path(estring_to_owned(s, self.bump)));
                         }
                     }
                 }
-                self.ctx.preloads = preloads;
             }
             ExprData::EString(s) => {
                 if s.len() > 0 {
-                    self.ctx.preloads = vec![estring_to_owned(s, self.bump)];
+                    preloads.push(self.preload_path(estring_to_owned(s, self.bump)));
                 }
             }
             ExprData::ENull(_) => {}
@@ -284,6 +291,9 @@ impl<'a> Parser<'a, '_> {
                 self.add_error(expr.loc, b"Expected preload to be an array")?;
             }
         }
+        // The ones that are there already come from `--preload`. They run after the file's.
+        preloads.append(&mut self.ctx.preloads);
+        self.ctx.preloads = preloads;
         Ok(())
     }
 
@@ -396,8 +406,16 @@ impl<'a> Parser<'a, '_> {
             self.load_log_level(&expr)?;
         }
 
+        let cli = self.ctx.cli_overrides;
+
         if let Some(expr) = json.get(b"define") {
-            self.ctx.args.define = Some(self.parse_define_map(&expr)?);
+            let mut define = self.parse_define_map(&expr)?;
+            // Of two entries with the same key the later one counts.
+            if let Some(flags) = self.ctx.args.define.take().filter(|_| cli.define) {
+                define.keys.extend(flags.keys);
+                define.values.extend(flags.values);
+            }
+            self.ctx.args.define = Some(define);
         }
 
         if let Some(expr) = json.get(b"origin") {
@@ -441,12 +459,13 @@ impl<'a> Parser<'a, '_> {
         if cmd == CommandTag::RunCommand || cmd == CommandTag::AutoCommand {
             if let Some(expr) = json.get(b"smol") {
                 self.expect(&expr, ExprTag::EBoolean)?;
-                self.ctx.runtime_options.smol = expr.as_bool().expect("infallible: type checked");
+                self.ctx.runtime_options.smol |= expr.as_bool().expect("infallible: type checked");
             }
         }
 
         self.read_for_tool(&json)?;
 
+        // The flags of `bun test` are applied already, and they win over these keys.
         if cmd == CommandTag::TestCommand {
             if let Some(test) = json.get(b"test") {
                 if let Some(root) = test.get(b"root") {
@@ -465,13 +484,13 @@ impl<'a> Parser<'a, '_> {
 
                 if let Some(expr) = test.get(b"coverage") {
                     self.expect(&expr, ExprTag::EBoolean)?;
-                    self.ctx.test_options.coverage.enabled =
+                    self.ctx.test_options.coverage.enabled |=
                         expr.as_bool().expect("infallible: type checked");
                 }
 
                 if let Some(expr) = test.get(b"onlyFailures") {
                     self.expect(&expr, ExprTag::EBoolean)?;
-                    self.ctx.test_options.reporters.only_failures =
+                    self.ctx.test_options.reporters.only_failures |=
                         expr.as_bool().expect("infallible: type checked");
                 }
 
@@ -482,19 +501,22 @@ impl<'a> Parser<'a, '_> {
                         if let ExprData::EString(s) = &junit_expr.data {
                             if s.len() > 0 {
                                 self.ctx.test_options.reporters.junit = true;
-                                self.ctx.test_options.reporter_outfile =
-                                    Some(estring_to_owned(s, self.bump));
+                                if self.ctx.test_options.reporter_outfile.is_none() {
+                                    self.ctx.test_options.reporter_outfile =
+                                        Some(estring_to_owned(s, self.bump));
+                                }
                             }
                         }
                     }
                     if let Some(dots_expr) = expr.get(b"dots").or_else(|| expr.get(b"dot")) {
                         self.expect(&dots_expr, ExprTag::EBoolean)?;
-                        self.ctx.test_options.reporters.dots =
+                        self.ctx.test_options.reporters.dots |=
                             dots_expr.as_bool().expect("infallible: type checked");
                     }
                 }
 
                 if let Some(expr) = test.get(b"coverageReporter") {
+                    let from_flag = self.ctx.test_options.coverage.reporters;
                     'brk: {
                         self.ctx.test_options.coverage.reporters = CoverageReporters {
                             text: false,
@@ -513,17 +535,22 @@ impl<'a> Parser<'a, '_> {
                             self.apply_coverage_reporter_item(item)?;
                         }
                     }
+                    if cli.coverage_reporter {
+                        self.ctx.test_options.coverage.reporters = from_flag;
+                    }
                 }
 
                 if let Some(expr) = test.get(b"coverageDir") {
                     self.expect_string(&expr)?;
-                    self.ctx.test_options.coverage.reports_directory = estring_to_owned(
-                        expr.data
-                            .e_string()
-                            .expect("infallible: variant checked")
-                            .get(),
-                        self.bump,
-                    );
+                    if !cli.coverage_dir {
+                        self.ctx.test_options.coverage.reports_directory = estring_to_owned(
+                            expr.data
+                                .e_string()
+                                .expect("infallible: variant checked")
+                                .get(),
+                            self.bump,
+                        );
+                    }
                 }
 
                 if let Some(expr) = test.get(b"coverageThreshold") {
@@ -577,7 +604,7 @@ impl<'a> Parser<'a, '_> {
                 if let Some(expr) = test.get(b"randomize") {
                     self.expect(&expr, ExprTag::EBoolean)?;
                     randomize_from_config = expr.as_bool();
-                    self.ctx.test_options.randomize =
+                    self.ctx.test_options.randomize |=
                         expr.as_bool().expect("infallible: type checked");
                 }
 
@@ -596,27 +623,39 @@ impl<'a> Parser<'a, '_> {
                         )?;
                     }
 
-                    self.ctx.test_options.seed = Some(seed_value);
+                    if self.ctx.test_options.seed.is_none() {
+                        self.ctx.test_options.seed = Some(seed_value);
+                    }
                 }
 
                 if let Some(expr) = test.get(b"rerunEach") {
                     self.expect(&expr, ExprTag::ENumber)?;
-                    if self.ctx.test_options.retry != 0 {
-                        self.add_error(expr.loc, b"\"rerunEach\" cannot be used with \"retry\"")?;
-                        return Ok(());
+                    if !cli.rerun_each {
+                        if self.ctx.test_options.retry != 0 {
+                            self.add_error(
+                                expr.loc,
+                                b"\"rerunEach\" cannot be used with \"retry\"",
+                            )?;
+                            return Ok(());
+                        }
+                        self.ctx.test_options.repeat_count =
+                            num_to_u32(expr.as_number().expect("infallible: type checked"));
                     }
-                    self.ctx.test_options.repeat_count =
-                        num_to_u32(expr.as_number().expect("infallible: type checked"));
                 }
 
                 if let Some(expr) = test.get(b"retry") {
                     self.expect(&expr, ExprTag::ENumber)?;
-                    if self.ctx.test_options.repeat_count != 0 {
-                        self.add_error(expr.loc, b"\"retry\" cannot be used with \"rerunEach\"")?;
-                        return Ok(());
+                    if !cli.retry {
+                        if self.ctx.test_options.repeat_count != 0 {
+                            self.add_error(
+                                expr.loc,
+                                b"\"retry\" cannot be used with \"rerunEach\"",
+                            )?;
+                            return Ok(());
+                        }
+                        self.ctx.test_options.retry =
+                            num_to_u32(expr.as_number().expect("infallible: type checked"));
                     }
-                    self.ctx.test_options.retry =
-                        num_to_u32(expr.as_number().expect("infallible: type checked"));
                 }
 
                 if let Some(expr) = test.get(b"concurrentTestGlob") {
@@ -746,6 +785,45 @@ impl<'a> Parser<'a, '_> {
                         }
                     }
                 }
+
+                if let Some(expr) = test.get(b"filePatterns") {
+                    match &expr.data {
+                        ExprData::EString(s) => {
+                            self.ctx.test_options.file_patterns =
+                                vec![estring_to_owned(s, self.bump)];
+                        }
+                        ExprData::EArray(arr) => {
+                            let items = arr.items.slice();
+                            let mut patterns: Vec<Box<[u8]>> = Vec::with_capacity(items.len());
+                            for item in items {
+                                let ExprData::EString(s) = &item.data else {
+                                    self.add_error(
+                                        item.loc,
+                                        b"filePatterns array must contain only strings",
+                                    )?;
+                                    return Ok(());
+                                };
+                                patterns.push(estring_to_owned(s, self.bump));
+                            }
+                            self.ctx.test_options.file_patterns = patterns;
+                        }
+                        _ => {
+                            self.add_error(
+                                expr.loc,
+                                b"filePatterns must be a string or array of strings",
+                            )?;
+                            return Ok(());
+                        }
+                    }
+                }
+
+                if let Some(expr) = test.get(b"isolate") {
+                    self.expect(&expr, ExprTag::EBoolean)?;
+                    if !cli.no_isolate {
+                        self.ctx.test_options.isolate |=
+                            expr.as_bool().expect("infallible: type checked");
+                    }
+                }
             }
         }
 
@@ -762,9 +840,9 @@ impl<'a> Parser<'a, '_> {
                 }
 
                 if let Some(auto_install_expr) = install_obj.get(b"auto") {
-                    if let ExprData::EString(_) = &auto_install_expr.data {
+                    let auto_install = if let ExprData::EString(_) = &auto_install_expr.data {
                         let key = auto_install_expr.as_string(self.bump).unwrap_or(b"");
-                        self.ctx.debug.global_cache = match GlobalCache::MAP.get(key) {
+                        match GlobalCache::MAP.get(key) {
                             Some(v) => *v,
                             None => {
                                 self.add_error(
@@ -773,19 +851,22 @@ impl<'a> Parser<'a, '_> {
                                 )?;
                                 return Ok(());
                             }
-                        };
+                        }
                     } else if let ExprData::EBoolean(b) = auto_install_expr.data {
-                        self.ctx.debug.global_cache = if b.value {
+                        if b.value {
                             GlobalCache::allow_install
                         } else {
                             GlobalCache::disable
-                        };
+                        }
                     } else {
                         self.add_error(
                             auto_install_expr.loc,
                             b"Invalid auto install setting, must be one of true, false, \"auto\", \"force\", \"fallback\", or \"disable\"",
                         )?;
                         return Ok(());
+                    };
+                    if !cli.auto_install {
+                        self.ctx.debug.global_cache = auto_install;
                     }
                 }
 
@@ -847,10 +928,10 @@ impl<'a> Parser<'a, '_> {
 
                 if let Some(shell) = run_expr.get(b"shell") {
                     if let Some(value) = shell.as_string(self.bump) {
-                        if value == b"bun" {
-                            self.ctx.debug.use_system_shell = false;
-                        } else if value == b"system" {
-                            self.ctx.debug.use_system_shell = true;
+                        if value == b"bun" || value == b"system" {
+                            if !cli.shell {
+                                self.ctx.debug.use_system_shell = value == b"system";
+                            }
                         } else {
                             self.add_error(
                                 shell.loc,
@@ -864,7 +945,9 @@ impl<'a> Parser<'a, '_> {
 
                 if let Some(bun_flag) = run_expr.get(b"bun") {
                     if let Some(value) = bun_flag.as_bool() {
-                        self.ctx.debug.run_in_bun = value;
+                        if !cli.run_in_bun {
+                            self.ctx.debug.run_in_bun = value;
+                        }
                     } else {
                         self.add_error(bun_flag.loc, b"Expected boolean")?;
                     }
@@ -884,13 +967,15 @@ impl<'a> Parser<'a, '_> {
             if let Some(console_expr) = json.get(b"console") {
                 if let Some(depth) = console_expr.get(b"depth") {
                     if let Some(n) = depth.as_number() {
-                        let depth_value = n as u16;
-                        // Treat depth=0 as maxInt(u16) for infinite depth
-                        self.ctx.runtime_options.console_depth = Some(if depth_value == 0 {
-                            u16::MAX
-                        } else {
-                            depth_value
-                        });
+                        if !cli.console_depth {
+                            let depth_value = n as u16;
+                            // Treat depth=0 as maxInt(u16) for infinite depth
+                            self.ctx.runtime_options.console_depth = Some(if depth_value == 0 {
+                                u16::MAX
+                            } else {
+                                depth_value
+                            });
+                        }
                     } else {
                         self.add_error(depth.loc, b"Expected number")?;
                     }
@@ -1009,12 +1094,12 @@ impl<'a> Parser<'a, '_> {
 
         if let Some(expr) = json.get(b"jsx") {
             if let Some(value) = expr.as_string(self.bump) {
-                if value == b"react" {
+                if value.eq_ignore_ascii_case(b"react") {
                     jsx_runtime = api::JsxRuntime::Classic;
-                } else if value == b"react-jsx" {
+                } else if value.eq_ignore_ascii_case(b"react-jsx") {
                     jsx_runtime = api::JsxRuntime::Automatic;
                     jsx_dev = false;
-                } else if value == b"react-jsxDEV" {
+                } else if value.eq_ignore_ascii_case(b"react-jsxdev") {
                     jsx_runtime = api::JsxRuntime::Automatic;
                     jsx_dev = true;
                 } else {
@@ -1042,16 +1127,18 @@ impl<'a> Parser<'a, '_> {
         }
         {
             if let Some(jsx) = self.ctx.args.jsx.as_mut() {
-                if !jsx_factory.is_empty() {
+                if !jsx_factory.is_empty() && !cli.jsx_factory {
                     jsx.factory = jsx_factory;
                 }
-                if !jsx_fragment.is_empty() {
+                if !jsx_fragment.is_empty() && !cli.jsx_fragment {
                     jsx.fragment = jsx_fragment;
                 }
-                if !jsx_import_source.is_empty() {
+                if !jsx_import_source.is_empty() && !cli.jsx_import_source {
                     jsx.import_source = jsx_import_source;
                 }
-                jsx.runtime = jsx_runtime;
+                if !cli.jsx_runtime {
+                    jsx.runtime = jsx_runtime;
+                }
                 jsx.development = jsx_dev;
             } else {
                 self.ctx.args.jsx = Some(api::Jsx {
@@ -1079,8 +1166,10 @@ impl<'a> Parser<'a, '_> {
                     self.ctx.debug.macros = MacroOptions::Disable;
                 }
             } else {
-                self.ctx.debug.macros =
-                    MacroOptions::Map(parse_macros_json(&expr, self.log, self.source, self.bump));
+                let remaps = parse_macros_json(&expr, self.log, self.source, self.bump);
+                if !cli.macros {
+                    self.ctx.debug.macros = MacroOptions::Map(remaps);
+                }
             }
             bun_analytics::features::macros.fetch_add(1, Ordering::Relaxed);
         }
@@ -1117,10 +1206,8 @@ impl<'a> Parser<'a, '_> {
                 let key = key_expr
                     .as_string(self.bump)
                     .expect("infallible: type checked");
-                if key.is_empty() {
-                    continue;
-                }
-                if key[0] != b'.' {
+                // An empty key is for files with no extension, as in `--loader :tsx`.
+                if !key.is_empty() && key[0] != b'.' {
                     self.add_error(
                         key_expr.loc,
                         b"file extension for loader must start with a '.'",
@@ -1139,6 +1226,11 @@ impl<'a> Parser<'a, '_> {
                 loader_names.push(key.into());
                 loader_values.push(loader.to_api());
             }
+            // Of two entries with the same extension the later one counts.
+            if let Some(flags) = self.ctx.args.loaders.take().filter(|_| cli.loaders) {
+                loader_names.extend(flags.extensions);
+                loader_values.extend(flags.loaders);
+            }
             self.ctx.args.loaders = Some(api::LoaderMap {
                 extensions: loader_names,
                 loaders: loader_values,
@@ -1154,6 +1246,7 @@ impl Bunfig {
         cmd: CommandTag,
         source: &bun_ast::Source,
         is_project_file: bool,
+        is_above_cwd: bool,
         ctx: &mut ContextData,
         tool: Option<&mut crate::ToolReader<'_>>,
         counts: Counts,
@@ -1229,6 +1322,7 @@ impl Bunfig {
             ctx,
             bump: &bump,
             is_project_file,
+            is_above_cwd,
             tool,
             counts,
         };
@@ -1259,7 +1353,15 @@ impl Bunfig {
             ..Default::default()
         };
         let cmd = CommandTag::InstallCommand;
-        Self::parse(cmd, source, true, &mut ctx, None, Counts::OnlyInstall)?;
+        Self::parse(
+            cmd,
+            source,
+            true,
+            false,
+            &mut ctx,
+            None,
+            Counts::OnlyInstall,
+        )?;
         Ok(ctx.install)
     }
 }
@@ -1324,7 +1426,7 @@ impl<'a> Parser<'a, '_> {
         }
     }
 
-    /// Resolves a relative path in `[install]` against the directory that contains the bunfig.toml.
+    /// Resolves a relative path against the directory that contains the bunfig.toml.
     fn install_path(&self, path: &[u8]) -> Box<[u8]> {
         let dir = bun_paths::dirname(self.source.path.text).unwrap_or_default();
         api::BunInstall::resolve_path(dir, path)
diff --git a/src/clap/comptime.rs b/src/clap/comptime.rs
index 193dad5f5e82..50078922d927 100644
--- a/src/clap/comptime.rs
+++ b/src/clap/comptime.rs
@@ -483,6 +483,8 @@ pub struct ComptimeClap<Id> {
     pub(crate) flags: Box<[bool]>,
     pub(crate) pos: Box<[&'static [u8]]>,
     pub(crate) passthrough_positionals: Box<[&'static [u8]]>,
+    /// A `--` right after the last positional was left out of `passthrough_positionals`.
+    pub(crate) passthrough_follows_separator: bool,
 
     // The converted params are
     // carried as a `&'static` table — either rodata (`comptime_table!`) or
@@ -532,6 +534,7 @@ impl<Id> ComptimeClap<Id> {
 
         let mut pos: Vec<&'static [u8]> = Vec::new();
         let mut passthrough_positionals: Vec<&'static [u8]> = Vec::new();
+        let mut passthrough_follows_separator = false;
 
         let mut single_options: Box<[Option<&'static [u8]>]> =
             vec![None; table.n_single].into_boxed_slice();
@@ -562,6 +565,7 @@ impl<Id> ComptimeClap<Id> {
                     };
                     if !first.is_empty() && first == b"--" {
                         remaining_ = &remaining_[1..];
+                        passthrough_follows_separator = true;
                     }
 
                     passthrough_positionals.reserve_exact(remaining_.len());
@@ -594,6 +598,7 @@ impl<Id> ComptimeClap<Id> {
             flags,
             pos: pos.into_boxed_slice(),
             passthrough_positionals: passthrough_positionals.into_boxed_slice(),
+            passthrough_follows_separator,
             table,
             _id: PhantomData,
         })
@@ -660,4 +665,8 @@ impl<Id> ComptimeClap<Id> {
     pub(crate) fn remaining(&self) -> &[&'static [u8]] {
         &self.passthrough_positionals
     }
+
+    pub(crate) fn remaining_follows_separator(&self) -> bool {
+        self.passthrough_follows_separator
+    }
 }
diff --git a/src/clap/lib.rs b/src/clap/lib.rs
index e523cc9ad6f5..bc00de5d7dac 100644
--- a/src/clap/lib.rs
+++ b/src/clap/lib.rs
@@ -385,7 +385,7 @@ pub struct ParseOptions<'a> {
     /// such a flag is skipped.
     pub unknown_long_flags_are_positional: bool,
     /// Such a flag fails the parse, unless it comes from `BUN_OPTIONS`, which applies to every
-    /// command.
+    /// command: there it is skipped, and so is its value.
     pub unknown_long_flags_are_errors: bool,
     pub ignored_long_flags: IgnoredLongFlags,
 }
@@ -466,6 +466,11 @@ impl<Id: 'static> Args<Id> {
     pub fn remaining(&self) -> &[&'static [u8]] {
         self.clap.remaining()
     }
+
+    /// Whether a `--` right after the last positional was left out of `remaining`.
+    pub fn remaining_follows_separator(&self) -> bool {
+        self.clap.remaining_follows_separator()
+    }
 }
 
 /// Same as `parse_ex` but uses the `args::OsIterator` by default.
diff --git a/src/clap/streaming.rs b/src/clap/streaming.rs
index 159ede686d14..9d723c25c464 100644
--- a/src/clap/streaming.rs
+++ b/src/clap/streaming.rs
@@ -216,6 +216,10 @@ where
             }
             ArgKind::Short => self.chainging(Chaining { arg, index: 0 }),
             ArgKind::Positional => {
+                // The value of a flag in `BUN_OPTIONS` that was skipped.
+                if self.unknown_long_flags_are_errors && self.iter.last_is_from_bun_options() {
+                    return self.next();
+                }
                 if let Some(param) = self.positional_param() {
                     // If we find a positional with the value `--` then we
                     // interpret the rest of the arguments as positional
diff --git a/src/crash_handler/lib.rs b/src/crash_handler/lib.rs
index 95f7eb4d00bd..8d4b9a665673 100644
--- a/src/crash_handler/lib.rs
+++ b/src/crash_handler/lib.rs
@@ -1656,7 +1656,7 @@ mod draft {
     // in `reset_segfault_handler` on a double-remove).
 
     #[cfg(unix)]
-    pub fn reset_on_posix() {
+    fn reset_on_posix() {
         if Environment::ENABLE_ASAN {
             return;
         }
diff --git a/src/dotenv/env_loader.rs b/src/dotenv/env_loader.rs
index dd6a969344ac..86152189298a 100644
--- a/src/dotenv/env_loader.rs
+++ b/src/dotenv/env_loader.rs
@@ -162,6 +162,13 @@ static NODE_PATH_TO_USE_SET_ONCE: bun_core::RwLock<Option<Box<[u8]>>> = bun_core
 // PORTING.md §Concurrency: OnceLock — set once from CLI flag, read many.
 pub static HAS_NO_CLEAR_SCREEN_CLI_FLAG: OnceLock<bool> = OnceLock::new();
 
+static DEFAULT_FILES_DISABLED: AtomicBool = AtomicBool::new(false);
+
+/// `--no-env-file` or bunfig `env = false`: from here on no `Loader` of the process reads a default `.env` file.
+pub fn disable_default_files() {
+    DEFAULT_FILES_DISABLED.store(true, Ordering::Relaxed);
+}
+
 /// Compares like [`HashTable`] keys: ASCII case-insensitive on Windows.
 fn is_ipc_channel_key(key: &[u8]) -> bool {
     const KEYS: [&[u8]; 2] = [b"NODE_CHANNEL_FD", b"NODE_CHANNEL_SERIALIZATION_MODE"];
@@ -223,6 +230,16 @@ impl Loader {
         self.get_node_env() == Some(b"test")
     }
 
+    /// Makes `value` win over a `NODE_ENV` or `BUN_ENV` of the process environment.
+    pub fn override_node_env(&mut self, value: &[u8]) -> Result<(), AllocError> {
+        // `load_process` replaces the keys that exist, so it has to come first.
+        self.load_process()?;
+        if self.map.get(b"BUN_ENV").is_some() {
+            self.map.put(b"BUN_ENV", value)?;
+        }
+        self.map.put(b"NODE_ENV", value)
+    }
+
     pub fn get_node_path<'b>(
         &mut self,
         fs: &bun_paths::fs::FileSystem,
@@ -646,7 +663,7 @@ impl Loader {
             //
             // See https://github.com/oven-sh/bun/issues/9635#issuecomment-2021350123
             // for more details on how this edge case works.
-            if !skip_default_env {
+            if !skip_default_env && !DEFAULT_FILES_DISABLED.load(Ordering::Relaxed) {
                 self.load_default_files(suffix, dir, &mut value_buffer)?;
             }
         }
@@ -1120,23 +1137,65 @@ impl<'a> Parser<'a> {
         self.pos = end;
         Ok(strings::trim(&self.src[start..end], WHITESPACE_CHARS))
     }
+}
 
-    fn expand_value(&mut self, map: &Map, value: &[u8]) -> Result<Option<&[u8]>, AllocError> {
-        if value.len() < 2 {
-            return Ok(None);
+#[derive(Copy, Clone, PartialEq, Eq)]
+enum ExpandState {
+    Raw,
+    Expanding,
+    Done,
+}
+
+/// Expands the values of the keys that one file added to `map`. Every other value in it is final.
+struct Expansion<'a> {
+    map: &'a mut Map,
+    /// Index in `map` of the first key that the file added.
+    first: usize,
+    /// One per key that the file added.
+    states: Vec<ExpandState>,
+}
+
+impl Expansion<'_> {
+    /// Expands the value at `index`, a key of the file, in place and only once.
+    fn expand_value(&mut self, index: usize, depth: u8) {
+        let state = index - self.first;
+        if self.states[state] != ExpandState::Raw {
+            return;
         }
-        self.value_buffer.clear();
-        if !Self::expand_into(map, value, self.value_buffer, 0) {
-            return Ok(None);
+        self.states[state] = ExpandState::Expanding;
+        let raw = core::mem::take(&mut self.map.map.values_mut()[index].value);
+        let mut expanded = Vec::new();
+        let changed = raw.len() >= 2 && self.expand_into(&raw, &mut expanded, depth);
+        self.map.map.values_mut()[index].value = if changed {
+            expanded.into_boxed_slice()
+        } else {
+            raw
+        };
+        self.states[state] = ExpandState::Done;
+    }
+
+    /// Appends the expanded value of `key`. False if it is unset, which a key is inside its own value.
+    fn append_value_of(&mut self, key: &[u8], out: &mut Vec<u8>, depth: u8) -> bool {
+        let Some(index) = self.map.map.get_index(key) else {
+            return false;
+        };
+        if index >= self.first {
+            if self.states[index - self.first] == ExpandState::Expanding {
+                return false;
+            }
+            if depth < 200 {
+                self.expand_value(index, depth + 1);
+            }
         }
-        Ok(Some(self.value_buffer.as_slice()))
+        out.extend_from_slice(&self.map.map.values()[index].value);
+        true
     }
 
     /// Left-to-right expansion of `$NAME` / `${NAME}` / `${NAME:-default}`.
     /// `${...}` locates its matching `}` by depth (`${` opens, `}` closes,
     /// `\x` skipped); malformed forms fall through as literal text. The `:-`
     /// default clause is expanded recursively.
-    fn expand_into(map: &Map, value: &[u8], out: &mut Vec<u8>, depth: u8) -> bool {
+    fn expand_into(&mut self, value: &[u8], out: &mut Vec<u8>, depth: u8) -> bool {
         #[inline]
         fn is_ident(b: u8) -> bool {
             matches!(b, b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9' | b'_')
@@ -1202,16 +1261,14 @@ impl<'a> Parser<'a> {
                 let key = &inner[..key_end];
                 let rest = &inner[key_end..];
                 if rest.is_empty() {
-                    if let Some(v) = map.get(key) {
-                        out.extend_from_slice(v);
-                    }
+                    self.append_value_of(key, out, depth);
                 } else if let Some(default) = rest.strip_prefix(b":-") {
-                    if let Some(v) = map.get(key) {
-                        out.extend_from_slice(v);
-                    } else if depth < 200 {
-                        Self::expand_into(map, default, out, depth + 1);
-                    } else {
-                        out.extend_from_slice(default);
+                    if !self.append_value_of(key, out, depth) {
+                        if depth < 200 {
+                            self.expand_into(default, out, depth + 1);
+                        } else {
+                            out.extend_from_slice(default);
+                        }
                     }
                 } else {
                     out.extend_from_slice(&value[pos..=close]);
@@ -1226,9 +1283,7 @@ impl<'a> Parser<'a> {
                 while k < value.len() && is_ident(value[k]) {
                     k += 1;
                 }
-                if let Some(v) = map.get(&value[key_start..k]) {
-                    out.extend_from_slice(v);
-                }
+                self.append_value_of(&value[key_start..k], out, depth);
                 pos = k;
                 continue;
             }
@@ -1237,12 +1292,14 @@ impl<'a> Parser<'a> {
         }
         changed
     }
+}
 
+impl<'a> Parser<'a> {
     fn parse<const OVERRIDE: bool, const IS_PROCESS: bool, const EXPAND: bool>(
         &mut self,
         map: &mut Map,
     ) -> Result<(), AllocError> {
-        let mut count = map.map.count();
+        let count = map.map.count();
         while self.pos < self.src.len() {
             let Some(key) = self.parse_key::<true>() else {
                 self.skip_line();
@@ -1265,24 +1322,16 @@ impl<'a> Parser<'a> {
             *entry.value_ptr = HashTableValue { value: value_owned };
         }
         if !IS_PROCESS && EXPAND {
-            // borrowck — index-based iteration: clone the value bytes, run
-            // expansion against an immutable `&Map`, then write back via
-            // `values_mut()`. Values are dupe'd by `parse` above, so length
-            // is bounded by file size.
             let total = map.map.count();
-            let mut idx = count;
-            while idx < total {
-                let current: Box<[u8]> = Box::from(&*map.map.values()[idx].value);
-                if let Some(expanded) = self.expand_value(map, &current)? {
-                    map.map.values_mut()[idx] = HashTableValue {
-                        value: Box::from(expanded),
-                    };
-                }
-                idx += 1;
+            let mut expansion = Expansion {
+                map,
+                first: count,
+                states: vec![ExpandState::Raw; total - count],
+            };
+            for index in count..total {
+                expansion.expand_value(index, 0);
             }
-            count = 0;
         }
-        let _ = count;
         Ok(())
     }
 
diff --git a/src/dotenv/lib.rs b/src/dotenv/lib.rs
index b99816e76d72..c2d574a4a622 100644
--- a/src/dotenv/lib.rs
+++ b/src/dotenv/lib.rs
@@ -7,8 +7,8 @@ pub use error::{Error, Result};
 
 pub use env_loader::{
     DirEntryKeys, DotEnvBehavior, DotEnvFileSuffix, HAS_NO_CLEAR_SCREEN_CLI_FLAG, HashTable,
-    HashTableValue, INSTANCE, Loader, Map, NullDelimitedEnvMap, S3Credentials, instance,
-    set_instance,
+    HashTableValue, INSTANCE, Loader, Map, NullDelimitedEnvMap, S3Credentials,
+    disable_default_files, instance, set_instance,
 };
 
 /// `dotenv::map::{HashTable, Entry}` namespace expected by `install_jsc::ini_jsc` et al.
diff --git a/src/glob/lib.rs b/src/glob/lib.rs
index 8627d84f4f09..e47cf136b483 100644
--- a/src/glob/lib.rs
+++ b/src/glob/lib.rs
@@ -39,6 +39,19 @@ impl<P: AsRef<[u8]>> Prepared<P> {
     }
 }
 
+/// Whether one of `results` is a match and none of them is a `!` pattern that rejects the path.
+pub fn any_matches(results: impl Iterator<Item = MatchResult>) -> bool {
+    let mut is_match = false;
+    for result in results {
+        if !result.is_negated() {
+            is_match |= result.matches();
+        } else if !result.matches() {
+            return false;
+        }
+    }
+    is_match
+}
+
 // `ignore_filter_fn` is a runtime fn-pointer field supplied at `init()` rather than a type
 // parameter (const-generic fn ptrs are unstable).
 pub type BunGlobWalker = walk::GlobWalker<walk::SyscallAccessor, false>;
diff --git a/src/install/PackageManager.rs b/src/install/PackageManager.rs
index 9197d5ec109b..4388b5f86bb9 100644
--- a/src/install/PackageManager.rs
+++ b/src/install/PackageManager.rs
@@ -2034,7 +2034,7 @@ impl<'a> PackageJsonWalk<'a> {
             );
             if !matches!(&opened, Err(e) if e.get_errno() == bun_sys::E::ENOENT)
                 && dir.len() != self.cwd.len()
-                && is_shared_directory(dir)
+                && bun_sys::is_shared_directory(dir)
             {
                 bun_core::warn!(
                     "ignoring package.json in <b>{}<r>: directory is writable by other users",
@@ -2249,22 +2249,6 @@ fn find_workspace_root_above<'a>(
     Ok(None)
 }
 
-/// Returns true if `dir` is sticky and group- or world-writable, like `/tmp`. Any local user can
-/// create a `package.json` there.
-#[cfg(unix)]
-fn is_shared_directory(dir: &[u8]) -> bool {
-    use bun_sys::S;
-    !bun_sys::stat(&ZBox::from_bytes(dir)).is_ok_and(|st| {
-        let mode = st.st_mode as bun_sys::Mode;
-        mode & S::ISVTX == 0 || mode & (S::IWGRP | S::IWOTH) == 0
-    })
-}
-
-#[cfg(not(unix))]
-fn is_shared_directory(_: &[u8]) -> bool {
-    false
-}
-
 /// Finds the project that `dir` is in, the way `init` does: the directory of the nearest
 /// package.json, or the workspace root that this directory belongs to. A package.json that only
 /// says how to read the files next to it, such as `{ "type": "commonjs" }`, belongs to the project
@@ -3167,7 +3151,6 @@ fn init_with_runtime_once(
 
     if Output::enable_ansi_colors_stderr() {
         manager.progress = Progress::default();
-        manager.progress.supports_ansi_escape_codes = Output::enable_ansi_colors_stderr();
         let _ = manager.progress.start(b"", 0);
     } else {
         manager.options.log_level = package_manager_options::LogLevel::DefaultNoProgress;
diff --git a/src/install/PackageManager/PackageManagerDirectories.rs b/src/install/PackageManager/PackageManagerDirectories.rs
index c6d631fcb460..a59886a3b670 100644
--- a/src/install/PackageManager/PackageManagerDirectories.rs
+++ b/src/install/PackageManager/PackageManagerDirectories.rs
@@ -1354,7 +1354,6 @@ pub fn save_lockfile(
     let mut save_node: *mut ProgressNode = core::ptr::null_mut();
 
     if log_level.show_progress() {
-        this.progress.supports_ansi_escape_codes = Output::enable_ansi_colors_stderr();
         save_node = this.progress.start(ProgressStrings::save(), 0);
         // SAFETY: `save_node` was just set by `progress.start()` and is non-null.
         unsafe { (*save_node).activate() };
diff --git a/src/install/PackageManager/ProgressStrings.rs b/src/install/PackageManager/ProgressStrings.rs
index d1f5825991ac..7aded13eafd1 100644
--- a/src/install/PackageManager/ProgressStrings.rs
+++ b/src/install/PackageManager/ProgressStrings.rs
@@ -122,7 +122,6 @@ impl PackageManager {
     }
 
     pub(crate) fn start_progress_bar(&mut self) {
-        self.progress.supports_ansi_escape_codes = Output::enable_ansi_colors_stderr();
         // `Progress::start` returns `&mut Node` borrowing `self.progress`;
         // decay to a raw ptr immediately so the exclusive borrow ends before we
         // re-borrow `&mut self` for `set_node_name` / `progress.refresh()`.
diff --git a/src/install/PackageManager/install_with_manager.rs b/src/install/PackageManager/install_with_manager.rs
index fdf7de1a335b..f8841529366c 100644
--- a/src/install/PackageManager/install_with_manager.rs
+++ b/src/install/PackageManager/install_with_manager.rs
@@ -2742,7 +2742,6 @@ fn write_yarn_lock_with_progress(
     // `&mut manager` borrow ends instead of keeping a live `&mut Node`.
     let mut node_started = false;
     if log_level.show_progress() {
-        manager.progress.supports_ansi_escape_codes = Output::enable_ansi_colors_stderr();
         let _ = manager.progress.start(b"Saving yarn.lock", 0);
         manager.progress.refresh();
         node_started = true;
diff --git a/src/install/hoisted_install.rs b/src/install/hoisted_install.rs
index 32a93e9cd40d..3f6895cd186e 100644
--- a/src/install/hoisted_install.rs
+++ b/src/install/hoisted_install.rs
@@ -232,7 +232,6 @@ pub(crate) fn install_hoisted_packages(
     if log_level.show_progress() {
         let hoisted_len = this.lockfile.buffers.hoisted_dependencies.len();
         let progress = &mut this.progress;
-        progress.supports_ansi_escape_codes = Output::enable_ansi_colors_stderr();
         let root_node = progress.start(b"", 0);
         download_node = root_node.start(ProgressStrings::download(), 0);
         install_node = root_node.start(ProgressStrings::install(), hoisted_len);
diff --git a/src/install/isolated_install.rs b/src/install/isolated_install.rs
index 88bb7acb851f..ce3aec195928 100644
--- a/src/install/isolated_install.rs
+++ b/src/install/isolated_install.rs
@@ -2163,7 +2163,6 @@ pub(crate) fn install_isolated_packages(
         let progress = unsafe { &mut *progress };
 
         if manager.options.log_level.show_progress() {
-            progress.supports_ansi_escape_codes = Output::enable_ansi_colors_stderr();
             let root_node = progress.start(b"", 0);
             download_node = root_node.start(ProgressStrings::download(), 0);
             install_node = root_node.start(ProgressStrings::install(), store.entries.len());
diff --git a/src/install/lockfile/Package.rs b/src/install/lockfile/Package.rs
index 90ecff8af174..f5da997c63a7 100644
--- a/src/install/lockfile/Package.rs
+++ b/src/install/lockfile/Package.rs
@@ -2495,7 +2495,7 @@ impl Package<u64> {
                                 log,
                                 source,
                                 dependencies_q.loc,
-                                "{0} expects a map of specifiers, e.g.\n  <r><green>\"{0}\"<r>: {{\n    <green>\"bun\"<r>: <green>\"latest\"<r>\n  }}",
+                                "{0} expects a map of specifiers, e.g.\n  <r><green>\"{0}\"<r>: {{\n    \"bun\": \"latest\"\n  }}",
                                 bstr::BStr::new(group.prop)
                             );
                             return Err(crate::Error::InvalidPackageJSON);
@@ -2616,7 +2616,7 @@ impl Package<u64> {
                                     log,
                                     source,
                                     value_loc_of(source, key_loc),
-                                    "{0} expects a map of specifiers, e.g.\n  <r><green>\"{0}\"<r>: {{\n    <green>\"bun\"<r>: <green>\"latest\"<r>\n  }}",
+                                    "{0} expects a map of specifiers, e.g.\n  <r><green>\"{0}\"<r>: {{\n    \"bun\": \"latest\"\n  }}",
                                     bstr::BStr::new(group.prop)
                                 );
                                 return Err(crate::Error::InvalidPackageJSON);
@@ -2651,7 +2651,7 @@ impl Package<u64> {
                             log,
                             source,
                             dependencies_q.loc,
-                            "{0} expects a map of specifiers, e.g.\n  <r><green>\"{0}\"<r>: {{\n    <green>\"bun\"<r>: <green>\"latest\"<r>\n  }}",
+                            "{0} expects a map of specifiers, e.g.\n  <r><green>\"{0}\"<r>: {{\n    \"bun\": \"latest\"\n  }}",
                             bstr::BStr::new(group.prop)
                         );
                     }
diff --git a/src/jsc/VirtualMachine.rs b/src/jsc/VirtualMachine.rs
index db9bbe3804a0..f1f31b8802c7 100644
--- a/src/jsc/VirtualMachine.rs
+++ b/src/jsc/VirtualMachine.rs
@@ -3980,10 +3980,7 @@ pub struct Options {
     // forward-dep crate; callers pass it as the resolver's trait object so
     // both VM and resolver can hold it without the cycle.
     pub graph: Option<&'static dyn bun_resolver::StandaloneModuleGraph>,
-    // Note: debugger
-    // configuration is plumbed through `RuntimeHooks::ensure_debugger` (the
-    // CLI option struct lives in `bun_cli`, a forward dep). See
-    // `runtime/jsc_hooks.rs` for the `configureDebugger` call site.
+    pub debugger: bun_options_types::context::Debugger,
     pub is_main_thread: bool,
 }
 
@@ -4799,6 +4796,7 @@ impl VirtualMachine {
         let graph = opts.graph.expect("init_with_module_graph requires graph");
         let init_opts = InitOptions {
             transform_options: opts.args,
+            debugger: opts.debugger,
             graph: Some(graph),
             log: opts.log,
             env_loader: opts.env_loader,
@@ -4811,6 +4809,7 @@ impl VirtualMachine {
         let vm = Self::init(init_opts)?;
         // SAFETY: `vm` is the unique live VM on this thread.
         let vm_ref = unsafe { &mut *vm };
+        vm_ref.dns_result_order = opts.dns_result_order;
         vm_ref.transpiler.resolver.standalone_module_graph = Some(graph);
         vm_ref.let_heap_take_initial_module_graph(graph);
         // Avoid reading from tsconfig.json & package.json when in standalone mode
@@ -5327,10 +5326,20 @@ impl VirtualMachine {
         let result_path = result
             .path_const()
             .ok_or(crate::CrateError::ModuleNotFound)?;
-        // SAFETY: `result_path.text` borrows the resolver's arena, which
+        // `--preserve-symlinks-main`: the entry point keeps the path it was given. `set_realpath` left it in `pretty`.
+        let keeps_given_path = result_path.is_symlink
+            && source == MAIN_FILE_NAME
+            && bun_options_types::context::try_get()
+                .is_some_and(|ctx| ctx.runtime_options.preserve_symlinks_main_enabled());
+        let path = if keeps_given_path {
+            result_path.pretty
+        } else {
+            result_path.text
+        };
+        // SAFETY: `path` borrows the resolver's arena, which
         // outlives `ResolveFunctionResult` (see the struct's lifetime-erasure
         // note).
-        ret.path = unsafe { bun_ptr::detach_lifetime(result_path.text) };
+        ret.path = unsafe { bun_ptr::detach_lifetime(path) };
 
         Ok(())
     }
diff --git a/src/options_types/context.rs b/src/options_types/context.rs
index d7dd2d282fa9..06e30ac051f0 100644
--- a/src/options_types/context.rs
+++ b/src/options_types/context.rs
@@ -44,6 +44,44 @@ pub struct ContextData {
 
     pub preloads: Vec<Box<[u8]>>,
     pub has_loaded_global_config: bool,
+    pub cli_overrides: CliOverrides,
+}
+
+/// Settings given as flags, which a bunfig.toml that is read after the flags are applied leaves alone.
+#[derive(Clone, Copy, Default)]
+pub struct CliOverrides {
+    /// `--define`
+    pub define: bool,
+    /// `--loader`
+    pub loaders: bool,
+    /// `--jsx-runtime`
+    pub jsx_runtime: bool,
+    /// `--jsx-factory`
+    pub jsx_factory: bool,
+    /// `--jsx-fragment`
+    pub jsx_fragment: bool,
+    /// `--jsx-import-source`
+    pub jsx_import_source: bool,
+    /// `--console-depth`
+    pub console_depth: bool,
+    /// `--install`, `-i` or `--no-install`
+    pub auto_install: bool,
+    /// `--no-macros`
+    pub macros: bool,
+    /// `--shell`
+    pub shell: bool,
+    /// `--bun`
+    pub run_in_bun: bool,
+    /// `--coverage-reporter`
+    pub coverage_reporter: bool,
+    /// `--coverage-dir`
+    pub coverage_dir: bool,
+    /// `--rerun-each`
+    pub rerun_each: bool,
+    /// `--retry`
+    pub retry: bool,
+    /// `--no-isolate`
+    pub no_isolate: bool,
 }
 
 impl Default for ContextData {
@@ -84,6 +122,7 @@ impl Default for ContextData {
             no_exit_on_error: false,
             preloads: Vec::new(),
             has_loaded_global_config: false,
+            cli_overrides: CliOverrides::default(),
         }
     }
 }
@@ -439,6 +478,8 @@ pub struct TestOptions {
     pub coverage: CodeCoverageOptions,
     pub path_ignore_patterns: Vec<Box<[u8]>>,
     pub path_ignore_patterns_from_cli: bool,
+    /// `[test] filePatterns`: which files are tests. Empty: the ones with a test suffix.
+    pub file_patterns: Vec<Box<[u8]>>,
     pub test_filter_pattern: Option<Box<[u8]>>,
     /// `?*bun.jsc.RegularExpression` — typed as opaque to keep this file free
     /// of `jsc/` references. Read via `test_filter_regex()`.
@@ -523,6 +564,7 @@ impl Default for TestOptions {
             coverage: CodeCoverageOptions::default(),
             path_ignore_patterns: Vec::new(),
             path_ignore_patterns_from_cli: false,
+            file_patterns: Vec::new(),
             test_filter_pattern: None,
             test_filter_regex: None,
             // Under ASAN every spawned `bun` child is several-× heavier in
@@ -634,6 +676,16 @@ pub struct HeapProf {
     pub dir: Box<[u8]>,
 }
 
+impl RuntimeOptions {
+    /// `--preserve-symlinks-main` or `NODE_PRESERVE_SYMLINKS_MAIN=1`.
+    pub fn preserve_symlinks_main_enabled(&self) -> bool {
+        self.preserve_symlinks_main
+            || bun_core::env_var::NODE_PRESERVE_SYMLINKS_MAIN
+                .get()
+                .unwrap_or(false)
+    }
+}
+
 impl Default for RuntimeOptions {
     // See `ContextData::default` — folded into the single startup call site.
     #[inline(always)]
diff --git a/src/options_types/jsx.rs b/src/options_types/jsx.rs
index 0cda8d160553..3485e55296d4 100644
--- a/src/options_types/jsx.rs
+++ b/src/options_types/jsx.rs
@@ -208,6 +208,9 @@ impl Pragma {
         // `runtime` selects classic vs automatic emission; `development`
         // selects `jsx` vs `jsxDEV`. Both shape transpiled output.
         hasher.update(&[self.runtime as u8, self.development as u8]);
+        if self.side_effects {
+            hasher.update(b"side_effects");
+        }
     }
 
     pub fn import_source(&self) -> &[u8] {
diff --git a/src/options_types/schema.rs b/src/options_types/schema.rs
index f07fc96205a4..150eb112b03c 100644
--- a/src/options_types/schema.rs
+++ b/src/options_types/schema.rs
@@ -59,6 +59,8 @@ pub mod api {
     pub struct TransformOptions {
         /// jsx
         pub jsx: Option<Jsx>,
+        /// from `--jsx-side-effects`, which alone leaves the rest of `jsx` to tsconfig.json
+        pub jsx_side_effects: bool,
         /// tsconfig_override
         pub tsconfig_override: Option<Box<[u8]>>,
         /// origin
@@ -93,8 +95,10 @@ pub mod api {
         pub serve: Option<bool>,
         /// env_files
         pub env_files: Vec<Box<[u8]>>,
-        /// disable_default_env_files
+        /// `--no-env-file` or `env = false` in bunfig.toml. Holds for the whole process.
         pub disable_default_env_files: bool,
+        /// Set by Bun itself: the VM reads no default `.env` file at its start, what it builds later does.
+        pub skip_default_env_files: bool,
         /// extension_order
         pub extension_order: Vec<Box<[u8]>>,
         /// no_summary
diff --git a/src/resolver/resolver.rs b/src/resolver/resolver.rs
index b4bab754c3d7..65190eec22e8 100644
--- a/src/resolver/resolver.rs
+++ b/src/resolver/resolver.rs
@@ -1643,11 +1643,16 @@ impl<'a> Resolver<'a> {
                 }
             }
 
+            // Imports only, as in Node. For `EntryPointRun` the option holds `--preserve-symlinks-main`.
+            let preserve_symlinks =
+                self.opts.preserve_symlinks && kind != ast::ImportKind::EntryPointBuild;
+
             // Probe the listing in one `entries_mutex` critical section: a
             // concurrent resolver at a newer generation rewrites this `DirEntry`'s
             // map in place under that lock. The entry pointer stays valid after
             // unlock (EntryStore-owned).
-            if let Some(query) = dir.get_entry(self.generation, name.filename) {
+            if !preserve_symlinks && let Some(query) = dir.get_entry(self.generation, name.filename)
+            {
                 // SAFETY: rfs points at the process-global RealFS; the lazy-stat
                 // rewrite inside `symlink()` is serialized on the per-entry mutex.
                 let symlink_path = unsafe { query.entry().symlink(self.rfs_ptr(), self.store_fd) };
diff --git a/src/runtime/api/BunObject.rs b/src/runtime/api/BunObject.rs
index 460a05cf0509..5575ba84f7dc 100644
--- a/src/runtime/api/BunObject.rs
+++ b/src/runtime/api/BunObject.rs
@@ -721,6 +721,12 @@ pub(crate) fn get_main(global_this: &JSGlobalObject) -> JSValue {
             if strings::ends_with(main, b"[stdin]") {
                 break 'use_resolved_path;
             }
+            // The main module is registered under the path it was given.
+            if bun_options_types::context::try_get()
+                .is_some_and(|ctx| ctx.runtime_options.preserve_symlinks_main_enabled())
+            {
+                break 'use_resolved_path;
+            }
 
             let Ok(fd) = sys::openat_a(
                 if cfg!(windows) {
diff --git a/src/runtime/api/JSBundler.rs b/src/runtime/api/JSBundler.rs
index dcc0aefd3f9f..3953f27ff46c 100644
--- a/src/runtime/api/JSBundler.rs
+++ b/src/runtime/api/JSBundler.rs
@@ -1233,7 +1233,8 @@ pub(crate) mod js_bundler {
                     global_this,
                     loaders_ref,
                     jsc::JSPropertyIteratorOptions {
-                        skip_empty_name: true,
+                        // `""` is for files with no extension, as in `--loader :tsx`.
+                        skip_empty_name: false,
                         include_value: true,
                         ..Default::default()
                     },
@@ -1253,7 +1254,9 @@ pub(crate) mod js_bundler {
 
                 while let Some((prop, value)) = loader_iter.next()? {
                     let prop_slice = prop.to_utf8();
-                    if !prop_slice.slice().starts_with(b".") || prop.length() < 2 {
+                    if !prop_slice.slice().is_empty()
+                        && (!prop_slice.slice().starts_with(b".") || prop.length() < 2)
+                    {
                         return Err(global_this.throw_invalid_arguments(format_args!(
                             "loader property names must be file extensions, such as '.txt'"
                         )));
diff --git a/src/runtime/cli/Arguments.rs b/src/runtime/cli/Arguments.rs
index 653b9dcf3cd2..77491a4952eb 100644
--- a/src/runtime/cli/Arguments.rs
+++ b/src/runtime/cli/Arguments.rs
@@ -35,6 +35,13 @@ fn slice_to_owned(input: &[&[u8]]) -> Vec<Box<[u8]>> {
     input.iter().map(|s| Box::<[u8]>::from(*s)).collect()
 }
 
+/// [`slice_to_owned`] for a flag whose value can be a list: `--main-fields=module,main`.
+fn comma_lists_to_owned(input: &[&[u8]]) -> Vec<Box<[u8]>> {
+    (input.iter().flat_map(|list| strings::tokenize(list, b",")))
+        .map(Box::<[u8]>::from)
+        .collect()
+}
+
 pub(crate) fn loader_resolver(input: &[u8]) -> crate::Result<api::Loader> {
     let option_loader = bun_ast::Loader::from_string(input).ok_or(crate::Error::InvalidLoader)?;
     Ok(option_loader.to_api())
@@ -120,7 +127,7 @@ const TRANSPILER_PARAMS_: &[ParamType] = &[
         "--feature <STR>...               Enable a feature flag for dead-code elimination, e.g. --feature=SUPER_SECRET"
     ),
     parse_param!(
-        "-l, --loader <STR>...             Parse files with .ext:loader, e.g. --loader .js:jsx. Valid loaders: js, jsx, ts, tsx, json, toml, text, file, wasm, napi"
+        "-l, --loader <STR>...             Parse files with .ext:loader, e.g. --loader .js:jsx. Valid loaders: js, jsx, ts, tsx, json, toml, yaml, json5, xml, text, md, css, html, wasm, napi, sqlite, file"
     ),
     parse_param!(
         "--no-macros                       Disable macros from being executed in the bundler, transpiler and runtime"
@@ -614,7 +621,7 @@ pub(crate) const TEST_ONLY_PARAMS: &[ParamType] = &[
         "-t, --test-name-pattern/--grep <STR>    Run only tests with a name that matches the given regex."
     ),
     parse_param!(
-        "--reporter <STR>                 Test output reporter format. Available: 'junit' (requires --reporter-outfile), 'dots'. Default: console output."
+        "--reporter <STR>...              Test output reporter format. Available: 'junit' (requires --reporter-outfile), 'dots'. Default: console output."
     ),
     parse_param!(
         "--reporter-outfile <STR>         Output file path for the reporter format (required with --reporter)."
@@ -781,6 +788,18 @@ pub(crate) use bun_bunfig::arguments::{load_config_path, load_config_with_cmd_ar
 /// the attached value `e`. Bun's `-p` takes the code, so `-pe X` is `-p X`.
 pub(crate) const NODE_SHORT_ALIASES: &[(&[u8], &[u8])] = &[(b"-pe", b"-p")];
 
+/// Whether `flag`, which stands before the command, has its value in the next argument: `--cwd dir`, not `--cwd=dir`.
+pub(crate) fn value_is_next_arg(flag: &[u8]) -> bool {
+    AUTO_PARAMS.iter().any(|param| {
+        matches!(param.takes_value, clap::Values::One | clap::Values::Many)
+            && match flag {
+                [b'-', b'-', long @ ..] => param.names.matches_long(long),
+                [b'-', short] => param.names.short == Some(*short),
+                _ => false,
+            }
+    })
+}
+
 /// `--disallow-code-generation-from-strings[=<value>]`. Raises the process's level; never lowers it.
 fn disallow_code_generation_from_strings(value: &[u8]) {
     match bun_core::CodeGenerationFromStrings::from_flag_value(value) {
@@ -965,6 +984,7 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
     let defines_tuple = DefineColonList::resolve(args.options(b"--define"))?;
 
     if !defines_tuple.keys.is_empty() {
+        ctx.cli_overrides.define = true;
         opts.define = Some(api::StringMap {
             keys: defines_tuple
                 .keys
@@ -994,6 +1014,7 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
     };
 
     if !loader_tuple.keys.is_empty() {
+        ctx.cli_overrides.loaders = true;
         opts.loaders = Some(api::LoaderMap {
             extensions: loader_tuple
                 .keys
@@ -1013,11 +1034,11 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
         ))
     });
 
-    opts.main_fields = slice_to_owned(args.options(b"--main-fields"));
+    opts.main_fields = comma_lists_to_owned(args.options(b"--main-fields"));
     // we never actually supported inject.
     // opts.inject = args.options(b"--inject");
     opts.env_files = slice_to_owned(args.options(b"--env-file"));
-    opts.extension_order = slice_to_owned(args.options(b"--extension-order"));
+    opts.extension_order = comma_lists_to_owned(args.options(b"--extension-order"));
 
     if args.flag(b"--no-env-file") {
         opts.disable_default_env_files = true;
@@ -1032,6 +1053,18 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
 
     ctx.passthrough = slice_to_owned(args.remaining());
 
+    // `bun run --parallel a b -- --watch`: parsing stops at `a`, so `b` is a name too, and `--watch` is for the scripts.
+    if ctx.parallel || ctx.sequential {
+        let remaining = args.remaining();
+        let (names, arguments) = match remaining.iter().position(|arg| *arg == b"--") {
+            _ if args.remaining_follows_separator() => (&remaining[..0], remaining),
+            Some(separator) => (&remaining[..separator], &remaining[separator + 1..]),
+            None => (remaining, &remaining[..0]),
+        };
+        ctx.positionals.extend(slice_to_owned(names));
+        ctx.passthrough = slice_to_owned(arguments);
+    }
+
     // Declared in both RUNTIME_PARAMS_ and BUILD_ONLY_PARAMS, so every table has it.
     if !args.options(b"--conditions").is_empty() {
         opts.conditions = slice_to_owned(args.options(b"--conditions"));
@@ -1199,6 +1232,9 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
                 Some(bun_options_types::offline_mode::OfflineMode::Latest);
         }
 
+        ctx.cli_overrides.auto_install = args.flag(b"--no-install")
+            || (args.flag(b"-i") && cmd != CommandTag::RunAsNodeCommand)
+            || args.option(b"--install").is_some();
         if args.flag(b"--no-install") {
             ctx.debug.global_cache = options::GlobalCache::disable;
         } else if args.flag(b"-i") && cmd != CommandTag::RunAsNodeCommand {
@@ -1228,7 +1264,10 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
             ctx.runtime_options.eval.script = script.into();
         }
         ctx.runtime_options.if_present = args.flag(b"--if-present");
-        ctx.runtime_options.smol = args.flag(b"--smol");
+        // Without the flag, `smol` from bunfig.toml is kept.
+        if args.flag(b"--smol") {
+            ctx.runtime_options.smol = true;
+        }
         // To `node`, `--check` means something else.
         ctx.runtime_options.check = args.flag(b"--check") && cmd != CommandTag::RunAsNodeCommand;
         // Decided here: on Windows the process that starts it again is set up right after this.
@@ -1266,6 +1305,7 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
             };
             // Treat depth=0 as maxInt(u16) for infinite depth
             ctx.runtime_options.console_depth = Some(if depth == 0 { u16::MAX } else { depth });
+            ctx.cli_overrides.console_depth = true;
         }
 
         if let Some(order) = args.option(b"--dns-result-order") {
@@ -1508,7 +1548,7 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
     ctx.bundler_options.ignore_dce_annotations = args.flag(b"--ignore-dce-annotations");
 
     if cmd == CommandTag::BuildCommand {
-        parse_build_command_options(cmd, &args, &mut opts, ctx, &mut diag);
+        parse_build_command_options(cmd, &args, &mut opts, ctx);
     }
 
     if opts.entry_points.is_empty() {
@@ -1547,6 +1587,11 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
     let jsx_import_source = args.option(b"--jsx-import-source");
     let jsx_runtime = args.option(b"--jsx-runtime");
     let jsx_side_effects = args.flag(b"--jsx-side-effects");
+    opts.jsx_side_effects = jsx_side_effects;
+    ctx.cli_overrides.jsx_factory = jsx_factory.is_some();
+    ctx.cli_overrides.jsx_fragment = jsx_fragment.is_some();
+    ctx.cli_overrides.jsx_import_source = jsx_import_source.is_some();
+    ctx.cli_overrides.jsx_runtime = jsx_runtime.is_some();
 
     if matches!(cmd, CommandTag::AutoCommand | CommandTag::RunCommand) {
         // "run.silent" in bunfig.toml
@@ -1578,6 +1623,7 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
         // "run.bun" in bunfig.toml
         if args.flag(b"--bun") {
             ctx.debug.run_in_bun = true;
+            ctx.cli_overrides.run_in_bun = true;
         }
     }
 
@@ -1670,6 +1716,7 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
 
     if args.flag(b"--no-macros") {
         ctx.debug.macros = MacroOptions::Disable;
+        ctx.cli_overrides.macros = true;
     }
 
     opts.output_dir = output_dir.map(Box::<[u8]>::from);
@@ -1679,6 +1726,7 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
 
     if matches!(cmd, CommandTag::RunCommand | CommandTag::AutoCommand) {
         if let Some(shell) = args.option(b"--shell") {
+            ctx.cli_overrides.shell = true;
             if shell == b"bun" {
                 ctx.debug.use_system_shell = false;
             } else if shell == b"system" {
@@ -1747,6 +1795,7 @@ fn parse_test_command_options(args: &clap::Args<clap::Help>, ctx: Context<'_>) {
     }
 
     if !args.options(b"--coverage-reporter").is_empty() {
+        ctx.cli_overrides.coverage_reporter = true;
         ctx.test_options.coverage.enabled = true;
         ctx.test_options.coverage.reporters = CoverageReporters {
             text: false,
@@ -1771,7 +1820,7 @@ fn parse_test_command_options(args: &clap::Args<clap::Help>, ctx: Context<'_>) {
         ctx.test_options.reporter_outfile = Some(reporter_outfile.into());
     }
 
-    if let Some(reporter) = args.option(b"--reporter") {
+    for &reporter in args.options(b"--reporter") {
         if reporter == b"junit" {
             // A `--parallel` worker only collects for the coordinator's file.
             if ctx.test_options.reporter_outfile.is_none() && !args.flag(b"--test-worker") {
@@ -1804,6 +1853,7 @@ fn parse_test_command_options(args: &clap::Args<clap::Help>, ctx: Context<'_>) {
     }
 
     if let Some(dir) = args.option(b"--coverage-dir") {
+        ctx.cli_overrides.coverage_dir = true;
         ctx.test_options.coverage.reports_directory = Box::<[u8]>::from(dir);
     }
 
@@ -1837,6 +1887,7 @@ fn parse_test_command_options(args: &clap::Args<clap::Help>, ctx: Context<'_>) {
     }
     if let Some(repeat_count) = args.option(b"--rerun-each") {
         if !repeat_count.is_empty() {
+            ctx.cli_overrides.rerun_each = true;
             ctx.test_options.repeat_count = match strings::parse_int::<u32>(repeat_count, 10) {
                 Ok(v) => v,
                 Err(e) => {
@@ -1851,6 +1902,7 @@ fn parse_test_command_options(args: &clap::Args<clap::Help>, ctx: Context<'_>) {
     }
     if let Some(retry_count) = args.option(b"--retry") {
         if !retry_count.is_empty() {
+            ctx.cli_overrides.retry = true;
             ctx.test_options.retry = match strings::parse_int::<u32>(retry_count, 10) {
                 Ok(v) => v,
                 Err(e) => {
@@ -1957,6 +2009,7 @@ fn parse_test_command_options(args: &clap::Args<clap::Help>, ctx: Context<'_>) {
     ctx.test_options.concurrent = args.flag(b"--concurrent");
     ctx.test_options.randomize = args.flag(b"--randomize");
     let no_isolate = args.flag(b"--no-isolate");
+    ctx.cli_overrides.no_isolate = no_isolate;
     ctx.test_options.isolate = args.flag(b"--isolate") && !no_isolate;
     ctx.test_options.test_worker = args.flag(b"--test-worker");
 
@@ -2024,7 +2077,6 @@ fn parse_build_command_options(
     args: &clap::Args<clap::Help>,
     opts: &mut api::TransformOptions,
     ctx: Context<'_>,
-    diag: &mut clap::Diagnostic,
 ) {
     ctx.bundler_options.transform_only = args.flag(b"--no-bundle");
     ctx.bundler_options.check = args.flag(b"--check");
@@ -2182,7 +2234,13 @@ fn parse_build_command_options(
                     }
                 }
                 b"bun" => api::Target::Bun,
-                _ => cli::invalid_target(diag, target),
+                _ => {
+                    Output::err_generic(
+                        "Invalid value for --target: {}. Must be 'browser', 'bun', or 'node'.",
+                        (bun_core::fmt::quote(target),),
+                    );
+                    Global::exit(1);
+                }
             }));
 
             if opts.target.unwrap() == api::Target::Bun {
@@ -2191,12 +2249,7 @@ fn parse_build_command_options(
                 if ctx.bundler_options.bytecode {
                     Output::err_generic(
                         "target must be 'bun' when bytecode is true. Received: {}",
-                        format_args!(
-                            "{:?}",
-                            <bun_ast::Target as bun_options_types::TargetExt>::from_api(
-                                opts.target
-                            )
-                        ),
+                        format_args!("{}", BStr::new(target)),
                     );
                     Global::exit(1);
                 }
@@ -2204,12 +2257,7 @@ fn parse_build_command_options(
                 if ctx.bundler_options.bake {
                     Output::err_generic(
                         "target must be 'bun' when using --app. Received: {}",
-                        format_args!(
-                            "{:?}",
-                            <bun_ast::Target as bun_options_types::TargetExt>::from_api(
-                                opts.target
-                            )
-                        ),
+                        format_args!("{}", BStr::new(target)),
                     );
                 }
             }
diff --git a/src/runtime/cli/build_command.rs b/src/runtime/cli/build_command.rs
index eab2470ca802..148f317b0a67 100644
--- a/src/runtime/cli/build_command.rs
+++ b/src/runtime/cli/build_command.rs
@@ -482,8 +482,7 @@ impl BuildCommand {
             .clone_from(&ctx.bundler_options.env_prefix);
 
         if ctx.bundler_options.production {
-            // SAFETY: `env` is a process-lifetime singleton set in `Transpiler::init`.
-            unsafe { (*this_transpiler.env).map.put(b"NODE_ENV", b"production")? };
+            this_transpiler.env_mut().override_node_env(b"production")?;
         }
 
         this_transpiler.configure_defines()?;
diff --git a/src/runtime/cli/bunx_command.rs b/src/runtime/cli/bunx_command.rs
index 1e928966fd57..78bc379d5ccd 100644
--- a/src/runtime/cli/bunx_command.rs
+++ b/src/runtime/cli/bunx_command.rs
@@ -1117,7 +1117,7 @@ impl BunxCommand {
 
         let envp = env_loader.map.create_null_delimited_env_map()?;
 
-        let spawn_result = match proc_sync::spawn(&proc_sync::Options {
+        let install_status = match proc_sync::spawn(&proc_sync::Options {
             argv: args.iter().map(|s| Box::<[u8]>::from(*s)).collect(),
             envp: Some(envp.as_ptr().cast::<*const ::core::ffi::c_char>()),
             cwd: Box::<[u8]>::from(bunx_cache_dir),
@@ -1146,8 +1146,8 @@ impl BunxCommand {
                 );
                 Global::exit(1);
             }
-            Ok(Err(_)) => Global::exit(1),
-            Ok(Ok(result)) => result,
+            Ok(Err(err)) => SpawnStatus::Err(err),
+            Ok(Ok(result)) => result.status,
         };
 
         // These are only for the install. A `bunx` or `bun install` that the tool itself runs must
@@ -1166,7 +1166,7 @@ impl BunxCommand {
             Global::raise_ignoring_panic_handler_raw(core::ffi::c_int::from(signal))
         }
 
-        match &spawn_result.status {
+        match &install_status {
             SpawnStatus::Exited(exited) => {
                 if exited.signal != 0 {
                     raise(exited.signal);
diff --git a/src/runtime/cli/create_command.rs b/src/runtime/cli/create_command.rs
index c2145c8d5658..8e7663f83db8 100644
--- a/src/runtime/cli/create_command.rs
+++ b/src/runtime/cli/create_command.rs
@@ -167,8 +167,10 @@ impl CreateOptions {
         };
 
         let mut positionals = args.positionals().to_vec();
-        if !positionals.is_empty() && (positionals[0] == b"c" || positionals[0] == b"create") {
-            positionals.remove(0);
+        // What precedes the command is the value of a flag of `bun`.
+        let is_command = |it: &&[u8]| matches!(*it, b"c" | b"create");
+        if let Some(command) = positionals.iter().position(is_command) {
+            positionals.drain(..=command);
         }
 
         Ok(CreateOptions {
@@ -350,10 +352,6 @@ impl CreateCommand {
         let mut create_options = CreateOptions::parse()?;
         let positionals = &create_options.positionals;
 
-        if positionals.is_empty() {
-            return CreateListExamplesCommand::exec(&ctx);
-        }
-
         // SAFETY: `fs::FileSystem::init` returns a process-global singleton pointer.
         let filesystem: &mut fs::FileSystem = unsafe { &mut *fs::FileSystem::init(None)? };
         // Process-lifetime: every mini event loop (the tasks', a Windows spawn's) keeps a pointer to it.
@@ -375,10 +373,7 @@ impl CreateCommand {
                     bun_paths::platform::Loose,
                 >(filesystem.top_level_dir, dirname))?;
 
-        let mut progress = Progress {
-            supports_ansi_escape_codes: Output::enable_ansi_colors_stderr(),
-            ..Default::default()
-        };
+        let mut progress = Progress::default();
         let verb = if example_tag == ExampleTag::JslikeFile {
             "Analyzing"
         } else {
@@ -445,9 +440,9 @@ impl CreateCommand {
                                 Output::flush();
 
                                 let examples = Example::fetch_all_local_and_remote(
-                                    &ctx, None, env_loader, filesystem,
+                                    &ctx, env_loader, filesystem,
                                 )?;
-                                Example::print(&examples, Some(dirname));
+                                Example::print(&examples, dirname);
                                 Global::exit(1);
                             }
                         }
@@ -485,9 +480,9 @@ impl CreateCommand {
                                     Output::flush();
 
                                     let examples = Example::fetch_all_local_and_remote(
-                                        &ctx, None, env_loader, filesystem,
+                                        &ctx, env_loader, filesystem,
                                     )?;
-                                    Example::print(&examples, Some(dirname));
+                                    Example::print(&examples, dirname);
                                 } else {
                                     pretty_errorln!("\n\n");
                                     return Err(err);
@@ -1564,14 +1559,8 @@ static NPM_REGISTRY_URL_BUF: bun_core::RacyCell<[u8; 1024]> = bun_core::RacyCell
 impl Example {
     const EXAMPLES_URL: &'static [u8] = b"https://registry.npmjs.org/bun-examples-all/latest";
 
-    pub(crate) fn print(examples: &[Example], default_app_name: Option<&[u8]>) {
+    pub(crate) fn print(examples: &[Example], app_name: &[u8]) {
         for example in examples {
-            let generated = format!(
-                "./{}-app",
-                bstr::BStr::new(&example.name[0..example.name.len().min(492)])
-            );
-            let app_name: &[u8] = default_app_name.unwrap_or(generated.as_bytes());
-
             if !example.description.is_empty() {
                 bun_core::pretty!(
                     "  <r># {}<r>\n  <b>bun create <cyan>{}<r><b> {}<r>\n<d>  \n\n",
@@ -1591,14 +1580,10 @@ impl Example {
 
     pub(crate) fn fetch_all_local_and_remote(
         ctx: &Command::Context,
-        mut node: Option<&mut ProgressNode>,
         env_loader: &mut DotEnv::Loader,
         filesystem: &mut fs::FileSystem,
     ) -> crate::Result<Vec<Example>> {
-        let mut examples = Example::fetch_all(ctx, env_loader, node.as_deref_mut())?;
-        if let Some(node_) = node {
-            node_.end();
-        }
+        let mut examples = Example::fetch_all(ctx, env_loader)?;
 
         // SAFETY: single-threaded CLI access to module-level static path buffer
         let home_dir_buf = unsafe { &mut *HOME_DIR_BUF.get() };
@@ -1933,7 +1918,6 @@ impl Example {
     pub(crate) fn fetch_all(
         ctx: &Command::Context,
         env_loader: &mut DotEnv::Loader,
-        progress_node: Option<&mut ProgressNode>,
     ) -> crate::Result<Vec<Example>> {
         let url = URL::parse(Self::EXAMPLES_URL);
         let http_proxy = env_loader.get_http_proxy_for(&url);
@@ -1953,10 +1937,6 @@ impl Example {
         ));
         async_http.client.flags.reject_unauthorized = env_loader.get_tls_reject_unauthorized();
 
-        if Output::enable_ansi_colors_stdout() {
-            async_http.client.progress_node = progress_node.map(core::ptr::NonNull::from);
-        }
-
         let response = match async_http.send_sync(mutable) {
             Ok(r) => r,
             Err(err) => {
@@ -2040,53 +2020,6 @@ impl Example {
     }
 }
 
-struct CreateListExamplesCommand;
-
-impl CreateListExamplesCommand {
-    fn exec(ctx: &Command::Context) -> crate::Result<()> {
-        // SAFETY: FileSystem::init returns the process-global singleton; valid for 'static.
-        let filesystem = unsafe { &mut *fs::FileSystem::init(None)? };
-        let mut env_loader = DotEnv::Loader::init();
-
-        env_loader.load_process()?;
-
-        let mut progress = Progress {
-            supports_ansi_escape_codes: Output::enable_ansi_colors_stderr(),
-            ..Default::default()
-        };
-        // A raw pointer, so that `progress.refresh()` can borrow `progress` again.
-        let node: *mut ProgressNode = progress.start(b"Fetching manifest", 0);
-        progress.refresh();
-
-        // SAFETY: `node` points into `progress`, which outlives this call; single-threaded.
-        let examples = Example::fetch_all_local_and_remote(
-            ctx,
-            Some(unsafe { &mut *node }),
-            &mut env_loader,
-            filesystem,
-        )?;
-        bun_core::prettyln!(
-            "Welcome to bun! Create a new project by pasting any of the following:\n",
-        );
-        Output::flush();
-
-        Example::print(&examples, None);
-
-        bun_core::prettyln!(
-            "<r><d>#<r> You can also paste a GitHub repository:\n\n  <b>bun create <cyan>ahfarmer/calculator calc<r>\n",
-        );
-
-        let homedir = env_loader.map.get(bun_core::env_var::HOME.key());
-        bun_core::prettyln!(
-            "<d>This command is completely optional. To add a new local template, create a folder in {}/.bun-create/. To publish a new template, git clone https://github.com/oven-sh/bun, add a new folder to the \"examples\" folder, and submit a PR.<r>",
-            bstr::BStr::new(homedir.unwrap_or(b"$HOME")),
-        );
-
-        Output::flush();
-        Ok(())
-    }
-}
-
 struct GitHandler;
 
 impl GitHandler {
diff --git a/src/runtime/cli/filter_arg.rs b/src/runtime/cli/filter_arg.rs
index a9045de7265e..544c44b9fa6b 100644
--- a/src/runtime/cli/filter_arg.rs
+++ b/src/runtime/cli/filter_arg.rs
@@ -18,8 +18,6 @@ use bun_resolver::package_json::{IncludeDependencies, IncludeScripts};
 use crate::cli::Command;
 
 const SKIP_LIST: &[&[u8]] = &[
-    // skip hidden directories
-    b".",
     // skip node_modules
     b"node_modules",
     // skip .git folder
@@ -323,6 +321,71 @@ impl SelectedPackages {
     }
 }
 
+/// The variables of one package's scripts, over the environment that all scripts of a run share.
+#[derive(Clone)]
+pub(crate) struct ScriptEnv(Vec<(Box<[u8]>, Box<[u8]>)>);
+
+impl ScriptEnv {
+    /// What `json` has no value for keeps that of the package that `bun` was started in.
+    pub(crate) fn new(path: &[u8], json: Option<&bun_resolver::PackageJSON>) -> Self {
+        let mut env = Self(Vec::new());
+        env.set(b"PATH", path);
+        let Some(json) = json else {
+            return env;
+        };
+        env.set(b"npm_package_json", json.source.path.text);
+        if !json.name.is_empty() {
+            env.set(b"npm_package_name", &json.name);
+        }
+        if !json.version.is_empty() {
+            env.set(b"npm_package_version", &json.version);
+        }
+        if let Some(config) = json.config.as_deref() {
+            for (key, value) in config.iter() {
+                env.set(&strings::concat(&[b"npm_package_config_", &key[..]]), value);
+            }
+        }
+        env
+    }
+
+    fn set(&mut self, key: &[u8], value: &[u8]) {
+        self.0.push((key.into(), value.into()));
+    }
+
+    /// The environment block of the script `name`. Empty: a command that is not in `package.json`.
+    pub(crate) fn create_envp(
+        &self,
+        shared: &bun_dotenv::Map,
+        name: &[u8],
+    ) -> Result<bun_dotenv::NullDelimitedEnvMap, bun_alloc::AllocError> {
+        let mut map = shared.clone_with_allocator()?;
+        for (key, value) in &self.0 {
+            map.put(key, value)?;
+        }
+        if !name.is_empty() {
+            map.put(b"npm_lifecycle_event", name)?;
+        }
+        map.create_null_delimited_env_map()
+    }
+}
+
+/// For a run on a terminal: scripts write to pipes, where most programs leave colors out.
+pub(crate) fn force_color_in_scripts(env: &mut bun_dotenv::Loader) {
+    use bun_core::output::{ColorDepth, Source};
+    let decided: [&[u8]; 3] = [b"FORCE_COLOR", b"NO_COLOR", b"NODE_DISABLE_COLORS"];
+    if decided.iter().any(|key| env.map.get(key).is_some()) {
+        return;
+    }
+    let depth: &[u8] = match Source::color_depth() {
+        ColorDepth::C16m => b"3",
+        ColorDepth::C256 => b"2",
+        // Windows terminals show 16 million colors and set neither `TERM` nor `COLORTERM`.
+        ColorDepth::None if cfg!(windows) => b"3",
+        ColorDepth::C16 | ColorDepth::None => b"1",
+    };
+    let _ = env.map.put(b"FORCE_COLOR", depth);
+}
+
 // Heap-allocated so the walker keeps its address while the `PackageFilterIterator` moves. Held as
 // a `NonNull` rather than a `Box` because moving a `Box` asserts unique access, which the
 // `GlobWalkerIterator` borrowing the walker would violate.
@@ -393,6 +456,24 @@ impl<'a> PackageFilterIterator<'a> {
         })
     }
 
+    /// The file system looks up an entry without glob syntax, so it decides whether case matters.
+    fn find_literal(&self) -> Option<glob::walk::MatchedPath> {
+        let pattern: &[u8] = &self.patterns[self.pattern_idx];
+        if glob::detect_glob_syntax(pattern)
+            || strings::split_any(pattern, b"/\\").any(glob_ignore_fn)
+        {
+            return None;
+        }
+        let mut buf = path_buffer_pool::get();
+        let path = resolve_path::join_abs_string_buf_z_checked::<platform::Auto>(
+            self.root_dir,
+            &mut buf[..],
+            &[pattern],
+        )?;
+        let stat = bun_sys::stat(path).ok()?;
+        bun_sys::is_regular_file(stat.st_mode as bun_sys::Mode).then(|| path.as_bytes().into())
+    }
+
     /// As in `bun install`, a `!` entry removes a glob match, but never a path that's listed
     /// literally.
     fn is_excluded(&self, package_json_path: &[u8]) -> bool {
@@ -411,6 +492,10 @@ impl<'a> PackageFilterIterator<'a> {
                 if self.pattern_idx >= self.patterns.len() {
                     return Ok(None);
                 }
+                if let Some(path) = self.find_literal() {
+                    self.pattern_idx += 1;
+                    return Ok(Some(path));
+                }
                 self.active = Some(self.start_walk()?);
                 continue;
             };
diff --git a/src/runtime/cli/filter_run.rs b/src/runtime/cli/filter_run.rs
index db76c6a2209e..3ea78e6a749f 100644
--- a/src/runtime/cli/filter_run.rs
+++ b/src/runtime/cli/filter_run.rs
@@ -1,6 +1,6 @@
 use core::ffi::{c_char, c_void};
 use std::io::Write as _;
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::atomic::Ordering;
 use std::time::Instant;
 
 #[cfg(unix)]
@@ -8,6 +8,7 @@ use crate::api::bun::process::SpawnResultExt as _;
 use crate::api::bun::process::{self as spawn, Rusage, SpawnOptions, Status};
 use crate::cli::Command;
 use crate::cli::filter_arg as FilterArg;
+use crate::cli::multi_run::{AbortHandler, SHOULD_ABORT};
 use crate::cli::run_command::{ConfigureEnvOptions, RunCommand};
 use bun_collections::StringHashMap;
 use bun_core::{Global, Output};
@@ -35,8 +36,7 @@ struct ScriptConfig {
     // ../node_modules/.bin
     // ../../node_modules/.bin
     // and so forth, in addition to the user's $PATH.
-    #[allow(non_snake_case)]
-    PATH: Box<[u8]>,
+    env: FilterArg::ScriptEnv,
     elide_count: Option<usize>,
 }
 
@@ -97,45 +97,26 @@ impl<'a> ProcessHandle<'a> {
 
         let argv = ScriptArgv::new(state.shell_bin, handle.config.combined)?;
         let start_time = Instant::now();
-        let spawned: spawn::SpawnProcessResult = 'brk: {
-            // Get the envp with the PATH configured
-            // There's probably a more optimal way to do this where you have a Vec shared
-            // instead of creating a new one for each process
-            let env_ptr = state.env;
-            // The guard below borrows `env_ptr`.
-            let env_of_script = env_ptr;
-            // SAFETY: state.env is the process-lifetime DotEnv loader (Transpiler::env).
-            let env = unsafe { &mut *env_ptr };
-            // Copy to owned — `original_path` borrows env.map which is
-            // mutated by put() below.
-            let original_path: Box<[u8]> = env.map.get(b"PATH").unwrap_or(b"").into();
-            let _ = env.map.put(b"PATH", &handle.config.PATH);
-            // Restores PATH unconditionally at block exit (success OR error).
-            // Keep the guard armed for the whole block so `?` early-returns also
-            // restore.
-            scopeguard::defer! {
-                // SAFETY: env_ptr valid for the run loop lifetime (see above).
-                let _ = unsafe { (*env_ptr).map.put(b"PATH", &original_path) };
-            }
-            // SAFETY: see above; reborrow through raw ptr to avoid overlapping &mut with guard.
+        let spawned: spawn::SpawnProcessResult = {
+            let config = handle.config;
             let envp = crate::cli::script_or_command::with_package_script(
-                unsafe { &mut *env_of_script },
-                &handle.config.script_name,
+                // SAFETY: state.env is the process-lifetime DotEnv loader (Transpiler::env).
+                unsafe { &mut *state.env },
+                &config.script_name,
                 bun_paths::resolve_path::dirname::<bun_paths::platform::Auto>(
-                    &handle.config.package_json_path,
+                    &config.package_json_path,
                 ),
-                |env| env.map.create_null_delimited_env_map(),
+                |env| config.env.create_envp(&env.map, &config.script_name),
             )?;
             // SAFETY: `argv`/`envp` are local null-terminated C-string arrays
             // with argv[0] non-null; valid for this call.
-            break 'brk unsafe {
+            unsafe {
                 spawn::spawn_process(
                     &handle.options,
                     argv.as_ptr(),
                     envp.as_ptr().cast::<*const c_char>(),
                 )
-            }??;
-            // `_guard` drops here (or on `?` above), restoring PATH.
+            }??
         };
         #[cfg(unix)]
         let (stdout_fd, stderr_fd) = (spawned.stdout, spawned.stderr);
@@ -334,7 +315,7 @@ struct State<'a> {
     shell_bin: Option<&'static ZStr>,
     aborted: bool,
     // Raw `*mut` — process-lifetime singleton owned
-    // by Transpiler; ProcessHandle::start mutates `env.map` (PATH swap) so a
+    // by Transpiler; ProcessHandle::start mutates `env.map` so a
     // shared borrow won't do, and `&'a mut` would conflict with the Transpiler's
     // own raw-ptr field. Reborrow `&mut *env` at use sites.
     env: *mut bun_dotenv::Loader,
@@ -738,81 +719,6 @@ impl<'a> State<'a> {
     }
 }
 
-struct AbortHandler;
-
-static SHOULD_ABORT: AtomicBool = AtomicBool::new(false);
-// Atomic because it is set from a signal handler.
-
-impl AbortHandler {
-    #[cfg(unix)]
-    extern "C" fn posix_signal_handler(
-        sig: i32,
-        info: *const bun_sys::posix::siginfo_t,
-        _: *const c_void,
-    ) {
-        let _ = sig;
-        let _ = info;
-        SHOULD_ABORT.store(true, Ordering::SeqCst);
-    }
-
-    #[cfg(windows)]
-    extern "system" fn windows_ctrl_handler(
-        dw_ctrl_type: bun_sys::windows::DWORD,
-    ) -> bun_sys::windows::BOOL {
-        if dw_ctrl_type == bun_sys::windows::CTRL_C_EVENT {
-            SHOULD_ABORT.store(true, Ordering::SeqCst);
-            return bun_sys::windows::TRUE;
-        }
-        bun_sys::windows::FALSE
-    }
-
-    fn install() {
-        #[cfg(unix)]
-        {
-            // SAFETY: libc::sigaction is #[repr(C)] POD; all-zero is a valid value (fields overwritten below).
-            let mut act: libc::sigaction = bun_core::ffi::zeroed();
-            act.sa_sigaction = Self::posix_signal_handler as *const () as usize;
-            act.sa_flags = libc::SA_SIGINFO | libc::SA_RESTART | libc::SA_RESETHAND;
-            // SAFETY: sa_mask is a valid out-pointer; act is on the stack.
-            unsafe {
-                libc::sigemptyset(&raw mut act.sa_mask);
-                libc::sigaction(libc::SIGINT, &raw const act, core::ptr::null_mut());
-            }
-        }
-        #[cfg(not(unix))]
-        {
-            let res = bun_sys::c::SetConsoleCtrlHandler(
-                Some(Self::windows_ctrl_handler),
-                bun_sys::windows::TRUE,
-            );
-            if res == 0 {
-                if bun_core::env::IS_DEBUG {
-                    bun_core::warn!("Failed to set abort handler\n");
-                }
-            }
-        }
-    }
-
-    fn uninstall() {
-        // only necessary on Windows, as on posix we pass the SA_RESETHAND flag
-        #[cfg(windows)]
-        {
-            // (None, FALSE) clears the ignore attribute; it does NOT unregister
-            // a handler routine — pass the address.
-            let _ = bun_sys::c::SetConsoleCtrlHandler(
-                Some(Self::windows_ctrl_handler),
-                bun_sys::windows::FALSE,
-            );
-        }
-    }
-}
-
-#[cfg(windows)]
-fn windows_is_terminal() -> bool {
-    let res = bun_sys::windows::GetFileType(bun_sys::Fd::stdout().native());
-    res == bun_sys::windows::FILE_TYPE_CHAR
-}
-
 pub(crate) fn run_scripts_with_filter(
     ctx: Command::Context,
 ) -> crate::Result<core::convert::Infallible> {
@@ -872,6 +778,7 @@ pub(crate) fn run_scripts_with_filter(
         let run_in_bun = ctx.debug.run_in_bun;
         let path_var: Vec<u8> =
             RunCommand::path_for_run(this_transpiler.env_mut(), path, None, path, run_in_bun)?;
+        let package_env = FilterArg::ScriptEnv::new(&path_var, Some(&package.json));
 
         for (i, name) in [&pre_script_name[..], script_name, &post_script_name[..]]
             .iter()
@@ -932,7 +839,7 @@ pub(crate) fn run_scripts_with_filter(
                 script_content: Box::<[u8]>::from(&interned[0..len_command_only]),
                 combined,
                 deps,
-                PATH: Box::<[u8]>::from(&path_var[..]),
+                env: package_env.clone(),
                 elide_count: ctx.bundler_options.elide_lines,
             });
         }
@@ -986,20 +893,15 @@ pub(crate) fn run_scripts_with_filter(
         remaining_scripts: 0,
         draw_buf: Vec::new(),
         last_lines_written: 0,
-        pretty_output: {
-            #[cfg(windows)]
-            {
-                windows_is_terminal() && Output::enable_ansi_colors_stdout()
-            }
-            #[cfg(not(windows))]
-            {
-                Output::enable_ansi_colors_stdout()
-            }
-        },
+        pretty_output: Output::is_stdout_ansi_terminal(),
         shell_bin,
         aborted: false,
         env: env_ptr,
     };
+    if state.pretty_output {
+        // SAFETY: env_ptr is the live process-lifetime DotEnv loader.
+        FilterArg::force_color_in_scripts(unsafe { &mut *env_ptr });
+    }
 
     // initialize the handles
     // Self-referential — each `state.handles[i].state` points back at
diff --git a/src/runtime/cli/init_command.rs b/src/runtime/cli/init_command.rs
index c8fbf8a1d2aa..4b4f7ec66708 100644
--- a/src/runtime/cli/init_command.rs
+++ b/src/runtime/cli/init_command.rs
@@ -3,7 +3,6 @@
 
 use crate::Error;
 use bun_ast::StoreRef;
-use bun_collections::IntegerBitSet;
 use bun_core::{self as bun, Environment, Global, Output, env_var, fmt as bun_fmt};
 use bun_core::{MutableString, ZStr, strings};
 use bun_js_printer as js_printer;
@@ -390,6 +389,12 @@ impl InitCommand {
         }
 
         let _ = Fs::FileSystem::init(None)?;
+
+        // The React templates skip a package.json that exists, whatever it holds.
+        if template.is_react() {
+            return template.write_files_and_run_bun_dev();
+        }
+
         let pathname =
             Fs::PathName::init(Fs::FileSystem::get().top_level_dir_without_trailing_slash());
         let destination_dir = Fd::cwd();
@@ -464,25 +469,33 @@ impl InitCommand {
         let mut did_load_package_json = false;
         if !package_json_contents.list.is_empty() {
             'process_package_json: {
+                // Only whitespace is nothing to lose: it is replaced like a missing file.
+                if package_json_contents.list.trim_ascii().is_empty() {
+                    package_json_file = None;
+                    break 'process_package_json;
+                }
+
                 let source = bun_ast::Source::init_path_string(
-                    b"package.json",
+                    Fs::FileSystem::get().abs(&[b"package.json"]),
                     package_json_contents.list.as_slice(),
                 );
                 let mut log = bun_ast::Log::init();
                 let package_json_expr: bun_ast::Expr =
                     match json::parse_package_json_utf8(&source, &mut log, &bump) {
-                        Ok(e) => e,
-                        Err(_) => {
-                            package_json_file = None;
-                            break 'process_package_json;
+                        Ok(expr) if expr.data.is_e_object() => expr,
+                        result => {
+                            if let Ok(expr) = result {
+                                log.add_error(
+                                    Some(&source),
+                                    expr.loc,
+                                    "package.json root must be an object",
+                                );
+                            }
+                            let _ = log.print(std::ptr::from_mut(Output::error_writer()));
+                            Global::exit(1);
                         }
                     };
 
-                if !package_json_expr.data.is_e_object() {
-                    package_json_file = None;
-                    break 'process_package_json;
-                }
-
                 fields.object = package_json_expr.data.e_object();
 
                 if let Some(name) = package_json_expr.get(b"name") {
@@ -609,12 +622,8 @@ impl InitCommand {
             }
         }
 
-        match template {
-            Template::ReactBlank | Template::ReactTailwind | Template::ReactTailwindShadcn => {
-                template.write_files_and_run_bun_dev()?;
-                return Ok(());
-            }
-            _ => {}
+        if template.is_react() {
+            return template.write_files_and_run_bun_dev();
         }
 
         struct Steps {
@@ -656,18 +665,17 @@ impl InitCommand {
                 object.put_string(&bump, b"name", &fields.name)?;
             }
             if !fields.entry_point.is_empty() {
-                if object.has_property(b"module") {
-                    object.put_string(&bump, b"module", &fields.entry_point)?;
-                    object.put_string(&bump, b"type", b"module")?;
-                } else if object.has_property(b"main") {
+                if object.has_property(b"main") && !object.has_property(b"module") {
                     object.put_string(&bump, b"main", &fields.entry_point)?;
                 } else {
                     object.put_string(&bump, b"module", &fields.entry_point)?;
-                    object.put_string(&bump, b"type", b"module")?;
+                    if !object.has_property(b"type") {
+                        object.put_string(&bump, b"type", b"module")?;
+                    }
                 }
             }
 
-            if fields.private {
+            if fields.private && !object.has_property(b"private") {
                 object.put(
                     &bump,
                     b"private",
@@ -678,65 +686,25 @@ impl InitCommand {
 
         let need_run_bun_install;
         {
-            let all_dependencies = template.dependencies();
-            let dependencies = all_dependencies.dependencies;
-            let dev_dependencies = all_dependencies.dev_dependencies;
-            let mut needed_dependencies = IntegerBitSet::<64>::init_empty();
-            let mut needed_dev_dependencies = IntegerBitSet::<64>::init_empty();
-            needed_dependencies.set_range_value(
-                bun_collections::bit_set::Range {
-                    start: 0,
-                    end: dependencies.len(),
-                },
-                true,
-            );
-            needed_dev_dependencies.set_range_value(
-                bun_collections::bit_set::Range {
-                    start: 0,
-                    end: dev_dependencies.len(),
-                },
-                true,
+            let needs_bun_types_dependency = !lists_dependency(
+                object,
+                &[b"dependencies", b"devDependencies", b"optionalDependencies"],
+                b"@types/bun",
             );
 
-            let needs_dependencies = 'brk: {
-                if let Some(deps) = object.get(b"dependencies") {
-                    for (i, dep) in dependencies.iter().enumerate() {
-                        if deps.get(dep.name).is_some() {
-                            needed_dependencies.unset(i);
-                        }
-                    }
-                }
-                break 'brk needed_dependencies.count() > 0;
-            };
-
-            let needs_dev_dependencies = 'brk: {
-                if let Some(deps) = object.get(b"devDependencies") {
-                    for (i, dep) in dev_dependencies.iter().enumerate() {
-                        if deps.get(dep.name).is_some() {
-                            needed_dev_dependencies.unset(i);
-                        }
-                    }
-                }
-                break 'brk needed_dev_dependencies.count() > 0;
-            };
-
             let needs_typescript_dependency = !minimal
-                && 'brk: {
-                    if let Some(deps) = object.get(b"devDependencies") {
-                        if deps.has_any_property_named(&[b"typescript"]) {
-                            break 'brk false;
-                        }
-                    }
-                    if let Some(deps) = object.get(b"peerDependencies") {
-                        if deps.has_any_property_named(&[b"typescript"]) {
-                            break 'brk false;
-                        }
-                    }
-                    true
-                };
+                && !lists_dependency(
+                    object,
+                    &[
+                        b"dependencies",
+                        b"devDependencies",
+                        b"optionalDependencies",
+                        b"peerDependencies",
+                    ],
+                    b"typescript",
+                );
 
-            need_run_bun_install =
-                needs_dependencies || needs_dev_dependencies || needs_typescript_dependency;
+            need_run_bun_install = needs_bun_types_dependency || needs_typescript_dependency;
 
             // `bun check` needs no script. A script is where people and tools look for how a project is type checked.
             if !minimal && is_type_script_entry_point(&fields.entry_point) {
@@ -755,30 +723,14 @@ impl InitCommand {
                 }
             }
 
-            if needs_dependencies {
-                let mut dependencies_object = dependency_map(object, b"dependencies");
-                let mut iter = needed_dependencies.iter_set();
-                while let Some(index) = iter.next() {
-                    let dep = &dependencies[index];
-                    dependencies_object.data.as_e_object_mut().put_string(
-                        &bump,
-                        dep.name,
-                        dep.version,
-                    )?;
-                }
-                object.put(&bump, b"dependencies", dependencies_object)?;
-            }
-
-            if needs_dev_dependencies {
-                let mut obj = dependency_map(object, b"devDependencies");
-                let mut iter = needed_dev_dependencies.iter_set();
-                while let Some(index) = iter.next() {
-                    let dep = &dev_dependencies[index];
-                    obj.data
-                        .as_e_object_mut()
-                        .put_string(&bump, dep.name, dep.version)?;
-                }
-                object.put(&bump, b"devDependencies", obj)?;
+            if needs_bun_types_dependency {
+                let mut dev_dependencies = dependency_map(object, b"devDependencies");
+                dev_dependencies.data.as_e_object_mut().put_string(
+                    &bump,
+                    b"@types/bun",
+                    b"latest",
+                )?;
+                object.put(&bump, b"devDependencies", dev_dependencies)?;
             }
 
             if needs_typescript_dependency {
@@ -791,10 +743,6 @@ impl InitCommand {
             }
         }
 
-        if template.is_react() {
-            template.write_to_package_json(&mut fields, &bump)?;
-        }
-
         'write_package_json: {
             let (fd, created_close): (Fd, Option<bun_sys::CloseOnDrop>) = match package_json_file
                 .as_ref()
@@ -870,6 +818,7 @@ impl InitCommand {
 
                 if !fields.entry_point.is_empty()
                     && is_safe_entry_point_path(&fields.entry_point)
+                    && (!did_load_package_json || is_script_entry_point(&fields.entry_point))
                     && !exists(&fields.entry_point)
                 {
                     if let Some(dirname) = bun_core::dirname(&fields.entry_point) {
@@ -976,15 +925,6 @@ impl Assets {
         Self::create_full_inner(asset, asset_name, "", is_template, args)
     }
 
-    pub(crate) fn create_with_contents(
-        asset_name: &[u8],
-        contents: &'static [u8],
-        args: &[(&[u8], &[u8])],
-    ) -> Result<(), Error> {
-        let is_template = !args.is_empty();
-        Self::create_full_with_contents(asset_name, contents, "", is_template, args)
-    }
-
     fn create_new(filename: &ZStr, contents: &[u8]) -> Result<(), Error> {
         // Create parent dirs then open.
         if let Some(dir) = bun_core::dirname(filename.as_bytes()) {
@@ -1048,40 +988,6 @@ impl Assets {
         Output::flush();
         Ok(())
     }
-
-    fn create_full_with_contents(
-        // name of asset file to create
-        filename: &[u8],
-        contents: &'static [u8],
-        // optionally add a suffix to the end of the `+ filename` message. Must have a leading space.
-        message_suffix: &'static str,
-        // Treat the asset as a format string, using `args` to populate it. Only applies to known assets.
-        is_template: bool,
-        // Format arguments
-        args: &[(&[u8], &[u8])],
-    ) -> Result<(), Error> {
-        let file = bun_sys::File::openat(
-            Fd::cwd(),
-            filename,
-            bun_sys::O::WRONLY | bun_sys::O::CREAT | bun_sys::O::TRUNC,
-            0o666,
-        )?;
-
-        if is_template {
-            let buf = bun_fmt::substitute_named(contents, args);
-            file.write_all(&buf)?;
-        } else {
-            file.write_all(contents)?;
-        }
-
-        bun_core::prettyln!(
-            " + <r><d>{}{}<r>",
-            bstr::BStr::new(filename),
-            message_suffix,
-        );
-        Output::flush();
-        Ok(())
-    }
 }
 
 // ──────────────────────────────────────────────────────────────────────────
@@ -1173,166 +1079,6 @@ impl RadioChoice for ReactTemplateChoice {
     }
 }
 
-// ──────────────────────────────────────────────────────────────────────────
-// DependencyNeeded / DependencyGroup
-// ──────────────────────────────────────────────────────────────────────────
-
-#[derive(Copy, Clone)]
-pub(crate) struct DependencyNeeded {
-    pub name: &'static [u8],
-    pub version: &'static [u8],
-}
-
-struct DependencyGroup {
-    pub dependencies: &'static [DependencyNeeded],
-    pub dev_dependencies: &'static [DependencyNeeded],
-}
-
-impl DependencyGroup {
-    const BLANK: DependencyGroup = DependencyGroup {
-        dependencies: &[],
-        dev_dependencies: &[DependencyNeeded {
-            name: b"@types/bun",
-            version: b"latest",
-        }],
-    };
-
-    // `const` cannot concat slices; the lists are hand-expanded below.
-    const REACT: DependencyGroup = DependencyGroup {
-        dependencies: &[
-            DependencyNeeded {
-                name: b"react",
-                version: b"^19",
-            },
-            DependencyNeeded {
-                name: b"react-dom",
-                version: b"^19",
-            },
-        ],
-        dev_dependencies: &[
-            DependencyNeeded {
-                name: b"@types/react",
-                version: b"^19",
-            },
-            DependencyNeeded {
-                name: b"@types/react-dom",
-                version: b"^19",
-            },
-            // ++ blank.devDependencies
-            DependencyNeeded {
-                name: b"@types/bun",
-                version: b"latest",
-            },
-        ],
-    };
-
-    const TAILWIND: DependencyGroup = DependencyGroup {
-        dependencies: &[
-            DependencyNeeded {
-                name: b"tailwindcss",
-                version: b"^4",
-            },
-            // ++ react.dependencies
-            DependencyNeeded {
-                name: b"react",
-                version: b"^19",
-            },
-            DependencyNeeded {
-                name: b"react-dom",
-                version: b"^19",
-            },
-        ],
-        dev_dependencies: &[
-            DependencyNeeded {
-                name: b"bun-plugin-tailwind",
-                version: b"latest",
-            },
-            // ++ react.devDependencies
-            DependencyNeeded {
-                name: b"@types/react",
-                version: b"^19",
-            },
-            DependencyNeeded {
-                name: b"@types/react-dom",
-                version: b"^19",
-            },
-            DependencyNeeded {
-                name: b"@types/bun",
-                version: b"latest",
-            },
-        ],
-    };
-
-    const SHADCN: DependencyGroup = DependencyGroup {
-        dependencies: &[
-            DependencyNeeded {
-                name: b"class-variance-authority",
-                version: b"latest",
-            },
-            DependencyNeeded {
-                name: b"clsx",
-                version: b"latest",
-            },
-            DependencyNeeded {
-                name: b"tailwind-merge",
-                version: b"latest",
-            },
-            DependencyNeeded {
-                name: b"tw-animate-css",
-                version: b"latest",
-            },
-            DependencyNeeded {
-                name: b"lucide-react",
-                version: b"^1",
-            },
-            DependencyNeeded {
-                name: b"@radix-ui/react-label",
-                version: b"latest",
-            },
-            DependencyNeeded {
-                name: b"@radix-ui/react-select",
-                version: b"latest",
-            },
-            DependencyNeeded {
-                name: b"@radix-ui/react-slot",
-                version: b"latest",
-            },
-            // ++ tailwind.dependencies
-            DependencyNeeded {
-                name: b"tailwindcss",
-                version: b"^4",
-            },
-            DependencyNeeded {
-                name: b"react",
-                version: b"^19",
-            },
-            DependencyNeeded {
-                name: b"react-dom",
-                version: b"^19",
-            },
-        ],
-        // ++ tailwind.devDependencies
-        dev_dependencies: &[
-            DependencyNeeded {
-                name: b"bun-plugin-tailwind",
-                version: b"latest",
-            },
-            DependencyNeeded {
-                name: b"@types/react",
-                version: b"^19",
-            },
-            DependencyNeeded {
-                name: b"@types/react-dom",
-                version: b"^19",
-            },
-            DependencyNeeded {
-                name: b"@types/bun",
-                version: b"latest",
-            },
-        ],
-    };
-}
-
 // ──────────────────────────────────────────────────────────────────────────
 // Template
 // ──────────────────────────────────────────────────────────────────────────
@@ -1366,50 +1112,6 @@ impl Template {
         )
     }
 
-    fn write_to_package_json(
-        self,
-        fields: &mut PackageJSONFields,
-        bump: &bun_alloc::Arena,
-    ) -> Result<(), Error> {
-        type Rope = bun_ast::E::Rope;
-        fields.name = self.name().to_vec();
-        // Allocate in the process-lifetime CLI arena.
-        let key: &mut Rope = crate::cli::cli_arena().alloc(Rope {
-            head: bun_ast::Expr::init(bun_ast::E::String::init(b"scripts"), bun_ast::Loc::EMPTY),
-            next: core::ptr::null_mut(),
-        });
-        // SAFETY: object is arena-allocated and live for the command duration.
-        let object = unsafe { &mut *fields.object.unwrap().as_ptr() };
-        let mut scripts_json = object.get_or_put_object(key, bump).map_err(|e| match e {
-            bun_ast::E::SetError::OutOfMemory => Error::Alloc(bun_alloc::AllocError),
-            bun_ast::E::SetError::Clobber => Error::Unexpected,
-        })?;
-        let the_scripts = self.scripts();
-        let mut i: usize = 0;
-        while i < the_scripts.len() {
-            let script_name = the_scripts[i];
-            let script_command = the_scripts[i + 1];
-
-            scripts_json.data.e_object_mut().unwrap().put_string(
-                bump,
-                script_name,
-                script_command,
-            )?;
-            i += 2;
-        }
-        Ok(())
-    }
-
-    fn dependencies(self) -> &'static DependencyGroup {
-        match self {
-            Template::Blank => &DependencyGroup::BLANK,
-            Template::ReactBlank => &DependencyGroup::REACT,
-            Template::ReactTailwind => &DependencyGroup::TAILWIND,
-            Template::ReactTailwindShadcn => &DependencyGroup::SHADCN,
-            Template::TypescriptLibrary => &DependencyGroup::BLANK,
-        }
-    }
-
     fn name(self) -> &'static [u8] {
         match self {
             Template::Blank => b"bun-blank-template",
@@ -1420,24 +1122,6 @@ impl Template {
         }
     }
 
-    fn scripts(self) -> &'static [&'static [u8]] {
-        match self {
-            Template::Blank | Template::TypescriptLibrary => &[],
-            Template::ReactTailwind | Template::ReactTailwindShadcn => &[
-                b"dev", b"bun './**/*.html'",
-                b"build", b"bun 'REPLACE_ME_WITH_YOUR_APP_FILE_NAME.build.ts'",
-            ],
-            Template::ReactBlank => &[
-                b"dev",
-                b"bun --hot .",
-                b"static",
-                b"bun build ./src/index.html --outdir=dist --sourcemap --target=browser --minify --define:process.env.NODE_ENV='\"production\"' --env='BUN_PUBLIC_*'",
-                b"build",
-                b"NODE_ENV=production bun .",
-            ],
-        }
-    }
-
     const AGENT_RULE: &'static [u8] = include_bytes!("./init/rule.md");
     const CURSOR_RULE: TemplateFile = TemplateFile::new(
         b".cursor/rules/use-bun-instead-of-node-vite-npm-pnpm.mdc",
@@ -1635,26 +1319,27 @@ impl Template {
 
         for file in self.files() {
             let path = file.path;
-            let contents = file.contents;
-
-            let result = if path == b"README.md" {
-                Assets::create_with_contents(
-                    b"README.md",
-                    contents,
+            let readme;
+            let contents = if path == b"README.md" {
+                readme = bun_fmt::substitute_named(
+                    file.contents,
                     &[
                         (b"name", self.name()),
                         (b"bunVersion", Environment::VERSION_STRING.as_bytes()),
                     ],
-                )
+                );
+                readme.as_slice()
             } else {
-                let mut p = path.to_vec();
-                p.push(0);
-                Assets::create_new(
-                    ZStr::from_slice_with_nul(&p[..]),
-                    // SAFETY: p[len-1] == 0 written above
-                    contents,
-                )
+                file.contents
             };
+
+            let mut p = path.to_vec();
+            p.push(0);
+            let result = Assets::create_new(
+                ZStr::from_slice_with_nul(&p[..]),
+                // SAFETY: p[len-1] == 0 written above
+                contents,
+            );
             if let Err(err) = result {
                 if matches!(err, crate::Error::Sys(bun_errno::SystemErrno::EEXIST)) {
                     bun_core::prettyln!(
@@ -1927,6 +1612,15 @@ fn dependency_map(package_json: &bun_ast::E::Object, key: &[u8]) -> bun_ast::Exp
         .unwrap_or_else(|| bun_ast::Expr::init(bun_ast::E::Object::default(), bun_ast::Loc::EMPTY))
 }
 
+/// Whether one of the dependency `groups` of `package_json` lists `name`.
+fn lists_dependency(package_json: &bun_ast::E::Object, groups: &[&[u8]], name: &[u8]) -> bool {
+    groups.iter().any(|group| {
+        package_json
+            .get(group)
+            .is_some_and(|dependencies| dependencies.get(name).is_some())
+    })
+}
+
 fn is_type_script_entry_point(entry_point: &[u8]) -> bool {
     options::DEFAULT_LOADERS
         .get(bun_paths::extension(entry_point))
@@ -1935,6 +1629,13 @@ fn is_type_script_entry_point(entry_point: &[u8]) -> bool {
         .is_type_script()
 }
 
+/// A stub written at an extensionless `"main": "./index"` would be loaded instead of `index.js`.
+fn is_script_entry_point(entry_point: &[u8]) -> bool {
+    options::DEFAULT_LOADERS
+        .get(bun_paths::extension(entry_point))
+        .is_some_and(|loader| loader.is_java_script_like())
+}
+
 /// Refuse entry-point paths that would escape the project directory
 /// (absolute paths or any `..` segment), so `bun init` only creates files
 /// inside the current working directory.
diff --git a/src/runtime/cli/lint_command.rs b/src/runtime/cli/lint_command.rs
index dcbcdb64bc24..029fa30c957c 100644
--- a/src/runtime/cli/lint_command.rs
+++ b/src/runtime/cli/lint_command.rs
@@ -22,7 +22,7 @@ pub(crate) use bun_lint_driver::cli::HELP;
 /// build has none of it.
 const HAS_TEST_RUNNER: bool = bun_core::Environment::IS_CANARY || bun_core::Environment::IS_DEBUG;
 
-fn change_directory(cwd: &[u8]) {
+pub(crate) fn change_directory(cwd: &[u8]) {
     // The copy is freed here: `exit` does not return, so nothing would free it afterwards.
     let changed = bun_sys::chdir(&bun_core::ZBox::from_bytes(cwd));
     if let bun_sys::Result::Err(err) = changed {
@@ -36,7 +36,7 @@ fn change_directory(cwd: &[u8]) {
 }
 
 /// `--cwd` among the flags of `bun`, which precede `command`.
-fn cwd_before(command: &[u8]) -> Option<&'static [u8]> {
+pub(crate) fn cwd_before(command: &[u8]) -> Option<&'static [u8]> {
     let mut found = None;
     let mut args = bun_core::argv().into_iter();
     while let Some(arg) = args.next() {
diff --git a/src/runtime/cli/mod.rs b/src/runtime/cli/mod.rs
index c0ec18888b0e..62dca9231273 100644
--- a/src/runtime/cli/mod.rs
+++ b/src/runtime/cli/mod.rs
@@ -333,12 +333,6 @@ impl colon_list_type::ColonListValue for &'static [u8] {
     }
 }
 
-#[cold]
-fn invalid_target(diag: &mut bun_clap::Diagnostic, _target: &[u8]) -> ! {
-    let _ = diag.report(Output::error_writer(), bun_clap::Error::InvalidArgument);
-    Global::exit(1);
-}
-
 // ─── Cli (entry point) ───────────────────────────────────────────────────────
 pub(crate) mod cli {
     use super::*;
@@ -632,26 +626,21 @@ pub(crate) mod command {
     // `bun_clap::streaming::WARN_ON_UNRECOGNIZED_FLAG` so node-mode argv parsing
     // stays silent on unknown flags.
     // ──────────────────
-    fn is_bun_x(argv0: &[u8]) -> bool {
-        #[cfg(windows)]
-        {
-            return strings::ends_with(argv0, b"bunx.exe") || strings::ends_with(argv0, b"bunx");
-        }
-        #[cfg(not(windows))]
-        {
-            strings::ends_with(argv0, b"bunx")
+    /// Whether `argv0` ends in `name` in any case, with or without `.exe`: npm's `bun/bin/bunx.exe`, `bunx.EXE` by `PATHEXT`.
+    fn is_invoked_as(argv0: &[u8], name: &[u8]) -> bool {
+        fn without<'a>(text: &'a [u8], end: &[u8]) -> Option<&'a [u8]> {
+            let (rest, found) = text.split_at_checked(text.len().checked_sub(end.len())?)?;
+            found.eq_ignore_ascii_case(end).then_some(rest)
         }
+        without(without(argv0, b".exe").unwrap_or(argv0), name).is_some()
+    }
+
+    fn is_bun_x(argv0: &[u8]) -> bool {
+        is_invoked_as(argv0, b"bunx")
     }
 
     fn is_node(argv0: &[u8]) -> bool {
-        #[cfg(windows)]
-        {
-            return strings::ends_with(argv0, b"node.exe") || strings::ends_with(argv0, b"node");
-        }
-        #[cfg(not(windows))]
-        {
-            strings::ends_with(argv0, b"node")
-        }
+        is_invoked_as(argv0, b"node")
     }
 
     /// Cheap argv prescan for the dominant `bun <path>` / `bun .` shape.
@@ -754,24 +743,60 @@ pub(crate) mod command {
             return Tag::RunAsNodeCommand;
         }
 
-        let Some(mut first_arg_name) = iter.next() else {
-            return Tag::AutoCommand;
-        };
-        while !first_arg_name.is_empty()
-            && first_arg_name[0] == b'-'
-            && !(first_arg_name.len() > 1 && first_arg_name[1] == b'e')
-        {
+        // A flag of `bun` can have its value in the next argument, as in `bun --cwd dir run dev`.
+        let mut after_value = false;
+        let name = loop {
+            let Some(arg) = iter.next() else {
+                return Tag::AutoCommand;
+            };
+            if !arg.starts_with(b"-") {
+                break arg;
+            }
+            let flag = strings::split_once_char(arg, b'=').map_or(arg, |it| it.0);
+            if arg[1..].starts_with(b"e") || matches!(flag, b"--eval" | b"--print") {
+                return Tag::AutoCommand;
+            }
             // `--interactive` stays on AutoCommand: Arguments.rs parses it and the no-target check
             // routes to RunCommand::exec_node_repl. An early ReplCommand return here would bypass
             // that and boot the legacy `bun repl` implementation instead.
-            match iter.next() {
-                Some(n) => first_arg_name = n,
-                None => return Tag::AutoCommand,
+            if !arguments::value_is_next_arg(arg) {
+                continue;
+            }
+            let Some(value) = iter.next() else {
+                return Tag::AutoCommand;
+            };
+            // Commands give these flags other meanings: `bun -p install` is `bun install --production`.
+            if !after_value && command_named(value) != Tag::AutoCommand {
+                break value;
+            }
+            after_value = true;
+            // What follows names a script of other packages, or is for the code.
+            if matches!(arg, b"--filter" | b"-F" | b"-p") {
+                return Tag::AutoCommand;
             }
+        };
+
+        use super::script_or_command::{Runs, is_of_the_project, runs};
+        let tag = command_named(name);
+        let project_has_it = match tag {
+            Tag::AutoCommand | Tag::RunCommand => false,
+            Tag::CheckCommand | Tag::LintCommand | Tag::FormatCommand => is_of_the_project(name),
+            // `bun --cwd dir build` is `bun build` only if the project has no `build` to run. Scripts have `bun` in `PATH`.
+            _ if after_value => {
+                tag == Tag::ReservedCommand || name == b"bun" || runs(name) != Runs::Command
+            }
+            _ => false,
+        };
+        match project_has_it {
+            true => Tag::AutoCommand,
+            false => tag,
         }
+    }
 
+    /// The command that `name` spells, or `AutoCommand`.
+    fn command_named(name: &[u8]) -> Tag {
         type RootCommandMatcher = strings::ExactSizeMatcher<12>;
-        let x = RootCommandMatcher::r#match(first_arg_name);
+        let x = RootCommandMatcher::r#match(name);
         // PERF: `if x == const` is a chain of compares rather than a jump
         // table on the packed u96 — profile if it shows up on a hot path.
         if x == RootCommandMatcher::case(b"init") {
@@ -805,7 +830,7 @@ pub(crate) mod command {
             return Tag::ReplCommand;
         }
         if x == RootCommandMatcher::case(b"i") || x == RootCommandMatcher::case(b"install") {
-            for arg in argv.iter() {
+            for arg in bun::argv().iter() {
                 if arg == b"-g" || arg == b"--global" {
                     return Tag::AddCommand;
                 }
@@ -862,22 +887,13 @@ pub(crate) mod command {
             return Tag::AuditCommand;
         }
         if x == RootCommandMatcher::case(b"check") {
-            return match super::script_or_command::is_of_the_project(b"check") {
-                true => Tag::AutoCommand,
-                false => Tag::CheckCommand,
-            };
+            return Tag::CheckCommand;
         }
         if x == RootCommandMatcher::case(b"lint") {
-            return match super::script_or_command::is_of_the_project(b"lint") {
-                true => Tag::AutoCommand,
-                false => Tag::LintCommand,
-            };
+            return Tag::LintCommand;
         }
         if x == RootCommandMatcher::case(b"fmt") {
-            return match super::script_or_command::is_of_the_project(b"fmt") {
-                true => Tag::AutoCommand,
-                false => Tag::FormatCommand,
-            };
+            return Tag::FormatCommand;
         }
         if x == RootCommandMatcher::case(b"info") {
             return Tag::InfoCommand;
@@ -911,9 +927,6 @@ pub(crate) mod command {
             }
             return Tag::AutoCommand;
         }
-        if x == RootCommandMatcher::case(b"-e") {
-            return Tag::AutoCommand;
-        }
         Tag::AutoCommand
     }
 
@@ -1290,7 +1303,12 @@ pub(crate) mod command {
             return run_command::RunCommand::exec_node_repl(ctx);
         }
 
-        if tag == Tag::AutoCommand && !ctx.runtime_options.eval.script.is_empty() {
+        // `bun run -e code <target>` runs the target.
+        if (tag == Tag::AutoCommand || no_target) && !ctx.runtime_options.eval.script.is_empty() {
+            if no_target {
+                // The "run" of `bun run -e code` is not an argument of the code.
+                ctx.positionals.clear();
+            }
             lint_command::read_program_of_script(ctx);
             return run_command::RunCommand::exec_eval(ctx);
         }
@@ -1334,7 +1352,9 @@ pub(crate) mod command {
     fn exec_init() -> CmdResult {
         // InitCommand parses its own argv (no Context).
         let argv = argv_zslice();
-        super::init_command::InitCommand::exec(&argv[2.min(argv.len())..])
+        print_help_if_asked_before(&argv, b"init", Tag::InitCommand);
+        change_directory_before(b"init");
+        super::init_command::InitCommand::exec(after_command(&argv, b"init"))
     }
 
     #[cold]
@@ -1400,7 +1420,7 @@ pub(crate) mod command {
     }
 
     /// What follows `command`, which stands after the flags of `bun` and those of `BUN_OPTIONS`.
-    fn after_command<'a>(
+    pub(crate) fn after_command<'a>(
         argv: &'a [&'static bun_core::ZStr],
         command: &[u8],
     ) -> &'a [&'static bun_core::ZStr] {
@@ -1416,6 +1436,13 @@ pub(crate) mod command {
         &[]
     }
 
+    /// Applies `--cwd` among the flags of `bun`, which precede `command`, for a command that reads argv itself.
+    fn change_directory_before(command: &[u8]) {
+        if let Some(cwd) = lint_command::cwd_before(command) {
+            lint_command::change_directory(cwd);
+        }
+    }
+
     /// The flags of `command` that stand before it, as in `bun --check format` or `bun -c format`, and then what follows it. If
     /// they were dropped, `--check` would write. `knows` tells whether `command` has a flag. The others are for `bun`, or come
     /// from `BUN_OPTIONS`.
@@ -1718,7 +1745,10 @@ pub(crate) mod command {
             while remainder_i < remainder.len() && positional_i < positionals.len() {
                 let slice = strings::trim(remainder[remainder_i].as_bytes(), b" \t\n");
                 if !slice.is_empty() {
-                    if !strings::has_prefix(slice, b"--") {
+                    // What precedes the command is the value of a flag of `bun`.
+                    if !strings::has_prefix(slice, b"--")
+                        && (positional_i > 0 || matches!(slice, b"create" | b"c"))
+                    {
                         if positional_i == 1 {
                             template_name_start = remainder_i + 2;
                         }
@@ -1746,6 +1776,7 @@ pub(crate) mod command {
             Global::exit(0);
         }
 
+        change_directory_before(positionals[0]);
         let template_name = positionals[1];
 
         // if template_name is "react" — deprecated; redirect to react-app/vite.
diff --git a/src/runtime/cli/multi_run.rs b/src/runtime/cli/multi_run.rs
index 7c3e4992e5f8..272a4532f0db 100644
--- a/src/runtime/cli/multi_run.rs
+++ b/src/runtime/cli/multi_run.rs
@@ -44,8 +44,7 @@ struct ScriptConfig {
     name: Box<[u8]>,
     command: Box<[u8]>,
     cwd: Box<[u8]>,
-    /// PATH env var value for this script
-    path: Box<[u8]>,
+    env: FilterArg::ScriptEnv,
 }
 
 /// Wraps a BufferedReader and tracks whether it represents stdout or stderr,
@@ -150,23 +149,14 @@ impl<'a> ProcessHandle<'a> {
         )?;
 
         let start_time = Instant::now();
-        let envp;
-        let env_ptr = state.env;
         let spawned: SpawnProcessResult = {
-            // SAFETY: state.env points at the process-lifetime DotEnv loader.
-            let env = unsafe { &mut *env_ptr };
-            let original_path: Box<[u8]> = env.map.get(b"PATH").map(Box::from).unwrap_or_default();
-            let _ = env.map.put(b"PATH", &self.config.path);
-            let _restore = scopeguard::guard(original_path, move |original_path| {
-                // SAFETY: env_ptr is the process-lifetime loader; outlives this scope.
-                let _ = unsafe { (*env_ptr).map.put(b"PATH", &original_path) };
-            });
-            // SAFETY: same loader; the `_restore` guard's closure has not fired yet.
-            envp = crate::cli::script_or_command::with_package_script(
-                unsafe { &mut *env_ptr },
-                &self.config.name,
-                &self.config.cwd,
-                |env| env.map.create_null_delimited_env_map(),
+            let config = self.config;
+            let envp = crate::cli::script_or_command::with_package_script(
+                // SAFETY: state.env points at the process-lifetime DotEnv loader.
+                unsafe { &mut *state.env },
+                &config.name,
+                &config.cwd,
+                |env| config.env.create_envp(&env.map, &config.name),
             )?;
             // SAFETY: `argv` and `envp` are null-terminated C-string arrays
             // (argv[0] non-null) owned by locals that outlive this call.
@@ -609,9 +599,15 @@ impl<'a> State<'a> {
     }
 }
 
-struct AbortHandler;
+/// Shared with `bun run --filter`.
+pub(crate) struct AbortHandler;
+
+pub(crate) static SHOULD_ABORT: AtomicBool = AtomicBool::new(false);
 
-static SHOULD_ABORT: AtomicBool = AtomicBool::new(false);
+/// The loop that the run waits in. Windows calls `windows_ctrl_handler` on another thread.
+#[cfg(windows)]
+static LOOP: std::sync::atomic::AtomicPtr<bun_uws::Loop> =
+    std::sync::atomic::AtomicPtr::new(ptr::null_mut());
 
 impl AbortHandler {
     #[cfg(unix)]
@@ -629,12 +625,15 @@ impl AbortHandler {
     ) -> bun_sys::windows::BOOL {
         if dw_ctrl_type == bun_sys::windows::CTRL_C_EVENT {
             SHOULD_ABORT.store(true, Ordering::SeqCst);
+            // SAFETY: `install` stored the main thread's loop, which is never freed, before it
+            // registered this handler. Any thread may call `us_wakeup_loop`.
+            unsafe { bun_uws::us_wakeup_loop(LOOP.load(Ordering::Acquire)) };
             return bun_sys::windows::TRUE;
         }
         bun_sys::windows::FALSE
     }
 
-    fn install() {
+    pub(crate) fn install() {
         #[cfg(unix)]
         {
             // bun_sys::posix::Sigaction is a re-export of libc::sigaction; construct
@@ -651,6 +650,7 @@ impl AbortHandler {
         }
         #[cfg(not(unix))]
         {
+            LOOP.store(bun_uws::Loop::get(), Ordering::Release);
             let res = bun_sys::windows::SetConsoleCtrlHandler(
                 Some(Self::windows_ctrl_handler),
                 bun_sys::windows::TRUE,
@@ -663,9 +663,11 @@ impl AbortHandler {
         }
     }
 
-    fn uninstall() {
+    pub(crate) fn uninstall() {
+        // only necessary on Windows, as on posix we pass the SA_RESETHAND flag
         #[cfg(windows)]
         {
+            // (None, FALSE) only clears the ignore attribute: pass the handler to unregister it.
             let _ = bun_sys::windows::SetConsoleCtrlHandler(
                 Some(Self::windows_ctrl_handler),
                 bun_sys::windows::FALSE,
@@ -712,6 +714,7 @@ struct GroupInfo {
 
 /// Add configs for a single script name (with pre/post handling).
 /// When `label_prefix` is non-null, labels become "{prefix}:{name}" (for workspace runs).
+/// `arguments` is appended to the script or the command, not to its pre and post scripts.
 ///
 /// Generic over the scripts map value type so both the single-package path
 /// (values borrow the process-lifetime DirInfo-cached package.json) and the
@@ -723,8 +726,9 @@ fn add_script_configs<V: core::ops::Deref<Target = [u8]>>(
     raw_name: &[u8],
     scripts_map: Option<&StringArrayHashMap<V>>,
     cwd: &[u8],
-    path: &[u8],
+    env: &FilterArg::ScriptEnv,
     label_prefix: Option<&[u8]>,
+    arguments: &[u8],
 ) -> Result<(), Error> {
     let group_start = configs.len();
 
@@ -772,7 +776,7 @@ fn add_script_configs<V: core::ops::Deref<Target = [u8]>>(
                 name: pre_name.into_boxed_slice(),
                 command: cmd_buf.into_boxed_slice(),
                 cwd: Box::from(cwd),
-                path: Box::from(path),
+                env: env.clone(),
             });
         }
 
@@ -780,13 +784,14 @@ fn add_script_configs<V: core::ops::Deref<Target = [u8]>>(
         {
             let mut cmd_buf: Vec<u8> = Vec::with_capacity(content.len() + 1);
             RunCommand::replace_package_manager_run(&mut cmd_buf, content)?;
+            cmd_buf.extend_from_slice(arguments);
             cmd_buf.push(0);
             configs.push(ScriptConfig {
                 label: label.clone(),
                 name: Box::from(raw_name),
                 command: cmd_buf.into_boxed_slice(),
                 cwd: Box::from(cwd),
-                path: Box::from(path),
+                env: env.clone(),
             });
         }
 
@@ -799,7 +804,7 @@ fn add_script_configs<V: core::ops::Deref<Target = [u8]>>(
                 name: post_name.into_boxed_slice(),
                 command: cmd_buf.into_boxed_slice(),
                 cwd: Box::from(cwd),
-                path: Box::from(path),
+                env: env.clone(),
             });
         }
     } else {
@@ -819,12 +824,14 @@ fn add_script_configs<V: core::ops::Deref<Target = [u8]>>(
             v.extend_from_slice(bun_path);
             v.extend_from_slice(b"\" ");
             v.extend_from_slice(raw_name);
+            v.extend_from_slice(arguments);
             v.push(0);
             v.into_boxed_slice()
         } else {
             // allocator.dupeZ
             let mut v = Vec::with_capacity(raw_name.len() + 1);
             v.extend_from_slice(raw_name);
+            v.extend_from_slice(arguments);
             v.push(0);
             v.into_boxed_slice()
         };
@@ -833,7 +840,7 @@ fn add_script_configs<V: core::ops::Deref<Target = [u8]>>(
             name: Box::default(),
             command: command_z,
             cwd: Box::from(cwd),
-            path: Box::from(path),
+            env: env.clone(),
         });
     }
 
@@ -855,7 +862,7 @@ pub(crate) fn run(ctx: &mut Command::ContextData) -> Result<core::convert::Infal
         Global::exit(1);
     }
 
-    // Collect script names from positionals + passthrough
+    // Collect script names from positionals
     // For RunCommand: positionals[0] is "run", skip it. For AutoCommand: no "run" prefix.
     // Cloned to owned so the &mut ctx borrow below doesn't conflict.
     let mut script_names: Vec<Box<[u8]>> = Vec::new();
@@ -869,9 +876,14 @@ pub(crate) fn run(ctx: &mut Command::ContextData) -> Result<core::convert::Infal
             script_names.push(pos.clone());
         }
     }
-    for pt in &ctx.passthrough {
-        if !pt.is_empty() {
-            script_names.push(pt.clone());
+    // What follows `--` goes to each script, quoted as for `bun run a -- b`.
+    let mut arguments: Vec<u8> = Vec::new();
+    for part in &ctx.passthrough {
+        arguments.push(b' ');
+        if crate::shell::needs_escape_utf8_ascii_latin1(part) {
+            crate::shell::escape_8bit::<true, false>(part, &mut arguments).unwrap_or_oom();
+        } else {
+            arguments.extend_from_slice(part);
         }
     }
 
@@ -940,7 +952,7 @@ pub(crate) fn run(ctx: &mut Command::ContextData) -> Result<core::convert::Infal
             name: Box<[u8]>,
             dirpath: Box<[u8]>,
             scripts: OwnedScriptsMap,
-            path: Box<[u8]>,
+            env: FilterArg::ScriptEnv,
         }
         let mut matched_packages: Vec<MatchedPackage> = Vec::new();
 
@@ -969,7 +981,7 @@ pub(crate) fn run(ctx: &mut Command::ContextData) -> Result<core::convert::Infal
                 name: pkg_name,
                 dirpath: package.dir.clone(),
                 scripts: owned_scripts,
-                path: pkg_path_env.into(),
+                env: FilterArg::ScriptEnv::new(&pkg_path_env, Some(&package.json)),
             });
         }
 
@@ -1001,8 +1013,9 @@ pub(crate) fn run(ctx: &mut Command::ContextData) -> Result<core::convert::Infal
                             matched_name,
                             Some(&pkg.scripts),
                             &pkg.dirpath,
-                            &pkg.path,
+                            &pkg.env,
                             Some(&pkg.name),
+                            &arguments,
                         )?;
                     }
                 } else {
@@ -1013,8 +1026,9 @@ pub(crate) fn run(ctx: &mut Command::ContextData) -> Result<core::convert::Infal
                             raw_name,
                             Some(&pkg.scripts),
                             &pkg.dirpath,
-                            &pkg.path,
+                            &pkg.env,
                             Some(&pkg.name),
+                            &arguments,
                         )?;
                     } else if ctx.workspaces && !ctx.if_present {
                         bun_core::pretty_errorln!(
@@ -1040,6 +1054,7 @@ pub(crate) fn run(ctx: &mut Command::ContextData) -> Result<core::convert::Infal
         let run_in_bun = ctx.debug.run_in_bun;
         let path_env =
             RunCommand::path_for_run(this_transpiler.env_mut(), b"", None, cwd, run_in_bun)?;
+        let env = FilterArg::ScriptEnv::new(&path_env, None);
 
         // Load package.json scripts
         let root_dir_info = match this_transpiler.resolver.read_dir_info(cwd) {
@@ -1083,8 +1098,9 @@ pub(crate) fn run(ctx: &mut Command::ContextData) -> Result<core::convert::Infal
                             matched_name,
                             scripts_map,
                             cwd,
-                            &path_env,
+                            &env,
                             None,
+                            &arguments,
                         )?;
                     }
                 } else {
@@ -1101,8 +1117,9 @@ pub(crate) fn run(ctx: &mut Command::ContextData) -> Result<core::convert::Infal
                     raw_name,
                     scripts_map,
                     cwd,
-                    &path_env,
+                    &env,
                     None,
+                    &arguments,
                 )?;
             }
         }
@@ -1122,6 +1139,10 @@ pub(crate) fn run(ctx: &mut Command::ContextData) -> Result<core::convert::Infal
     }
 
     let use_colors = Output::enable_ansi_colors_stderr();
+    if Output::is_stdout_ansi_terminal() && Output::is_stderr_ansi_terminal() {
+        // SAFETY: env_ptr is the process-lifetime DotEnv loader; no other borrow of it is live.
+        FilterArg::force_color_in_scripts(unsafe { &mut *env_ptr });
+    }
 
     let mut state = State {
         handles: Box::default(),
diff --git a/src/runtime/cli/pack_command.rs b/src/runtime/cli/pack_command.rs
index 87546bdaa5bd..bb5ef602feb2 100644
--- a/src/runtime/cli/pack_command.rs
+++ b/src/runtime/cli/pack_command.rs
@@ -1953,7 +1953,6 @@ pub(crate) fn pack(
         let mut progress = Progress::Progress::default();
         let mut node: Option<&mut Progress::Node> = None;
         if log_level.show_progress() {
-            progress.supports_ansi_escape_codes = Output::enable_ansi_colors_stderr();
             let started = progress.start(b"", ctx.stats.total_files);
             started.unit = Progress::Unit::Files;
             node = Some(started);
diff --git a/src/runtime/cli/pm_trusted_command.rs b/src/runtime/cli/pm_trusted_command.rs
index 1e78f334c590..7e2ea9ee8e24 100644
--- a/src/runtime/cli/pm_trusted_command.rs
+++ b/src/runtime/cli/pm_trusted_command.rs
@@ -517,7 +517,6 @@ impl TrustCommand {
         if show_progress {
             // SAFETY: `pm_raw` singleton; `Node::start` returns an owned `Node` with raw backrefs into `pm.progress`.
             unsafe {
-                (*pm_raw).progress.supports_ansi_escape_codes = Output::enable_ansi_colors_stderr();
                 scripts_node = (*pm_raw)
                     .progress
                     .start(b"", 0)
diff --git a/src/runtime/cli/run_command.rs b/src/runtime/cli/run_command.rs
index d53c5853c48a..83c6496f9e7f 100644
--- a/src/runtime/cli/run_command.rs
+++ b/src/runtime/cli/run_command.rs
@@ -348,14 +348,11 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
         for part in passthrough {
             copy_script.push(b' ');
             if cfg!(windows) && use_system_shell && bun_which::batch_arg_has_cmd_metachars(part) {
-                if !silent {
-                    pretty_errorln!(
-                        "<r><red>error<r>: Failed to run script <b>{}<r>: argument {} contains a cmd.exe special character and cannot be passed to the system shell",
-                        bstr::BStr::new(name),
-                        bun_core::fmt::quote(&part[..]),
-                    );
-                    Output::flush();
-                }
+                pretty_errorln!(
+                    "<r><red>error<r>: Failed to run script <b>{}<r>: argument {} contains a cmd.exe special character and cannot be passed to the system shell",
+                    bstr::BStr::new(name),
+                    bun_core::fmt::quote(&part[..]),
+                );
                 Global::exit(1);
             }
             if needs_escape_utf8_ascii_latin1(part) {
@@ -393,13 +390,11 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
             ) {
                 Ok(c) => c,
                 Err(err) => {
-                    if !silent {
-                        pretty_errorln!(
-                            "<r><red>error<r>: Failed to run script <b>{}<r> due to error <b>{}<r>",
-                            bstr::BStr::new(name),
-                            bstr::BStr::new(err.name()),
-                        );
-                    }
+                    pretty_errorln!(
+                        "<r><red>error<r>: Failed to run script <b>{}<r> due to error <b>{}<r>",
+                        bstr::BStr::new(name),
+                        bstr::BStr::new(err.name()),
+                    );
                     Global::exit(1);
                 }
             };
@@ -482,26 +477,20 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
             ..Default::default()
         }) {
             Err(err) => {
-                if !silent {
-                    pretty_errorln!(
-                        "<r><red>error<r>: Failed to run script <b>{}<r> due to error <b>{}<r>",
-                        bstr::BStr::new(name),
-                        bstr::BStr::new(err.name()),
-                    );
-                }
-                Output::flush();
-                return Ok(());
+                pretty_errorln!(
+                    "<r><red>error<r>: Failed to run script <b>{}<r> due to error <b>{}<r>",
+                    bstr::BStr::new(name),
+                    bstr::BStr::new(err.name()),
+                );
+                Global::exit(1);
             }
             Ok(Err(err)) => {
-                if !silent {
-                    pretty_errorln!(
-                        "<r><red>error<r>: Failed to run script <b>{}<r> due to error:\n{}",
-                        bstr::BStr::new(name),
-                        err,
-                    );
-                }
-                Output::flush();
-                return Ok(());
+                pretty_errorln!(
+                    "<r><red>error<r>: Failed to run script <b>{}<r> due to error:\n{}",
+                    bstr::BStr::new(name),
+                    err,
+                );
+                Global::exit(1);
             }
             Ok(Ok(result)) => result,
         };
@@ -573,16 +562,12 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
             }
 
             SpawnStatus::Err(ref err) => {
-                if !silent {
-                    pretty_errorln!(
-                        "<r><red>error<r>: Failed to run script <b>{}<r> due to error:\n{}",
-                        bstr::BStr::new(name),
-                        err,
-                    );
-                }
-
-                Output::flush();
-                return Ok(());
+                pretty_errorln!(
+                    "<r><red>error<r>: Failed to run script <b>{}<r> due to error:\n{}",
+                    bstr::BStr::new(name),
+                    err,
+                );
+                Global::exit(1);
             }
 
             _ => {}
@@ -1266,6 +1251,7 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
             graph: Some(graph_dyn),
             is_main_thread: true,
             smol: ctx.runtime_options.smol,
+            debugger: ::core::mem::take(&mut ctx.runtime_options.debugger),
             // `Options::dns_result_order` is `u8` until the
             // b2-cycle widens it to `bun_dns::Order`; the enum is
             // `#[repr(u8)]` so `as u8` is exact.
@@ -1643,13 +1629,21 @@ impl Run<'_> {
         // ── core run-loop ──────────────────────────────────────────────────
         if vm.is_watcher_enabled() {
             vm.report_exception_in_hot_reloaded_module_if_needed();
+            // `tick_possibly_forever` also returns each second and on a signal. A reload can run entirely inside it.
+            let mut ran_out_of_work = true;
+            let mut generation = vm.hot_reload_counter;
             loop {
                 while vm.is_event_loop_alive() {
                     vm.tick();
                     vm.report_exception_in_hot_reloaded_module_if_needed();
                     vm.auto_tick_active();
+                    ran_out_of_work = true;
+                }
+                if ran_out_of_work || generation != vm.hot_reload_counter {
+                    vm.on_before_exit();
+                    ran_out_of_work = false;
+                    generation = vm.hot_reload_counter;
                 }
-                vm.on_before_exit();
                 vm.report_exception_in_hot_reloaded_module_if_needed();
                 // SAFETY: `event_loop` is a self-pointer into this VM; uniquely
                 // accessed here. Watcher arm keeps the process alive across
@@ -1723,6 +1717,10 @@ impl Run<'_> {
         if vm.unhandled_error_counter > 0 {
             vm.exit_handler.requested = true;
         }
+        // The `exit` listeners are told this code. It is stored again after them, so they cannot replace it.
+        if ANY_UNHANDLED.load(Ordering::Relaxed) {
+            vm.exit_handler.exit_code = 1;
+        }
         vm.on_exit();
 
         if ANY_UNHANDLED.load(Ordering::Relaxed) {
@@ -1790,6 +1788,10 @@ fn dump_build_error(vm: &mut VirtualMachine) {
     unsafe(link_section = ".text.unlikely")
 )]
 fn exit_with_unhandled_note(vm: &mut VirtualMachine) -> ! {
+    // A tsconfig.json that did not parse is why a `paths` alias is not found.
+    if log_has_msgs(vm) {
+        dump_build_error(vm);
+    }
     vm.exit_handler.exit_code = 1;
     vm.exit_handler.requested = true;
     vm.on_exit();
@@ -2175,14 +2177,12 @@ impl RunCommand {
         )
     }
 
-    fn run_binary_generic_error(executable: &[u8], silent: bool, err: &sys::Error) -> ! {
-        if !silent {
-            pretty_errorln!(
-                "<r><red>error<r>: Failed to run \"<b>{}<r>\" due to:\n{}",
-                bstr::BStr::new(Self::basename_or_bun(executable)),
-                err.with_path(executable),
-            );
-        }
+    fn run_binary_generic_error(executable: &[u8], err: &sys::Error) -> ! {
+        pretty_errorln!(
+            "<r><red>error<r>: Failed to run \"<b>{}<r>\" due to:\n{}",
+            bstr::BStr::new(Self::basename_or_bun(executable)),
+            err.with_path(executable),
+        );
         Global::exit(1);
     }
 
@@ -2243,39 +2243,37 @@ impl RunCommand {
                 // an error occurred before the process was spawned
                 #[allow(unused_labels)]
                 'print_error: {
-                    if !silent {
-                        #[cfg(unix)]
-                        {
-                            match sys::stat(executable_z) {
-                                Ok(stat) => {
-                                    if sys::S::ISDIR(stat.st_mode as _) {
-                                        pretty_errorln!(
-                                            "<r><red>error<r>: Failed to run directory \"<b>{}<r>\"\n",
-                                            bstr::BStr::new(Self::basename_or_bun(executable)),
-                                        );
-                                        break 'print_error;
-                                    }
+                    #[cfg(unix)]
+                    {
+                        match sys::stat(executable_z) {
+                            Ok(stat) => {
+                                if sys::S::ISDIR(stat.st_mode as _) {
+                                    pretty_errorln!(
+                                        "<r><red>error<r>: Failed to run directory \"<b>{}<r>\"\n",
+                                        bstr::BStr::new(Self::basename_or_bun(executable)),
+                                    );
+                                    break 'print_error;
                                 }
-                                Err(err2) => match err2.get_errno() {
-                                    sys::E::ENOENT | sys::E::EPERM | sys::E::ENOTDIR => {
-                                        pretty_errorln!(
-                                            "<r><red>error<r>: Failed to run \"<b>{}<r>\" due to error:\n{}",
-                                            bstr::BStr::new(Self::basename_or_bun(executable)),
-                                            err2,
-                                        );
-                                        break 'print_error;
-                                    }
-                                    _ => {}
-                                },
                             }
+                            Err(err2) => match err2.get_errno() {
+                                sys::E::ENOENT | sys::E::EPERM | sys::E::ENOTDIR => {
+                                    pretty_errorln!(
+                                        "<r><red>error<r>: Failed to run \"<b>{}<r>\" due to error:\n{}",
+                                        bstr::BStr::new(Self::basename_or_bun(executable)),
+                                        err2,
+                                    );
+                                    break 'print_error;
+                                }
+                                _ => {}
+                            },
                         }
-
-                        pretty_errorln!(
-                            "<r><red>error<r>: Failed to run \"<b>{}<r>\" due to <r><red>{}<r>",
-                            bstr::BStr::new(Self::basename_or_bun(executable)),
-                            bstr::BStr::new(err.name()),
-                        );
                     }
+
+                    pretty_errorln!(
+                        "<r><red>error<r>: Failed to run \"<b>{}<r>\" due to <r><red>{}<r>",
+                        bstr::BStr::new(Self::basename_or_bun(executable)),
+                        bstr::BStr::new(err.name()),
+                    );
                 }
                 Global::exit(1);
             }
@@ -2284,13 +2282,13 @@ impl RunCommand {
         match spawn_result {
             Err(err) => {
                 // an error occurred while spawning the process
-                Self::run_binary_generic_error(executable, silent, &err);
+                Self::run_binary_generic_error(executable, &err);
             }
             Ok(result) => {
                 match result.status {
                     // An error occurred after the process was spawned.
                     SpawnStatus::Err(err) => {
-                        Self::run_binary_generic_error(executable, silent, &err);
+                        Self::run_binary_generic_error(executable, &err);
                     }
 
                     SpawnStatus::Signaled(raw_signal) => {
@@ -2402,6 +2400,26 @@ impl RunCommand {
         }
     }
 
+    /// Whether the nearest package.json, in `dir` or above it, has a syntax error. `enclosing_package_json` skips such a file.
+    #[cold]
+    #[inline(never)]
+    fn nearest_package_json_is_broken(log: &bun_ast::Log, dir: bun_resolver::DirInfoRef) -> bool {
+        let loaded = dir.enclosing_package_json;
+        let loaded_path_len = loaded.map_or(0, |it| it.source.path.text.len());
+        // The resolver has read `dir` and its parents only, so a longer path is that of a nearer file.
+        log.msgs.iter().any(|msg| {
+            let Some(at) = &msg.data.location else {
+                return false;
+            };
+            msg.kind == bun_ast::Kind::Err
+                && at.file.len() > loaded_path_len
+                && paths::basename(&at.file) == b"package.json"
+                // A file of nothing but whitespace counts as no file.
+                && sys::File::read_from(Fd::cwd(), &at.file)
+                    .is_ok_and(|text| !strings::trim(&text, b" \t\r\n").is_empty())
+        })
+    }
+
     /// Dispatch `bun run <target>`: classify as file path vs. package.json
     pub(crate) fn exec_with_cfg(ctx: &mut ContextData, cfg: ExecCfg) -> crate::Result<bool> {
         let bin_dirs_only = cfg.bin_dirs_only;
@@ -2514,11 +2532,17 @@ impl RunCommand {
 
         // ── stdin (`bun run -`) ─────────────────────────────────────────────
         if target_name.len() == 1 && target_name[0] == b'-' {
-            return Self::exec_stdin(ctx);
+            return Self::exec_stdin(ctx, bun_sys::File::stdin(), b"-");
         }
 
         // ── package.json script lookup ──────────────────────────────────────
-        if !skip_script_check {
+        // SAFETY: `ctx.log` set in `create_context_data` (single-threaded
+        // CLI startup), process-lifetime.
+        let log = unsafe { ctx.log() };
+        let package_json_is_broken = !skip_script_check
+            && log.has_errors()
+            && Self::nearest_package_json_is_broken(log, root_dir);
+        if !skip_script_check && !package_json_is_broken {
             if let Some(package_json) = root_dir.enclosing_package_json {
                 if let Some(scripts) = package_json.scripts.as_deref() {
                     if let Some(&script_content) = scripts.get(target_name) {
@@ -2636,10 +2660,7 @@ impl RunCommand {
         let resolution: ::core::result::Result<bun_resolver::Result, bun_resolver::Error> = {
             let saved_preserve = this_transpiler.resolver.opts.preserve_symlinks;
             this_transpiler.resolver.opts.preserve_symlinks =
-                ctx.runtime_options.preserve_symlinks_main
-                    || bun_core::env_var::NODE_PRESERVE_SYMLINKS_MAIN
-                        .get()
-                        .unwrap_or(false);
+                ctx.runtime_options.preserve_symlinks_main_enabled();
             // SAFETY: `Transpiler::init` always sets `fs`; resolver-cache lifetime.
             let top_level_dir = unsafe { (*this_transpiler.fs).top_level_dir };
             let resolved = match this_transpiler.resolver.resolve(
@@ -2754,7 +2775,7 @@ impl RunCommand {
             let top_level_dir = fs.top_level_dir;
             let path = env_loader.get(b"PATH").unwrap_or(b"");
             let mut path_for_which = path;
-            if bin_dirs_only {
+            if bin_dirs_only || ctx.runtime_options.if_present {
                 if original_path.len() < path.len() {
                     path_for_which = &path[..path.len() - (original_path.len() + 1)];
                 } else {
@@ -2790,7 +2811,7 @@ impl RunCommand {
         }
 
         // ── failure ─────────────────────────────────────────────────────────
-        if ctx.runtime_options.if_present {
+        if ctx.runtime_options.if_present && !package_json_is_broken {
             return Ok(true);
         }
 
@@ -2854,7 +2875,7 @@ impl RunCommand {
             return Ok(true);
         }
 
-        if log_errors {
+        if log_errors || package_json_is_broken {
             // The resolver records a package.json that fails to load (a
             // syntax error, an unreadable file) in `ctx.log` and returns a
             // `DirInfo` without it.
@@ -2999,17 +3020,21 @@ impl RunCommand {
 
         // fstat: directories cannot be run. if only there was a faster way to
         // check this
-        let is_dir = match bun_sys::fstat(fd) {
-            Ok(st) => bun_sys::S::ISDIR(st.st_mode as _),
+        let mode = match bun_sys::fstat(fd) {
+            Ok(st) => st.st_mode as bun_sys::Mode,
             Err(_) => {
                 let _ = bun_sys::close(fd);
                 return false;
             }
         };
-        if is_dir {
+        if bun_sys::S::ISDIR(mode) {
             let _ = bun_sys::close(fd);
             return false;
         }
+        // A pipe (`bun <(echo ...)`, `bun /dev/stdin`) has no path to read it from a second time.
+        if bun_sys::S::ISFIFO(mode) {
+            return Self::exec_stdin(ctx, bun_sys::File::from_fd(fd), target).unwrap_or(false);
+        }
 
         Global::configure_allocator(core::Global::AllocatorConfiguration {
             long_running: true,
@@ -3017,26 +3042,39 @@ impl RunCommand {
         });
 
         // Re-derive the canonical absolute path from the open fd (resolves
-        // symlinks).
-        let absolute_script_path: Box<[u8]> = {
-            let resolved = match bun_sys::get_fd_path(fd, &mut script_name_buf) {
-                Ok(p) => p,
-                Err(_) => {
-                    let _ = bun_sys::close(fd);
-                    return false;
+        // symlinks). `--preserve-symlinks-main` keeps the path as given.
+        let absolute_script_path: Option<Box<[u8]>> =
+            if ctx.runtime_options.preserve_symlinks_main_enabled() {
+                let mut cwd_buf = bun_paths::path_buffer_pool::get();
+                let mut joined_buf = bun_paths::path_buffer_pool::get();
+                match bun_core::getcwd(&mut cwd_buf) {
+                    Ok(cwd) => {
+                        paths::resolve_path::join_abs_string_buf_checked::<paths::platform::Auto>(
+                            cwd.as_bytes(),
+                            &mut joined_buf.0,
+                            &[&script_name_buf[..open_len]],
+                        )
+                        .map(Box::from)
+                    }
+                    Err(_) => None,
                 }
+            } else {
+                bun_sys::get_fd_path(fd, &mut script_name_buf)
+                    .ok()
+                    .map(|resolved| Box::from(&*resolved))
             };
-            resolved.to_vec().into_boxed_slice()
-        };
         let _ = bun_sys::close(fd);
+        let Some(absolute_script_path) = absolute_script_path else {
+            return false;
+        };
 
         Self::boot_and_handle_error(ctx, &absolute_script_path, None)
     }
 
-    /// `bun run -` / `node -` — read script from stdin into
+    /// `bun run -` / `node -` / `bun <(echo ...)` — read script from `pipe` into
     /// `ctx.runtime_options.eval` and boot the VM with the synthetic `[stdin]`
-    /// path. `false` means stdin could not be read; the caller exits 1.
-    fn exec_stdin(ctx: &mut ContextData) -> crate::Result<bool> {
+    /// path. `name` is the entry point as typed. `false` means `pipe` could not be read.
+    fn exec_stdin(ctx: &mut ContextData, pipe: bun_sys::File, name: &[u8]) -> crate::Result<bool> {
         bun_core::scoped_log!(RUN_LOG, "Executing from stdin");
 
         // read from stdin
@@ -3045,9 +3083,10 @@ impl RunCommand {
         // `read_to_end_into` is the cursor-relative streaming reader
         // (stdin is a pipe/tty, not seekable; `read_to_end` would `pread(0)`).
         let mut list: Vec<u8> = Vec::new();
-        if bun_sys::File::stdin().read_to_end_into(&mut list).is_err() {
+        if pipe.read_to_end_into(&mut list).is_err() {
             return Ok(false);
         }
+        drop(pipe);
         ctx.runtime_options.eval.script = list.into_boxed_slice();
 
         #[cfg(windows)]
@@ -3064,10 +3103,10 @@ impl RunCommand {
         entry_point_buf[cwd_len..cwd_len + STDIN_TRIGGER.len()].copy_from_slice(STDIN_TRIGGER);
         let entry_path = &entry_point_buf[..cwd_len + STDIN_TRIGGER.len()];
 
-        // Prepend "-" to `ctx.passthrough` so `process.argv[1]` matches
+        // Prepend `name` to `ctx.passthrough` so `process.argv[1]` matches
         // Node's `node -` semantics.
         let mut passthrough_list: Vec<Box<[u8]>> = Vec::with_capacity(ctx.passthrough.len() + 1);
-        passthrough_list.push(b"-".to_vec().into_boxed_slice());
+        passthrough_list.push(name.to_vec().into_boxed_slice());
         passthrough_list.append(&mut ctx.passthrough);
         ctx.passthrough = passthrough_list;
 
@@ -3078,7 +3117,7 @@ impl RunCommand {
         // (= "[stdin]"), in the error message.
         let owned: Box<[u8]> = entry_path.to_vec().into_boxed_slice();
         if let Err(err) = Self::boot(ctx, owned, None) {
-            Self::boot_failed_exit(ctx, b"-", &err);
+            Self::boot_failed_exit(ctx, paths::basename(name), &err);
         }
         Ok(true)
     }
@@ -3139,7 +3178,7 @@ impl RunCommand {
         // Node.js does not auto-load `.env` files; match that here so tools with
         // their own `.env.{mode}` resolution (Vite etc.) don't see pre-populated
         // values. Explicit `--env-file` is still honored. #6338
-        ctx.args.disable_default_env_files = true;
+        ctx.args.skip_default_env_files = true;
 
         // `node --interactive [-e code]`: same gate as AutoCommand — a script
         // positional wins, and `-p` currently bypasses the REPL (see mod.rs).
@@ -3180,7 +3219,7 @@ impl RunCommand {
         // this positional, so everything after the `-` is already in
         // `ctx.passthrough`; `exec_stdin` puts the `-` itself back in front.
         if ctx.positionals[0].as_ref() == b"-" {
-            if Self::exec_stdin(ctx)? {
+            if Self::exec_stdin(ctx, bun_sys::File::stdin(), b"-")? {
                 return Ok(());
             }
             Global::exit(1);
@@ -4239,6 +4278,41 @@ impl BunXFastPath {
         bun_core::scoped_log!(BUNX_FAST_PATH_LOG, "did not start via shim");
     }
 
+    /// A child started from `bunx.exe`, with the flags of `bunx` as its `process.execArgv`, would run `bunx` again.
+    fn run_as_bun_exe(script_path: &[u8], passthrough: &[Box<[u8]>]) {
+        let Ok(self_exe) = core::self_exe_path() else {
+            return;
+        };
+        let self_exe = self_exe.as_bytes();
+        if !paths::basename(self_exe).eq_ignore_ascii_case(b"bunx.exe") {
+            return;
+        }
+        let bun_exe: Vec<u8> = [
+            &self_exe[..self_exe.len() - b"x.exe".len()],
+            b".exe".as_slice(),
+        ]
+        .concat();
+        if !sys::exists(&bun_exe) {
+            return;
+        }
+        let bun_exe = crate::node::process::EXEC_PATH_OVERRIDE
+            .get_or_init(|| core::ZBox::from_vec(bun_exe))
+            .as_zstr();
+
+        let to_zstr = <&'static ZStr as core::OptionsEnvArg>::from_slice;
+        let mut argv: Vec<&'static ZStr> = vec![bun_exe];
+        // What `BUN_OPTIONS` added comes first, and stays in `process.execArgv`.
+        argv.extend_from_slice(
+            (core::argv().as_slice())
+                .get(1..1 + core::bun_options_argc())
+                .unwrap_or_default(),
+        );
+        argv.push(to_zstr(script_path));
+        argv.extend(passthrough.iter().map(|arg| to_zstr(arg)));
+        // SAFETY: the CLI is single-threaded until the VM boots, so nothing reads `argv()` meanwhile.
+        unsafe { core::set_argv(core::intern_argv(argv)) };
+    }
+
     fn direct_launch_callback(wpath: &mut [u16], ctx: bun_options_types::context::Context<'_>) {
         // SAFETY: process-lifetime static, single-threaded CLI dispatch.
         // `try_launch` (still on the call stack) holds live `&mut [u16]`
@@ -4255,6 +4329,7 @@ impl BunXFastPath {
             ::core::slice::from_raw_parts_mut(raw.cast::<u8>(), bun_paths::PATH_MAX_WIDE * 2)
         };
         let utf8 = strings::convert_utf16_to_utf8_in_buffer(out_buf, wpath);
+        Self::run_as_bun_exe(utf8, &ctx.passthrough);
         if let Err(err) = RunCommand::boot(ctx, utf8.to_vec().into_boxed_slice(), None) {
             // SAFETY: `ctx.log` was set in `create_context_data`.
             let _ = unsafe { &mut *ctx.log }.print(std::ptr::from_mut(Output::error_writer()));
diff --git a/src/runtime/cli/test/Scanner.rs b/src/runtime/cli/test/Scanner.rs
index 3793b64510b0..a7de3250f1a6 100644
--- a/src/runtime/cli/test/Scanner.rs
+++ b/src/runtime/cli/test/Scanner.rs
@@ -24,6 +24,8 @@ pub(crate) struct Scanner<'a> {
     /// Glob patterns for paths to ignore. Matched against the path relative to the
     /// project root (top_level_dir). When a file matches any pattern, it is excluded.
     pub(crate) path_ignore_patterns: &'a [bun_glob::Prepared<&'a [u8]>],
+    /// `[test] filePatterns`, matched like `path_ignore_patterns`. Unless empty, replaces `TEST_NAME_SUFFIXES`.
+    pub(crate) file_patterns: &'a [bun_glob::Prepared<&'a [u8]>],
     pub(crate) dirs_to_scan: Fifo,
     /// Paths to test files found while scanning.
     pub(crate) test_files: Vec<Interned>,
@@ -81,6 +83,7 @@ impl<'a> Scanner<'a> {
             exclusion_names: &[],
             filter_names: &[],
             path_ignore_patterns: &[],
+            file_patterns: &[],
             dirs_to_scan: Fifo::new(),
             options: &transpiler.options,
             fs: transpiler.fs,
@@ -241,7 +244,8 @@ impl<'a> Scanner<'a> {
         if extname.is_empty() || !self.options.loader(extname).is_javascript_like() {
             return false;
         }
-        if !NEEDS_TEST_SUFFIX {
+        // `next` matches `file_patterns` once it has the path.
+        if !NEEDS_TEST_SUFFIX || !self.file_patterns.is_empty() {
             return true;
         }
         let name_without_extension = &name[..name.len() - extname.len()];
@@ -401,6 +405,14 @@ impl<'a> Scanner<'a> {
                 };
                 let path = &self.open_dir_buf[..path_len];
 
+                if !self.file_patterns.is_empty() {
+                    let rel_path = bun_paths::resolve_path::relative(self.top_level_dir(), path);
+                    let results = self.file_patterns.iter().map(|it| it.r#match(rel_path));
+                    if !bun_glob::any_matches(results) {
+                        return;
+                    }
+                }
+
                 if !self.does_absolute_path_match_filter(path) {
                     let rel_path = bun_paths::resolve_path::relative(self.top_level_dir(), path);
                     if !self.does_path_match_filter(rel_path) {
diff --git a/src/runtime/cli/test/parallel/Coordinator.rs b/src/runtime/cli/test/parallel/Coordinator.rs
index 93348a1feadc..3417687c04cd 100644
--- a/src/runtime/cli/test/parallel/Coordinator.rs
+++ b/src/runtime/cli/test/parallel/Coordinator.rs
@@ -540,6 +540,9 @@ impl<'a> Coordinator<'a> {
                     bun_core::handle_oom(merged.value_ptr.add(&report));
                 }
             }
+            frame::Kind::SnapshotWriteFailed => {
+                self.reporter.worker_snapshot_write_failed = true;
+            }
             frame::Kind::Run | frame::Kind::Shutdown => {}
         }
     }
@@ -1035,11 +1038,11 @@ fn describe_status<'b>(buf: &'b mut [u8; 32], status: &SpawnStatus) -> &'b [u8]
     }
 }
 
-/// Coordinator-side SIGINT/SIGTERM handling. The handler records the signal
-/// and wakes the loop; `Coordinator::drive` checks it and tears down workers
-/// itself so we don't do non-signal-safe work in the handler. Linux PDEATHSIG
-/// and the Windows Job Object are the safety net for when the coordinator
-/// can't run this (SIGKILL).
+/// Coordinator-side SIGINT/SIGTERM handling. The signal handler only sets a
+/// flag and wakes the loop; `Coordinator::drive` checks it and tears down workers itself so we
+/// don't do non-signal-safe work in the handler. Linux PDEATHSIG and the
+/// Windows Job Object are the safety net for when the coordinator can't run
+/// this (SIGKILL).
 pub(crate) mod abort_handler {
     use super::*;
 
@@ -1049,9 +1052,7 @@ pub(crate) mod abort_handler {
     /// The loop `Coordinator::drive` ticks. Set by `install`, cleared by `uninstall`.
     static LOOP: AtomicPtr<bun_uws::Loop> = AtomicPtr::new(core::ptr::null_mut());
 
-    /// Signal context on POSIX; the console control thread on Windows. The
-    /// poll retries on EINTR, so without the wakeup `drive` reads the flag
-    /// only when something else ends the poll.
+    /// In signal context (Windows: the console control thread). The poll retries on EINTR: wake it.
     fn request_abort(signal: i32) {
         ABORT_SIGNAL.store(signal, Ordering::Release);
         let loop_ = LOOP.load(Ordering::Acquire);
diff --git a/src/runtime/cli/test/parallel/Frame.rs b/src/runtime/cli/test/parallel/Frame.rs
index 3fbfd72144c1..97b7c66ddf68 100644
--- a/src/runtime/cli/test/parallel/Frame.rs
+++ b/src/runtime/cli/test/parallel/Frame.rs
@@ -30,6 +30,8 @@ pub(crate) enum Kind {
     /// as `bun_sourcemap_jsc::code_coverage::wire`. The coordinator merges
     /// every worker's per file and writes the one report.
     CoverageFile,
+    /// (empty) — sent at exit: this worker could not write its snapshots, so the run fails
+    SnapshotWriteFailed,
 }
 
 impl TryFrom<u8> for Kind {
@@ -45,6 +47,7 @@ impl TryFrom<u8> for Kind {
             5 => Kind::Run,
             6 => Kind::Shutdown,
             7 => Kind::CoverageFile,
+            8 => Kind::SnapshotWriteFailed,
             _ => return Err(()),
         })
     }
diff --git a/src/runtime/cli/test/parallel/runner.rs b/src/runtime/cli/test/parallel/runner.rs
index a8bf832b7208..69dbe6aae56a 100644
--- a/src/runtime/cli/test/parallel/runner.rs
+++ b/src/runtime/cli/test/parallel/runner.rs
@@ -306,12 +306,9 @@ fn build_worker_argv(ctx: &Command::ContextData) -> crate::Result<Box<[bun_spawn
     // (see test_command.rs handle_test_completed), which the coordinator would
     // misread as a crash. Cross-worker bail is handled at file granularity by
     // the coordinator instead.
-    if opts.repeat_count > 0 {
-        argv.push(print_z(format_args!("--rerun-each={}", opts.repeat_count))?);
-    }
-    if opts.retry > 0 {
-        argv.push(print_z(format_args!("--retry={}", opts.retry))?);
-    }
+    // Also when 0: the worker reads bunfig.toml too, and only a flag wins over its key.
+    argv.push(print_z(format_args!("--rerun-each={}", opts.repeat_count))?);
+    argv.push(print_z(format_args!("--retry={}", opts.retry))?);
     argv.push(print_z(format_args!(
         "--max-concurrency={}",
         opts.max_concurrency
@@ -384,6 +381,10 @@ fn build_worker_argv(ctx: &Command::ContextData) -> crate::Result<Box<[bun_spawn
     if ctx.args.allow_ffi_cc == Some(false) {
         argv.push(lit(b"--no-ffi-cc\0"));
     }
+    // For what a test builds. The worker itself reads no env file.
+    if ctx.args.disable_default_env_files {
+        argv.push(lit(b"--no-env-file\0"));
+    }
     match bun_core::code_generation_from_strings() {
         bun_core::CodeGenerationFromStrings::Allowed => {}
         bun_core::CodeGenerationFromStrings::DisallowedLikeNode => {
@@ -710,14 +711,24 @@ fn worker_flush_aggregates(
 ) {
     // Snapshots flush lazily when the next file opens its snapshot file; the
     // last file each worker ran has no successor to trigger that.
+    let mut snapshots_written = true;
     if let Some(runner) = crate::test_runner::jest::Jest::runner() {
-        let _ = runner.snapshots.write_inline_snapshots().unwrap_or(false);
-        let _ = runner.snapshots.write_snapshot_file();
+        snapshots_written = runner.snapshots.write_inline_snapshots().unwrap_or(false);
+        if runner.snapshots.write_snapshot_file().is_err() {
+            bun_core::err_generic!("Failed to write snapshot file");
+            snapshots_written = false;
+        }
     }
 
     // SAFETY: single-threaded worker; WORKER_FRAME is a process-global scratch buffer
     let wf = unsafe { &mut *WORKER_FRAME.get() };
 
+    // The coordinator ignores the exit status of a worker that is between files.
+    if !snapshots_written {
+        wf.begin(frame::Kind::SnapshotWriteFailed);
+        cmds.send(wf.finish());
+    }
+
     wf.begin(frame::Kind::RepeatBufs);
     wf.str(reporter.failures_to_repeat_buf.as_slice());
     wf.str(reporter.skips_to_repeat_buf.as_slice());
diff --git a/src/runtime/cli/test_command.rs b/src/runtime/cli/test_command.rs
index 17bbca36c5d1..94eb19cce778 100644
--- a/src/runtime/cli/test_command.rs
+++ b/src/runtime/cli/test_command.rs
@@ -962,6 +962,8 @@ pub(crate) struct CommandLineReporter {
     /// is sent over the IPC pipe instead of to stderr; the coordinator owns
     /// the terminal.
     pub(crate) worker_ipc_file_idx: Option<u32>,
+    /// Set in the `--parallel` coordinator when a worker could not write its snapshots.
+    pub(crate) worker_snapshot_write_failed: bool,
     /// Errors thrown by the test now running, captured while a reporter
     /// that attaches them to the test case (JUnit) is on. Taken by
     /// `handle_test_completed`.
@@ -1729,6 +1731,16 @@ extern "C" fn BunTest__shouldGenerateCodeCoverage(test_name_str: &bun_core::Stri
                     return false;
                 }
             }
+            let file_patterns = &runner.test_options.file_patterns;
+            if !file_patterns.is_empty() {
+                let rel_path = resolve_path::relative(FileSystem::instance().top_level_dir, slice);
+                let results = file_patterns
+                    .iter()
+                    .map(|it| bun_glob::r#match(it, rel_path));
+                if bun_glob::any_matches(results) {
+                    return false;
+                }
+            }
         }
     }
 
@@ -1835,6 +1847,13 @@ impl TestCommand {
             .iter()
             .map(|b| bun_glob::Prepared::new(unsafe { bun_ptr::detach_lifetime::<u8>(b) }))
             .collect();
+        // SAFETY: as for `path_ignore_patterns_view`.
+        let file_patterns_view: Vec<bun_glob::Prepared<&'static [u8]>> = ctx
+            .test_options
+            .file_patterns
+            .iter()
+            .map(|b| bun_glob::Prepared::new(unsafe { bun_ptr::detach_lifetime::<u8>(b) }))
+            .collect();
 
         // Keep an owned `Box` local — `exec()` never returns before process
         // exit, so the heap allocation outlives all raw-pointer observers
@@ -1881,6 +1900,7 @@ impl TestCommand {
             repeat_count: 1,
             last_printed_dot: core::cell::Cell::new(false),
             worker_ipc_file_idx: None,
+            worker_snapshot_write_failed: false,
             test_failure: None,
             failures_to_repeat_buf: Vec::new(),
             skips_to_repeat_buf: Vec::new(),
@@ -1918,7 +1938,7 @@ impl TestCommand {
         // The worker's environment already holds the coordinator's env file values, and `BUN_OPTIONS` in it can carry `--env-file`.
         if ctx.test_options.test_worker {
             ctx.args.env_files.clear();
-            ctx.args.disable_default_env_files = true;
+            ctx.args.skip_default_env_files = true;
         }
 
         bun_ast::initialize_store();
@@ -2024,6 +2044,8 @@ impl TestCommand {
         // frame, underlying bytes live in `ctx` (process-lifetime).
         scanner.path_ignore_patterns =
             unsafe { bun_ptr::detach_lifetime(&path_ignore_patterns_view[..]) };
+        // SAFETY: as for `path_ignore_patterns`.
+        scanner.file_patterns = unsafe { bun_ptr::detach_lifetime(&file_patterns_view[..]) };
         let has_relative_path = 'hr: {
             for arg in &ctx.positionals {
                 if bun_paths::is_absolute(arg)
@@ -2687,12 +2709,22 @@ impl TestCommand {
 
         let should_fail_on_no_tests = !ctx.test_options.pass_with_no_tests
             && (failed_to_find_any_tests || summary.did_label_filter_out_all_tests());
+        let is_coverage_too_low = coverage_options.enabled
+            && coverage_options.fractions.failing
+            && coverage_options.fail_on_low_coverage;
+        if is_coverage_too_low {
+            pretty_errorln!(
+                "<r><red>error<r><d>:<r> coverage below <b>coverageThreshold<r> (functions {:.2}%, lines {:.2}%)",
+                coverage_options.fractions.functions * 100.0,
+                coverage_options.fractions.lines * 100.0
+            );
+            Output::flush();
+        }
         if should_fail_on_no_tests
             || summary.fail > 0
-            || (coverage_options.enabled
-                && coverage_options.fractions.failing
-                && coverage_options.fail_on_low_coverage)
+            || is_coverage_too_low
             || !write_snapshots_success
+            || reporter.worker_snapshot_write_failed
             || reporter.jest.unhandled_errors_between_tests > 0
         {
             vm.exit_handler.exit_code = 1;
diff --git a/src/runtime/cli/upgrade_command.rs b/src/runtime/cli/upgrade_command.rs
index 2cba3f5e5983..9d70a7221e53 100644
--- a/src/runtime/cli/upgrade_command.rs
+++ b/src/runtime/cli/upgrade_command.rs
@@ -507,19 +507,17 @@ impl UpgradeCommand {
 
     #[cold]
     pub(crate) fn exec(ctx: Command::Context) -> crate::Result<()> {
-        let args = bun_core::argv();
-        if args.len() > 2 {
-            for arg in args.iter().skip(2) {
-                if !strings::contains(arg, b"--") {
-                    bun_core::pretty_error!(
-                        "<r><red>error<r><d>:<r> This command updates Bun itself, and does not take package names.\n<blue>note<r><d>:<r> Use `bun update"
-                    );
-                    for arg_err in args.iter().skip(2) {
-                        bun_core::pretty_error!(" {}", bstr::BStr::new(arg_err));
-                    }
-                    bun_core::pretty_errorln!("` instead.");
-                    Global::exit(1);
+        let args = Command::after_command(bun_core::argv().as_slice(), b"upgrade");
+        for arg in args {
+            if !strings::contains(arg.as_bytes(), b"--") {
+                bun_core::pretty_error!(
+                    "<r><red>error<r><d>:<r> This command updates Bun itself, and does not take package names.\n<blue>note<r><d>:<r> Use `bun update"
+                );
+                for arg_err in args {
+                    bun_core::pretty_error!(" {}", bstr::BStr::new(arg_err.as_bytes()));
                 }
+                bun_core::pretty_errorln!("` instead.");
+                Global::exit(1);
             }
         }
 
diff --git a/src/runtime/node/node_process.rs b/src/runtime/node/node_process.rs
index 492ac7536ef3..184aeaef5c54 100644
--- a/src/runtime/node/node_process.rs
+++ b/src/runtime/node/node_process.rs
@@ -28,9 +28,21 @@ extern "C" fn create_argv0(global_object: &JSGlobalObject) -> JSValue {
     EncodedSlice::from_bytes(argv0).to_js(global_object)
 }
 
+/// `bun.exe`, set when `bunx.exe` runs a bin in its own process. See `BunXFastPath::run_as_bun_exe`.
+pub(crate) static EXEC_PATH_OVERRIDE: std::sync::OnceLock<bun_core::ZBox> =
+    std::sync::OnceLock::new();
+
+/// `process.execPath` and `process.argv[0]`.
+fn exec_path() -> Option<&'static bun_core::ZStr> {
+    match EXEC_PATH_OVERRIDE.get() {
+        Some(path) => Some(path.as_zstr()),
+        None => bun_core::self_exe_path().ok(),
+    }
+}
+
 #[unsafe(export_name = "Bun__Process__getExecPath")]
 extern "C" fn get_exec_path(global_object: &JSGlobalObject) -> JSValue {
-    let Ok(out) = bun_core::self_exe_path() else {
+    let Some(out) = exec_path() else {
         // if for any reason we are unable to get the executable path, we just return argv[0]
         return create_argv0(global_object);
     };
@@ -381,8 +393,7 @@ mod _impl {
             // Even if they didn't type "bun", we still want to add it as argv[0]
             args_list.push(BunString::static_("bun"));
         } else {
-            let exe_path = bun_core::self_exe_path().ok();
-            args_list.push(match exe_path {
+            args_list.push(match super::exec_path() {
                 Some(str_) => BunString::borrow_utf8(str_.as_bytes()),
                 None => BunString::static_("bun"),
             });
diff --git a/src/spawn/Cargo.toml b/src/spawn/Cargo.toml
index 588f1e18d15f..70aab9035a48 100644
--- a/src/spawn/Cargo.toml
+++ b/src/spawn/Cargo.toml
@@ -19,7 +19,6 @@ scopeguard.workspace = true
 bun_analytics.workspace = true
 bun_dispatch.workspace = true
 bun_core.workspace = true
-bun_crash_handler.workspace = true
 bun_event_loop.workspace = true
 bun_io.workspace = true
 bun_output.workspace = true
diff --git a/src/spawn/lib.rs b/src/spawn/lib.rs
index 70eda17189d9..e5b5f91bc762 100644
--- a/src/spawn/lib.rs
+++ b/src/spawn/lib.rs
@@ -9,7 +9,7 @@
 //! `bun_runtime` re-exports them. The only non-leaf dependencies are
 //! `bun_io` (`FilePoll`/`KeepAlive`/`EventLoopCtx`), `bun_ptr`
 //! (`ThreadSafeRefCount`), `bun_io` (`BufferedWriter`), `bun_event_loop`,
-//! `bun_threading`, and `bun_crash_handler` — none of which depend back on
+//! and `bun_threading` — none of which depend back on
 //! this crate, so no cycle.
 
 // ──────────────────────────────────────────────────────────────────────────
diff --git a/src/spawn/process.rs b/src/spawn/process.rs
index eab686175988..d43f5e812e11 100644
--- a/src/spawn/process.rs
+++ b/src/spawn/process.rs
@@ -3032,8 +3032,7 @@ mod spawn_process_body {
         };
 
         /// RAII guard around `Bun__registerSignalsForForwarding`: registers on
-        /// construction, unregisters and restores the crash-handler signal
-        /// disposition on drop.
+        /// construction, unregisters on drop.
         #[cfg(unix)]
         struct SignalForwarding;
         #[cfg(unix)]
@@ -3048,7 +3047,6 @@ mod spawn_process_body {
         impl Drop for SignalForwarding {
             fn drop(&mut self) {
                 Bun__unregisterSignalsForForwarding();
-                bun_crash_handler::reset_on_posix();
             }
         }
 
diff --git a/src/spawn_sys/spawn_process.rs b/src/spawn_sys/spawn_process.rs
index d1cc73ec0371..516b4e0c7542 100644
--- a/src/spawn_sys/spawn_process.rs
+++ b/src/spawn_sys/spawn_process.rs
@@ -630,6 +630,7 @@ pub unsafe fn spawn_process_posix(
     envp: Envp,
 ) -> crate::Result<bun_sys::Result<PosixSpawnResult>> {
     bun_analytics::features::spawn.fetch_add(1, Ordering::Relaxed);
+    bun_core::util::keep_children_waitable();
     let mut actions = PosixSpawnActions::init()?;
 
     let mut attr = PosixSpawnAttr::init()?;
diff --git a/src/sys/lib.rs b/src/sys/lib.rs
index 17f6b6f321d6..71da64bc2a6f 100644
--- a/src/sys/lib.rs
+++ b/src/sys/lib.rs
@@ -9028,6 +9028,21 @@ pub fn exists(path: &[u8]) -> bool {
     let z = ZStr::from_buf(&buf.0[..], path.len());
     exists_z(z)
 }
+
+/// Returns true if `dir` is sticky and group- or world-writable, like `/tmp`: any local user can create a file there.
+#[cfg(unix)]
+pub fn is_shared_directory(dir: &[u8]) -> bool {
+    !stat(&bun_core::ZBox::from_bytes(dir)).is_ok_and(|st| {
+        let mode = st.st_mode as Mode;
+        mode & S::ISVTX == 0 || mode & (S::IWGRP | S::IWOTH) == 0
+    })
+}
+
+#[cfg(not(unix))]
+pub fn is_shared_directory(_: &[u8]) -> bool {
+    false
+}
+
 /// `moveFileZ`. Routes through
 /// [`renameat_concurrently_without_fallback`] (renameat2 NOREPLACE → EXCHANGE →
 /// delete-tree + rename); on EISDIR removes the dest dir and
diff --git a/test/bundler/bun-build-api.test.ts b/test/bundler/bun-build-api.test.ts
index d4a227c6ec38..5ef67b4dfcd5 100644
--- a/test/bundler/bun-build-api.test.ts
+++ b/test/bundler/bun-build-api.test.ts
@@ -900,8 +900,8 @@ describe("Bun.build", () => {
   //   throw new Error("test was not fully written");
   // });
 
-  test.concurrent("loader map with an empty-string key is ignored without leaving uninitialized slots", async () => {
-    // `JSPropertyIterator` skips empty-name properties, but `loader_names` was being
+  test.concurrent("loader map with an empty-string key does not leave uninitialized slots", async () => {
+    // The empty name was skipped, but `loader_names` was being
     // indexed by the property position instead of a dense counter, leaving garbage in
     // the skipped slot that was later read/freed. Run in a subprocess so a crash in the
     // bundler thread surfaces as a test failure instead of taking down the test runner.
@@ -933,6 +933,20 @@ describe("Bun.build", () => {
     expect(exitCode).toBe(0);
   });
 
+  test.concurrent("the empty key of the loader map is for files with no extension", async () => {
+    using dir = tempDir("bun-build-loader-no-extension", {
+      "entry.ts": `import license from "./LICENSE";\nconsole.log(license);\n`,
+      "LICENSE": "not (valid) typescript: at all",
+    });
+    const outputs = async (loader: Record<string, "text">) => {
+      const build = await Bun.build({ entrypoints: [join(String(dir), "entry.ts")], loader });
+      return build.outputs.map(output => output.kind);
+    };
+    expect(await outputs({ "": "text" })).toEqual(["entry-point"]);
+    // Without it such a file is copied.
+    expect(await outputs({})).toEqual(["entry-point", "asset"]);
+  });
+
   test.concurrent("rebuilding busts the directory entries cache", async () => {
     Bun.gc(true);
     const tmpdir = tempDirWithFiles("rebuild-bust-dirent-cache", {
diff --git a/test/bundler/bundler_compile_autoload.test.ts b/test/bundler/bundler_compile_autoload.test.ts
index 6b4338c26985..536d8b2516d4 100644
--- a/test/bundler/bundler_compile_autoload.test.ts
+++ b/test/bundler/bundler_compile_autoload.test.ts
@@ -103,6 +103,35 @@ console.log("PRELOAD");
     },
   });
 
+  // The executable starts itself again in a subdirectory, where only the entry point prints.
+  itBundled("compile/AutoloadBunfigOnlyFromCwd", {
+    compile: true,
+    files: {
+      "/entry.ts": /* js */ `
+        if (process.argv[2] === "in-subdirectory") {
+          console.log("ENTRY");
+        } else {
+          const child = Bun.spawnSync({ cmd: [process.execPath, "in-subdirectory"], cwd: "subdirectory" });
+          console.log(child.stdout.toString().trim());
+        }
+      `,
+    },
+    runtimeFiles: {
+      "/package.json": `{}`,
+      "/bunfig.toml": `
+preload = ["./preload.ts"]
+      `,
+      "/preload.ts": `
+console.log("PRELOAD");
+      `,
+      "/subdirectory/empty.txt": ``,
+    },
+    run: {
+      stdout: "PRELOAD\nENTRY",
+      setCwd: true,
+    },
+  });
+
   // Test that bunfig.toml can be disabled with autoloadBunfig: false
   itBundled("compile/AutoloadBunfigDisabled", {
     compile: {
diff --git a/test/bundler/bundler_jsx.test.ts b/test/bundler/bundler_jsx.test.ts
index d1ed6f089a0b..744b00443f4c 100644
--- a/test/bundler/bundler_jsx.test.ts
+++ b/test/bundler/bundler_jsx.test.ts
@@ -1093,6 +1093,38 @@ describe("bundler", () => {
         `);
       },
     });
+
+    test.concurrent.each([
+      [{ jsx: "react-jsx" }, undefined],
+      [{ jsx: "react", jsxFactory: "h" }, undefined],
+      [{ jsx: "react-jsx" }, `logLevel = "error"`],
+    ])(
+      "--jsx-side-effects alone only drops the annotation: tsconfig %j, bunfig %j",
+      async (compilerOptions, bunfig) => {
+        using dir = tempDir("jsx-side-effects-alone", {
+          "a.jsx": "export const a = <div />;\n",
+          "tsconfig.json": JSON.stringify({ compilerOptions }),
+          ...(bunfig ? { "bunfig.toml": bunfig } : {}),
+        });
+        async function build(...flags: string[]) {
+          await using proc = Bun.spawn({
+            cmd: [bunExe(), "build", "a.jsx", ...flags],
+            env: bunEnv,
+            cwd: String(dir),
+            stdout: "pipe",
+            stderr: "inherit",
+          });
+          const [stdout, exitCode] = await Promise.all([proc.stdout.text(), proc.exited]);
+          expect(exitCode).toBe(0);
+          return stdout;
+        }
+        for (const mode of [["--no-bundle"], ["--external", "*"]]) {
+          const annotated = await build(...mode);
+          expect(annotated).toContain("/* @__PURE__ */ ");
+          expect(await build(...mode, "--jsx-side-effects")).toBe(annotated.replaceAll("/* @__PURE__ */ ", ""));
+        }
+      },
+    );
   });
 
   // https://github.com/oven-sh/bun/issues/6858
diff --git a/test/bundler/bundler_minify.test.ts b/test/bundler/bundler_minify.test.ts
index 5a335ed1060c..2e34fb9df788 100644
--- a/test/bundler/bundler_minify.test.ts
+++ b/test/bundler/bundler_minify.test.ts
@@ -1043,7 +1043,7 @@ describe("bundler", () => {
       api.expectFile("/out.js").not.toContain("import.meta.hot");
     },
   });
-  itBundled("minify/ProductionMode", {
+  const productionMode: BundlerTestInput = {
     files: {
       "/entry.jsx": `
         import {foo} from 'dev-trap';
@@ -1092,6 +1092,44 @@ describe("bundler", () => {
       // Check JSX uses production runtime
       expect(output).toContain("jsx-runtime");
     },
+  };
+  itBundled("minify/ProductionMode", productionMode);
+  for (const name of ["NODE_ENV", "BUN_ENV"]) {
+    itBundled(`minify/ProductionModeWinsOverExported_${name}`, {
+      ...productionMode,
+      env: { NODE_ENV: undefined, BUN_ENV: undefined, [name]: "development" },
+    });
+  }
+  itBundled("minify/ProductionModeReadsDotEnvProductionUnderExportedNodeEnv", {
+    files: {
+      "/entry.js": `capture(process.env.WHICH_FILE);`,
+      "/.env.production": `WHICH_FILE=production`,
+      "/.env.development": `WHICH_FILE=development`,
+    },
+    production: true,
+    dotenv: "inline",
+    env: { NODE_ENV: "development", BUN_ENV: undefined },
+    capture: ['"production"'],
+  });
+  itBundled("minify/ProductionModeDoesNotAddBunEnv", {
+    files: {
+      "/entry.js": `
+        import { mode } from "./macro.ts" with { type: "macro" };
+        capture(mode());
+      `,
+      "/macro.ts": "export function mode() { return `${Bun.env.NODE_ENV},${Bun.env.BUN_ENV}`; }",
+    },
+    production: true,
+    env: { NODE_ENV: undefined, BUN_ENV: undefined },
+    capture: ['"production,undefined"'],
+  });
+  itBundled("minify/ExportedNodeEnvIsKeptWithoutProductionMode", {
+    files: {
+      "/entry.js": `capture(process.env.NODE_ENV);`,
+    },
+    minifySyntax: true,
+    env: { NODE_ENV: "staging", BUN_ENV: undefined },
+    capture: ['"staging"'],
   });
   itBundled("minify/UnusedInCommaExpression", {
     files: {
diff --git a/test/bundler/cli.test.ts b/test/bundler/cli.test.ts
index f71392c41cd4..b29a42fc6ef0 100644
--- a/test/bundler/cli.test.ts
+++ b/test/bundler/cli.test.ts
@@ -906,6 +906,23 @@ describe("CLI argument error messages", () => {
     expect(exitCode).toBe(1);
   });
 
+  test.each([
+    [["--target=nodejs"], `error: Invalid value for --target: "nodejs". Must be 'browser', 'bun', or 'node'.`],
+    [["--target=browser", "--bytecode"], "error: target must be 'bun' when bytecode is true. Received: browser"],
+  ])("%j names the flag and the value", async (flags, expected) => {
+    using dir = tempDir("build-target-err", { "in.js": "console.log(1)" });
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "build", ...flags, "in.js"],
+      env: bunEnv,
+      cwd: String(dir),
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    expect({ stdout, stderr: normalizeBunSnapshot(stderr) }).toEqual({ stdout: "", stderr: expected });
+    expect(exitCode).toBe(1);
+  });
+
   test("--loader without a ':' separator names the flag and the bad token", async () => {
     using dir = tempDir("build-loader-err", { "in.js": "console.log(1)" });
     await using proc = Bun.spawn({
diff --git a/test/bundler/compile-argv.test.ts b/test/bundler/compile-argv.test.ts
index cc25ff384511..82e1b3ee3e20 100644
--- a/test/bundler/compile-argv.test.ts
+++ b/test/bundler/compile-argv.test.ts
@@ -487,6 +487,36 @@ describe("bundler", () => {
     },
   });
 
+  // Flags that the VM acts on. `inspector.open()` refuses when `--inspect` has started an inspector.
+  const vmFlags = ["--inspect=127.0.0.1:0", "--dns-result-order=ipv4first"];
+  for (const [name, compile, env] of [
+    ["CompileExecArgv", { execArgv: vmFlags }, {}],
+    ["BunOptionsEnv", true, { BUN_OPTIONS: vmFlags.join(" ") }],
+  ] as const) {
+    itBundled(`compile/${name}InspectAndDnsResultOrder`, {
+      compile,
+      backend: "cli",
+      files: {
+        "/entry.ts": /* js */ `
+          import { getDefaultResultOrder } from "node:dns";
+          import inspector from "node:inspector";
+          let inspect = "off";
+          try {
+            inspector.open(0);
+          } catch (error) {
+            inspect = error.code;
+          }
+          console.log(getDefaultResultOrder(), inspect);
+          process.exit();
+        `,
+      },
+      run: {
+        env,
+        stdout: "ipv4first ERR_INSPECTOR_ALREADY_ACTIVATED",
+      },
+    });
+  }
+
   // `bun -e` / `bun -p` start JSC in one-shot mode (no concurrent JIT, one GC
   // marker). That is decided by scanning argv, and a compiled executable's argv
   // belongs to the program, so `./app -p 8080` must keep the full configuration.
diff --git a/test/bundler/transpiler/jsx-tsconfig-react-jsx.test.ts b/test/bundler/transpiler/jsx-tsconfig-react-jsx.test.ts
index de66b32662fd..df473733b902 100644
--- a/test/bundler/transpiler/jsx-tsconfig-react-jsx.test.ts
+++ b/test/bundler/transpiler/jsx-tsconfig-react-jsx.test.ts
@@ -145,3 +145,24 @@ describe("removed solid jsx runtime", () => {
     expect(exitCode).toBe(1);
   });
 });
+
+test.concurrent.each(["react-jsxDEV", "react-jsxdev"])(
+  'bunfig.toml jsx = "%s" selects the development runtime',
+  async jsx => {
+    using dir = tempDir("jsx-bunfig-dev", {
+      "bunfig.toml": `jsx = "${jsx}"\n`,
+      "m.jsx": `export const a = <div />;\n`,
+    });
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "build", "--no-bundle", "m.jsx"],
+      env: bunEnv,
+      cwd: String(dir),
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    expect(stderr).toBe("");
+    expect(stdout).toContain(`from "react/jsx-dev-runtime"`);
+    expect(exitCode).toBe(0);
+  },
+);
diff --git a/test/cli/bun.test.ts b/test/cli/bun.test.ts
index eefd93179321..bc068c382765 100644
--- a/test/cli/bun.test.ts
+++ b/test/cli/bun.test.ts
@@ -436,6 +436,121 @@ describe("bun", () => {
         expect(fs.readFileSync(join(String(dir), ".zshrc"), "utf8")).toBe(added);
       });
     });
+
+    describe("<TAB>", () => {
+      // stdout is a pipe, so the script for $SHELL is printed and not installed.
+      async function script(shell: string) {
+        await using proc = Bun.spawn({
+          cmd: [bunExe(), "completions"],
+          env: { ...bunEnv, SHELL: `/bin/${shell}` },
+          stdout: "pipe",
+          stderr: "inherit",
+        });
+        const [stdout, exitCode] = await Promise.all([proc.stdout.text(), proc.exited]);
+        expect(exitCode).toBe(0);
+        return stdout;
+      }
+
+      const project = {
+        "package.json": "{}",
+        "myscript.ts": "",
+        "foo.txt": "",
+        "src/index.ts": "",
+        "src/other.ts": "",
+        "test/a.test.ts": "",
+        // bun.fish asks `bun getcompletes` for the scripts and bins. This project has none.
+        "bin/bun": "#!/bin/sh\n",
+      };
+
+      // What each line offers at its end, sorted.
+      async function offered(dir: string, lines: string[], cmd: (line: string) => string[]) {
+        const replies: Record<string, string[]> = {};
+        for (const line of lines) {
+          await using proc = Bun.spawn({
+            cmd: cmd(line),
+            cwd: dir,
+            env: { ...bunEnv, HOME: dir, PATH: `${join(dir, "bin")}:${bunEnv.PATH}` },
+            stdout: "pipe",
+            stderr: "pipe",
+          });
+          const [stdout, stderr] = await Promise.all([proc.stdout.text(), proc.stderr.text()]);
+          expect(stderr).toBe("");
+          // fish prints a description after a tab.
+          replies[line] = stdout
+            .split("\n")
+            .filter(Boolean)
+            .map(reply => reply.split("\t")[0])
+            .sort();
+        }
+        return replies;
+      }
+
+      // The script needs associative arrays. macOS has bash 3.2.
+      const bashVersion = Bun.which("bash")
+        ? Number(spawnSync({ cmd: ["bash", "-c", "echo ${BASH_VERSINFO[0]}"], env: bunEnv }).stdout.toString())
+        : 0;
+
+      test.concurrent.skipIf(bashVersion < 4)("bash offers files, also after a flag or a script", async () => {
+        using dir = tempDir("completions-bash", { ...project, "bun.bash": await script("bash") });
+        const expected = {
+          "bun sr": ["src/"],
+          "bun src/": ["src/index.ts", "src/other.ts"],
+          "bun run src/": ["src/index.ts", "src/other.ts"],
+          "bun --hot src/o": ["src/other.ts"],
+          "bun --hot run src/o": ["src/other.ts"],
+          "bun --cwd . run src/o": ["src/other.ts"],
+          "bun test te": ["test/"],
+          "bun myscript.ts fo": ["foo.txt"],
+          "bun --silent add --p": ["--peer", "--production"],
+          // As before.
+          "bun add --p": ["--peer", "--production"],
+          "bun r": ["remove", "repl", "run"],
+          "bun te": ["test"],
+        };
+        const replies = await offered(String(dir), Object.keys(expected), line => {
+          const words = line.split(" ");
+          return [
+            "bash",
+            "--norc",
+            "--noprofile",
+            "-c",
+            `source ./bun.bash; COMP_WORDS=(${words.join(" ")}); COMP_CWORD=${words.length - 1}; _bun_completions; printf '%s\\n' "\${COMPREPLY[@]}"`,
+          ];
+        });
+        expect(replies).toEqual(expected);
+      });
+
+      test.concurrent.skipIf(!Bun.which("fish"))("fish offers files, also after a flag or a script", async () => {
+        using dir = tempDir("completions-fish-tab", { ...project, "bun.fish": await script("fish") });
+        fs.chmodSync(join(String(dir), "bin", "bun"), 0o755);
+        const expected = {
+          "bun run src/": ["src/index.ts", "src/other.ts"],
+          "bun --hot src/o": ["src/other.ts"],
+          "bun --hot run src/o": ["src/other.ts"],
+          "bun test te": ["test/"],
+          "bun myscript.ts fo": ["foo.txt"],
+          // As before.
+          "bun src/": ["src/index.ts", "src/other.ts"],
+          "bun add src/": [],
+          "bun pm ca": ["cache"],
+        };
+        const replies = await offered(String(dir), Object.keys(expected), line => [
+          "fish",
+          "--no-config",
+          "-c",
+          `source ./bun.fish; complete -C '${line}'`,
+        ]);
+        expect(replies).toEqual(expected);
+      });
+
+      test.concurrent.skipIf(!Bun.which("zsh"))("zsh parses the script", async () => {
+        using dir = tempDir("completions-zsh-syntax", { "_bun": await script("zsh") });
+        await using proc = Bun.spawn({ cmd: ["zsh", "-n", "_bun"], cwd: String(dir), env: bunEnv, stderr: "pipe" });
+        const [stderr, exitCode] = await Promise.all([proc.stderr.text(), proc.exited]);
+        expect(stderr).toBe("");
+        expect(exitCode).toBe(0);
+      });
+    });
   });
   describe("--help preserves <placeholder> text", () => {
     const env = { ...bunEnv, NO_COLOR: "1" };
@@ -472,6 +587,7 @@ describe("bun", () => {
       ["audit", "-L, --latest", "Also apply fixes your declared ranges exclude, rewriting package.json"],
       ["update", "-p, --production", "Only update dependencies and optionalDependencies (alias: --prod)"],
       ["install", "-p, --production", "Don't install devDependencies"],
+      ["run", "-l, --loader", "json, toml, yaml, json5, xml, text, md, css, html, wasm, napi, sqlite, file"],
     ];
     test.concurrent.each(flags)("bun %s --help keeps placeholder in %s description", async (cmd, flag, expected) => {
       await using proc = Bun.spawn({ cmd: [bunExe(), cmd, "--help"], env, stderr: "pipe" });
@@ -570,6 +686,114 @@ describe("bun", () => {
     });
   });
 
+  describe.concurrent("a flag and its value before the command", () => {
+    const words = ["build", "test", "install", "ci", "pm", "x"];
+    const files = {
+      "package.json": JSON.stringify({ name: "root", workspaces: ["with", "without"] }),
+      // Nothing here may reach a registry.
+      "bunfig.toml": `[install]\nregistry = "http://127.0.0.1:1/"\n`,
+      ".env.x": "FOO=foo",
+      "pre.ts": `globalThis.PRE = "pre";`,
+      "index.ts": `console.log(process.env.FOO ?? "-", globalThis.PRE ?? "-", typeof X === "undefined" ? "-" : X);`,
+      "with/package.json": JSON.stringify({
+        name: "with",
+        scripts: Object.fromEntries(["dev", ...words].map(word => [word, `echo script-${word}`])),
+      }),
+      "without/package.json": JSON.stringify({ name: "without" }),
+      "without/a.test.ts": `import { test } from "bun:test"; test("in without", () => {});`,
+    };
+
+    async function run(args: string[], env: Record<string, string> = {}) {
+      using dir = tempDir("flag-value-command", files);
+      await using proc = Bun.spawn({
+        cmd: [bunExe(), ...args],
+        cwd: String(dir),
+        env: { ...bunEnv, ...env },
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+      const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+      const manifest = fs.readFileSync(join(String(dir), "package.json"), "utf8");
+      return { stdout: stdout.replaceAll("\r\n", "\n"), stderr, exitCode, manifest };
+    }
+
+    test.each([
+      [["--cwd", "with", "run", "dev"], {}, "script-dev\n"],
+      [["--env-file", ".env.x", "run", "index.ts"], {}, "foo - -\n"],
+      [["--preload", "./pre.ts", "run", "index.ts"], {}, "- pre -\n"],
+      [["-r", "./pre.ts", "run", "index.ts"], {}, "- pre -\n"],
+      [["--define", "X=1", "run", "index.ts"], {}, "- - 1\n"],
+      [["run", "index.ts"], { BUN_OPTIONS: "--preload ./pre.ts" }, "- pre -\n"],
+    ])("bun %j runs what follows `run`", async (args, env, expected) => {
+      const { stdout, exitCode } = await run(args, env);
+      expect(stdout).toBe(expected);
+      expect(exitCode).toBe(0);
+    });
+
+    test.each(words)("bun --cwd with %s runs the script of that name", async word => {
+      const { stdout, exitCode } = await run(["--cwd", "with", word]);
+      expect(stdout).toBe(`script-${word}\n`);
+      expect(exitCode).toBe(0);
+    });
+
+    test("bun --cwd without test runs the tests, as there is no such script", async () => {
+      const { stderr, exitCode } = await run(["--cwd", "without", "test"]);
+      expect(stderr).toContain("1 pass");
+      expect(exitCode).toBe(0);
+    });
+
+    test("bun --env-file .env.x exec runs the command", async () => {
+      const { stdout, exitCode } = await run(["--env-file", ".env.x", "exec", "echo $FOO"]);
+      expect(stdout).toBe("foo\n");
+      expect(exitCode).toBe(0);
+    });
+
+    test("bun install with a flag and its value in BUN_OPTIONS adds no package", async () => {
+      const { stdout, exitCode, manifest } = await run(["install"], { BUN_OPTIONS: "--preload ./pre.ts" });
+      expect(stdout).toContain("bun install");
+      expect(manifest).toBe(files["package.json"]);
+      expect(exitCode).toBe(0);
+    });
+
+    test.each([["--filter=with"], ["--workspaces"]])("bun %s test runs the tests", async flag => {
+      const { stdout, stderr, exitCode } = await run([flag, "test"]);
+      expect(stdout).not.toContain("script-test");
+      expect(stderr).toContain("1 pass");
+      expect(exitCode).toBe(0);
+    });
+
+    test("bun --filter with test runs the script", async () => {
+      const { stdout, exitCode } = await run(["--filter", "with", "test"]);
+      expect(stdout).toContain("script-test");
+      expect(exitCode).toBe(0);
+    });
+
+    test("bun -p install is bun install --production", async () => {
+      const { stdout, exitCode } = await run(["-p", "install"]);
+      expect(stdout).toContain("bun install");
+      expect(exitCode).toBe(0);
+    });
+  });
+
+  test.concurrent.each([
+    [["--main-fields=module,main", "m.ts"], "module\n"],
+    [["--extension-order=.js,.ts", "r.cjs"], "JS\n"],
+  ])("bun %j reads the value as a list", async (args, expected) => {
+    using dir = tempDir("flag-list-value", {
+      "node_modules/mf/package.json": JSON.stringify({ name: "mf", main: "./main.js", module: "./module.js" }),
+      "node_modules/mf/main.js": `export default "main";`,
+      "node_modules/mf/module.js": `export default "module";`,
+      "m.ts": `import x from "mf"; console.log(x);`,
+      "d.ts": `export default "TS";`,
+      "d.js": `export default "JS";`,
+      "r.cjs": `console.log(require("./d").default);`,
+    });
+    await using proc = Bun.spawn({ cmd: [bunExe(), ...args], cwd: String(dir), env: bunEnv, stderr: "inherit" });
+    const [stdout, exitCode] = await Promise.all([proc.stdout.text(), proc.exited]);
+    expect(stdout).toBe(expected);
+    expect(exitCode).toBe(0);
+  });
+
   describe("test command line arguments", () => {
     test("test --config, issue #4128", () => {
       const path = `${tmpdir()}/bunfig-${Date.now()}.toml`;
diff --git a/test/cli/bunfig-test-options.test.ts b/test/cli/bunfig-test-options.test.ts
index 63a87492c3ff..be4f793cd737 100644
--- a/test/cli/bunfig-test-options.test.ts
+++ b/test/cli/bunfig-test-options.test.ts
@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test";
-import { bunEnv, bunExe, tempDir } from "harness";
+import { bunEnv, bunExe, isLinux, tempDir } from "harness";
+import { readdirSync } from "node:fs";
 
 describe("bunfig.toml test options", () => {
   test("randomize with seed produces consistent order", async () => {
@@ -197,3 +198,212 @@ describe("bunfig.toml test options", () => {
     expect(output).toContain("4 pass");
   });
 });
+
+async function bunTest(cwd: string, ...args: string[]) {
+  await using proc = Bun.spawn({ cmd: [bunExe(), "test", ...args], cwd, env: bunEnv, stdout: "pipe", stderr: "pipe" });
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+  return { stdout, stderr: stderr.replaceAll("\\", "/"), exitCode };
+}
+
+/** Adds `name`: `bun test <args>` and the keys, on one line. */
+function named<Row extends { bunfig: string; args: string[] }>(rows: Row[]) {
+  return rows.map(row => ({
+    ...row,
+    name: ["bun test", ...row.args].join(" ") + " with " + (row.bunfig.replaceAll("\n", ", ") || "no key"),
+  }));
+}
+
+describe.concurrent("a flag of `bun test` wins over its [test] key", () => {
+  const files = {
+    "lib.ts": `export const used = () => 1;\nexport const unused = () => 2;\n`,
+    "a.test.ts": `import { used } from "./lib";\ntest("one", () => {\n  used();\n});\ntest("two", () => {});\n`,
+    // Passes on the third attempt.
+    "flaky.test.ts": `let attempts = 0;\ntest("flaky", () => {\n  expect(++attempts).toBe(3);\n});\n`,
+  };
+
+  test.each(
+    named([
+      { bunfig: `coverage = false`, args: ["--coverage"], prints: "% Funcs" },
+      { bunfig: `coverage = true\ncoverageReporter = "lcov"`, args: ["--coverage-reporter=text"], prints: "% Funcs" },
+      {
+        bunfig: `coverage = true\ncoverageReporter = "lcov"\ncoverageDir = "from-file"`,
+        args: ["--coverage-dir=from-flag"],
+        writes: ["from-flag", "from-flag/lcov.info"],
+      },
+      {
+        bunfig: `reporter.junit = "from-file.xml"`,
+        args: ["--reporter-outfile=from-flag.xml"],
+        writes: ["from-flag.xml"],
+      },
+      { bunfig: `reporter.dots = false`, args: ["--dots"], hides: "(pass)" },
+      { bunfig: `onlyFailures = false`, args: ["--only-failures"], hides: "(pass)" },
+      { bunfig: `randomize = false`, args: ["--randomize"], prints: "--seed=" },
+      { bunfig: `randomize = true\nseed = 1`, args: ["--seed=2"], prints: "--seed=2" },
+      { bunfig: `rerunEach = 3`, args: ["--rerun-each=1"], prints: " 2 pass" },
+      { bunfig: `retry = 2`, args: ["--retry=0", "flaky"], prints: " 1 fail", exitCode: 1 },
+      { bunfig: `retry = 0`, args: ["--retry=2", "flaky"], prints: " 1 pass" },
+    ]),
+  )("$name", async ({ bunfig, args, prints = "", hides = "\0", writes = [], exitCode = 0 }) => {
+    using dir = tempDir("test-flag-wins", { ...files, "bunfig.toml": `[test]\n${bunfig}\n` });
+    const result = await bunTest(String(dir), ...(args.includes("flaky") ? args : [...args, "a.test"]));
+    expect(result.stderr).toContain(prints);
+    expect(result.stderr).not.toContain(hides);
+    const written = readdirSync(String(dir), { recursive: true })
+      .map(name => String(name).replaceAll("\\", "/"))
+      .filter(name => !(name in files) && name !== "bunfig.toml");
+    expect(written.sort()).toEqual(writes);
+    expect(result.exitCode).toBe(exitCode);
+  });
+
+  // A worker reads bunfig.toml too. Workers only start when there are two files.
+  test("bun test --parallel=2 --retry=0 with retry = 2", async () => {
+    using dir = tempDir("test-flag-wins", {
+      "flaky1.test.ts": files["flaky.test.ts"],
+      "flaky2.test.ts": files["flaky.test.ts"],
+      "bunfig.toml": `[test]\nretry = 2\n`,
+    });
+    const { stderr, exitCode } = await bunTest(String(dir), "--parallel=2", "--retry=0");
+    expect(stderr).toContain(" 2 fail");
+    expect(exitCode).toBe(1);
+  });
+
+  test.each(
+    named([
+      {
+        bunfig: `seed = 1`,
+        args: [],
+        error: `error: "seed" can only be used when "randomize" is true\n    at <dir>/bunfig.toml:2:8\n`,
+      },
+      {
+        bunfig: `retry = 2`,
+        args: ["--rerun-each=3"],
+        error: `error: "retry" cannot be used with "rerunEach"\n    at <dir>/bunfig.toml:2:9\n`,
+      },
+      {
+        bunfig: `rerunEach = 3`,
+        args: ["--retry=2"],
+        error: `error: "rerunEach" cannot be used with "retry"\n    at <dir>/bunfig.toml:2:13\n`,
+      },
+      {
+        bunfig: `reporter.junit = "from-file.xml"`,
+        args: ["--reporter=junit"],
+        error: `error: --reporter=junit requires --reporter-outfile [file] to specify where to save the XML report\n`,
+      },
+    ]),
+  )("$name is an error as before", async ({ bunfig, args, error }) => {
+    using dir = tempDir("test-flag-error", { ...files, "bunfig.toml": `[test]\n${bunfig}\n` });
+    const { stderr, exitCode } = await bunTest(String(dir), ...args);
+    expect(stderr.replaceAll(String(dir).replaceAll("\\", "/"), "<dir>")).toContain(error);
+    expect(exitCode).toBe(1);
+  });
+
+  test("bun test --randomize with seed = 1 runs with that seed as before", async () => {
+    using dir = tempDir("test-flag-wins", { ...files, "bunfig.toml": `[test]\nseed = 1\n` });
+    const { stderr, exitCode } = await bunTest(String(dir), "--randomize", "a.test");
+    expect(stderr).toContain("--seed=1");
+    expect(exitCode).toBe(0);
+  });
+});
+
+describe.concurrent("[test] filePatterns", () => {
+  const empty = `test("passes", () => {});\n`;
+  const files = {
+    "a.itest.ts": empty,
+    "b.test.ts": empty,
+    "src/c.itest.ts": empty,
+    "src/d.spec.tsx": empty,
+  };
+  /** The `path/to/file.ts:` lines. */
+  const ran = (stderr: string) => [...stderr.matchAll(/^(\S+):$/gm)].map(match => match[1]).sort();
+
+  test.each(
+    named([
+      { bunfig: ``, args: [], expected: ["b.test.ts", "src/d.spec.tsx"] },
+      { bunfig: `filePatterns = "**/*.itest.ts"`, args: [], expected: ["a.itest.ts", "src/c.itest.ts"] },
+      {
+        bunfig: `filePatterns = ["*.itest.ts", "**/*.spec.tsx"]`,
+        args: [],
+        expected: ["a.itest.ts", "src/d.spec.tsx"],
+      },
+      { bunfig: `filePatterns = ["**/*.itest.ts", "!src/**"]`, args: [], expected: ["a.itest.ts"] },
+      { bunfig: `filePatterns = "**/*.itest.ts"`, args: ["src"], expected: ["src/c.itest.ts"] },
+      { bunfig: `filePatterns = "**/*.itest.ts"`, args: ["./b.test.ts"], expected: ["b.test.ts"] },
+      { bunfig: `filePatterns = "**/*.itest.ts"\npathIgnorePatterns = "src/**"`, args: [], expected: ["a.itest.ts"] },
+    ]),
+  )("$name", async ({ bunfig, args, expected }) => {
+    using dir = tempDir("test-file-patterns", { ...files, "bunfig.toml": `[test]\n${bunfig}\n` });
+    const { stderr, exitCode } = await bunTest(String(dir), ...args);
+    expect(ran(stderr)).toEqual(expected);
+    expect(exitCode).toBe(0);
+  });
+
+  test("coverageSkipTestFiles leaves the matching files out of the coverage table", async () => {
+    using dir = tempDir("test-file-patterns", {
+      "lib.ts": `export const used = () => 1;\n`,
+      "lib.itest.ts": `import { used } from "./lib";\ntest("one", () => {\n  used();\n});\n`,
+      "bunfig.toml": `[test]\nfilePatterns = "*.itest.ts"\ncoverageSkipTestFiles = true\n`,
+    });
+    const { stderr, exitCode } = await bunTest(String(dir), "--coverage");
+    expect(stderr).toContain(" lib.ts ");
+    expect(stderr).not.toContain(" lib.itest.ts ");
+    expect(exitCode).toBe(0);
+  });
+
+  test("a number is an error", async () => {
+    using dir = tempDir("test-file-patterns", { ...files, "bunfig.toml": `[test]\nfilePatterns = 1\n` });
+    const { stderr, exitCode } = await bunTest(String(dir));
+    expect(stderr).toContain("error: filePatterns must be a string or array of strings\n");
+    expect(exitCode).toBe(1);
+  });
+});
+
+describe.concurrent("[test] isolate", () => {
+  test.each(
+    named([
+      { bunfig: ``, args: [], sees: "1" },
+      { bunfig: `isolate = false`, args: [], sees: "1" },
+      { bunfig: `isolate = true`, args: [], sees: "undefined" },
+      { bunfig: `isolate = true`, args: ["--no-isolate"], sees: "1" },
+      { bunfig: `isolate = false`, args: ["--isolate"], sees: "undefined" },
+      // With this delay one worker runs both files.
+      { bunfig: `isolate = false`, args: ["--parallel=2", "--parallel-delay=1000000"], sees: "undefined" },
+      { bunfig: `isolate = true`, args: ["--parallel=2", "--parallel-delay=1000000", "--no-isolate"], sees: "1" },
+    ]),
+  )("$name: the second file sees $sees", async ({ bunfig, args, sees }) => {
+    using dir = tempDir("test-isolate", {
+      "a.test.ts": `globalThis.leaked = 1;\ntest("leaks", () => {});\n`,
+      "b.test.ts": `test("sees " + globalThis.leaked, () => {});\n`,
+      "bunfig.toml": `[test]\n${bunfig}\n`,
+    });
+    const { stderr, exitCode } = await bunTest(String(dir), ...args);
+    expect(stderr).toContain(`(pass) sees ${sees}`);
+    expect(exitCode).toBe(0);
+  });
+});
+
+// In smol mode a Blob is kept in a memfd from 1 MiB on, otherwise from 8 MiB on.
+test.concurrent.skipIf(!isLinux).each([
+  { bunfig: ``, expected: "normal" },
+  { bunfig: `smol = true`, expected: "smol" },
+])("bun test with [test] $bunfig is $expected", async ({ bunfig, expected }) => {
+  using dir = tempDir("test-smol", {
+    "bunfig.toml": `[test]\n${bunfig}\n`,
+    "a.test.ts": `
+      import { readdirSync, readlinkSync } from "node:fs";
+      test("probe", () => {
+        const blob = new Blob([new Uint8Array(2 * 1024 * 1024)]);
+        const links = readdirSync("/proc/self/fd").map(fd => {
+          try {
+            return readlinkSync("/proc/self/fd/" + fd);
+          } catch {
+            return "";
+          }
+        });
+        console.log(links.some(link => link.startsWith("/memfd:memfd-num-")) ? "smol" : "normal", blob.size);
+      });
+    `,
+  });
+  const { stdout, exitCode } = await bunTest(String(dir));
+  expect(stdout).toContain(`${expected} 2097152\n`);
+  expect(exitCode).toBe(0);
+});
diff --git a/test/cli/hot/hot.test.ts b/test/cli/hot/hot.test.ts
index 1f011aecfb4a..625813ec0449 100644
--- a/test/cli/hot/hot.test.ts
+++ b/test/cli/hot/hot.test.ts
@@ -1,7 +1,7 @@
 import { spawn } from "bun";
 import { beforeEach, expect, it } from "bun:test";
 import { copyFileSync, cpSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync } from "fs";
-import { bunEnv, bunExe, isDebug, isWindows, tempDir, tmpdirSync, waitForFileToExist } from "harness";
+import { bunEnv, bunExe, forEachLine, isDebug, isWindows, tempDir, tmpdirSync, waitForFileToExist } from "harness";
 import { join } from "path";
 
 const timeout = isDebug ? Infinity : 10_000;
@@ -928,3 +928,43 @@ it.each([
     stderr: [],
   });
 });
+
+// A signal listener runs without keeping the event loop alive, so a signal only wakes the idle process up.
+it.skipIf(isWindows).each(["--hot", "--watch"])(
+  "%s emits beforeExit once per run of the script, not each time the idle process wakes up",
+  async flag => {
+    const source = `
+      console.log("start");
+      if (!globalThis.listening) {
+        globalThis.listening = true;
+        process.on("beforeExit", () => console.log("beforeExit"));
+        process.on("SIGUSR2", () => console.log("signal"));
+      }
+    `;
+    using dir = tempDir("hot-before-exit", { "main.js": source });
+    await using runner = spawn({
+      cmd: [bunExe(), flag, "--no-clear-screen", "main.js"],
+      env: bunEnv,
+      cwd: String(dir),
+      stdout: "pipe",
+      stderr: "inherit",
+      stdin: "ignore",
+    });
+    const lines = forEachLine(runner.stdout);
+    const nextLine = async () => (await lines.next()).value;
+
+    expect(await nextLine()).toBe("start");
+    expect(await nextLine()).toBe("beforeExit");
+    for (let i = 0; i < 3; i++) {
+      runner.kill("SIGUSR2");
+      expect(await nextLine()).toBe("signal");
+    }
+
+    writeHotFileAtomicSync(join(String(dir), "main.js"), source + "// saved");
+    expect(await nextLine()).toBe("start");
+    // One save can reach the watcher as two events.
+    let line = await nextLine();
+    while (line === "start") line = await nextLine();
+    expect(line).toBe("beforeExit");
+  },
+);
diff --git a/test/cli/init/init.test.ts b/test/cli/init/init.test.ts
index ff3ee799b165..e5d77cd0fd2d 100644
--- a/test/cli/init/init.test.ts
+++ b/test/cli/init/init.test.ts
@@ -1,4 +1,4 @@
-import { beforeAll, describe, expect, test } from "bun:test";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import fs, { readdirSync } from "fs";
 import { bunEnv, bunExe, isWindows, tempDir, tempDirWithFiles } from "harness";
 import path from "path";
@@ -69,6 +69,48 @@ const initEnv = { ...bunEnv, BUN_AGENT_RULE_DISABLED: "1" };
     expect(fs.existsSync(path.join(temp, "tsconfig.json"))).toBe(true);
   }, 30_000);
 
+  test.each([
+    [["--smol"], {}, "package.json"],
+    [[], { BUN_OPTIONS: "--smol" }, "package.json"],
+    [["--cwd=target"], {}, "target/package.json"],
+    [["--cwd", "target"], {}, "target/package.json"],
+  ])(
+    "bun %j init, with %j in the environment, writes %s",
+    async (flags, env, expected) => {
+      await using temp = tempDir("bun-init-after-flags", { "target/.gitkeep": "" });
+
+      await using proc = Bun.spawn({
+        cmd: [bunExe(), ...flags, "init", "-y", "-m"],
+        cwd: String(temp),
+        stdio: ["ignore", "ignore", "ignore"],
+        env: { ...initEnv, ...env },
+      });
+
+      expect(await proc.exited).toBe(0);
+      const written = ["package.json", "target/package.json", "init/package.json"];
+      expect(written.filter(file => fs.existsSync(path.join(String(temp), file)))).toEqual([expected]);
+    },
+    30_000,
+  );
+
+  test("bun --help init prints the help and writes nothing", async () => {
+    await using temp = tempDir("bun-help-init", {});
+
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "--help", "init"],
+      cwd: String(temp),
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "inherit",
+      env: initEnv,
+    });
+    const [stdout, exitCode] = await Promise.all([proc.stdout.text(), proc.exited]);
+
+    expect(stdout).toContain("bun init");
+    expect(readdirSync(String(temp))).toEqual([]);
+    expect(exitCode).toBe(0);
+  });
+
   test("bun init falls back to --yes when stdin is not a TTY", async () => {
     await using temp = tempDir("bun-init-no-tty", {});
 
@@ -724,3 +766,147 @@ const initEnv = { ...bunEnv, BUN_AGENT_RULE_DISABLED: "1" };
     expect(fs.existsSync(path.join(temp, ".cursor"))).toBe(false);
   });
 });
+
+(isWindows ? describe : describe.concurrent)("bun init beside files that exist", () => {
+  // Where a nested `bun install` runs, it finds no package here and needs no network.
+  const registry = Bun.serve({ hostname: "127.0.0.1", port: 0, fetch: () => new Response(null, { status: 404 }) });
+  afterAll(() => registry.stop(true));
+
+  // A package.json that lists these two gets no dependency, so no nested `bun install` runs.
+  const listed = { devDependencies: { "@types/bun": "latest" }, peerDependencies: { typescript: "^7" } };
+
+  async function runInit(cwd: string, ...args: string[]) {
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "init", ...args],
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: {
+        ...initEnv,
+        BUN_CONFIG_REGISTRY: `http://127.0.0.1:${registry.port}/`,
+        BUN_INSTALL_CACHE_DIR: path.join(cwd, ".cache"),
+      },
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    return { stdout, stderr, exitCode };
+  }
+
+  test.each([
+    {
+      title: "does not parse",
+      contents: '{\n  "name": "myapp",\n  "dependencies": {\n    "react": "^19"\n  }\n',
+      error: 'error: Expected "}" but found end of file',
+    },
+    { title: "is not an object", contents: '["myapp"]\n', error: "error: package.json root must be an object" },
+  ])("bun init -y exits 1 and writes nothing beside a package.json that $title", async ({ contents, error }) => {
+    await using temp = tempDir("bun-init-unusable-package-json", { "package.json": contents });
+
+    const { stdout, stderr, exitCode } = await runInit(String(temp), "-y");
+
+    expect(stderr).toContain(error);
+    expect(stderr).toContain("package.json:");
+    expect(stdout).toBe("");
+    expect(readdirSync(temp)).toEqual(["package.json"]);
+    expect(await Bun.file(path.join(temp, "package.json")).text()).toBe(contents);
+    expect(exitCode).toBe(1);
+  });
+
+  test.each([
+    { title: "no package.json", files: {} },
+    { title: "a package.json of only whitespace", files: { "package.json": "\n" } },
+  ])("bun init -y with $title prints and writes the blank template", async ({ files }) => {
+    await using temp = tempDir("bun-init-blank", files);
+
+    const { stdout, exitCode } = await runInit(String(temp), "-y");
+
+    expect(stdout).toStartWith(
+      " + .gitignore\n + index.ts\n + tsconfig.json (for bun check and editor autocomplete)\n + README.md\n" +
+        "\nTo get started, run:\n\n    bun run index.ts\n\nTo type check, run:\n\n    bun check\n\n",
+    );
+    expect(await Bun.file(path.join(temp, "package.json")).json()).toEqual({
+      name: path.basename(temp).toLowerCase().replaceAll(" ", "-"),
+      module: "index.ts",
+      type: "module",
+      private: true,
+      scripts: { typecheck: "bun check" },
+      ...listed,
+    });
+    expect(exitCode).toBe(0);
+  });
+
+  test("bun init --react skips a README.md and an unparsable package.json", async () => {
+    const files = { "README.md": "mine\n", "package.json": '{ "name": ' };
+    await using temp = tempDir("bun-init-react-existing", files);
+
+    const { stdout, exitCode } = await runInit(String(temp), "--react");
+
+    expect(stdout).toContain(" ○ package.json (already exists, skipping)\n");
+    expect(stdout).toContain(" ○ README.md (already exists, skipping)\n");
+    expect({
+      "README.md": await Bun.file(path.join(temp, "README.md")).text(),
+      "package.json": await Bun.file(path.join(temp, "package.json")).text(),
+    }).toEqual(files);
+    expect(exitCode).toBe(0);
+  });
+
+  test.each([
+    { args: "-y", does: "writes no file at", main: "./index", written: false },
+    { args: "-y", does: "writes the missing", main: "dist/index.js", written: true },
+    { args: "-m -y", does: "writes the missing", main: "dist/index.js", written: true },
+  ])('bun init $args $does "main": "$main" beside index.js', async ({ args, main, written }) => {
+    await using temp = tempDir("bun-init-main", {
+      "package.json": JSON.stringify({ name: "app", main, ...listed }),
+      "index.js": "module.exports = 1;\n",
+    });
+
+    const { exitCode } = await runInit(String(temp), ...args.split(" "));
+
+    expect(fs.existsSync(path.join(temp, main))).toBe(written);
+    expect(exitCode).toBe(0);
+  });
+
+  test.each([
+    { title: "keeps", before: { type: "commonjs", private: false }, after: { type: "commonjs", private: false } },
+    { title: "adds a missing", before: {}, after: { type: "module", private: true } },
+  ])("bun init -y $title type and private", async ({ before, after }) => {
+    const manifest = { name: "app", ...before, ...listed };
+    await using temp = tempDir("bun-init-type-private", {
+      "package.json": JSON.stringify(manifest),
+      "index.js": "module.exports = 1;\n",
+    });
+
+    const { exitCode } = await runInit(String(temp), "-y");
+
+    expect(await Bun.file(path.join(temp, "package.json")).json()).toEqual({
+      ...manifest,
+      module: "index.js",
+      ...after,
+    });
+    expect(exitCode).toBe(0);
+  });
+
+  test.each([
+    { adds: "nothing", group: "dependencies", added: {} },
+    { adds: "nothing", group: "optionalDependencies", added: {} },
+    { adds: "@types/bun", group: "peerDependencies", added: { devDependencies: { "@types/bun": "latest" } } },
+  ])("bun init -y adds $adds where $group lists @types/bun and typescript", async ({ adds, group, added }) => {
+    const manifest = {
+      name: "app",
+      module: "index.ts",
+      type: "module",
+      private: true,
+      scripts: { typecheck: "bun check" },
+      [group]: { "@types/bun": "1.1.0", typescript: "5.6.2" },
+    };
+    await using temp = tempDir("bun-init-listed-dependency", {
+      "package.json": JSON.stringify(manifest),
+      "index.ts": "export {};\n",
+    });
+
+    const { stdout, exitCode } = await runInit(String(temp), "-y");
+
+    expect(await Bun.file(path.join(temp, "package.json")).json()).toEqual({ ...manifest, ...added });
+    // `bun init` runs `bun install` only after it added a dependency.
+    expect(stdout.includes("bun install")).toBe(adds !== "nothing");
+    expect(exitCode).toBe(0);
+  });
+});
diff --git a/test/cli/install/bun-create.test.ts b/test/cli/install/bun-create.test.ts
index 20a5cb61a2e8..846b2a4d5c89 100644
--- a/test/cli/install/bun-create.test.ts
+++ b/test/cli/install/bun-create.test.ts
@@ -570,6 +570,22 @@ it("should create template from local folder", async () => {
   expect(await Bun.file(join(x_dir, testTemplate, "foo", "bar.js")).text()).toBe("hi");
 });
 
+it.concurrent.each([[["--cwd", "proj"]], [["--cwd=proj"]]])("bun %j create works in that folder", async flags => {
+  using dir = tempDir("create-after-cwd", { "bun-create/tpl/tpl.txt": "template", "proj/mine.txt": "mine" });
+  await using proc = spawn({
+    cmd: [bunExe(), ...flags, "create", "tpl", "dest", "--no-git"],
+    cwd: String(dir),
+    env: { ...env, BUN_CREATE_DIR: join(String(dir), "bun-create") },
+    stdin: "ignore",
+    stdout: "ignore",
+    stderr: "inherit",
+  });
+
+  const exitCode = await proc.exited;
+  expect(await tree(join(String(dir), "proj"))).toEqual({ "dest/tpl.txt": "template", "mine.txt": "mine" });
+  expect(exitCode).toBe(0);
+});
+
 async function tree(dir: string) {
   const files: Record<string, string> = {};
   for (const path of (await Array.fromAsync(new Bun.Glob("**").scan({ cwd: dir, dot: true }))).sort()) {
diff --git a/test/cli/install/bun-install.test.ts b/test/cli/install/bun-install.test.ts
index 339911c9e570..a64d17ac2c23 100644
--- a/test/cli/install/bun-install.test.ts
+++ b/test/cli/install/bun-install.test.ts
@@ -7584,7 +7584,7 @@ describe.concurrent("bun-install", () => {
                                             ^
         error: dependencies expects a map of specifiers, e.g.
           "dependencies": {
-            <green>"bun"<r>: <green>"latest"<r>
+            "bun": "latest"
           }
             at [dir]/package.json:1:33
         "
@@ -7622,7 +7622,7 @@ describe.concurrent("bun-install", () => {
         `                                    ^`,
         `error: optionalDependencies expects a map of specifiers, e.g.`,
         `  "optionalDependencies": {`,
-        `    <green>"bun"<r>: <green>"latest"<r>`,
+        `    "bun": "latest"`,
         `  }`,
         `    at [dir]/package.json:1:33`,
       ]);
@@ -7632,6 +7632,24 @@ describe.concurrent("bun-install", () => {
     });
   });
 
+  it("should report error on a dependency version that is not a string", async () => {
+    using dir = tempDir("dependency-version-not-a-string", {
+      "package.json": JSON.stringify({ name: "foo", version: "0.0.1", dependencies: { bun: 1 } }),
+    });
+    await using proc = spawn({
+      cmd: [bunExe(), "install"],
+      cwd: String(dir),
+      env,
+      stdout: "ignore",
+      stderr: "pipe",
+    });
+    const [err, exitCode] = await Promise.all([proc.stderr.text(), proc.exited]);
+    expect(err).toContain(
+      `error: dependencies expects a map of specifiers, e.g.\n  "dependencies": {\n    "bun": "latest"\n  }\n`,
+    );
+    expect(exitCode).toBe(1);
+  });
+
   it("should report error on invalid format for workspaces", async () => {
     await withContext(defaultOpts, async ctx => {
       await writeFile(
@@ -17665,3 +17683,24 @@ describe.concurrent.each(["hoisted", "isolated"])(
     });
   },
 );
+
+// BUN_INSTALL_PROGRESS=1 asks for the progress bar where stderr is not a terminal.
+it("the progress bar with FORCE_COLOR=1 does not move the cursor in a pipe", async () => {
+  using dir = tempDir("install-progress-pipe", {
+    "package.json": JSON.stringify({ name: "root", dependencies: { dep: "file:./dep" } }),
+    dep: { "package.json": JSON.stringify({ name: "dep", version: "1.0.0" }) },
+  });
+  await using proc = spawn({
+    cmd: [bunExe(), "install"],
+    cwd: String(dir),
+    env: { ...bunEnv, NO_COLOR: undefined, FORCE_COLOR: "1", BUN_INSTALL_PROGRESS: "1" },
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+  // On Windows, only a console gets the bar.
+  if (!isWindows) expect(stderr).toContain("Saving lockfile");
+  // Colors end in `m`.
+  expect(stdout + stderr).not.toMatch(/\x1b\[[\d;]*[^\d;m]/);
+  expect(exitCode).toBe(0);
+});
diff --git a/test/cli/install/bun-run-bunfig.test.ts b/test/cli/install/bun-run-bunfig.test.ts
index f8aecb74304c..8df8bf6b4893 100644
--- a/test/cli/install/bun-run-bunfig.test.ts
+++ b/test/cli/install/bun-run-bunfig.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import { realpathSync } from "fs";
-import { bunEnv, bunExe, isWindows, tempDir, toTOMLString } from "harness";
+import { bunEnv, bunExe, isLinux, isWindows, tempDir, toTOMLString } from "harness";
 import { join as pathJoin } from "node:path";
 
 describe.each(["bun run", "bun"])(`%s`, cmd => {
@@ -172,7 +172,7 @@ describe.each(["bun run", "bun"])(`%s`, cmd => {
     }
   });
 
-  test("NOT autoload local bunfig.toml (sub cwd)", async () => {
+  test("autoload the project's bunfig.toml (sub cwd)", async () => {
     const runCmd = cmd === "bun" ? ["run"] : [];
 
     const bunfig = toTOMLString({
@@ -205,7 +205,11 @@ describe.each(["bun run", "bun"])(`%s`, cmd => {
     });
     const nodeBin = result.stdout.toString().trim();
 
-    expect(realpathSync(nodeBin)).toBe(realpathSync(node));
+    if (isWindows) {
+      expect(realpathSync(nodeBin)).toContain("\\bun-node-");
+    } else {
+      expect(realpathSync(nodeBin)).toBe(realpathSync(execPath));
+    }
     expect(result.success).toBeTrue();
   });
 
@@ -248,3 +252,168 @@ describe.each(["bun run", "bun"])(`%s`, cmd => {
     expect(result.success).toBeTrue();
   });
 });
+
+async function bun(cwd: string, ...args: string[]) {
+  await using proc = Bun.spawn({ cmd: [bunExe(), ...args], cwd, env: bunEnv, stdout: "pipe", stderr: "pipe" });
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+  return { stdout, stderr, exitCode };
+}
+
+describe.concurrent("a flag of `bun run <file>` wins over its key in bunfig.toml", () => {
+  test.each([
+    {
+      name: "--define replaces the same key of [define] and keeps the others",
+      files: {
+        "bunfig.toml": `[define]\nA = "1"\nB = "2"\n`,
+        "index.js": `console.log(A, B, typeof C);`,
+      },
+      entry: "index.js",
+      flags: ["--define", "B=20", "--define", "C=3"],
+      withFlags: "1 20 number\n",
+      withoutFlags: "1 2 undefined\n",
+    },
+    {
+      name: "--loader replaces the same extension of [loader] and keeps the others",
+      files: {
+        "bunfig.toml": `[loader]\n".foo" = "json"\n".bar" = "json"\n`,
+        "a.foo": `{}`,
+        "a.bar": `{}`,
+        "index.js": `import foo from "./a.foo";\nimport bar from "./a.bar";\nconsole.log(typeof foo, typeof bar);`,
+      },
+      entry: "index.js",
+      flags: ["--loader", ".bar:text"],
+      withFlags: "object string\n",
+      withoutFlags: "object object\n",
+    },
+    {
+      name: "--console-depth",
+      files: {
+        "bunfig.toml": `[console]\ndepth = 1\n`,
+        "index.js": `console.log({ a: { b: { c: 1 } } });`,
+      },
+      entry: "index.js",
+      flags: ["--console-depth", "3"],
+      withFlags: "{\n  a: {\n    b: {\n      c: 1,\n    },\n  },\n}\n",
+      withoutFlags: "{\n  a: {\n    b: [Object ...],\n  },\n}\n",
+    },
+    {
+      name: "--jsx-factory",
+      files: {
+        "bunfig.toml": `jsx = "react"\njsxFactory = "fromFile"\n`,
+        "index.jsx": `const fromFile = () => "file", fromFlag = () => "flag";\nconsole.log(<div />);`,
+      },
+      entry: "index.jsx",
+      flags: ["--jsx-factory", "fromFlag"],
+      withFlags: "flag\n",
+      withoutFlags: "file\n",
+    },
+  ])("$name", async ({ files, entry, flags, withFlags, withoutFlags }) => {
+    using dir = tempDir("run-flag-wins", files);
+    expect(await bun(String(dir), "run", ...flags, entry)).toEqual({ stdout: withFlags, stderr: "", exitCode: 0 });
+    expect(await bun(String(dir), "run", entry)).toEqual({ stdout: withoutFlags, stderr: "", exitCode: 0 });
+  });
+
+  test("--jsx-runtime classic, next to a bunfig.toml without a jsx key", async () => {
+    using dir = tempDir("run-flag-wins", {
+      "bunfig.toml": `logLevel = "warn"\n`,
+      "index.jsx": `const React = { createElement: tag => "classic " + tag };\nconsole.log(<div />);`,
+    });
+    expect(await bun(String(dir), "run", "--jsx-runtime", "classic", "index.jsx")).toEqual({
+      stdout: "classic div\n",
+      stderr: "",
+      exitCode: 0,
+    });
+  });
+
+  test("--no-macros, next to a [macros] table", async () => {
+    using dir = tempDir("run-flag-wins", {
+      "bunfig.toml": `[macros]\npkg = { value = "./macro.ts" }\n`,
+      "macro.ts": `export const value = () => 42;`,
+      "index.ts": `import { value } from "./macro.ts" with { type: "macro" };\nconsole.log(value());`,
+    });
+    const { stderr, exitCode } = await bun(String(dir), "run", "--no-macros", "index.ts");
+    expect(stderr).toContain("Macros are disabled");
+    expect(exitCode).toBe(1);
+  });
+
+  test('--no-install, next to [install] auto = "fallback"', async () => {
+    const requests: string[] = [];
+    using registry = Bun.serve({
+      port: 0,
+      fetch(req) {
+        requests.push(new URL(req.url).pathname);
+        return new Response("not found", { status: 404 });
+      },
+    });
+    using dir = tempDir("run-flag-wins", {
+      "bunfig.toml": `[install]\nauto = "fallback"\nregistry = "http://127.0.0.1:${registry.port}/"\n`,
+      "index.js": `import "not-installed";`,
+    });
+    expect((await bun(String(dir), "run", "--no-install", "index.js")).exitCode).toBe(1);
+    expect(requests).toEqual([]);
+    expect((await bun(String(dir), "run", "index.js")).exitCode).toBe(1);
+    expect(requests).toEqual(["/not-installed"]);
+  });
+
+  // On Windows package.json scripts always run in Bun's shell.
+  test.skipIf(isWindows).each([
+    { key: "bun", flag: "system", expected: expect.not.stringContaining("bun: command not found") },
+    { key: "system", flag: "bun", expected: expect.stringContaining("bun: command not found") },
+  ])('--shell=$flag, next to [run] shell = "$key"', async ({ key, flag, expected }) => {
+    using dir = tempDir("run-flag-wins", {
+      "bunfig.toml": `[run]\nshell = "${key}"\n`,
+      "package.json": JSON.stringify({ scripts: { start: "not-a-command" } }),
+    });
+    const { stderr, exitCode } = await bun(String(dir), "run", "--silent", `--shell=${flag}`, "start");
+    expect(stderr).toEqual(expected);
+    expect(exitCode).not.toBe(0);
+  });
+
+  test("--bun, next to [run] bun = false", async () => {
+    using dir = tempDir("run-flag-wins", {
+      "bunfig.toml": `[run]\nbun = false\n`,
+      "package.json": JSON.stringify({ scripts: { start: `node -e "console.log(typeof Bun)"` } }),
+    });
+    expect(await bun(String(dir), "run", "--silent", "--bun", "start")).toEqual({
+      stdout: "object\n",
+      stderr: "",
+      exitCode: 0,
+    });
+  });
+});
+
+// In smol mode a Blob is kept in a memfd from 1 MiB on, otherwise from 8 MiB on.
+describe.skipIf(!isLinux).concurrent("smol in bunfig.toml", () => {
+  const isSmol = `
+    const { readdirSync, readlinkSync } = require("node:fs");
+    const blob = new Blob([new Uint8Array(2 * 1024 * 1024)]);
+    const links = readdirSync("/proc/self/fd").map(fd => {
+      try {
+        return readlinkSync("/proc/self/fd/" + fd);
+      } catch {
+        return "";
+      }
+    });
+    console.log(links.some(link => link.startsWith("/memfd:memfd-num-")) ? "smol" : "normal", blob.size);
+  `;
+
+  test.each([
+    { name: "bun index.js without the key is not smol", bunfig: "", args: ["index.js"], expected: "normal" },
+    { name: "smol = true applies to bun index.js", bunfig: "smol = true", args: ["index.js"], expected: "smol" },
+    {
+      name: "smol = true applies to bun run index.js",
+      bunfig: "smol = true",
+      args: ["run", "index.js"],
+      expected: "smol",
+    },
+    {
+      name: "bun run --smol wins over smol = false",
+      bunfig: "smol = false",
+      args: ["run", "--smol", "index.js"],
+      expected: "smol",
+    },
+  ])("$name", async ({ bunfig, args, expected }) => {
+    using dir = tempDir("bunfig-smol", { "bunfig.toml": bunfig, "index.js": isSmol });
+    expect(await bun(String(dir), ...args)).toEqual({ stdout: `${expected} 2097152\n`, stderr: "", exitCode: 0 });
+  });
+});
diff --git a/test/cli/install/bun-run.test.ts b/test/cli/install/bun-run.test.ts
index 1c8918227511..11c51c9b3446 100644
--- a/test/cli/install/bun-run.test.ts
+++ b/test/cli/install/bun-run.test.ts
@@ -1346,7 +1346,7 @@ describe.concurrent("bun run", () => {
 
     {
       await using proc = Bun.spawn({
-        cmd: [bunExe(), "run", "--shell=system", "say", "%PATH%"],
+        cmd: [bunExe(), "run", "--silent", "--shell=system", "say", "%PATH%"],
         cwd: String(dir),
         env: bunEnv,
         stdout: "pipe",
@@ -1361,6 +1361,100 @@ describe.concurrent("bun run", () => {
     }
   });
 
+  for (const flags of [[], ["--silent"]]) {
+    it.skipIf(isWindows)(`exits 1 at the first script whose shell cannot be started ${flags}`.trim(), async () => {
+      using dir = tempDir("bun-run-broken-shell", {
+        "package.json": JSON.stringify({ scripts: { prehi: "echo pre", hi: "echo hi", posthi: "echo post" } }),
+        // The only shell in PATH. Its interpreter does not exist.
+        "bin/sh": "#!/nonexistent\n",
+      });
+      chmodSync(join(String(dir), "bin", "sh"), 0o755);
+
+      await using proc = Bun.spawn({
+        cmd: [bunExe(), "run", ...flags, "--shell=system", "hi"],
+        cwd: String(dir),
+        env: { ...bunEnv, PATH: join(String(dir), "bin") },
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+      const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+
+      expect(stderr.replaceAll(String(dir), "<dir>")).toBe(
+        (flags.length ? "" : "$ echo pre\n") +
+          "error: Failed to run script prehi due to error:\n" +
+          "ENOENT: <dir>/bin/sh: No such file or directory (posix_spawn())\n",
+      );
+      expect(stdout).toBe("");
+      expect(exitCode).toBe(1);
+    });
+  }
+
+  it.skipIf(isWindows)("--silent says why a bin in node_modules/.bin cannot be started", async () => {
+    using dir = tempDir("bun-run-broken-bin", {
+      "package.json": "{}",
+      "node_modules/.bin/no-interpreter": "#!/nonexistent\n",
+    });
+    chmodSync(join(String(dir), "node_modules", ".bin", "no-interpreter"), 0o755);
+
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "run", "--silent", "no-interpreter"],
+      cwd: String(dir),
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+
+    expect(stderr.replaceAll(String(dir), "<dir>")).toBe(
+      'error: Failed to run "no-interpreter" due to:\n' +
+        "ENOENT: <dir>/node_modules/.bin/no-interpreter: No such file or directory (posix_spawn())\n",
+    );
+    expect(stdout).toBe("");
+    expect(exitCode).toBe(1);
+  });
+
+  // An ignored SIGCHLD survives exec. The kernel then reaps a child before its parent can wait for it.
+  it.skipIf(isWindows)("reports the exit code of a script when the parent process ignores SIGCHLD", async () => {
+    using dir = tempDir("bun-run-sigchld-ignored", {
+      "package.json": JSON.stringify({ scripts: { bad: "exit 3" } }),
+    });
+
+    await using proc = Bun.spawn({
+      cmd: ["sh", "-c", 'trap "" CHLD; exec "$0" "$@"', bunExe(), "run", "--shell=system", "bad"],
+      cwd: String(dir),
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+
+    expect(stderr).toBe('$ exit 3\nerror: script "bad" exited with code 3\n');
+    expect(stdout).toBe("");
+    expect(exitCode).toBe(3);
+  });
+
+  it("--silent --shell=bun says why a script cannot be run", async () => {
+    using dir = tempDir("bun-run-bun-shell-failure", {
+      "package.json": JSON.stringify({
+        // Nested deeper than bun's shell reads.
+        scripts: { deep: "echo " + Buffer.alloc(400, "$(").toString() + "echo x" + Buffer.alloc(200, ")").toString() },
+      }),
+    });
+
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "run", "--silent", "--shell=bun", "deep"],
+      cwd: String(dir),
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+
+    expect(stderr).toBe("error: Failed to run script deep due to error SubshellDepthExceeded\n");
+    expect(stdout).toBe("");
+    expect(exitCode).toBe(1);
+  });
+
   // The node/bun shims live in one directory shared by every bun process of
   // the same build (and, for debug builds, by all debug builds). A bun that is
   // starting up may add the links but must never remove ones that already
diff --git a/test/cli/install/bun-upgrade.test.ts b/test/cli/install/bun-upgrade.test.ts
index eacecd6981fa..3252258952cb 100644
--- a/test/cli/install/bun-upgrade.test.ts
+++ b/test/cli/install/bun-upgrade.test.ts
@@ -323,6 +323,28 @@ describe.concurrent(() => {
     expect(err).toEndWith(unpackFailure);
     expect(exitCode).toBe(1);
   });
+
+  it.each([
+    [["--smol"], {}],
+    [[], { BUN_OPTIONS: "--smol" }],
+  ])("a flag before the command (%j, %j) is not a package name", async (flags, extraEnv) => {
+    // The archive is garbage, so the upgrade fails after the arguments are accepted.
+    using server = startReleaseServer({ tagName: "bun-v9.9.9" });
+    using stagingRoot = tempDir("bun-upgrade-after-flag", {});
+    await using proc = spawn({
+      cmd: [standInExe, ...flags, "upgrade", "--stable"],
+      cwd: standInDir,
+      stdout: null,
+      stdin: "pipe",
+      stderr: "pipe",
+      env: { ...server.env, ...extraEnv, BUN_TMPDIR: String(stagingRoot) },
+    });
+
+    const [err, exitCode] = await Promise.all([proc.stderr.text(), proc.exited]);
+    expect(err).not.toContain("does not take package names");
+    expectTargetsRelease(err, "9.9.9");
+    expect(exitCode).toBe(1);
+  });
 });
 
 it.concurrent(
diff --git a/test/cli/install/bunx.test.ts b/test/cli/install/bunx.test.ts
index 6d557cbdcc29..e9e233dc78c3 100644
--- a/test/cli/install/bunx.test.ts
+++ b/test/cli/install/bunx.test.ts
@@ -756,6 +756,21 @@ describe("bunx --no-install", () => {
     expect(exited).toBe(1);
   });
 
+  it.concurrent.skipIf(isWindows)("says why a bin cannot be started, and nothing about a bin's exit code", async () => {
+    const ctx = setup();
+    const bin = join(ctx.x_dir, "node_modules", ".bin");
+    mkdirSync(bin, { recursive: true });
+    writeFileSync(join(bin, "no-interpreter"), "#!/nonexistent\n", { mode: 0o755 });
+    writeFileSync(join(bin, "exits-3"), "#!/bin/sh\nexit 3\n", { mode: 0o755 });
+
+    expect(await run(ctx, "--no-install", "no-interpreter")).toEqual([
+      `error: Failed to run "no-interpreter" due to:\nENOENT: ${join(bin, "no-interpreter")}: No such file or directory (posix_spawn())\n`,
+      "",
+      1,
+    ]);
+    expect(await run(ctx, "--no-install", "exits-3")).toEqual(["", "", 3]);
+  });
+
   /*
     yes, multiple package tests are neccessary.
       1. there's specialized logic for `bunx tsc` and `bunx typescript`
@@ -819,6 +834,30 @@ describe("bunx --no-install", () => {
   });
 });
 
+// The npm package `bun` has `bin/bunx.exe` on every platform, and a lookup through PATHEXT finds `bunx.EXE`.
+it.concurrent.each(isWindows ? ["bunx.EXE"] : ["bunx.exe", "BUNX"])("is bunx when started as %s", async name => {
+  using dir = tempDir("bunx-by-name", {});
+  if (isWindows) {
+    copyFileSync(bunExe(), join(String(dir), "bunx.exe"));
+  } else {
+    symlinkSync(bunExe(), join(String(dir), name));
+  }
+
+  await using proc = spawn({
+    cmd: [join(String(dir), name), "--help"],
+    cwd: String(dir),
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+    env: bunEnv,
+  });
+  const [out, err, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+
+  expect(err).toContain("Usage: bunx");
+  expect(out).toBe("");
+  expect(exitCode).toBe(0);
+});
+
 it.concurrent("should handle postinstall scripts correctly with symlinked bunx", async () => {
   const { x_dir, env } = setup();
   // Copies rather than symlinks: bun re-runs its own executable path for the
@@ -862,6 +901,49 @@ it.concurrent("should handle postinstall scripts correctly with symlinked bunx",
   expect(exited).toBe(0);
 });
 
+// On Windows `bunx --bun` runs a bin that has a node shebang in its own process.
+it.concurrent.skipIf(!isWindows)("a bin that bunx.exe --bun runs can fork()", async () => {
+  using dir = tempDir("bunx-exe-fork", {
+    "package.json": JSON.stringify({ name: "app", dependencies: { tool: "file:./tool" } }),
+    "tool/package.json": JSON.stringify({ name: "tool", version: "1.0.0", bin: { tool: "cli.js" } }),
+    "tool/cli.js": `#!/usr/bin/env node
+      const { basename, join } = require("node:path");
+      console.log(basename(process.execPath), basename(process.argv[0]), JSON.stringify(process.execArgv));
+      require("node:child_process").fork(join(__dirname, "child.js"));
+    `,
+    "tool/child.js": `console.log("child ran");`,
+    "exes/.keep": "",
+  });
+  const exes = join(String(dir), "exes");
+  copyFileSync(bunExe(), join(exes, "bun.exe"));
+  copyFileSync(bunExe(), join(exes, "bunx.exe"));
+
+  await using install = spawn({
+    cmd: [bunExe(), "install"],
+    cwd: String(dir),
+    env: bunEnv,
+    stdout: "ignore",
+    stderr: "inherit",
+  });
+  expect(await install.exited).toBe(0);
+
+  for (const [exe, args, execArgv] of [
+    ["bunx.exe", ["--bun", "--no-install", "tool"], `["--smol"]`],
+    ["bun.exe", ["--bun", "run", "tool"], `["--smol","--bun"]`],
+  ] as const) {
+    await using proc = spawn({
+      cmd: [join(exes, exe), ...args],
+      cwd: String(dir),
+      env: { ...bunEnv, BUN_OPTIONS: "--smol" },
+      stdout: "pipe",
+      stderr: "inherit",
+    });
+    const [stdout, exitCode] = await Promise.all([proc.stdout.text(), proc.exited]);
+    expect(stdout).toBe(`bun.exe bun.exe ${execArgv}\nchild ran\n`);
+    expect(exitCode).toBe(0);
+  }
+});
+
 // Stands in for `bunx --bun @angular/cli`, whose `ng` refuses to start on a
 // Node.js older than its engines range (Bun used to self-report 22.6.0 and
 // fail it). The fixture applies the same gate to the version Bun reports under
diff --git a/test/cli/run/as-node.test.ts b/test/cli/run/as-node.test.ts
index 29e5766df601..7504a32c7a65 100644
--- a/test/cli/run/as-node.test.ts
+++ b/test/cli/run/as-node.test.ts
@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test";
+import { copyFileSync, symlinkSync } from "node:fs";
 import { join } from "path";
-import { bunEnv, bunExe, fakeNodeRun, tempDir } from "../../harness";
+import { bunEnv, bunExe, fakeNodeRun, isWindows, tempDir } from "../../harness";
 
 describe("fake node cli", () => {
   test("the node cli actually works", () => {
@@ -9,6 +10,25 @@ describe("fake node cli", () => {
     });
     expect(fakeNodeRun(temp, join(temp, "index.ts")).stdout).toBe(Bun.version);
   });
+  test(`is node when started as ${isWindows ? "node.EXE" : "NODE"}`, async () => {
+    using temp = tempDir("node-by-name", {});
+    if (isWindows) {
+      copyFileSync(bunExe(), join(String(temp), "node.exe"));
+    } else {
+      symlinkSync(bunExe(), join(String(temp), "NODE"));
+    }
+    await using proc = Bun.spawn({
+      cmd: [join(String(temp), isWindows ? "node.EXE" : "NODE")],
+      env: bunEnv,
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    expect(stderr).toContain("Missing script");
+    expect(stdout).toBe("");
+    expect(exitCode).toBe(1);
+  });
   test("doesnt resolve bins", () => {
     using temp = tempDir("fake-node", {
       "vite.js": "console.log('pass')",
diff --git a/test/cli/run/env.test.ts b/test/cli/run/env.test.ts
index e08c7692fab1..42455396d1b2 100644
--- a/test/cli/run/env.test.ts
+++ b/test/cli/run/env.test.ts
@@ -254,6 +254,85 @@ test.concurrent(".env value expansion", async () => {
   expect(stdout).toBe("foo|foo bar|foo foo bar moo");
 });
 
+const printExpanded =
+  "console.log(JSON.stringify(Object.fromEntries(Object.entries(process.env).filter(([k]) => k.startsWith('XP_')))));";
+
+test.concurrent(".env value expansion of a key from further down the file, and of the key itself", async () => {
+  using dir = tempDir("dotenv-expand-in-file", {
+    ".env": [
+      "XP_Z=$XP_Y",
+      "XP_Y=$XP_X",
+      "XP_X=1",
+      "XP_PORT=${XP_PORT:-3000}",
+      "XP_SELF=$XP_SELF-bar",
+      "XP_URL=u:$XP_PASS@h",
+      "XP_PASS=abc\\$def",
+      "XP_LOOP_A=a$XP_LOOP_B",
+      "XP_LOOP_B=b$XP_LOOP_A",
+    ].join("\n"),
+    "index.ts": printExpanded,
+  });
+  const { stdout } = await bunRun(`${dir}/index.ts`);
+  expect(JSON.parse(stdout)).toEqual({
+    XP_Z: "1",
+    XP_Y: "1",
+    XP_X: "1",
+    XP_PORT: "3000",
+    XP_SELF: "-bar",
+    XP_URL: "u:abc$def@h",
+    XP_PASS: "abc$def",
+    XP_LOOP_A: "ab",
+    XP_LOOP_B: "b",
+  });
+});
+
+test.concurrent(".env values that existing projects depend on", async () => {
+  using dir = tempDir("dotenv-expand-pinned", {
+    ".env": [
+      "XP_VAR=hello",
+      "XP_URL=https://x.dev/path#frag",
+      "XP_PASSWORD=pa$$w0rd",
+      "XP_SINGLE_QUOTED='p$XP_VAR'",
+      "XP_DEFAULT=${XP_NOPE:-fallback}",
+      "XP_EMPTY=",
+      "XP_EMPTY_IS_SET=${XP_EMPTY:-fallback}",
+      "XP_EXPORTED=${XP_EXPORTED:-3000}",
+      "XP_EXPORTED_AS_IS=$XP_EXPORTED_DOLLAR",
+    ].join("\n"),
+    "index.ts": printExpanded,
+  });
+  const { stdout } = await bunRun(`${dir}/index.ts`, { XP_EXPORTED: "9", XP_EXPORTED_DOLLAR: "a$XP_VAR" });
+  expect(JSON.parse(stdout)).toEqual({
+    XP_VAR: "hello",
+    XP_URL: "https://x.dev/path",
+    XP_PASSWORD: "pa$",
+    XP_SINGLE_QUOTED: "phello",
+    XP_DEFAULT: "fallback",
+    XP_EMPTY: "",
+    XP_EMPTY_IS_SET: "",
+    XP_EXPORTED: "9",
+    XP_EXPORTED_DOLLAR: "a$XP_VAR",
+    XP_EXPORTED_AS_IS: "a$XP_VAR",
+  });
+});
+
+test.concurrent("$VAR in an env file sees the files that win over it, and no other file", async () => {
+  const winner = "XP_WINNER=w\nXP_REF=[$XP_BASE]\nXP_PORT=${XP_BASE:-3000}\n";
+  const loser = "XP_BASE=4000\nXP_SEES_WINNER=$XP_WINNER\n";
+  using dir = tempDir("dotenv-expand-other-file", {
+    ".env.local": winner,
+    ".env": loser,
+    "first.env": loser,
+    "second.env": winner,
+    "index.ts": printExpanded,
+  });
+  const expected = { XP_WINNER: "w", XP_REF: "[]", XP_PORT: "3000", XP_BASE: "4000", XP_SEES_WINNER: "w" };
+  const defaults = await bunRun(`${dir}/index.ts`);
+  expect(JSON.parse(defaults.stdout)).toEqual(expected);
+  const explicit = await bunRun([`--env-file=${dir}/first.env`, `--env-file=${dir}/second.env`, `${dir}/index.ts`]);
+  expect(JSON.parse(explicit.stdout)).toEqual(expected);
+});
+
 test(".env ${VAR:-default} with nested references (issue #32411)", async () => {
   // https://github.com/oven-sh/bun/issues/32411
   // `${` pairs with its matching `}` by depth and the `:-` default is expanded
diff --git a/test/cli/run/filter-workspace.test.ts b/test/cli/run/filter-workspace.test.ts
index 99c209b09d45..d0f07d104352 100644
--- a/test/cli/run/filter-workspace.test.ts
+++ b/test/cli/run/filter-workspace.test.ts
@@ -1,7 +1,7 @@
 import { spawnSync } from "bun";
 import { install_test_helpers } from "bun:internal-for-testing";
 import { describe, expect, test } from "bun:test";
-import { bunEnv, bunExe, isLinux, isWindows, runBunInstall, tempDir, tempDirWithFiles } from "harness";
+import { bunEnv, bunExe, isLinux, isMacOS, isWindows, runBunInstall, tempDir, tempDirWithFiles } from "harness";
 import { existsSync, symlinkSync } from "node:fs";
 import { setTimeout as sleep } from "node:timers/promises";
 import { constants } from "os";
@@ -135,8 +135,6 @@ function runInCwdSuccess({
   antipattern,
   command = ["present"],
   auto = false,
-  env = {},
-  elideCount,
 }: {
   cwd: string;
   pattern: string | string[];
@@ -144,16 +142,9 @@ function runInCwdSuccess({
   antipattern?: RegExp | RegExp[];
   command?: string[];
   auto?: boolean;
-  env?: Record<string, string | undefined>;
-  elideCount?: number;
 }) {
   const cmd = auto ? [bunExe()] : [bunExe(), "run"];
 
-  // Add elide-lines first if specified
-  if (elideCount !== undefined) {
-    cmd.push("--elide-lines", elideCount.toString());
-  }
-
   if (Array.isArray(pattern)) {
     for (const p of pattern) {
       cmd.push("--filter", p);
@@ -169,7 +160,7 @@ function runInCwdSuccess({
   const { exitCode, stdout, stderr } = spawnSync({
     cwd,
     cmd,
-    env: { ...bunEnv, ...env },
+    env: bunEnv,
     stdout: "pipe",
     stderr: "pipe",
   });
@@ -199,6 +190,30 @@ function runInCwdFailure(cwd: string, pkgname: string, scriptname: string, resul
   expect(exitCode).not.toBe(0);
 }
 
+/** Runs `bun <args>` on a pseudo-terminal. `text` is what it drew, without the escape sequences. */
+async function runInTerminal(cwd: string, args: string[], env: Record<string, string | undefined> = {}) {
+  const decoder = new TextDecoder();
+  let output = "";
+  const eof = Promise.withResolvers<void>();
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), ...args],
+    cwd,
+    // With the NO_COLOR=1 of bunEnv, a terminal gets the same lines as a pipe.
+    env: { ...bunEnv, NO_COLOR: undefined, ...env },
+    terminal: {
+      cols: 250,
+      rows: 50,
+      data: (_terminal, chunk) => void (output += decoder.decode(chunk, { stream: true })),
+      exit: () => eof.resolve(),
+    },
+  });
+  const exitCode = await proc.exited;
+  await eof.promise;
+  proc.terminal!.close();
+  output += decoder.decode();
+  return { exitCode, output, text: Bun.stripANSI(output).replaceAll("\r\n", "\n") };
+}
+
 describe("bun", () => {
   const dirs = [cwd_root, cwd_packages, cwd_a, cwd_b, cwd_c, cwd_d];
   const packages = [
@@ -616,103 +631,80 @@ describe("bun", () => {
     expect(exitCode).toBe(128 + signal);
   });
 
-  function runElideLinesTest({
-    elideLines,
-    target_pattern,
-    antipattern,
-  }: {
-    elideLines?: number;
-    target_pattern: RegExp[];
-    antipattern?: RegExp[];
-  }) {
-    const dir = tempDirWithFiles("testworkspace", {
+  const twentyLines = () =>
+    tempDir("testworkspace", {
       packages: {
         dep0: {
           "index.js": Array(20).fill("console.log('log_line');").join("\n"),
-          "package.json": JSON.stringify({
-            name: "dep0",
-            scripts: {
-              script: `${bunExe()} run index.js`,
-            },
-          }),
+          "package.json": JSON.stringify({ name: "dep0", scripts: { script: `${bunExe()} run index.js` } }),
         },
       },
-      "package.json": JSON.stringify({
-        name: "ws",
-        workspaces: ["packages/*"],
-      }),
+      "package.json": JSON.stringify({ name: "ws", workspaces: ["packages/*"] }),
     });
 
-    if (process.platform === "win32") {
-      // Windows spawnSync pipes stdout, so `windowsIsTerminal()` returns false,
-      // `state.pretty_output` is false, and `redraw()` short-circuits before
-      // ever emitting elision output. `target_pattern` is intentionally NOT
-      // iterated here: every caller bundles TTY-only regexes such as
-      // `/\[N lines elided\]/` that would never appear in piped Windows output
-      // and would fail the test for the wrong reason. The hardcoded log_line
-      // match covers the non-TTY subset of every caller's target_pattern.
-      // `antipattern` is iterated because absence-checks remain valid on either
-      // code path.
-      const { exitCode, stderr, stdout } = spawnSync({
-        cwd: dir,
-        cmd: [
-          bunExe(),
-          "run",
-          "--filter",
-          "./packages/dep0",
-          ...(elideLines === undefined ? [] : ["--elide-lines", String(elideLines)]),
-          "script",
-        ],
-        env: { ...bunEnv, FORCE_COLOR: "1", NO_COLOR: "0" },
-        stdout: "pipe",
-        stderr: "pipe",
-      });
-
-      const stdoutval = stdout.toString();
-      expect(stderr.toString()).not.toContain("--elide-lines is only supported in terminal environments");
-      expect(stdoutval).toMatch(/(?:log_line[\s\S]*?){20}/);
-      if (antipattern) {
-        for (const r of antipattern) {
-          expect(stdoutval).not.toMatch(r);
-        }
-      }
-      expect(exitCode).toBe(0);
-      return;
-    }
-
-    runInCwdSuccess({
-      cwd: dir,
-      pattern: "./packages/dep0",
-      env: { FORCE_COLOR: "1", NO_COLOR: "0" },
-      target_pattern,
-      antipattern,
-      command: ["script"],
-      elideCount: elideLines,
-    });
+  // Only a terminal gets the panes that are redrawn, which is where lines are elided.
+  async function runElideLinesTest({
+    elideLines,
+    target_pattern,
+    antipattern = [],
+  }: {
+    elideLines?: number;
+    target_pattern: RegExp[];
+    antipattern?: RegExp[];
+  }) {
+    using dir = twentyLines();
+    const { text, exitCode } = await runInTerminal(String(dir), [
+      "run",
+      "--filter",
+      "./packages/dep0",
+      ...(elideLines === undefined ? [] : ["--elide-lines", String(elideLines)]),
+      "script",
+    ]);
+    for (const r of target_pattern) expect(text).toMatch(r);
+    for (const r of antipattern) expect(text).not.toMatch(r);
+    expect(exitCode).toBe(0);
   }
 
-  test("does not elide output by default when using --filter", () => {
-    runElideLinesTest({
+  test.concurrent("does not elide output by default when using --filter", async () => {
+    await runElideLinesTest({
       target_pattern: [/(?:log_line[\s\S]*?){20}/],
       antipattern: [/lines elided/],
     });
   });
 
-  test("respects --elide-lines argument", () => {
-    runElideLinesTest({
+  test.concurrent("respects --elide-lines argument", async () => {
+    await runElideLinesTest({
       elideLines: 15,
-      target_pattern: [/\[5 lines elided\]/, /(?:log_line[\s\S]*?){20}/],
+      target_pattern: [/\[5 lines elided\]/, /(?:log_line[\s\S]*?){15}/],
     });
   });
 
-  test("--elide-lines=0 shows all output", () => {
-    runElideLinesTest({
+  test.concurrent("--elide-lines=0 shows all output", async () => {
+    await runElideLinesTest({
       elideLines: 0,
       target_pattern: [/(?:log_line[\s\S]*?){20}/],
       antipattern: [/lines elided/],
     });
   });
 
+  test.concurrent("FORCE_COLOR=1 does not draw panes into a pipe", async () => {
+    using dir = twentyLines();
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "run", "--filter", "./packages/dep0", "script"],
+      cwd: String(dir),
+      env: { ...bunEnv, NO_COLOR: undefined, FORCE_COLOR: "1" },
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, exitCode] = await Promise.all([proc.stdout.text(), proc.exited]);
+    expect(stdout.split("\n")).toEqual([
+      ...Array(20).fill("dep0 script: log_line"),
+      "dep0 script: Exited with code 0",
+      "",
+    ]);
+    expect(exitCode).toBe(0);
+  });
+
   test("--elide-lines is a no-op (not an error) when stdout is not a terminal", () => {
     using dir = tempDir("testworkspace", {
       packages: {
@@ -744,8 +736,7 @@ describe("bun", () => {
     expect(exitCode).toBe(0);
   });
 
-  // The terminal renderer is TTY-only on Windows (see runElideLinesTest).
-  test.skipIf(isWindows)("terminal output reports how long a successful script took", () => {
+  test.concurrent("terminal output reports how long a successful script took", async () => {
     using dir = tempDir("filter-done-in", {
       packages: {
         dep0: {
@@ -755,15 +746,8 @@ describe("bun", () => {
       "package.json": JSON.stringify({ name: "ws", workspaces: ["packages/*"] }),
     });
 
-    const { exitCode, stdout } = spawnSync({
-      cwd: String(dir),
-      cmd: [bunExe(), "run", "--filter", "dep0", "script"],
-      env: { ...bunEnv, FORCE_COLOR: "1", NO_COLOR: "0" },
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-
-    expect(stdout.toString()).toMatch(/Done in (?:\d+ ms|\d+\.\d{2} s)/);
+    const { text, exitCode } = await runInTerminal(String(dir), ["run", "--filter", "dep0", "script"]);
+    expect(text).toMatch(/Done in (?:\d+ ms|\d+\.\d{2} s)/);
     expect(exitCode).toBe(0);
   });
 
@@ -859,6 +843,25 @@ describe("bun", () => {
         workspaces: ["packages/*/*"],
         files: { packages: { UPPER: { Inner: member("core") }, group: { lower: member("lower") } } },
       },
+      // The names of these file systems ignore case.
+      ...(isMacOS || isWindows
+        ? [
+            {
+              entry: "a literal path in lower case",
+              workspaces: ["./packages/core", "packages/lower"],
+              files: { packages: { Core: member("core"), lower: member("lower") } },
+            },
+          ]
+        : []),
+      ...(isLinux
+        ? [
+            {
+              entry: "a literal path, next to the same name in lower case",
+              workspaces: ["packages/Core", "packages/core"],
+              files: { packages: { Core: member("core"), core: member("lower") } },
+            },
+          ]
+        : []),
     ])("is found through $entry in workspaces", async ({ workspaces, files }) => {
       using dir = tempDir("filter-upper-case-dir", {
         ...files,
@@ -1401,6 +1404,115 @@ describe.skipIf(!isWindows).each([
   );
 });
 
+// #42962: the scripts are not on the console of `bun`, so Ctrl+C reaches `bun` alone, on a thread
+// of its own. The helper makes a console, starts `bun` on it and sends a real CTRL_C_EVENT once the
+// script is up. AllocConsole rebinds the std handles, so it reports through a file.
+describe.skipIf(!isWindows).each([
+  { via: "--filter", argv: ["--filter", "*", "dev"] },
+  { via: "run --parallel", argv: ["run", "--parallel", "dev"] },
+])("windows: $via", ({ argv }) => {
+  test.concurrent(
+    "Ctrl+C ends the run while the script prints nothing",
+    async () => {
+      using dir = tempDir("filter-win-ctrlc", {
+        "package.json": JSON.stringify({ name: "ws", workspaces: ["packages/*"] }),
+        "packages/app/server.js": `
+          require("fs").writeFileSync(process.env.PIDFILE, String(process.pid));
+          setInterval(() => {}, 1000);
+        `,
+        "packages/app/package.json": JSON.stringify({
+          name: "app",
+          scripts: { dev: `"${bunExe()}" server.js` },
+        }),
+        "ctrlc-fixture.js": `
+          const { dlopen, FFIType } = require("bun:ffi");
+          const fs = require("fs");
+          const { setTimeout: sleep } = require("timers/promises");
+          const k32 = dlopen("kernel32.dll", {
+            FreeConsole: { args: [], returns: FFIType.i32 },
+            AllocConsole: { args: [], returns: FFIType.i32 },
+            SetConsoleCtrlHandler: { args: [FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
+            GenerateConsoleCtrlEvent: { args: [FFIType.u32, FFIType.u32], returns: FFIType.i32 },
+          }).symbols;
+          const isAlive = pid => { try { process.kill(pid, 0); return true; } catch { return false; } };
+          const result = { parentExited: false, parentExitCode: null, leafDead: false, error: "" };
+          let parent, leafPid = 0;
+          try {
+            k32.FreeConsole();
+            if (!k32.AllocConsole()) throw new Error("AllocConsole failed");
+            // A CI harness can start the test with Ctrl+C disabled. Children
+            // inherit that attribute, so clear it before the spawn.
+            k32.SetConsoleCtrlHandler(null, 0);
+            parent = Bun.spawn({
+              cmd: [process.execPath, ...JSON.parse(process.env.PARENT_ARGV)],
+              cwd: process.env.PARENT_CWD,
+              env: process.env,
+              stdin: "ignore",
+              stdout: "ignore",
+              stderr: "ignore",
+            });
+            // Ignore Ctrl+C in this process only. Set after the spawn: the
+            // ignore attribute is inherited by children.
+            process.on("SIGINT", () => {});
+            k32.SetConsoleCtrlHandler(null, 1);
+            const deadline = Date.now() + 10000;
+            while (leafPid === 0 && Date.now() < deadline) {
+              try { leafPid = Number(fs.readFileSync(process.env.PIDFILE, "utf8").trim()) || 0; } catch {}
+              if (leafPid === 0) await sleep(25);
+            }
+            if (leafPid === 0) throw new Error("leaf never wrote pidfile");
+            if (!k32.GenerateConsoleCtrlEvent(0, 0)) throw new Error("GenerateConsoleCtrlEvent failed");
+            let timer;
+            result.parentExited = await Promise.race([
+              parent.exited.then(() => true),
+              new Promise(resolve => { timer = setTimeout(() => resolve(false), 5000); }),
+            ]);
+            clearTimeout(timer);
+            result.parentExitCode = parent.exitCode;
+            const leafDeadline = Date.now() + 5000;
+            while (isAlive(leafPid) && Date.now() < leafDeadline) await sleep(25);
+            result.leafDead = !isAlive(leafPid);
+          } catch (e) {
+            result.error = String(e);
+          } finally {
+            if (parent) { try { parent.kill("SIGKILL"); } catch {} await parent.exited; }
+            if (leafPid && isAlive(leafPid)) { try { process.kill(leafPid, "SIGKILL"); } catch {} }
+            fs.writeFileSync(process.env.RESULTFILE, JSON.stringify(result));
+          }
+        `,
+      });
+
+      const env: Record<string, string | undefined> = {
+        ...bunEnv,
+        PIDFILE: join(String(dir), "leaf.pid"),
+        RESULTFILE: join(String(dir), "result.json"),
+        PARENT_ARGV: JSON.stringify(argv),
+        PARENT_CWD: join(String(dir), "packages", "app"),
+        BUN_FEATURE_FLAG_NO_ORPHANS: undefined,
+      };
+      await using helper = Bun.spawn({
+        cmd: [bunExe(), "ctrlc-fixture.js"],
+        env,
+        cwd: String(dir),
+        stdout: "ignore",
+        stderr: "pipe",
+      });
+      const [stderr, exitCode] = await Promise.all([helper.stderr.text(), helper.exited]);
+      expect(stderr).toBe("");
+      expect(await Bun.file(env.RESULTFILE!).json()).toEqual({
+        parentExited: true,
+        parentExitCode: 130,
+        leafDead: true,
+        error: "",
+      });
+      expect(exitCode).toBe(0);
+    },
+    // When the run does not end, the helper needs up to 20 s to report and to
+    // kill the runner and the leaf it started.
+    30000,
+  );
+});
+
 // The script runner never passes the default .env* files into package.json
 // scripts (see "does not pass variables from .env files into scripts" in
 // env.test.ts): the script's own bun instance loads them, so a script such as
@@ -1611,6 +1723,41 @@ describe("output timing", () => {
     // Waiting out the grandchild's 30s sleep means the abort bypass regressed.
     expect(Date.now() - start).toBeLessThan(15000);
   });
+
+  // The terminal sends Ctrl+C to `bun run` and to the script. A second SIGINT from `bun run` would
+  // kill a server in the middle of its shutdown.
+  test.skipIf(isWindows)("Ctrl+C reaches a script that shuts down quietly once", async () => {
+    using dir = tempDir("filter-one-sigint", {
+      "package.json": JSON.stringify({ name: "ws", workspaces: ["packages/*"] }),
+      "packages/web/package.json": JSON.stringify({ name: "web", scripts: { start: `exec ${bunExe()} server.js` } }),
+      "packages/web/server.js": `
+        process.once("SIGINT", () => {
+          Bun.spawnSync({ cmd: [process.execPath, "-e", ""] });
+          process.exit(0);
+        });
+        setInterval(() => {}, 1000);
+        await Bun.write("ready.txt", "");
+      `,
+    });
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "run", "--filter", "web", "start"],
+      env: bunEnv,
+      cwd: String(dir),
+      stdout: "pipe",
+      stderr: "pipe",
+      // New session, so the group signal below cannot reach the test runner.
+      detached: true,
+    });
+    const ready = join(String(dir), "packages", "web", "ready.txt");
+    while (!existsSync(ready) && proc.exitCode === null) await Bun.sleep(10);
+    process.kill(-proc.pid, "SIGINT");
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    expect({ stdout, stderr, exitCode }).toEqual({
+      stdout: "web start: Exited with code 0\n",
+      stderr: "",
+      exitCode: 0,
+    });
+  });
 });
 
 describe("auto-discovered bunfig.toml [run] section", () => {
@@ -1634,11 +1781,11 @@ describe("auto-discovered bunfig.toml [run] section", () => {
     });
   }
 
-  function run(dir: string, args: string[], env: Record<string, string | undefined> = {}) {
+  function run(dir: string, args: string[]) {
     const { exitCode, stdout, stderr } = spawnSync({
       cwd: dir,
       cmd: [bunExe(), ...args],
-      env: { ...bunEnv, ...env },
+      env: bunEnv,
       stdout: "pipe",
       stderr: "pipe",
     });
@@ -1663,23 +1810,19 @@ describe("auto-discovered bunfig.toml [run] section", () => {
     expect(r.exitCode).toBe(0);
   });
 
-  // Elision only happens on a terminal. On POSIX FORCE_COLOR=1 turns the
-  // terminal renderer on for a pipe; on Windows it stays off (see runElideLinesTest).
-  test.skipIf(isWindows)("[run] elide-lines enables elision for --filter", () => {
+  // Elision only happens on a terminal.
+  test("[run] elide-lines enables elision for --filter", async () => {
     using dir = workspace("filter-bunfig-elide", "[run]\nelide-lines = 15\n");
-    const r = run(String(dir), ["run", "--filter", "dep0", "lines"], { FORCE_COLOR: "1", NO_COLOR: "0" });
-    expect(r.stdout).toMatch(/\[5 lines elided\]/);
+    const r = await runInTerminal(String(dir), ["run", "--filter", "dep0", "lines"]);
+    expect(r.text).toMatch(/\[5 lines elided\]/);
     expect(r.exitCode).toBe(0);
   });
 
-  test.skipIf(isWindows)("--elide-lines on the CLI wins over [run] elide-lines", () => {
+  test("--elide-lines on the CLI wins over [run] elide-lines", async () => {
     using dir = workspace("filter-bunfig-cli-elide", "[run]\nelide-lines = 15\n");
-    const r = run(String(dir), ["run", "--elide-lines", "0", "--filter", "dep0", "lines"], {
-      FORCE_COLOR: "1",
-      NO_COLOR: "0",
-    });
-    expect(r.stdout).not.toMatch(/lines elided/);
-    expect(r.stdout).toMatch(/(?:log_line[\s\S]*?){20}/);
+    const r = await runInTerminal(String(dir), ["run", "--elide-lines", "0", "--filter", "dep0", "lines"]);
+    expect(r.text).not.toMatch(/lines elided/);
+    expect(r.text).toMatch(/(?:log_line[\s\S]*?){20}/);
     expect(r.exitCode).toBe(0);
   });
 
@@ -1715,3 +1858,101 @@ test.concurrent.each([
   expect(stderr).toBe("");
   expect(exitCode).toBe(0);
 });
+
+// https://github.com/oven-sh/bun/issues/10346
+describe.concurrent("colors in scripts, which write to pipes", () => {
+  const workspace = () =>
+    tempDir("filter-color", {
+      "package.json": JSON.stringify({ name: "ws", workspaces: ["packages/*"] }),
+      "packages/a/package.json": JSON.stringify({ name: "a", scripts: { probe: `${bunExe()} probe.js` } }),
+      "packages/a/probe.js": `console.log("FORCE_COLOR=" + process.env.FORCE_COLOR, "colors=" + Bun.enableANSIColors);`,
+    });
+  // What tells how many colors the terminal has.
+  const xterm256 = {
+    TERM: "xterm-256color",
+    COLORTERM: undefined,
+    TERM_PROGRAM: undefined,
+    TMUX: undefined,
+    CI: undefined,
+  };
+  const runners = [[["--filter", "a"]], [["--parallel", "--filter", "a"]]];
+
+  test.each(runners)("%j on a terminal turns them on", async args => {
+    using dir = workspace();
+    const { text, exitCode } = await runInTerminal(String(dir), ["run", ...args, "probe"], xterm256);
+    expect(text).toContain("FORCE_COLOR=2 colors=true");
+    expect(exitCode).toBe(0);
+  });
+
+  test.each([
+    [{ NO_COLOR: "1" }, "undefined"],
+    [{ NODE_DISABLE_COLORS: "1" }, "undefined"],
+    [{ FORCE_COLOR: "0" }, "0"],
+  ])("%j on a terminal is left alone", async (env, seen) => {
+    using dir = workspace();
+    const { text, exitCode } = await runInTerminal(String(dir), ["run", "--filter", "a", "probe"], {
+      ...xterm256,
+      ...env,
+    });
+    expect(text).toContain(`FORCE_COLOR=${seen} colors=false`);
+    expect(exitCode).toBe(0);
+  });
+
+  test.each(runners)("%j into a pipe leaves them off", async args => {
+    using dir = workspace();
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "run", ...args, "probe"],
+      cwd: String(dir),
+      env: { ...bunEnv, ...xterm256, NO_COLOR: undefined },
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, exitCode] = await Promise.all([proc.stdout.text(), proc.exited]);
+    expect(stdout).toContain("FORCE_COLOR=undefined colors=false");
+    expect(exitCode).toBe(0);
+  });
+});
+
+describe.concurrent("npm_* variables of a script", () => {
+  const show =
+    "echo name=$npm_package_name version=$npm_package_version json=$npm_package_json " +
+    "port=$npm_package_config_port host=$npm_package_config_host event=$npm_lifecycle_event";
+
+  test.each([
+    [["--filter", "*"]],
+    [["--workspaces"]],
+    [["--parallel", "--filter", "*"]],
+    [["--sequential", "--workspaces"]],
+  ])("%j: they are those of its package, or else of the package that bun runs in", async args => {
+    using dir = tempDir("filter-npm-env", {
+      "package.json": JSON.stringify({
+        name: "root",
+        version: "3.4.5",
+        config: { port: "1", host: "localhost" },
+        workspaces: ["packages/*"],
+      }),
+      "packages/a/package.json": JSON.stringify({
+        name: "a",
+        version: "1.1.1",
+        config: { port: "8080" },
+        scripts: { preshow: show, show },
+      }),
+      "packages/b/package.json": JSON.stringify({ name: "b", scripts: { show } }),
+    });
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "run", ...args, "show"],
+      cwd: String(dir),
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, exitCode] = await Promise.all([proc.stdout.text(), proc.exited]);
+    const seen = stdout.replaceAll("\\", "/").match(/name=.*/g)!;
+    expect(seen.map(line => line.replace(/json=.*\/packages/, "json=packages")).sort()).toEqual([
+      "name=a version=1.1.1 json=packages/a/package.json port=8080 host=localhost event=preshow",
+      "name=a version=1.1.1 json=packages/a/package.json port=8080 host=localhost event=show",
+      "name=b version=3.4.5 json=packages/b/package.json port=1 host=localhost event=show",
+    ]);
+    expect(exitCode).toBe(0);
+  });
+});
diff --git a/test/cli/run/if-present.test.ts b/test/cli/run/if-present.test.ts
index 96e712a46658..d8bbd411e090 100644
--- a/test/cli/run/if-present.test.ts
+++ b/test/cli/run/if-present.test.ts
@@ -1,6 +1,8 @@
 import { spawnSync } from "bun";
 import { beforeAll, describe, expect, test } from "bun:test";
-import { bunEnv, bunExe, tempDirWithFiles } from "harness";
+import { bunEnv, bunExe, isWindows, tempDirWithFiles } from "harness";
+import { chmodSync } from "node:fs";
+import { join } from "node:path";
 
 let cwd: string;
 
@@ -13,7 +15,9 @@ beforeAll(() => {
         "present": "echo 'Here!'",
       },
     }),
+    "node_modules/.bin/tool": "#!/bin/sh\necho tool $@\n",
   });
+  chmodSync(join(cwd, "node_modules", ".bin", "tool"), 0o755);
 });
 
 describe("bun", () => {
@@ -116,4 +120,28 @@ describe("bun --if-present", () => {
     expect(stderr.toString()).toBeEmpty();
     expect(exitCode).toBe(0);
   });
+  test.skipIf(isWindows)("should not run a program from the system's PATH", () => {
+    const { exitCode, stdout, stderr } = spawnSync({
+      cwd,
+      cmd: [bunExe(), "run", "--if-present", "test"],
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(stdout.toString()).toBeEmpty();
+    expect(stderr.toString()).toBeEmpty();
+    expect(exitCode).toBe(0);
+  });
+  test.skipIf(isWindows)("should run a program from node_modules/.bin", () => {
+    const { exitCode, stdout, stderr } = spawnSync({
+      cwd,
+      cmd: [bunExe(), "run", "--if-present", "tool", "--flag"],
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(stdout.toString()).toBe("tool --flag\n");
+    expect(stderr.toString()).toBeEmpty();
+    expect(exitCode).toBe(0);
+  });
 });
diff --git a/test/cli/run/multi-run.test.ts b/test/cli/run/multi-run.test.ts
index 32cc82ed21ad..4afe2bc63759 100644
--- a/test/cli/run/multi-run.test.ts
+++ b/test/cli/run/multi-run.test.ts
@@ -739,6 +739,16 @@ describe.concurrent("pre/post scripts", () => {
     }
     expect(r.exitCode).toBe(0);
   });
+
+  test("npm_lifecycle_event is the name of the script, and unset for a command that is no script", async () => {
+    const show = "echo event=$npm_lifecycle_event.";
+    using dir = tempDir("mr-lifecycle-event", {
+      "package.json": JSON.stringify({ scripts: { prebuild: show, build: show } }),
+    });
+    const r = await runMulti(["run", "--sequential", "build", show], String(dir));
+    expect(r.stdout.match(/\| event=.*/g)).toEqual(["| event=prebuild.", "| event=build.", "| event=."]);
+    expect(r.exitCode).toBe(0);
+  });
 });
 
 // ─── VALIDATION & ERROR MESSAGES ──────────────────────────────────────────────
@@ -1875,6 +1885,51 @@ describe.concurrent("glob pattern matching", () => {
   });
 });
 
+// ─── ARGUMENTS AFTER `--` ───────────────────────────────────────────────────
+
+describe.concurrent("arguments after --", () => {
+  const code = "$(echo run)";
+
+  test.each([
+    [
+      ["run", "--sequential", "a", "b", "--", "--watch", code],
+      ["a | pre-got", `a | a-got --watch ${code}`, `b | b-got --watch ${code}`],
+    ],
+    [
+      ["run", "--sequential", "a", "--", "b"],
+      ["a | pre-got", "a | a-got b"],
+    ],
+    [["--sequential", "b", "--", "a"], ["b | b-got a"]],
+    [["run", "--sequential", "b", "--"], ["b | b-got"]],
+    [["run", "--sequential", "echo raw-got", "--", "-x", code], [`echo raw-got | raw-got -x ${code}`]],
+    [["run", "--sequential", "./args.js", "--", "-x", "two words"], [`./args.js | file-got ["-x","two words"]`]],
+    // These name scripts, as without the `--`.
+    [
+      ["run", "--sequential", "--", "b", "a"],
+      ["b | b-got", "a | pre-got", "a | a-got"],
+    ],
+  ])("bun %j", async (args, expected) => {
+    using dir = tempDir("mr-arguments", {
+      "args.js": `console.log("file-got", JSON.stringify(process.argv.slice(2)));`,
+      "package.json": JSON.stringify({ scripts: { prea: "echo pre-got", a: "echo a-got", b: "echo b-got" } }),
+    });
+    const r = await runMulti(args, String(dir));
+    expect(r.stdout.match(/^.*-got.*$/gm)?.map(line => line.replace(/ +\| /, " | "))).toEqual(expected);
+    expect(r.exitCode).toBe(0);
+  });
+
+  test("--filter: they reach the script in every package", async () => {
+    using dir = makeWorkspace("mr-arguments-filter", {
+      "pkg-a": { build: "echo a-got" },
+      "pkg-b": { build: "echo b-got" },
+    });
+    const r = await runMulti(["run", "--parallel", "--filter", "*", "build", "--", "--watch"], String(dir));
+    expectPrefixed(r.stdout, "pkg-a:build", "a-got --watch");
+    expectPrefixed(r.stdout, "pkg-b:build", "b-got --watch");
+    expect(r.exitCode).toBe(0);
+  });
+});
+
 // ─── WORKSPACE INTEGRATION ──────────────────────────────────────────────────
 
 /** Helper to create a monorepo workspace temp directory. */
diff --git a/test/cli/run/no-envfile.test.ts b/test/cli/run/no-envfile.test.ts
index fd55d3926492..16c08a4bc0ab 100644
--- a/test/cli/run/no-envfile.test.ts
+++ b/test/cli/run/no-envfile.test.ts
@@ -1,4 +1,4 @@
-import { expect, test } from "bun:test";
+import { describe, expect, test } from "bun:test";
 import { bunEnv, bunExe, tempDir } from "harness";
 
 test("--no-env-file disables .env loading", async () => {
@@ -263,3 +263,106 @@ test("--no-env-file in production mode", async () => {
   expect(stdout.trim()).toBe("undefined");
   expect(exitCode).toBe(0);
 });
+
+describe("what the process builds and starts later", () => {
+  const env = { ...bunEnv, NODE_ENV: undefined, BUN_OPTIONS: undefined, API_KEY: undefined };
+  const files = {
+    ".env": "API_KEY=from-dot-env\n",
+    "custom.env": "CUSTOM=from-custom-env\n",
+    "client.ts": "console.log(process.env.API_KEY);\n",
+    "worker.ts": "postMessage(String(process.env.API_KEY));\n",
+    "inlined.ts": `
+      export async function inlined() {
+        const build = await Bun.build({ entrypoints: ["./client.ts"], env: "inline" });
+        return /console\\.log\\((.*)\\);/.exec(await build.outputs[0].text())![1];
+      }
+    `,
+    "main.ts": `
+      import { inlined } from "./inlined.ts";
+
+      const bundle = await inlined();
+      const worker = new Worker(new URL("./worker.ts", import.meta.url).href);
+      const fromWorker = await new Promise(resolve => (worker.onmessage = event => resolve(event.data)));
+      await worker.terminate();
+      console.log(JSON.stringify({ bundle, worker: fromWorker }));
+    `,
+  };
+
+  async function run(cwd: string, args: string[], argv0?: string) {
+    await using proc = Bun.spawn({ cmd: [bunExe(), ...args], argv0, env, cwd, stdout: "pipe", stderr: "pipe" });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    return { stdout, stderr, exitCode };
+  }
+
+  type Row = [label: string, args: string[], extra: string | undefined];
+
+  test.concurrent.each<Row>([
+    ["--no-env-file", ["--no-env-file", "main.ts"], undefined],
+    ["bunfig env = false", ["run", "main.ts"], "env = false\n"],
+  ])("%s: no value of .env in a Bun.build(), nor in a Worker started after it", async (_, args, bunfig) => {
+    using dir = tempDir("no-env-file-later", bunfig ? { ...files, "bunfig.toml": bunfig } : files);
+    const { stdout, exitCode } = await run(String(dir), args);
+    expect(JSON.parse(stdout)).toEqual({ bundle: "process.env.API_KEY", worker: "undefined" });
+    expect(exitCode).toBe(0);
+  });
+
+  test.concurrent.each<Row>([
+    ["no switch", ["main.ts"], undefined],
+    ["--env-file", ["--env-file=custom.env", "main.ts"], undefined],
+    ["bun invoked as node", ["main.ts"], "node"],
+  ])("%s: Bun.build() inlines the values of .env", async (_, args, argv0) => {
+    using dir = tempDir("no-env-file-later", files);
+    const { stdout, exitCode } = await run(String(dir), args, argv0);
+    expect(JSON.parse(stdout).bundle).toBe('"from-dot-env"');
+    expect(exitCode).toBe(0);
+  });
+
+  test.concurrent.each<Row>([
+    ["--no-env-file", ["--no-env-file", "server.ts"], "process.env.API_KEY"],
+    ["no switch", ["server.ts"], '"from-dot-env"'],
+  ])("%s: an HTML route with [serve.static] env = 'inline'", async (_, args, expected) => {
+    using dir = tempDir("no-env-file-html", {
+      ".env": files[".env"],
+      "bunfig.toml": '[serve.static]\nenv = "inline"\n',
+      "client.ts": files["client.ts"],
+      "index.html": '<!doctype html><script type="module" src="./client.ts"></script>\n',
+      "server.ts": `
+        import index from "./index.html";
+
+        using server = Bun.serve({ port: 0, development: false, routes: { "/": index } });
+        const html = await (await fetch(server.url)).text();
+        const script = await (await fetch(new URL(/src="([^"]+)"/.exec(html)![1], server.url))).text();
+        console.log(/console\\.log\\((.*?)\\)/.exec(script)![1]);
+      `,
+    });
+    const { stdout, exitCode } = await run(String(dir), args);
+    expect(stdout).toBe(expected + "\n");
+    expect(exitCode).toBe(0);
+  });
+
+  // A worker of `bun test --parallel` reads no env file when it starts, with or without the switch.
+  test.concurrent.each<Row>([
+    ["--no-env-file", ["--no-env-file"], "process.env.API_KEY"],
+    ["no switch", [], '"from-dot-env"'],
+  ])("bun test --parallel, %s: a build in a directory with a .env of its own", async (_, flags, expected) => {
+    const testFile = `
+      import { test } from "bun:test";
+      import { inlined } from "./inlined.ts";
+
+      test("build", async () => {
+        process.chdir(import.meta.dir + "/pkg");
+        console.log("INLINED " + (await inlined()));
+      });
+    `;
+    using dir = tempDir("no-env-file-parallel", {
+      "pkg/.env": files[".env"],
+      "pkg/client.ts": files["client.ts"],
+      "inlined.ts": files["inlined.ts"],
+      "a.test.ts": testFile,
+      "b.test.ts": testFile,
+    });
+    const { stdout, stderr, exitCode } = await run(String(dir), ["test", "--parallel=2", ...flags]);
+    expect([...(stdout + stderr).matchAll(/^INLINED (.*)$/gm)].map(match => match[1])).toEqual([expected, expected]);
+    expect(exitCode).toBe(0);
+  });
+});
diff --git a/test/cli/run/run-autoinstall.test.ts b/test/cli/run/run-autoinstall.test.ts
index 95ee83d0ac08..7aea1b139c6d 100644
--- a/test/cli/run/run-autoinstall.test.ts
+++ b/test/cli/run/run-autoinstall.test.ts
@@ -2591,13 +2591,15 @@ describe.concurrent("auto-install is off when a security scanner is configured",
     ["cannot be parsed", "[install.security\n", unreadable],
     ["configures a scanner", scanner, configured],
   ])("a bunfig.toml that %s", (_, bunfig, why) => {
+    // Run from outside the project: inside it bun reads that file itself, and does not start if it cannot be parsed.
     test("in the project root", async () => {
-      expect(await run({ ...project, "app/bunfig.toml": bunfig }, { cwd: "app/src" })).toEqual(refused(why));
+      const options = { cwd: "elsewhere", args: ["../app/src/index.js"] };
+      expect(await run({ ...project, "app/bunfig.toml": bunfig }, options)).toEqual(refused(why));
     });
 
-    test("between the working directory and the project root", async () => {
+    test("between the importing file and the project root", async () => {
       const files = { ...project, "app/src/bunfig.toml": bunfig, "app/src/deep/index.js": requireIt };
-      expect(await run(files, { cwd: "app/src/deep" })).toEqual(refused(why));
+      expect(await run(files, { cwd: "elsewhere", args: ["../app/src/deep/index.js"] })).toEqual(refused(why));
     });
 
     test("above the project root is not read", async () => {
@@ -2635,7 +2637,7 @@ describe.concurrent("auto-install is off when a security scanner is configured",
 
   test("the error of an import statement names the file that cannot be parsed", async () => {
     const files = { ...project, "app/bunfig.toml": "[install.security\n", "app/src/index.js": `import "no-deps";\n` };
-    const result = await run(files, { cwd: "app/src" });
+    const result = await run(files, { cwd: "elsewhere", args: ["../app/src/index.js"] });
     expect(result.stderr).toContain(unreadable);
     expect(result.stderr).toMatch(/cannot read or parse "\S+[\\/]bunfig\.toml"/);
     expect({ ...result, stderr: "" }).toEqual({ stdout: "", stderr: "", exitCode: 1, requests: [] });
diff --git a/test/cli/run/run-eval.test.ts b/test/cli/run/run-eval.test.ts
index 0c7462e3b5ec..5f8d80b56763 100644
--- a/test/cli/run/run-eval.test.ts
+++ b/test/cli/run/run-eval.test.ts
@@ -108,6 +108,70 @@ for (const flag of ["-e", "--print"]) {
   });
 }
 
+describe.concurrent("bun run -e / -p", () => {
+  async function run(cwd: string, ...args: string[]) {
+    await using proc = Bun.spawn({ cmd: [bunExe(), "run", ...args], cwd, env: bunEnv, stdout: "pipe", stderr: "pipe" });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    return { stdout: stdout.replaceAll("\r\n", "\n"), stderr, exitCode };
+  }
+
+  test.each([
+    [["-e", "console.log(process.argv.length)"], "1\n"],
+    [["--eval=console.log(1 + 2)"], "3\n"],
+    [["-p", "1 + 2"], "3\n"],
+  ])("%j evaluates the code", async (args, stdout) => {
+    using dir = tempDir("run-eval", { "package.json": JSON.stringify({ scripts: { dev: "echo dev" } }) });
+    expect(await run(String(dir), ...args)).toEqual({ stdout, stderr: "", exitCode: 0 });
+  });
+
+  test("with a script after it, the script runs", async () => {
+    using dir = tempDir("run-eval-target", { "package.json": JSON.stringify({ scripts: { dev: "echo dev" } }) });
+    expect(await run(String(dir), "-p", "3000", "dev")).toEqual({
+      stdout: "dev\n",
+      stderr: "$ echo dev\n",
+      exitCode: 0,
+    });
+  });
+});
+
+describe.concurrent("a word that names a command, after the flag", () => {
+  async function run(...args: string[]) {
+    using dir = tempDir("eval-command-word", {});
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), ...args],
+      cwd: String(dir),
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    return { stdout, stderr, exitCode };
+  }
+  const argv = "JSON.stringify(process.argv.slice(1))";
+
+  test.each([
+    ["--print", "x"],
+    ["--eval", "test"],
+  ])("bun %s %s evaluates the word", async (flag, word) => {
+    const { stdout, stderr, exitCode } = await run(flag, word);
+    expect(stderr).toContain(`ReferenceError: ${word} is not defined`);
+    expect(stdout).toBe("");
+    expect(exitCode).toBe(1);
+  });
+
+  test.each([[[`--print=${argv}`, "test"]], [[`--eval=console.log(${argv})`, "test"]], [["-p", argv, "test"]]])(
+    "bun %j passes the word to the code",
+    async args => {
+      expect(await run(...args)).toEqual({ stdout: `["test"]\n`, stderr: "", exitCode: 0 });
+    },
+  );
+
+  test("bun -p test runs the tests", async () => {
+    const { stdout } = await run("-p", "test");
+    expect(stdout).toContain("bun test");
+  });
+});
+
 describe("--print for cjs/esm", () => {
   test("eval result between esm imports", async () => {
     let cwd = tmpdirSync();
diff --git a/test/cli/run/run-extensionless.test.ts b/test/cli/run/run-extensionless.test.ts
index 9541b6cc4943..9bd1bb49aa62 100644
--- a/test/cli/run/run-extensionless.test.ts
+++ b/test/cli/run/run-extensionless.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import { mkdirSync, writeFileSync } from "fs";
-import { bunEnv, bunExe, isWindows, tmpdirSync } from "harness";
+import { bunEnv, bunExe, isWindows, tempDir, tmpdirSync } from "harness";
 import { join } from "path";
 
 describe.concurrent("run-extensionless", () => {
@@ -32,4 +32,24 @@ describe.concurrent("run-extensionless", () => {
     const stdout = await proc.stdout.text();
     expect(stdout).toEqual("hello world\n");
   });
+
+  // `<T>(x: T) => x` is a generic arrow function to the ts loader and an unclosed tag to the tsx loader.
+  test.each([
+    ["--loader=:ts", {}, ["--loader=:ts"]],
+    [`"" = "ts" under [loader] in bunfig.toml`, { "bunfig.toml": `[loader]\n"" = "ts"\n` }, []],
+  ])("%s sets the loader of a file with no extension", async (_, files, args) => {
+    using dir = tempDir("run-extensionless-loader", {
+      ...files,
+      "cool": `const id = <T>(x: T) => x; console.log(id("hello world"));`,
+    });
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), ...args, "./cool"],
+      cwd: String(dir),
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    expect({ stdout, stderr, exitCode }).toEqual({ stdout: "hello world\n", stderr: "", exitCode: 0 });
+  });
 });
diff --git a/test/cli/run/run_command.test.ts b/test/cli/run/run_command.test.ts
index 1190b3c3ba23..9bce69a96894 100644
--- a/test/cli/run/run_command.test.ts
+++ b/test/cli/run/run_command.test.ts
@@ -79,6 +79,53 @@ describe("bun", () => {
     expect(err).toContain('Script not found "nope"');
     expect(exitCode).toBe(1);
   });
+
+  describe.each(["buildall", "--if-present buildall"])("bun run %s, below a package that has the script", args => {
+    const run = (packageJson: string) => {
+      using dir = tempDir("package-json-below-a-package", {
+        "package.json": JSON.stringify({ name: "root", scripts: { buildall: "echo root" } }),
+        "packages/a/package.json": packageJson,
+      });
+      const { exitCode, stdout, stderr } = spawnSync({
+        cwd: join(String(dir), "packages", "a"),
+        cmd: [bunExe(), "run", ...args.split(" ")],
+        env: bunEnv,
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+      return { stdout: stdout.toString().trim(), stderr: stderr.toString(), exitCode };
+    };
+
+    test("a package.json that fails to parse is an error", () => {
+      expect(run(`{\n<<<<<<< HEAD\n  "scripts": { "buildall": "echo a" }\n}`)).toEqual({
+        stdout: "",
+        stderr: expect.stringContaining(join("packages", "a", "package.json") + ":2:1"),
+        exitCode: 1,
+      });
+    });
+
+    test.each(["\n", "[]"])("a package.json that is %j is no package.json", packageJson => {
+      expect(run(packageJson)).toEqual({ stdout: "root", stderr: "$ echo root\n", exitCode: 0 });
+    });
+  });
+
+  test.skipIf(isWindows)("a program in node_modules/.bin runs beside a package.json that fails to parse", () => {
+    using dir = tempDir("broken-package-json-bin", {
+      "package.json": "{",
+      "node_modules/.bin/tool": "#!/bin/sh\necho tool\n",
+    });
+    chmodSync(join(String(dir), "node_modules", ".bin", "tool"), 0o755);
+    const { exitCode, stdout, stderr } = spawnSync({
+      cwd: String(dir),
+      cmd: [bunExe(), "run", "tool"],
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(stderr.toString()).toBeEmpty();
+    expect(stdout.toString()).toBe("tool\n");
+    expect(exitCode).toBe(0);
+  });
 });
 
 // A working directory can be PATH_MAX - 1 bytes long. A file in it whose own path no longer fits a path buffer
@@ -142,6 +189,19 @@ describe.concurrent.skipIf(!isLinux)("a working directory close to PATH_MAX", ()
   });
 });
 
+test.skipIf(isWindows)("runs an entry point that is a pipe", async () => {
+  await using proc = Bun.spawn({
+    cmd: ["sh", "-c", `echo 'console.log(process.argv.slice(1).join())' | "$0" /dev/stdin extra`, bunExe()],
+    env: bunEnv,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+  expect(stderr).toBe("");
+  expect(stdout).toBe("/dev/stdin,extra\n");
+  expect(exitCode).toBe(0);
+});
+
 test.if(isWindows)("[windows] A file in drive root runs", async () => {
   const path = "C:\\root-file" + Math.random().toString().slice(2) + ".js";
   try {
diff --git a/test/cli/test/coverage.test.ts b/test/cli/test/coverage.test.ts
index f1caa6bfa312..9691adeabeb7 100644
--- a/test/cli/test/coverage.test.ts
+++ b/test/cli/test/coverage.test.ts
@@ -695,6 +695,38 @@ test("only imports the function", () => {
   expect(exitCode).toBe(0);
 });
 
+test.concurrent.each([
+  { threshold: "0.9", message: true, exitCode: 1 },
+  { threshold: "0.25", message: false, exitCode: 0 },
+])("coverageThreshold = $threshold with one of two functions covered exits $exitCode", async expected => {
+  using dir = tempDir("cov-threshold", {
+    "bunfig.toml": `[test]\ncoverageSkipTestFiles = true\ncoverageThreshold = ${expected.threshold}\n`,
+    "subject.ts": `export function called() {
+  return 1;
+}
+export function neverCalled() {
+  return 2;
+}
+`,
+    "subject.test.ts": `import { called } from "./subject.ts";
+test("calls one", () => {
+  called();
+});
+`,
+  });
+  // Without the table, the message is all that says why the run fails.
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), "test", "--coverage", "--coverage-reporter=lcov"],
+    env: bunEnv,
+    cwd: String(dir),
+    stdout: "ignore",
+    stderr: "pipe",
+  });
+  const [stderr, exitCode] = await Promise.all([proc.stderr.text(), proc.exited]);
+  const message = stderr.includes("error: coverage below coverageThreshold (functions 90.00%, lines 90.00%)\n");
+  expect({ threshold: expected.threshold, message, exitCode }).toEqual(expected);
+});
+
 // https://github.com/oven-sh/bun/issues/40586
 // Each worker executes a different function of the same module; the merged
 // report must count a function as covered if any worker ran it.
diff --git a/test/cli/test/parallel.test.ts b/test/cli/test/parallel.test.ts
index e27cba3868a9..0a628a4438d5 100644
--- a/test/cli/test/parallel.test.ts
+++ b/test/cli/test/parallel.test.ts
@@ -1,6 +1,7 @@
 import { expect, test } from "bun:test";
 import { bunEnv, bunExe, isASAN, isDebug, isLinux, isWindows, normalizeBunSnapshot, tempDir, tls } from "harness";
 import { mkfifo } from "mkfifo";
+import { symlinkSync } from "node:fs";
 import path from "path";
 
 test("--parallel: each worker has a unique JEST_WORKER_ID and BUN_TEST_WORKER_ID", async () => {
@@ -995,6 +996,46 @@ test("--parallel writes new snapshots from every worker", async () => {
   expect(code2).toBe(0);
 });
 
+test("--parallel exits 1 when a worker cannot update an inline snapshot", async () => {
+  using dir = tempDir("parallel-inline-snapshot-conflict", {
+    "a.test.js": `import {test,expect} from "bun:test"; test.each([1, 2])("value %i", v => { expect(v).toMatchInlineSnapshot(); });`,
+    "b.test.js": `import {test,expect} from "bun:test"; test("b",()=>expect(1).toBe(1));`,
+  });
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), "test", "--parallel=2"],
+    env: { ...bunEnv, BUN_TEST_PARALLEL_SCALE_MS: "0", CI: "false" },
+    cwd: String(dir),
+    stderr: "pipe",
+    stdout: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+  expect(stdout).toContain("PARALLEL");
+  expect(stderr).toContain("Failed to update inline snapshot");
+  expect(stderr).toContain("0 fail");
+  expect(exitCode).toBe(1);
+});
+
+test.skipIf(!isLinux)("--parallel exits 1 when a worker cannot write a .snap file", async () => {
+  using dir = tempDir("parallel-snap-disk-full", {
+    "a.test.js": `import {test,expect} from "bun:test"; test("a",()=>expect("value").toMatchSnapshot());`,
+    "b.test.js": `import {test,expect} from "bun:test"; test("b",()=>expect(1).toBe(1));`,
+    "__snapshots__": {},
+  });
+  symlinkSync("/dev/full", path.join(String(dir), "__snapshots__", "a.test.js.snap"));
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), "test", "--parallel=2"],
+    env: { ...bunEnv, BUN_TEST_PARALLEL_SCALE_MS: "0", CI: "false" },
+    cwd: String(dir),
+    stderr: "pipe",
+    stdout: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+  expect(stdout).toContain("PARALLEL");
+  expect(stderr).toContain("error: Failed to write snapshot file");
+  expect(stderr).toContain("0 fail");
+  expect(exitCode).toBe(1);
+});
+
 test("--parallel: a test producing a >64MB result line is truncated, not treated as a crash", async () => {
   // Test name just over the 64MB IPC frame limit → the per-test status line
   // itself exceeds it. The encoder must truncate so the receiver doesn't drop
diff --git a/test/cli/test/test-changed.test.ts b/test/cli/test/test-changed.test.ts
index abea2aadcd25..082986d228fc 100644
--- a/test/cli/test/test-changed.test.ts
+++ b/test/cli/test/test-changed.test.ts
@@ -393,6 +393,24 @@ describe.concurrent("bun test --changed", () => {
     expect(ranFiles(stderr, testNames)).toEqual(["alias.test.ts", "relative.test.ts"]);
     expect(exitCode).toBe(0);
   });
+
+  test("a WebAssembly read out of bounds throws in a selected test", async () => {
+    using dir = tempDir("test-changed-wasm-oob", {
+      "package.json": JSON.stringify({ name: "wasm-oob", type: "module" }),
+      // (memory 1) (func (export "f") (param i32) (result i32) (i32.load (local.get 0)))
+      "oob.test.ts": `import { test, expect } from "bun:test";
+const bytes = new Uint8Array([0,0x61,0x73,0x6d,1,0,0,0, 1,6,1,0x60,1,0x7f,1,0x7f, 3,2,1,0, 5,3,1,0,1, 7,5,1,1,0x66,0,0, 0x0a,9,1,7,0,0x20,0,0x28,2,0,0x0b]);
+const { f } = new WebAssembly.Instance(new WebAssembly.Module(bytes)).exports;
+test("oob", () => expect(() => f(70000)).toThrow(WebAssembly.RuntimeError));
+`,
+    });
+    initRepo(String(dir));
+    appendFileSync(join(String(dir), "oob.test.ts"), "// touched\n");
+
+    const { stderr, exitCode } = await runTestChanged(String(dir));
+    expect(stderr).toContain("(pass) oob");
+    expect(exitCode).toBe(0);
+  });
 });
 
 // On Windows, `bun test --watch` runs as a parent watcher-manager that
diff --git a/test/cli/watch/watch.test.ts b/test/cli/watch/watch.test.ts
index 8a871093c192..d69a16c493a4 100644
--- a/test/cli/watch/watch.test.ts
+++ b/test/cli/watch/watch.test.ts
@@ -24,6 +24,35 @@ function stdoutWaiter(proc: Subprocess<"ignore", "pipe", any>) {
   };
 }
 
+/** Collects what a child of `spawn({ terminal })` draws. */
+function terminalOutput() {
+  const decoder = new TextDecoder();
+  let output = "";
+  let closed = false;
+  let wake: (() => void) | undefined;
+  return {
+    options: {
+      cols: 120,
+      rows: 24,
+      data(_: unknown, chunk: Uint8Array) {
+        output += decoder.decode(chunk, { stream: true });
+        wake?.();
+      },
+      exit() {
+        closed = true;
+        wake?.();
+      },
+    },
+    output: () => output,
+    async waitFor(needle: string) {
+      while (!output.includes(needle)) {
+        if (closed) throw new Error(`terminal closed, output so far: ${JSON.stringify(output)}`);
+        await new Promise<void>(resolve => (wake = resolve));
+      }
+    },
+  };
+}
+
 for (const dir of ["dir", "©️"]) {
   it.todoIf(isBroken && isWindows)(
     `should watch files${dir === "dir" ? "" : " (non-ascii path)"}`,
@@ -344,11 +373,13 @@ it("--watch forces a restart when the kill-signal handler itself never returns",
   await watchee.exited;
 }, 30000);
 
-// With colors enabled, a reload also clears the terminal. The forced reload
+const clearScreen = "\x1b[2J\x1b[3J\x1b[H";
+
+// On a terminal, a reload also clears the screen. The forced reload
 // runs on the grace thread, which has its own thread-local Output state; the
 // clear used to write through that thread's never-initialized writers and
 // segfault instead of restarting.
-it("--watch forced restart clears the terminal when colors are enabled", async () => {
+it("--watch forced restart clears the terminal", async () => {
   using dir = tempDir("watch-busy-sigterm-clear-screen", {
     "busy.js": `
       process.on("SIGTERM", () => {});
@@ -359,42 +390,93 @@ it("--watch forced restart clears the terminal when colors are enabled", async (
     `,
   });
 
-  const env: typeof bunEnv = { ...bunEnv, FORCE_COLOR: "1" };
-  delete env.NO_COLOR;
-  // stderr is piped, not inherited: the clear sequence below would otherwise
-  // wipe the terminal running the test suite.
+  const screen = terminalOutput();
   const proc = spawn({
     cmd: [bunExe(), "--watch", "busy.js"],
     cwd: String(dir),
-    env,
-    stdout: "pipe",
-    stderr: "pipe",
+    env: { ...bunEnv, NO_COLOR: undefined },
+    terminal: screen.options,
   });
   watchee = proc;
-  const stderr = proc.stderr.text();
 
-  const { waitFor, release, output } = stdoutWaiter(proc);
-
-  await waitFor("iter first");
+  await screen.waitFor("iter first");
   await Bun.write(
     join(String(dir), "busy.js"),
     `process.on("SIGTERM", () => {});
      console.log("iter second");
      process.exit(0);`,
   );
+  await screen.waitFor("iter second");
+
+  proc.kill("SIGKILL");
+  await proc.exited;
+  proc.terminal!.close();
+
+  // A Windows pseudoconsole repaints its screen instead of passing the bytes on.
+  if (!isWindows) {
+    const output = screen.output();
+    const clearedAt = output.indexOf(clearScreen);
+    expect(clearedAt).toBeGreaterThan(-1);
+    expect(output.slice(0, clearedAt)).toContain("iter first");
+    expect(output.slice(clearedAt)).toContain("iter second");
+  }
+}, 30000);
+
+it("--watch with FORCE_COLOR=1 does not write the screen clear into a pipe", async () => {
+  using dir = tempDir("watch-no-clear-in-pipe", {
+    "app.js": `console.log("iter first"); setInterval(() => {}, 1000);`,
+  });
+
+  const proc = spawn({
+    cmd: [bunExe(), "--watch", "app.js"],
+    cwd: String(dir),
+    env: { ...bunEnv, NO_COLOR: undefined, FORCE_COLOR: "1" },
+    stdout: "pipe",
+    stderr: "pipe",
+    stdin: "ignore",
+  });
+  watchee = proc;
+  const stderr = proc.stderr.text();
+  const { waitFor, release, output } = stdoutWaiter(proc);
+
+  await waitFor("iter first");
+  await Bun.write(join(String(dir), "app.js"), `console.log("iter second"); setInterval(() => {}, 1000);`);
   await waitFor("iter second");
 
   release();
   proc.kill("SIGKILL");
   await proc.exited;
 
-  const clearScreen = "\x1b[2J\x1b[3J\x1b[H";
-  expect(output()).toContain(clearScreen);
-  const [beforeReload, afterReload] = output().split(clearScreen);
-  expect(beforeReload).toContain("iter first");
-  expect(afterReload).toContain("iter second");
-  expect(await stderr).toContain(clearScreen);
-}, 30000);
+  expect(output()).toBe("iter first\niter second\n");
+  expect(await stderr).not.toContain(clearScreen);
+});
+
+// `bun --watch server.ts | pino-pretty`: stderr is the terminal, and it is not cleared through it.
+it.skipIf(isWindows)("--watch piped into another program leaves the terminal as it is", async () => {
+  using dir = tempDir("watch-piped-on-terminal", {
+    "app.js": `console.log("iter first"); setInterval(() => {}, 1000);`,
+  });
+
+  const screen = terminalOutput();
+  const proc = spawn({
+    cmd: ["sh", "-c", `"${bunExe()}" --watch app.js | cat`],
+    cwd: String(dir),
+    env: { ...bunEnv, NO_COLOR: undefined },
+    terminal: screen.options,
+  });
+  watchee = proc;
+
+  await screen.waitFor("iter first");
+  await Bun.write(join(String(dir), "app.js"), `console.log("iter second"); setInterval(() => {}, 1000);`);
+  await screen.waitFor("iter second");
+
+  // `sh` leads the process group of the terminal, which `bun` and `cat` are in.
+  process.kill(-proc.pid, "SIGKILL");
+  await proc.exited;
+  proc.terminal!.close();
+
+  expect(screen.output()).not.toContain("\x1b[2J");
+});
 
 // execve replaces the process without reaching on_exit(), so the compile
 // cache must be flushed explicitly on the reload path; otherwise
diff --git a/test/config/bunfig/preload.test.ts b/test/config/bunfig/preload.test.ts
index 112725f55cad..958f75ec4d2a 100644
--- a/test/config/bunfig/preload.test.ts
+++ b/test/config/bunfig/preload.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, it, test } from "bun:test";
-import { bunEnv, bunExe, normalizeBunSnapshot } from "harness";
+import { bunEnv, bunExe, normalizeBunSnapshot, tempDir } from "harness";
 import { join, resolve } from "path";
 
 const fixturePath = (...segs: string[]) => resolve(import.meta.dirname, "fixtures", "preload", ...segs);
@@ -103,11 +103,11 @@ describe.concurrent("Given a `bunfig.toml` with a list of preloads", () => {
     //
     "--preload ./preload3.ts",
     "--preload=./preload3.ts",
+    "--preload=./preload3.ts run",
+    "run --preload ./preload3.ts",
+    "run --preload=./preload3.ts",
     // FIXME: Tests are failing due to active bugs
     // "--preload ./preload3.ts run",
-    // "--preload=./preload3.ts run",
-    // "run --preload ./preload3.ts",
-    // "run --preload=./preload3.ts",
   ])("When `bun %s index.ts` is run, `--preload` adds the target file to the list of preloads", async args => {
     const [out, err, code] = await run("index.ts", { args: args.split(" "), cwd: dir });
     expect(err).toBe("");
@@ -210,3 +210,98 @@ test.concurrent("Test BUN_INSPECT_PRELOAD is used to set preloads", async () =>
   expect(out).toMatchInlineSnapshot(`"[ "many/preload1.ts" ]"`);
   expect(code).toBe(0);
 }); // </Test BUN_INSPECT_PRELOAD is used to set preloads>
+
+describe.concurrent("Given a working directory without a `bunfig.toml`", () => {
+  const rootBunfig = `preload = ["./preload.ts"]\n[define]\nFROM_ROOT = "1"\n[test]\npreload = ["./preload.ts"]\n`;
+  const index = `console.log(typeof FROM_ROOT, typeof FROM_A);`;
+  const monorepo = {
+    "package.json": JSON.stringify({ name: "root", workspaces: ["packages/*"] }),
+    "bunfig.toml": rootBunfig,
+    "preload.ts": `console.log("root preload");`,
+    "packages/a/package.json": JSON.stringify({ name: "a" }),
+    "packages/a/index.ts": index,
+    "packages/a/src/index.ts": index,
+    "packages/a/a.test.ts": `test("passes", () => {\n  ${index}\n});`,
+  };
+  const fromRoot = "root preload\nnumber undefined";
+  const none = "undefined undefined";
+
+  it.each([
+    { name: "`bun <file>` in a workspace reads the one of the workspace root", args: [], out: fromRoot },
+    { name: "`bun run <file>` in a workspace reads the one of the workspace root", args: ["run"], out: fromRoot },
+    { name: "a directory below a workspace reads it too", cwd: "packages/a/src", out: fromRoot },
+    {
+      name: "a directory below a package.json reads the one next to the package.json",
+      files: { "package.json": `{}`, "scripts/index.ts": index },
+      cwd: "scripts",
+      out: fromRoot,
+    },
+    {
+      name: "the nearest one counts and the one above it does not",
+      files: { "packages/a/bunfig.toml": `[define]\nFROM_A = "1"\n` },
+      cwd: "packages/a/src",
+      out: "undefined number",
+    },
+    {
+      name: "the one above the workspace root does not count",
+      files: { "package.json": `{}`, "packages/package.json": JSON.stringify({ workspaces: ["*"] }) },
+      out: none,
+    },
+    {
+      name: "a package that is not a workspace of the root does not read the root's",
+      files: { "package.json": JSON.stringify({ workspaces: ["packages/*", "!packages/a"] }) },
+      out: none,
+    },
+    {
+      name: "a package below a package.json without workspaces does not read the one above",
+      files: { "package.json": `{}` },
+      out: none,
+    },
+    {
+      name: "a directory in node_modules does not read the project's",
+      files: { "node_modules/a/index.ts": index },
+      cwd: "node_modules/a",
+      out: none,
+    },
+  ])("$name", async ({ files = {}, cwd = "packages/a", args = [], out }) => {
+    using dir = tempDir("bunfig-above", { ...monorepo, ...files });
+    expect(await run("index.ts", { args, cwd: join(String(dir), cwd) })).toEqual([out, "", 0]);
+  });
+
+  it("`bun <file>` in a workspace fails if the one of the workspace root cannot be parsed", async () => {
+    using dir = tempDir("bunfig-above", { ...monorepo, "bunfig.toml": `[define\n` });
+    const [out, err, code] = await run("index.ts", { cwd: join(String(dir), "packages/a") });
+    expect(err).toContain("failed to load bunfig");
+    expect(out).toBe("");
+    expect(code).toBe(1);
+  });
+
+  it("`bun test` in a workspace reads the one of the workspace root", async () => {
+    using dir = tempDir("bunfig-above", monorepo);
+    const [out, , code] = await run("a.test.ts", { args: ["test"], cwd: join(String(dir), "packages/a") });
+    expect(out).toEndWith(fromRoot);
+    expect(code).toBe(0);
+  });
+
+  it("`bun build` in a workspace reads the one of the workspace root", async () => {
+    using dir = tempDir("bunfig-above", monorepo);
+    const [out, err, code] = await run("index.ts", { args: ["build"], cwd: join(String(dir), "packages/a") });
+    expect(err).toBe("");
+    expect(out).toContain(`console.log("number", typeof FROM_A);`);
+    expect(code).toBe(0);
+  });
+});
+
+it.concurrent("`--config` in another directory loads preloads from the working directory", async () => {
+  using dir = tempDir("bunfig-named", {
+    "config/bunfig.toml": `preload = ["./preload.ts"]`,
+    "config/preload.ts": `console.log("preload next to the config");`,
+    "preload.ts": `console.log("preload in the working directory");`,
+    "index.ts": `console.log("index");`,
+  });
+  expect(await run("index.ts", { args: ["--config=config/bunfig.toml"], cwd: String(dir) })).toEqual([
+    "preload in the working directory\nindex",
+    "",
+    0,
+  ]);
+});
diff --git a/test/js/bun/resolve/resolve.test.ts b/test/js/bun/resolve/resolve.test.ts
index f4768a73c60a..802c61dfd77e 100644
--- a/test/js/bun/resolve/resolve.test.ts
+++ b/test/js/bun/resolve/resolve.test.ts
@@ -1892,6 +1892,33 @@ describe("tsconfig paths skip `.d.ts` substitutions", () => {
   });
 });
 
+describe("a syntax error in tsconfig.json", () => {
+  const files = {
+    "tsconfig.json": `{ "compilerOptions": { "paths": { "@m/*": ["./src/*"] } } "include": [] }`,
+    "src/x.ts": `export const x = 1;`,
+    // Nothing is installed on the fly.
+    "node_modules/.keep": "",
+  };
+
+  test.concurrent("is printed when the entry point fails to load", async () => {
+    using dir = tempDir("tsconfig-syntax-error", {
+      ...files,
+      "entry.ts": `import { x } from "@m/x";\nconsole.log(x);`,
+    });
+    const result = await runWildcardScript(String(dir), "entry.ts");
+    expect(result.stdout).toBe("");
+    expect(result.stderr).toContain(`Cannot find module '@m/x'`);
+    expect(result.stderr).toContain(`error: Expected "," but found ""include""`);
+    expect(result.stderr).toContain(join(String(dir), "tsconfig.json") + ":1:");
+    expect(result.exitCode).toBe(1);
+  });
+
+  test.concurrent("is not printed by a script that calls process.exit()", async () => {
+    using dir = tempDir("tsconfig-syntax-error-exit", { ...files, "entry.ts": `console.log("ran"); process.exit(0);` });
+    expect(await runWildcardScript(String(dir), "entry.ts")).toEqual({ stdout: "ran", stderr: "", exitCode: 0 });
+  });
+});
+
 it.skipIf(isWindows)("runs a script from a working directory nested 256 directories deep", async () => {
   using dir = tempDir("resolver-deep-cwd", { ".keep": "" });
   const base = realpathSync(String(dir));
@@ -2121,3 +2148,85 @@ test.concurrent.each(["import", "require"])(
     expect({ stdout, stderr, exitCode }).toEqual({ stdout: "later.mjs\nlater.mjs\n", stderr: "", exitCode: 0 });
   },
 );
+
+describe.concurrent("--preserve-symlinks", () => {
+  // app/imported.mjs and app/entry.cjs are links to files of shared/. app/node_modules/foo is a link to store/foo.
+  function makeTree() {
+    const dir = tempDir("preserve-symlinks", {
+      "shared/imported.mjs": `
+        import { relative } from "node:path";
+        import dep from "./dep.mjs";
+        console.log(relative(process.cwd(), import.meta.path).replaceAll("\\\\", "/"), dep, import.meta.main);
+      `,
+      "shared/entry.cjs": `console.log(require("./dep.mjs").default, require.main === module);`,
+      "shared/dep.mjs": `export default "shared/dep.mjs";`,
+      "app/dep.mjs": `export default "app/dep.mjs";`,
+      "app/main.mjs": `import "./imported.mjs";`,
+      "app/worker.mjs": `new Worker("./imported.mjs");`,
+      "app/package-worker.mjs": `new Worker("./node_modules/foo/worker.js");`,
+      "app/node_modules/bar/index.js": `module.exports = "bar of app";`,
+      "store/foo/worker.js": `console.log(require("bar"));`,
+    });
+    const root = String(dir);
+    symlinkSync(join(root, "shared", "imported.mjs"), join(root, "app", "imported.mjs"), "file");
+    symlinkSync(join(root, "shared", "entry.cjs"), join(root, "app", "entry.cjs"), "file");
+    symlinkSync(join(root, "store", "foo"), join(root, "app", "node_modules", "foo"), "junction");
+    return dir;
+  }
+
+  async function run(args: string[], env: Record<string, string | undefined> = {}) {
+    using dir = makeTree();
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), ...args],
+      env: { ...bunEnv, ...env },
+      cwd: join(String(dir), "app"),
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    return { stdout, stderr, exitCode };
+  }
+
+  const atTheLink = "imported.mjs app/dep.mjs";
+  const atTheTarget = "../shared/imported.mjs shared/dep.mjs";
+
+  it.each([
+    ["an imported link runs where the link is", ["--preserve-symlinks", "main.mjs"], {}, `${atTheLink} false\n`],
+    ["so it does with NODE_PRESERVE_SYMLINKS=1", ["main.mjs"], { NODE_PRESERVE_SYMLINKS: "1" }, `${atTheLink} false\n`],
+    ["without the flag it runs where the link points", ["main.mjs"], {}, `${atTheTarget} false\n`],
+    ["an entry point runs where the link points", ["--preserve-symlinks", "imported.mjs"], {}, `${atTheTarget} true\n`],
+    ["a worker runs where the link points", ["--preserve-symlinks", "worker.mjs"], {}, `${atTheTarget} false\n`],
+    [
+      "a worker in a linked package finds the packages of the app",
+      ["--preserve-symlinks", "package-worker.mjs"],
+      {},
+      "bar of app\n",
+    ],
+    [
+      "with --preserve-symlinks-main an entry point runs where the link is",
+      ["--preserve-symlinks-main", "imported.mjs"],
+      {},
+      `${atTheLink} true\n`,
+    ],
+    [
+      "with --preserve-symlinks-main an entry point given without its extension runs where the link is",
+      ["run", "--preserve-symlinks-main", "./imported"],
+      {},
+      `${atTheLink} true\n`,
+    ],
+    [
+      "with --preserve-symlinks-main a CommonJS entry point is require.main",
+      ["--preserve-symlinks-main", "entry.cjs"],
+      {},
+      "app/dep.mjs true\n",
+    ],
+  ])("%s", async (_, args, env, stdout) => {
+    expect(await run(args, env)).toEqual({ stdout, stderr: "", exitCode: 0 });
+  });
+
+  it("bun build bundles an imported link from where the link is", async () => {
+    const { stdout, exitCode } = await run(["build", "--target=bun", "--preserve-symlinks", "main.mjs"]);
+    expect(stdout).toContain(`"app/dep.mjs"`);
+    expect(exitCode).toBe(0);
+  });
+});
diff --git a/test/js/bun/spawn/spawn.test.ts b/test/js/bun/spawn/spawn.test.ts
index da349043f5aa..e30338fc591e 100644
--- a/test/js/bun/spawn/spawn.test.ts
+++ b/test/js/bun/spawn/spawn.test.ts
@@ -2367,3 +2367,24 @@ describe.skipIf(!isPosix)("a spawn while fd 0, 1 or 2 is closed", () => {
     });
   });
 });
+
+// An ignored SIGCHLD survives exec. The kernel then reaps a child before its parent can wait for it.
+it.skipIf(isWindows)("reports the exit code of a child when the parent process ignores SIGCHLD", async () => {
+  await using proc = spawn({
+    cmd: [
+      "sh",
+      "-c",
+      'trap "" CHLD; exec "$0" "$@"',
+      bunExe(),
+      "-e",
+      `console.log(await Bun.spawn(["sh", "-c", "exit 3"]).exited)`,
+    ],
+    env: bunEnv,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+  expect(stderr).toBe("");
+  expect(stdout).toBe("3\n");
+  expect(exitCode).toBe(0);
+});
diff --git a/test/js/junit-reporter/junit.test.js b/test/js/junit-reporter/junit.test.js
index 5cf40e2d295d..7a5950c60d0d 100644
--- a/test/js/junit-reporter/junit.test.js
+++ b/test/js/junit-reporter/junit.test.js
@@ -608,6 +608,28 @@ describe("junit reporter", () => {
     expect(longPathCase.failure[0]._).toContain(`at fromLongPath (${longPath}:1:`);
     expect(pathCase.failure[0]._).toContain("at fromPath (generated.js:1:");
   });
+
+  it.each([
+    [["--reporter=junit", "--reporter=dots", "--reporter-outfile=junit.xml"], true],
+    [["--reporter-outfile=junit.xml"], false],
+  ])("%j writes the report: %p", async (flags, written) => {
+    await using tmpDir = tempDir("junit-and-dots", {
+      "package.json": "{}",
+      "a.test.js": `test("one", () => {});`,
+    });
+    await using proc = spawn([bunExe(), "test", ...flags], {
+      cwd: String(tmpDir),
+      env: bunEnv,
+      stdout: "ignore",
+      stderr: "pipe",
+    });
+    const [stderr, exitCode] = await Promise.all([proc.stderr.text(), proc.exited]);
+
+    expect(stderr).toContain("1 pass");
+    if (flags.includes("--reporter=dots")) expect(stderr).not.toContain("(pass)");
+    expect(await file(join(String(tmpDir), "junit.xml")).exists()).toBe(written);
+    expect(exitCode).toBe(0);
+  });
 });
 
 function filterJunitXmlOutput(xmlContent) {
diff --git a/test/js/node/process/process.test.js b/test/js/node/process/process.test.js
index 15dc93631425..75aa0e03c9c2 100644
--- a/test/js/node/process/process.test.js
+++ b/test/js/node/process/process.test.js
@@ -2366,6 +2366,22 @@ describe("process.exitCode", () => {
     );
   });
 
+  it.concurrent.each([
+    ["and nothing else", ""],
+    ["and process.exit() in the listener exits with 1", "process.exit();"],
+    ["and process.exitCode = 0 in the listener still exits with 1", "process.exitCode = 0;"],
+    ["and process.exitCode = 98 in the listener still exits with 1", "process.exitCode = 98;"],
+  ])("after an unhandled rejection an exit listener is told 1, %s", async (_, inListener) => {
+    await runInlineFixture(
+      `
+      process.on("exit", (code) => { console.log("exit", code, process.exitCode); ${inListener} });
+      Promise.reject(new Error("oops"));
+    `,
+      "exit 1 1\n",
+      1,
+    );
+  });
+
   it("exitsOnExitCodeSet", async () => {
     await runInlineFixture(
       `
diff --git a/test/js/web/console/console-log.test.ts b/test/js/web/console/console-log.test.ts
index 1152b1cb6cbc..11b203b77f6d 100644
--- a/test/js/web/console/console-log.test.ts
+++ b/test/js/web/console/console-log.test.ts
@@ -1,6 +1,6 @@
 import { file, spawn } from "bun";
 import { expect, it } from "bun:test";
-import { bunEnv, bunExe } from "harness";
+import { bunEnv, bunExe, isWindows } from "harness";
 import { join } from "node:path";
 
 it("should log to console correctly", async () => {
@@ -157,6 +157,35 @@ NamedError: console.error a named error
 `);
 });
 
+it("console.clear() with FORCE_COLOR=1 writes nothing into a pipe", async () => {
+  await using proc = spawn({
+    cmd: [bunExe(), "-e", "console.clear(); console.log('after clear');"],
+    env: { ...bunEnv, NO_COLOR: undefined, FORCE_COLOR: "1" },
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+  expect({ stdout, stderr, exitCode }).toEqual({ stdout: "after clear\n", stderr: "", exitCode: 0 });
+});
+
+// A Windows pseudoconsole repaints its screen instead of passing the bytes on.
+it.skipIf(isWindows)("console.clear() clears a terminal", async () => {
+  let output = "";
+  const eof = Promise.withResolvers<void>();
+  await using proc = spawn({
+    cmd: [bunExe(), "-e", "console.clear()"],
+    env: { ...bunEnv, NO_COLOR: undefined },
+    terminal: {
+      data: (_terminal, chunk) => void (output += Buffer.from(chunk).toString("latin1")),
+      exit: () => eof.resolve(),
+    },
+  });
+  const exitCode = await proc.exited;
+  await eof.promise;
+  expect(output).toBe("\x1b[2J\x1b[3J\x1b[H");
+  expect(exitCode).toBe(0);
+});
+
 it("console.log with SharedArrayBuffer", () => {
   // console.log(x) === Bun.inspect(x) + "\n" written to stdout.
   expect(Bun.inspect(new ArrayBuffer(0))).toBe("ArrayBuffer(0) []");

From 026a7e0a840afa71175ffaf4c51f5cf3fdf0dac9 Mon Sep 17 00:00:00 2001
From: Jarred Sumner <jarred@jarredsumner.com>
Date: Mon, 19 Oct 2026 02:30:00 +0000
Subject: [PATCH 19/24] cli: keep released behavior where the ported changes
 went past it

---
 completions/bun.bash                       |   6 +-
 docs/runtime/bunfig.mdx                    |   2 +-
 src/bunfig/arguments.rs                    |  18 +-
 src/dotenv/env_loader.rs                   |  32 ++-
 src/install/PackageManager.rs              |  18 +-
 src/js_parser_jsc/Macro.rs                 |   9 +-
 src/jsc/VirtualMachine.rs                  |   8 +-
 src/resolver/lib.rs                        |   7 +-
 src/resolver/resolver.rs                   |  11 +-
 src/runtime/cli/Arguments.rs               |  12 +-
 src/runtime/cli/create_command.rs          |   6 +-
 src/runtime/cli/filter_arg.rs              |  24 +--
 src/runtime/cli/mod.rs                     |  31 ++-
 src/runtime/cli/repl.rs                    |   3 +-
 src/runtime/cli/run_command.rs             | 120 ++++++------
 src/runtime/cli/test_command.rs            |  23 ++-
 src/runtime/jsc_hooks.rs                   |   4 +-
 src/sys/lib.rs                             |  15 --
 test/bundler/transpiler/macro-test.test.ts |  12 +-
 test/cli/bun.test.ts                       |  17 +-
 test/cli/bunfig-test-options.test.ts       |  13 ++
 test/cli/install/bun-create.test.ts        |  11 +-
 test/cli/install/bun-patch.test.ts         |  51 -----
 test/cli/run/filter-workspace.test.ts      |  41 ++--
 test/cli/run/hide-paths.c                  | 216 ---------------------
 test/cli/run/run-shell.test.ts             |  74 +++----
 test/cli/run/run_command.test.ts           |  29 ++-
 test/cli/test/parallel-signal.test.ts      |  87 ---------
 test/config/bunfig/preload.test.ts         |  18 +-
 test/js/bun/resolve/resolve.test.ts        |  12 ++
 test/js/junit-reporter/junit.test.js       |   2 +
 31 files changed, 324 insertions(+), 608 deletions(-)
 delete mode 100644 test/cli/run/hide-paths.c
 delete mode 100644 test/cli/test/parallel-signal.test.ts

diff --git a/completions/bun.bash b/completions/bun.bash
index 7f4898d29757..2072b438b655 100644
--- a/completions/bun.bash
+++ b/completions/bun.bash
@@ -47,7 +47,7 @@ _read_scripts_in_package_json() {
         local package_json_compreply;
         local matched="${BASH_REMATCH[@]:1}";
         local scripts="${matched%%\}*}";
-        scripts="${scripts//@(\"|\')/}";
+        scripts="${scripts//[\"\']/}";
         readarray -td, scripts <<<"${scripts}";
         for completion in "${scripts[@]}"; do
             [[ "${completion}" =~ ^[[:space:]]*([[:alnum:]@/:._-]+)[[:space:]]*: ]] && package_json_compreply+=( "${BASH_REMATCH[1]}" );
@@ -58,8 +58,7 @@ _read_scripts_in_package_json() {
     # when a script is passed as an option, do not show other scripts as part of the completion anymore
     local re_prev_script="(^| )${prev}($| )";
     [[
-        ( "${COMPREPLY[*]}" =~ ${re_prev_script} && -n "${COMP_WORDS[2]}" ) || \
-            ( "${COMPREPLY[*]}" =~ ${re_comp_word_script} )
+        ( "${COMPREPLY[*]}" =~ ${re_prev_script} && -n "${COMP_WORDS[2]}" )
     ]] && {
         local filtered_reply=();
         local reply_word script_name keep;
@@ -238,7 +237,6 @@ _bun_completions() {
                 "${GLOBAL_OPTIONS[*]}" \
                 "${GLOBAL_OPTIONS[SHORT_OPTIONS]}"
             [[ "${cur_word}" != -* ]] && {
-                _read_scripts_in_package_json;
                 COMPREPLY+=( $(compgen -W "${SUBCOMMANDS}" -- "${cur_word}") );
                 _file_arguments "${RUNNABLE_FILES}";
             }
diff --git a/docs/runtime/bunfig.mdx b/docs/runtime/bunfig.mdx
index 44cc30e9d89d..e82ac6a717d5 100644
--- a/docs/runtime/bunfig.mdx
+++ b/docs/runtime/bunfig.mdx
@@ -11,7 +11,7 @@ Bun relies on pre-existing configuration files like `package.json` and `tsconfig
 
 Put `bunfig.toml` in your project root, alongside your `package.json`.
 
-`bun <file>`, `bun run`, `bun test`, and `bun build` read the `bunfig.toml` in the working directory. If there is none, they read the nearest one in a parent directory of the same project. The search stops at the directory of the nearest `package.json`, or at the workspace root whose `workspaces` lists that directory. Bun reads only one of these files and does not merge them. It does not search parent directories when the working directory is inside `node_modules`.
+`bun <file>`, `bun run`, `bun test`, and `bun build` read the `bunfig.toml` in the working directory. If there is none, they read the nearest one in a parent directory of the same project. The search stops at the directory of the nearest `package.json`, or at the workspace root whose `workspaces` lists that directory. Bun reads only one of these files and does not merge them. It skips a file in a parent directory that belongs to another user than the working directory, and it does not search parent directories when the working directory is inside `node_modules`.
 
 To configure Bun's package manager globally, you can also create a `.bunfig.toml` file at one of the following paths:
 
diff --git a/src/bunfig/arguments.rs b/src/bunfig/arguments.rs
index ba4e71df3a82..8b05ba4f3ee6 100644
--- a/src/bunfig/arguments.rs
+++ b/src/bunfig/arguments.rs
@@ -178,6 +178,20 @@ fn lists_workspace(root: &[u8], dir: &[u8], buf: &mut PathBuffer) -> Option<bool
     })))
 }
 
+/// Whether `path` exists and, not following a link, has the owner of `cwd`, who could put the same file into `cwd`.
+#[cfg(unix)]
+fn has_owner_of(path: &ZStr, cwd: &[u8]) -> bool {
+    let Ok(file) = bun_sys::lstat(path) else {
+        return false;
+    };
+    bun_sys::lstat(&bun_core::ZBox::from_bytes(cwd)).is_ok_and(|dir| dir.st_uid == file.st_uid)
+}
+
+#[cfg(not(unix))]
+fn has_owner_of(path: &ZStr, _: &[u8]) -> bool {
+    bun_sys::exists_z(path)
+}
+
 /// The nearest bunfig.toml above `cwd` that is in the same project: not above the nearest package.json, or the workspace root that lists it.
 fn find_config_above<'buf>(cwd: &[u8], buf: &'buf mut PathBuffer) -> Option<&'buf ZStr> {
     // A dependency's scripts and a compiled executable are not part of the project they run in.
@@ -189,9 +203,7 @@ fn find_config_above<'buf>(cwd: &[u8], buf: &'buf mut PathBuffer) -> Option<&'bu
     let mut config_dir = cwd;
     loop {
         config_dir = bun_core::dirname(config_dir)?;
-        if bun_sys::exists_z(join_config_path(config_dir, b"bunfig.toml", buf)?)
-            && !bun_sys::is_shared_directory(config_dir)
-        {
+        if has_owner_of(join_config_path(config_dir, b"bunfig.toml", buf)?, cwd) {
             break;
         }
     }
diff --git a/src/dotenv/env_loader.rs b/src/dotenv/env_loader.rs
index 86152189298a..efb721e58000 100644
--- a/src/dotenv/env_loader.rs
+++ b/src/dotenv/env_loader.rs
@@ -164,6 +164,9 @@ pub static HAS_NO_CLEAR_SCREEN_CLI_FLAG: OnceLock<bool> = OnceLock::new();
 
 static DEFAULT_FILES_DISABLED: AtomicBool = AtomicBool::new(false);
 
+/// Held while a thread copies, adds to or reads a `Loader` that the other threads of a build use too.
+static SHARED: bun_core::Mutex<()> = bun_core::Mutex::new(());
+
 /// `--no-env-file` or bunfig `env = false`: from here on no `Loader` of the process reads a default `.env` file.
 pub fn disable_default_files() {
     DEFAULT_FILES_DISABLED.store(true, Ordering::Relaxed);
@@ -584,10 +587,9 @@ impl Loader {
         })
     }
 
-    /// A copy for a VM on another thread: the map plus the record of what the
-    /// source already loaded (process env, default and explicit `.env` files).
-    /// The copy reads only the files the source skipped, into its own map.
+    /// A copy for a VM on another thread, with the record of what `self` has read, so it reads only the rest.
     pub fn clone_loaded(&self) -> Result<Loader, AllocError> {
+        let _shared = SHARED.lock();
         Ok(Loader {
             map: self.map.clone_with_allocator()?,
             default_files_loaded: self.default_files_loaded,
@@ -599,6 +601,27 @@ impl Loader {
         })
     }
 
+    /// Takes over what `copy`, made by `clone_loaded`, has read from env files since.
+    pub fn adopt_loaded(&mut self, copy: &Loader) -> Result<(), AllocError> {
+        let _shared = SHARED.lock();
+        for (key, entry) in copy.map.map.iter() {
+            if self.map.get(key).is_none() {
+                self.map.put(key, &entry.value)?;
+            }
+        }
+        self.default_files_loaded |= copy.default_files_loaded;
+        for file in copy.custom_files_loaded.keys() {
+            self.custom_files_loaded.insert(file)?;
+        }
+        Ok(())
+    }
+
+    /// `NODE_PATH`, as a copy: the thread of a macro VM may be in `adopt_loaded`.
+    pub fn node_path(&self) -> Box<[u8]> {
+        let _shared = SHARED.lock();
+        self.get(b"NODE_PATH").map(Box::from).unwrap_or_default()
+    }
+
     pub fn load_process(&mut self) -> Result<(), AllocError> {
         if self.did_load_process {
             return Ok(());
@@ -613,8 +636,7 @@ impl Loader {
                 let key = &env[..i as usize];
                 let value = &env[i as usize + 1..];
                 if !key.is_empty() {
-                    // Our inherited IPC channel is not for children spawned from
-                    // this env (Node drops these too); `bun run` re-adds them.
+                    // Not for the children spawned from this env, as in Node. `bun run` adds them again.
                     if is_ipc_channel_key(key) {
                         continue;
                     }
diff --git a/src/install/PackageManager.rs b/src/install/PackageManager.rs
index 4388b5f86bb9..ce8e603d6514 100644
--- a/src/install/PackageManager.rs
+++ b/src/install/PackageManager.rs
@@ -2034,7 +2034,7 @@ impl<'a> PackageJsonWalk<'a> {
             );
             if !matches!(&opened, Err(e) if e.get_errno() == bun_sys::E::ENOENT)
                 && dir.len() != self.cwd.len()
-                && bun_sys::is_shared_directory(dir)
+                && is_shared_directory(dir)
             {
                 bun_core::warn!(
                     "ignoring package.json in <b>{}<r>: directory is writable by other users",
@@ -2249,6 +2249,22 @@ fn find_workspace_root_above<'a>(
     Ok(None)
 }
 
+/// Returns true if `dir` is sticky and group- or world-writable, like `/tmp`. Any local user can
+/// create a `package.json` there.
+#[cfg(unix)]
+fn is_shared_directory(dir: &[u8]) -> bool {
+    use bun_sys::S;
+    !bun_sys::stat(&ZBox::from_bytes(dir)).is_ok_and(|st| {
+        let mode = st.st_mode as bun_sys::Mode;
+        mode & S::ISVTX == 0 || mode & (S::IWGRP | S::IWOTH) == 0
+    })
+}
+
+#[cfg(not(unix))]
+fn is_shared_directory(_: &[u8]) -> bool {
+    false
+}
+
 /// Finds the project that `dir` is in, the way `init` does: the directory of the nearest
 /// package.json, or the workspace root that this directory belongs to. A package.json that only
 /// says how to read the files next to it, such as `{ "type": "commonjs" }`, belongs to the project
diff --git a/src/js_parser_jsc/Macro.rs b/src/js_parser_jsc/Macro.rs
index b7918323713b..6087a7c3f3ef 100644
--- a/src/js_parser_jsc/Macro.rs
+++ b/src/js_parser_jsc/Macro.rs
@@ -446,8 +446,8 @@ impl Macro {
             // build thread reads it while this thread parses. This VM's transpiler
             // loads `.env` files into its loader, so it gets a copy, owned by the VM.
             // SAFETY: `env` comes from `MacroContext.env`, the transpiler's loader,
-            // which is live for the whole build. The bundler does not write it
-            // while parse tasks run.
+            // which is live for the whole build. While parse tasks run it is written
+            // only by `adopt_loaded`, under the lock that `clone_loaded` takes.
             let owned_env_loader = match unsafe { env.as_ref() } {
                 Some(env) => Some(Box::new(env.clone_loaded()?)),
                 None => None,
@@ -475,6 +475,11 @@ impl Macro {
         if is_new_vm {
             // SAFETY: `vm` is the freshly-allocated per-thread VM.
             unsafe { (*vm).transpiler.configure_defines()? };
+            // The build resolves the imports of this module with what the VM read, a `NODE_PATH` in `.env`.
+            // SAFETY: as for `clone_loaded` above; the VM's loader is its own.
+            if let Some(env) = unsafe { env.as_mut() } {
+                env.adopt_loaded(unsafe { (*vm).transpiler.env() })?;
+            }
         }
 
         // SAFETY: `vm` is the per-thread VM; uniquely accessed here.
diff --git a/src/jsc/VirtualMachine.rs b/src/jsc/VirtualMachine.rs
index f1f31b8802c7..9a0d36c773e4 100644
--- a/src/jsc/VirtualMachine.rs
+++ b/src/jsc/VirtualMachine.rs
@@ -93,10 +93,7 @@ pub struct InitOptions {
     /// `RuntimeHooks::init_runtime_state` so the high-tier `Transpiler::init`
     /// reuses the caller's env loader.
     pub env_loader: Option<NonNull<bun_dotenv::Loader>>,
-    /// An env loader the VM owns, for a VM whose caller's loader belongs to
-    /// another thread (a parse-worker macro VM copies the build's loader).
-    /// The VM's transpiler uses it in place of `env_loader`, and the VM's
-    /// runtime state frees it on teardown.
+    /// Used in place of `env_loader` and freed with the VM: a macro VM's copy of the loader of the build.
     pub owned_env_loader: Option<Box<bun_dotenv::Loader>>,
     pub graph: Option<&'static dyn bun_resolver::StandaloneModuleGraph>,
     /// `--install=...`; the resolver needs it before `configure_linker()` caches package.json.
@@ -4335,8 +4332,7 @@ impl VirtualMachine {
             self.transpiler_store.enabled = false;
         }
 
-        // Not in `map`: `Loader::load_process` drops it so children don't inherit
-        // the channel. Main thread only (Node: no process.send() in workers).
+        // `Loader::load_process` keeps it out of `map` so that children don't inherit the channel.
         if self.is_main_thread() {
             if let Some(fd_s) = bun_core::env_var::NODE_CHANNEL_FD.get() {
                 let advanced = bun_core::env_var::NODE_CHANNEL_SERIALIZATION_MODE
diff --git a/src/resolver/lib.rs b/src/resolver/lib.rs
index 466c2aa92824..9b535d3c45be 100644
--- a/src/resolver/lib.rs
+++ b/src/resolver/lib.rs
@@ -1741,7 +1741,12 @@ pub mod dir_entry_accessor {
 
     impl AccessorDirEntry for DirEntryIterResult {
         fn name_slice(&self) -> &[u8] {
-            self.entry.base()
+            // On disks that ignore case the lower-case name opens, and lower-case patterns match it.
+            if cfg!(any(windows, target_os = "macos")) {
+                self.entry.base_lowercase()
+            } else {
+                self.entry.base()
+            }
         }
         fn kind(&self) -> bun_sys::FileKind {
             self.kind
diff --git a/src/resolver/resolver.rs b/src/resolver/resolver.rs
index 65190eec22e8..dc5f1d78fddf 100644
--- a/src/resolver/resolver.rs
+++ b/src/resolver/resolver.rs
@@ -1643,9 +1643,8 @@ impl<'a> Resolver<'a> {
                 }
             }
 
-            // Imports only, as in Node. For `EntryPointRun` the option holds `--preserve-symlinks-main`.
-            let preserve_symlinks =
-                self.opts.preserve_symlinks && kind != ast::ImportKind::EntryPointBuild;
+            // Imports only, as in Node. An entry point that is a link keeps the link's path in `pretty`.
+            let preserve_symlinks = self.opts.preserve_symlinks && !kind.is_entry_point();
 
             // Probe the listing in one `entries_mutex` critical section: a
             // concurrent resolver at a newer generation rewrites this `DirEntry`'s
@@ -2873,10 +2872,10 @@ impl<'a> Resolver<'a> {
 
         // try resolve from `NODE_PATH`
         // https://nodejs.org/api/modules.html#loading-from-the-global-folders
-        let node_path: &[u8] = self
+        let node_path: Box<[u8]> = self
             .env_loader()
-            .and_then(|env| env.get(b"NODE_PATH"))
-            .unwrap_or(b"");
+            .map(DotEnv::Loader::node_path)
+            .unwrap_or_default();
         if !node_path.is_empty() {
             let delim = if cfg!(windows) { b';' } else { b':' };
             for path in node_path.split(|&b| b == delim).filter(|s| !s.is_empty()) {
diff --git a/src/runtime/cli/Arguments.rs b/src/runtime/cli/Arguments.rs
index 77491a4952eb..21db02b7b43d 100644
--- a/src/runtime/cli/Arguments.rs
+++ b/src/runtime/cli/Arguments.rs
@@ -1820,7 +1820,17 @@ fn parse_test_command_options(args: &clap::Args<clap::Help>, ctx: Context<'_>) {
         ctx.test_options.reporter_outfile = Some(reporter_outfile.into());
     }
 
-    for &reporter in args.options(b"--reporter") {
+    if let Some((&reporter, earlier)) = args.options(b"--reporter").split_last() {
+        // Only the last one can fail the run.
+        for &reporter in earlier {
+            match reporter {
+                b"junit" if ctx.test_options.reporter_outfile.is_some() => {
+                    ctx.test_options.reporters.junit = true;
+                }
+                b"dots" | b"dot" => ctx.test_options.reporters.dots = true,
+                _ => {}
+            }
+        }
         if reporter == b"junit" {
             // A `--parallel` worker only collects for the coordinator's file.
             if ctx.test_options.reporter_outfile.is_none() && !args.flag(b"--test-worker") {
diff --git a/src/runtime/cli/create_command.rs b/src/runtime/cli/create_command.rs
index 8e7663f83db8..a7e9917a334c 100644
--- a/src/runtime/cli/create_command.rs
+++ b/src/runtime/cli/create_command.rs
@@ -167,10 +167,8 @@ impl CreateOptions {
         };
 
         let mut positionals = args.positionals().to_vec();
-        // What precedes the command is the value of a flag of `bun`.
-        let is_command = |it: &&[u8]| matches!(*it, b"c" | b"create");
-        if let Some(command) = positionals.iter().position(is_command) {
-            positionals.drain(..=command);
+        if !positionals.is_empty() && (positionals[0] == b"c" || positionals[0] == b"create") {
+            positionals.remove(0);
         }
 
         Ok(CreateOptions {
diff --git a/src/runtime/cli/filter_arg.rs b/src/runtime/cli/filter_arg.rs
index 544c44b9fa6b..6dc8528727cc 100644
--- a/src/runtime/cli/filter_arg.rs
+++ b/src/runtime/cli/filter_arg.rs
@@ -18,6 +18,8 @@ use bun_resolver::package_json::{IncludeDependencies, IncludeScripts};
 use crate::cli::Command;
 
 const SKIP_LIST: &[&[u8]] = &[
+    // skip hidden directories
+    b".",
     // skip node_modules
     b"node_modules",
     // skip .git folder
@@ -456,24 +458,6 @@ impl<'a> PackageFilterIterator<'a> {
         })
     }
 
-    /// The file system looks up an entry without glob syntax, so it decides whether case matters.
-    fn find_literal(&self) -> Option<glob::walk::MatchedPath> {
-        let pattern: &[u8] = &self.patterns[self.pattern_idx];
-        if glob::detect_glob_syntax(pattern)
-            || strings::split_any(pattern, b"/\\").any(glob_ignore_fn)
-        {
-            return None;
-        }
-        let mut buf = path_buffer_pool::get();
-        let path = resolve_path::join_abs_string_buf_z_checked::<platform::Auto>(
-            self.root_dir,
-            &mut buf[..],
-            &[pattern],
-        )?;
-        let stat = bun_sys::stat(path).ok()?;
-        bun_sys::is_regular_file(stat.st_mode as bun_sys::Mode).then(|| path.as_bytes().into())
-    }
-
     /// As in `bun install`, a `!` entry removes a glob match, but never a path that's listed
     /// literally.
     fn is_excluded(&self, package_json_path: &[u8]) -> bool {
@@ -492,10 +476,6 @@ impl<'a> PackageFilterIterator<'a> {
                 if self.pattern_idx >= self.patterns.len() {
                     return Ok(None);
                 }
-                if let Some(path) = self.find_literal() {
-                    self.pattern_idx += 1;
-                    return Ok(Some(path));
-                }
                 self.active = Some(self.start_walk()?);
                 continue;
             };
diff --git a/src/runtime/cli/mod.rs b/src/runtime/cli/mod.rs
index 62dca9231273..0b2a829b914e 100644
--- a/src/runtime/cli/mod.rs
+++ b/src/runtime/cli/mod.rs
@@ -745,6 +745,7 @@ pub(crate) mod command {
 
         // A flag of `bun` can have its value in the next argument, as in `bun --cwd dir run dev`.
         let mut after_value = false;
+        let mut in_packages = false;
         let name = loop {
             let Some(arg) = iter.next() else {
                 return Tag::AutoCommand;
@@ -756,6 +757,8 @@ pub(crate) mod command {
             if arg[1..].starts_with(b"e") || matches!(flag, b"--eval" | b"--print") {
                 return Tag::AutoCommand;
             }
+            in_packages |=
+                arg == b"--workspaces" || arg.starts_with(b"--filter") || arg.starts_with(b"-F");
             // `--interactive` stays on AutoCommand: Arguments.rs parses it and the no-target check
             // routes to RunCommand::exec_node_repl. An early ReplCommand return here would bypass
             // that and boot the legacy `bun repl` implementation instead.
@@ -779,13 +782,14 @@ pub(crate) mod command {
         use super::script_or_command::{Runs, is_of_the_project, runs};
         let tag = command_named(name);
         let project_has_it = match tag {
-            Tag::AutoCommand | Tag::RunCommand => false,
+            Tag::AutoCommand => false,
+            // `bun --workspaces --cwd dir run` runs the `run` script of each package.
+            Tag::RunCommand => after_value && in_packages,
             Tag::CheckCommand | Tag::LintCommand | Tag::FormatCommand => is_of_the_project(name),
+            // `bun create` would ignore the `--cwd`, and a reserved word is no command.
+            Tag::CreateCommand | Tag::ReservedCommand => after_value,
             // `bun --cwd dir build` is `bun build` only if the project has no `build` to run. Scripts have `bun` in `PATH`.
-            _ if after_value => {
-                tag == Tag::ReservedCommand || name == b"bun" || runs(name) != Runs::Command
-            }
-            _ => false,
+            _ => after_value && (name == b"bun" || runs(name) != Runs::Command),
         };
         match project_has_it {
             true => Tag::AutoCommand,
@@ -1353,7 +1357,9 @@ pub(crate) mod command {
         // InitCommand parses its own argv (no Context).
         let argv = argv_zslice();
         print_help_if_asked_before(&argv, b"init", Tag::InitCommand);
-        change_directory_before(b"init");
+        if let Some(cwd) = lint_command::cwd_before(b"init") {
+            lint_command::change_directory(cwd);
+        }
         super::init_command::InitCommand::exec(after_command(&argv, b"init"))
     }
 
@@ -1436,13 +1442,6 @@ pub(crate) mod command {
         &[]
     }
 
-    /// Applies `--cwd` among the flags of `bun`, which precede `command`, for a command that reads argv itself.
-    fn change_directory_before(command: &[u8]) {
-        if let Some(cwd) = lint_command::cwd_before(command) {
-            lint_command::change_directory(cwd);
-        }
-    }
-
     /// The flags of `command` that stand before it, as in `bun --check format` or `bun -c format`, and then what follows it. If
     /// they were dropped, `--check` would write. `knows` tells whether `command` has a flag. The others are for `bun`, or come
     /// from `BUN_OPTIONS`.
@@ -1745,10 +1744,7 @@ pub(crate) mod command {
             while remainder_i < remainder.len() && positional_i < positionals.len() {
                 let slice = strings::trim(remainder[remainder_i].as_bytes(), b" \t\n");
                 if !slice.is_empty() {
-                    // What precedes the command is the value of a flag of `bun`.
-                    if !strings::has_prefix(slice, b"--")
-                        && (positional_i > 0 || matches!(slice, b"create" | b"c"))
-                    {
+                    if !strings::has_prefix(slice, b"--") {
                         if positional_i == 1 {
                             template_name_start = remainder_i + 2;
                         }
@@ -1776,7 +1772,6 @@ pub(crate) mod command {
             Global::exit(0);
         }
 
-        change_directory_before(positionals[0]);
         let template_name = positionals[1];
 
         // if template_name is "react" — deprecated; redirect to react-app/vite.
diff --git a/src/runtime/cli/repl.rs b/src/runtime/cli/repl.rs
index ca00b44d6226..ecd43b98e0d0 100644
--- a/src/runtime/cli/repl.rs
+++ b/src/runtime/cli/repl.rs
@@ -2852,8 +2852,7 @@ static SIGINT_ARMED: core::sync::atomic::AtomicBool = core::sync::atomic::Atomic
 /// A SIGINT arrived during such a wait: stop waiting. Not a VM stop — the VM stays usable.
 static SIGINT_DURING_WAIT: core::sync::atomic::AtomicBool =
     core::sync::atomic::AtomicBool::new(false);
-/// The loop that wait parks in. The poll retries on EINTR, so the signal does not end it:
-/// `sigint_handler` wakes it.
+/// The loop that wait parks in. The poll retries on EINTR, so `sigint_handler` wakes it.
 #[cfg(unix)]
 static SIGINT_WAKES: core::sync::atomic::AtomicPtr<bun_uws::Loop> =
     core::sync::atomic::AtomicPtr::new(core::ptr::null_mut());
diff --git a/src/runtime/cli/run_command.rs b/src/runtime/cli/run_command.rs
index 83c6496f9e7f..2b5244601443 100644
--- a/src/runtime/cli/run_command.rs
+++ b/src/runtime/cli/run_command.rs
@@ -436,8 +436,7 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
         #[cfg(windows)]
         let ipc_fd: Option<bun_sys::Fd> = None; // TODO: implement on Windows
 
-        // `Loader::load_process` drops these; a package script inherits the
-        // channel on purpose (#11132), so restore them alongside `ipc_fd`.
+        // `Loader::load_process` drops these, but a package script inherits the channel on purpose (#11132).
         #[cfg(not(windows))]
         if ipc_fd.is_some() {
             if let Some(fd_s) = bun_core::env_var::NODE_CHANNEL_FD.get() {
@@ -2400,24 +2399,32 @@ impl RunCommand {
         }
     }
 
-    /// Whether the nearest package.json, in `dir` or above it, has a syntax error. `enclosing_package_json` skips such a file.
+    /// The file that the error `msg` is located in.
+    fn file_of_error(msg: &bun_ast::Msg) -> Option<&[u8]> {
+        let at = msg.data.location.as_ref()?;
+        (msg.kind == bun_ast::Kind::Err).then_some(&at.file[..])
+    }
+
+    /// The nearest package.json, in `dir` or above it, if it has a syntax error. `enclosing_package_json` skips such a file.
     #[cold]
     #[inline(never)]
-    fn nearest_package_json_is_broken(log: &bun_ast::Log, dir: bun_resolver::DirInfoRef) -> bool {
+    fn nearest_broken_package_json(
+        log: &bun_ast::Log,
+        dir: bun_resolver::DirInfoRef,
+    ) -> Option<Box<[u8]>> {
         let loaded = dir.enclosing_package_json;
         let loaded_path_len = loaded.map_or(0, |it| it.source.path.text.len());
         // The resolver has read `dir` and its parents only, so a longer path is that of a nearer file.
-        log.msgs.iter().any(|msg| {
-            let Some(at) = &msg.data.location else {
-                return false;
-            };
-            msg.kind == bun_ast::Kind::Err
-                && at.file.len() > loaded_path_len
-                && paths::basename(&at.file) == b"package.json"
-                // A file of nothing but whitespace counts as no file.
-                && sys::File::read_from(Fd::cwd(), &at.file)
+        (log.msgs.iter().filter_map(Self::file_of_error))
+            .filter(|file| file.len() > loaded_path_len)
+            .filter(|file| paths::basename(file) == b"package.json")
+            // A file of nothing but whitespace counts as no file.
+            .filter(|file| {
+                sys::File::read_from(Fd::cwd(), file)
                     .is_ok_and(|text| !strings::trim(&text, b" \t\r\n").is_empty())
-        })
+            })
+            .max_by_key(|file| file.len())
+            .map(Box::from)
     }
 
     /// Dispatch `bun run <target>`: classify as file path vs. package.json
@@ -2539,10 +2546,12 @@ impl RunCommand {
         // SAFETY: `ctx.log` set in `create_context_data` (single-threaded
         // CLI startup), process-lifetime.
         let log = unsafe { ctx.log() };
-        let package_json_is_broken = !skip_script_check
-            && log.has_errors()
-            && Self::nearest_package_json_is_broken(log, root_dir);
-        if !skip_script_check && !package_json_is_broken {
+        let broken_package_json = if !skip_script_check && log.has_errors() {
+            Self::nearest_broken_package_json(log, root_dir)
+        } else {
+            None
+        };
+        if !skip_script_check && broken_package_json.is_none() {
             if let Some(package_json) = root_dir.enclosing_package_json {
                 if let Some(scripts) = package_json.scripts.as_deref() {
                     if let Some(&script_content) = scripts.get(target_name) {
@@ -2701,7 +2710,9 @@ impl RunCommand {
                     bun_core::scoped_log!(RUN_LOG, "Resolved to: `{}`", bstr::BStr::new(path.text));
                     // borrowck — `boot_and_handle_error` takes
                     // `&mut ctx`; copy `path.text` out of the resolver borrow.
-                    let text: Box<[u8]> = path.text.to_vec().into_boxed_slice();
+                    let keeps_link = ctx.runtime_options.preserve_symlinks_main && path.is_symlink;
+                    let text = if keeps_link { path.pretty } else { path.text };
+                    let text: Box<[u8]> = text.to_vec().into_boxed_slice();
                     return Ok(Self::boot_and_handle_error(ctx, &text, Some(loader)));
                 } else {
                     bun_core::scoped_log!(
@@ -2811,7 +2822,7 @@ impl RunCommand {
         }
 
         // ── failure ─────────────────────────────────────────────────────────
-        if ctx.runtime_options.if_present && !package_json_is_broken {
+        if ctx.runtime_options.if_present && broken_package_json.is_none() {
             return Ok(true);
         }
 
@@ -2875,16 +2886,13 @@ impl RunCommand {
             return Ok(true);
         }
 
-        if log_errors || package_json_is_broken {
-            // The resolver records a package.json that fails to load (a
-            // syntax error, an unreadable file) in `ctx.log` and returns a
-            // `DirInfo` without it.
-            //
-            // SAFETY: `ctx.log` set in `create_context_data` (single-threaded
-            // CLI startup), process-lifetime.
-            let log = unsafe { ctx.log() };
-            let has_log_errors = log.has_errors();
-            if has_log_errors {
+        if log_errors || broken_package_json.is_some() {
+            if let Some(path) = &broken_package_json {
+                // SAFETY: `ctx.log` set in `create_context_data` (single-threaded
+                // CLI startup), process-lifetime.
+                let log = unsafe { ctx.log() };
+                log.msgs
+                    .retain(|msg| Self::file_of_error(msg) == Some(&path[..]));
                 let _ = log.print(std::ptr::from_mut::<bun_core::io::Writer>(
                     Output::error_writer(),
                 ));
@@ -2918,11 +2926,7 @@ impl RunCommand {
                         "<r><red>error<r><d>:<r> <b>File not found \"<b>{}<r>\"",
                         bstr::BStr::new(target_name),
                     );
-                } else if !(has_log_errors && root_dir.enclosing_package_json.is_none()) {
-                    // With no usable package.json and an error that says
-                    // why, the error is the message. "Script not found"
-                    // would claim the script is absent from a file that
-                    // did not load.
+                } else {
                     pretty_errorln!(
                         "<r><red>error<r><d>:<r> <b>Script not found \"<b>{}<r>\"",
                         bstr::BStr::new(target_name),
@@ -3043,26 +3047,26 @@ impl RunCommand {
 
         // Re-derive the canonical absolute path from the open fd (resolves
         // symlinks). `--preserve-symlinks-main` keeps the path as given.
-        let absolute_script_path: Option<Box<[u8]>> =
-            if ctx.runtime_options.preserve_symlinks_main_enabled() {
-                let mut cwd_buf = bun_paths::path_buffer_pool::get();
-                let mut joined_buf = bun_paths::path_buffer_pool::get();
-                match bun_core::getcwd(&mut cwd_buf) {
-                    Ok(cwd) => {
-                        paths::resolve_path::join_abs_string_buf_checked::<paths::platform::Auto>(
-                            cwd.as_bytes(),
-                            &mut joined_buf.0,
-                            &[&script_name_buf[..open_len]],
-                        )
-                        .map(Box::from)
-                    }
-                    Err(_) => None,
+        let keeps_link = ctx.runtime_options.preserve_symlinks_main;
+        let absolute_script_path: Option<Box<[u8]>> = if keeps_link {
+            let mut cwd_buf = bun_paths::path_buffer_pool::get();
+            let mut joined_buf = bun_paths::path_buffer_pool::get();
+            match bun_core::getcwd(&mut cwd_buf) {
+                Ok(cwd) => {
+                    paths::resolve_path::join_abs_string_buf_checked::<paths::platform::Auto>(
+                        cwd.as_bytes(),
+                        &mut joined_buf.0,
+                        &[&script_name_buf[..open_len]],
+                    )
+                    .map(Box::from)
                 }
-            } else {
-                bun_sys::get_fd_path(fd, &mut script_name_buf)
-                    .ok()
-                    .map(|resolved| Box::from(&*resolved))
-            };
+                Err(_) => None,
+            }
+        } else {
+            bun_sys::get_fd_path(fd, &mut script_name_buf)
+                .ok()
+                .map(|resolved| Box::from(&*resolved))
+        };
         let _ = bun_sys::close(fd);
         let Some(absolute_script_path) = absolute_script_path else {
             return false;
@@ -3071,9 +3075,7 @@ impl RunCommand {
         Self::boot_and_handle_error(ctx, &absolute_script_path, None)
     }
 
-    /// `bun run -` / `node -` / `bun <(echo ...)` — read script from `pipe` into
-    /// `ctx.runtime_options.eval` and boot the VM with the synthetic `[stdin]`
-    /// path. `name` is the entry point as typed. `false` means `pipe` could not be read.
+    /// Runs the script read from `pipe` as `[stdin]`; `name` is the entry point as typed. `false`: `pipe` could not be read.
     fn exec_stdin(ctx: &mut ContextData, pipe: bun_sys::File, name: &[u8]) -> crate::Result<bool> {
         bun_core::scoped_log!(RUN_LOG, "Executing from stdin");
 
@@ -3215,9 +3217,7 @@ impl RunCommand {
             Self::exec_as_if_node_missing_script();
         }
 
-        // `node -` reads the script from stdin. `Arguments::parse` stopped at
-        // this positional, so everything after the `-` is already in
-        // `ctx.passthrough`; `exec_stdin` puts the `-` itself back in front.
+        // `Arguments::parse` stopped at the `-`, so what follows it is already in `ctx.passthrough`.
         if ctx.positionals[0].as_ref() == b"-" {
             if Self::exec_stdin(ctx, bun_sys::File::stdin(), b"-")? {
                 return Ok(());
diff --git a/src/runtime/cli/test_command.rs b/src/runtime/cli/test_command.rs
index 94eb19cce778..bbae3c97d059 100644
--- a/src/runtime/cli/test_command.rs
+++ b/src/runtime/cli/test_command.rs
@@ -2478,10 +2478,18 @@ impl TestCommand {
         if test_files.is_empty() && !pass_with_no_tests_from_filter {
             failed_to_find_any_tests = true;
 
+            let file_patterns = ctx.test_options.file_patterns.join(&b", "[..]);
+            let file_patterns = bstr::BStr::new(&file_patterns);
+
             // "bun test" - positionals[0] == "test"
             // Therefore positionals starts at [1].
             if ctx.positionals.len() < 2 {
-                if Output::is_ai_agent() {
+                if !file_patterns.is_empty() {
+                    pretty_errorln!(
+                        "<yellow>No tests found!<r>\n\nTests need to match <b>filePatterns<r> in bunfig.toml: {}\n",
+                        file_patterns
+                    );
+                } else if Output::is_ai_agent() {
                     // Be very clear to ai.
                     Output::err_generic(
                         "0 test files matching **{{.test,.spec,_test_,_spec_}}.{{js,ts,jsx,tsx}} in --cwd={}",
@@ -2526,9 +2534,16 @@ impl TestCommand {
                     Output::print_start_end(ctx.start_time, bun::time::nano_timestamp());
                 }
 
-                pretty_errorln!(
-                    "\n\n<blue>note<r><d>:<r> Tests need \".test\", \"_test_\", \".spec\" or \"_spec_\" in the filename <d>(ex: \"MyApp.test.ts\")<r>"
-                );
+                if !file_patterns.is_empty() {
+                    pretty_errorln!(
+                        "\n\n<blue>note<r><d>:<r> Tests need to match <b>filePatterns<r> in bunfig.toml: {}",
+                        file_patterns
+                    );
+                } else {
+                    pretty_errorln!(
+                        "\n\n<blue>note<r><d>:<r> Tests need \".test\", \"_test_\", \".spec\" or \"_spec_\" in the filename <d>(ex: \"MyApp.test.ts\")<r>"
+                    );
+                }
 
                 // print a helpful note
                 if let Some(i) = has_file_like {
diff --git a/src/runtime/jsc_hooks.rs b/src/runtime/jsc_hooks.rs
index b9ba6310cbbb..c30988a34dd3 100644
--- a/src/runtime/jsc_hooks.rs
+++ b/src/runtime/jsc_hooks.rs
@@ -84,9 +84,7 @@ pub(crate) struct RuntimeState {
     /// leaked per-VM (PORTING.md §Forbidden: leaking only for true
     /// process-lifetime singletons via `OnceLock`, which a per-VM arena is not).
     pub(crate) transpiler_arena: Box<bun_alloc::Arena>,
-    /// The env loader `vm.transpiler` points at when the VM owns its own
-    /// (`InitOptions::owned_env_loader`). `None` when the transpiler shares
-    /// the caller's loader. Freed with the state, after the VM.
+    /// `InitOptions::owned_env_loader`, which `vm.transpiler` points at. Freed with the state, after the VM.
     pub(crate) owned_env_loader: Option<Box<bun_dotenv::Loader>>,
     /// `vm.body_value_pool` — pooled storage for `Body.Value`
     /// (`Request.body` payloads).
diff --git a/src/sys/lib.rs b/src/sys/lib.rs
index 71da64bc2a6f..17f6b6f321d6 100644
--- a/src/sys/lib.rs
+++ b/src/sys/lib.rs
@@ -9028,21 +9028,6 @@ pub fn exists(path: &[u8]) -> bool {
     let z = ZStr::from_buf(&buf.0[..], path.len());
     exists_z(z)
 }
-
-/// Returns true if `dir` is sticky and group- or world-writable, like `/tmp`: any local user can create a file there.
-#[cfg(unix)]
-pub fn is_shared_directory(dir: &[u8]) -> bool {
-    !stat(&bun_core::ZBox::from_bytes(dir)).is_ok_and(|st| {
-        let mode = st.st_mode as Mode;
-        mode & S::ISVTX == 0 || mode & (S::IWGRP | S::IWOTH) == 0
-    })
-}
-
-#[cfg(not(unix))]
-pub fn is_shared_directory(_: &[u8]) -> bool {
-    false
-}
-
 /// `moveFileZ`. Routes through
 /// [`renameat_concurrently_without_fallback`] (renameat2 NOREPLACE → EXCHANGE →
 /// delete-tree + rename); on EISDIR removes the dest dir and
diff --git a/test/bundler/transpiler/macro-test.test.ts b/test/bundler/transpiler/macro-test.test.ts
index 58ee6f1440d6..0c761202e44f 100644
--- a/test/bundler/transpiler/macro-test.test.ts
+++ b/test/bundler/transpiler/macro-test.test.ts
@@ -628,7 +628,7 @@ describe("--no-macros", () => {
 
 // Each parse-worker thread creates its own macro VM at its first macro call. The VM's transpiler
 // loads the `.env` files of the cwd into the VM's env loader, so the macro's `process.env` sees
-// them. That loader used to be the build's own loader, shared by every worker thread.
+// them. That loader is a copy of the build's, which every worker thread shares.
 describe("the macro VM's env loader is its own", () => {
   const macroModules = 8;
   const files: Record<string, string> = {
@@ -669,10 +669,10 @@ describe("the macro VM's env loader is its own", () => {
     }
   }, 60_000);
 
-  // `bun build` without `--env` does not read `.env`. The macro VM reads it for its own
-  // `process.env`, and that read must not change what the build's resolver sees.
-  test.concurrent("a macro's .env load does not reach the build's resolver", async () => {
-    using dir = tempDir("macro-env-loader-isolated", {
+  // `bun build` without `--env` does not read `.env`. A macro VM does, and the build takes over what
+  // it read before the imports of the module that calls the macro are resolved.
+  test.concurrent("a NODE_PATH that only .env sets resolves the imports of a module that calls a macro", async () => {
+    using dir = tempDir("macro-env-loader-node-path", {
       "vendor/dep/index.ts": `export const dep = "from NODE_PATH";\n`,
       "macro.ts": `export function value(name: string) {\n  return name;\n}\n`,
       "with-macro.ts": `import { value } from "./macro.ts" with { type: "macro" };\nimport { dep } from "dep";\nconsole.log(value("a"), dep);\n`,
@@ -695,8 +695,8 @@ describe("the macro VM's env loader is its own", () => {
       };
     };
     const [withMacro, withoutMacro] = await Promise.all([build("./with-macro.ts"), build("./without-macro.ts")]);
+    expect(withMacro).toEqual({ resolved: true, unresolved: false, exitCode: 0 });
     expect(withoutMacro).toEqual({ resolved: false, unresolved: true, exitCode: 1 });
-    expect(withMacro).toEqual(withoutMacro);
   });
 
   test.concurrent("a macro reads .env through its own loader", async () => {
diff --git a/test/cli/bun.test.ts b/test/cli/bun.test.ts
index bc068c382765..3a4db607451e 100644
--- a/test/cli/bun.test.ts
+++ b/test/cli/bun.test.ts
@@ -452,13 +452,13 @@ describe("bun", () => {
       }
 
       const project = {
-        "package.json": "{}",
+        "package.json": JSON.stringify({ scripts: { "dev": "echo dev", "test:unit": "echo unit" } }, null, 2),
         "myscript.ts": "",
         "foo.txt": "",
         "src/index.ts": "",
         "src/other.ts": "",
         "test/a.test.ts": "",
-        // bun.fish asks `bun getcompletes` for the scripts and bins. This project has none.
+        // bun.fish asks `bun getcompletes` for the scripts and bins. This one has no answer.
         "bin/bun": "#!/bin/sh\n",
       };
 
@@ -490,12 +490,14 @@ describe("bun", () => {
         ? Number(spawnSync({ cmd: ["bash", "-c", "echo ${BASH_VERSINFO[0]}"], env: bunEnv }).stdout.toString())
         : 0;
 
-      test.concurrent.skipIf(bashVersion < 4)("bash offers files, also after a flag or a script", async () => {
+      test.concurrent.skipIf(bashVersion < 4)("bash offers files and scripts, also after a flag", async () => {
         using dir = tempDir("completions-bash", { ...project, "bun.bash": await script("bash") });
         const expected = {
           "bun sr": ["src/"],
           "bun src/": ["src/index.ts", "src/other.ts"],
           "bun run src/": ["src/index.ts", "src/other.ts"],
+          "bun run d": ["dev"],
+          "bun run te": ["test/", "test:unit"],
           "bun --hot src/o": ["src/other.ts"],
           "bun --hot run src/o": ["src/other.ts"],
           "bun --cwd . run src/o": ["src/other.ts"],
@@ -665,6 +667,7 @@ describe("bun", () => {
           /^ {2}Also add it to the current project's package\.json as a link: dependency\.\n {2}bun link --save <package>$/m,
         ],
       ],
+      ["bun patch --help", ["patch"], [/^ {2}bun patch --commit --patches-dir 'my-patches' 'node_modules\/jquery'$/m]],
       [
         "bun audit --help",
         ["audit"],
@@ -697,7 +700,7 @@ describe("bun", () => {
       "index.ts": `console.log(process.env.FOO ?? "-", globalThis.PRE ?? "-", typeof X === "undefined" ? "-" : X);`,
       "with/package.json": JSON.stringify({
         name: "with",
-        scripts: Object.fromEntries(["dev", ...words].map(word => [word, `echo script-${word}`])),
+        scripts: Object.fromEntries(["dev", "run", ...words].map(word => [word, `echo script-${word}`])),
       }),
       "without/package.json": JSON.stringify({ name: "without" }),
       "without/a.test.ts": `import { test } from "bun:test"; test("in without", () => {});`,
@@ -768,6 +771,12 @@ describe("bun", () => {
       expect(exitCode).toBe(0);
     });
 
+    test("bun --filter=with --cwd . run dev runs the script that is named run", async () => {
+      const { stdout, exitCode } = await run(["--filter=with", "--cwd", ".", "run", "dev"]);
+      expect(stdout).toContain("script-run dev");
+      expect(exitCode).toBe(0);
+    });
+
     test("bun -p install is bun install --production", async () => {
       const { stdout, exitCode } = await run(["-p", "install"]);
       expect(stdout).toContain("bun install");
diff --git a/test/cli/bunfig-test-options.test.ts b/test/cli/bunfig-test-options.test.ts
index be4f793cd737..65c25d2c037a 100644
--- a/test/cli/bunfig-test-options.test.ts
+++ b/test/cli/bunfig-test-options.test.ts
@@ -349,6 +349,19 @@ describe.concurrent("[test] filePatterns", () => {
     expect(exitCode).toBe(0);
   });
 
+  test.each(
+    named([
+      { bunfig: `filePatterns = ["*.a.ts", "*.b.ts"]`, args: [] },
+      { bunfig: `filePatterns = ["*.a.ts", "*.b.ts"]`, args: ["filter"] },
+    ]),
+  )("$name finds nothing and names the patterns", async ({ bunfig, args }) => {
+    using dir = tempDir("test-file-patterns", { ...files, "bunfig.toml": `[test]\n${bunfig}\n` });
+    const { stderr, exitCode } = await bunTest(String(dir), ...args);
+    expect(stderr).toContain("Tests need to match filePatterns in bunfig.toml: *.a.ts, *.b.ts\n");
+    expect(stderr).not.toContain(`".test"`);
+    expect(exitCode).toBe(1);
+  });
+
   test("a number is an error", async () => {
     using dir = tempDir("test-file-patterns", { ...files, "bunfig.toml": `[test]\nfilePatterns = 1\n` });
     const { stderr, exitCode } = await bunTest(String(dir));
diff --git a/test/cli/install/bun-create.test.ts b/test/cli/install/bun-create.test.ts
index 846b2a4d5c89..c9c3ceb1ea13 100644
--- a/test/cli/install/bun-create.test.ts
+++ b/test/cli/install/bun-create.test.ts
@@ -570,7 +570,10 @@ it("should create template from local folder", async () => {
   expect(await Bun.file(join(x_dir, testTemplate, "foo", "bar.js")).text()).toBe("hi");
 });
 
-it.concurrent.each([[["--cwd", "proj"]], [["--cwd=proj"]]])("bun %j create works in that folder", async flags => {
+it.concurrent.each([
+  [["--cwd=proj"], ["dest/tpl.txt"], 0],
+  [["--cwd", "proj"], [], 1],
+])("bun %j create tpl dest writes %j and exits with %d", async (flags, written, expectedExitCode) => {
   using dir = tempDir("create-after-cwd", { "bun-create/tpl/tpl.txt": "template", "proj/mine.txt": "mine" });
   await using proc = spawn({
     cmd: [bunExe(), ...flags, "create", "tpl", "dest", "--no-git"],
@@ -578,12 +581,12 @@ it.concurrent.each([[["--cwd", "proj"]], [["--cwd=proj"]]])("bun %j create works
     env: { ...env, BUN_CREATE_DIR: join(String(dir), "bun-create") },
     stdin: "ignore",
     stdout: "ignore",
-    stderr: "inherit",
+    stderr: "ignore",
   });
 
   const exitCode = await proc.exited;
-  expect(await tree(join(String(dir), "proj"))).toEqual({ "dest/tpl.txt": "template", "mine.txt": "mine" });
-  expect(exitCode).toBe(0);
+  expect(Object.keys(await tree(String(dir)))).toEqual(["bun-create/tpl/tpl.txt", ...written, "proj/mine.txt"]);
+  expect(exitCode).toBe(expectedExitCode);
 });
 
 async function tree(dir: string) {
diff --git a/test/cli/install/bun-patch.test.ts b/test/cli/install/bun-patch.test.ts
index a12b81848d93..10203f1bc209 100644
--- a/test/cli/install/bun-patch.test.ts
+++ b/test/cli/install/bun-patch.test.ts
@@ -201,57 +201,6 @@ describe.concurrent("error messages", () => {
   });
 });
 
-// Each example is run as the help prints it, in a project where `jquery` is an alias of a stand-in.
-describe.concurrent("the examples in 'bun patch --help'", () => {
-  test.each([
-    ["Generate a patch file for changes made to jquery", "patches"],
-    ["Generate a patch file in a custom directory for changes made to jquery", "my-patches"],
-  ])("%s", async (commitExample, patchesDir) => {
-    await using project = await installedProject({ dependencies: { jquery: "npm:no-deps@1.0.0" } });
-    const { dir, env } = project;
-    const indexJs = join(dir, "node_modules", "jquery", "index.js");
-    const help = (await bunOk(dir, env, "patch", "--help")).split(/\r?\n/).map(line => line.trim());
-
-    /** Runs the command that the help prints under `description`, without the quotes a shell removes. */
-    async function runExample(description: string) {
-      expect(help).toContain(description);
-      const [bun, ...args] = help[help.indexOf(description) + 1].split(" ");
-      expect(bun).toBe("bun");
-      await bunOk(dir, env, ...args.map(arg => arg.replace(/^'(.*)'$/, "$1")));
-    }
-
-    await runExample("Prepare jquery for patching");
-    await Bun.write(indexJs, patched);
-    await runExample(commitExample);
-
-    expect({
-      patchedDependencies: (await Bun.file(join(dir, "package.json")).json()).patchedDependencies,
-      patchFile: existsSync(join(dir, patchesDir, "no-deps@1.0.0.patch")),
-      indexJs: await Bun.file(indexJs).text(),
-    }).toEqual({
-      patchedDependencies: { "no-deps@1.0.0": `${patchesDir}/no-deps@1.0.0.patch` },
-      patchFile: true,
-      indexJs: patched,
-    });
-    expect(await Bun.file(join(dir, patchesDir, "no-deps@1.0.0.patch")).text()).toMatchInlineSnapshot(`
-      "diff --git a/index.js b/index.js
-      index bb9c6f6876154493527577cd78279aa6bb686ebb..486c735f2b33e6d1beb1de227b99684124172cb9 100644
-      --- a/index.js
-      +++ b/index.js
-      @@ -1,7 +1 @@
-      -module.exports = require(\`./package.json\`);
-      -
-      -for (const key of [\`dependencies\`, \`devDependencies\`, \`peerDependencies\`]) {
-      -  for (const dep of Object.keys(module.exports[key] || {})) {
-      -    module.exports[key][dep] = require(dep);
-      -  }
-      -}
-      +module.exports = 'patched';
-      "
-    `);
-  });
-});
-
 // `bun patch` identifies packages by `name@label`, where a tarball package's label is
 // the spec it was installed from. These labels used to be formatted into 1024 byte
 // stack buffers (512 bytes in the installer itself), so a long enough spec crashed
diff --git a/test/cli/run/filter-workspace.test.ts b/test/cli/run/filter-workspace.test.ts
index d0f07d104352..d3574c1f66fa 100644
--- a/test/cli/run/filter-workspace.test.ts
+++ b/test/cli/run/filter-workspace.test.ts
@@ -827,42 +827,47 @@ describe("bun", () => {
       "package.json": JSON.stringify({ name, scripts: { build: `echo BUILD-${name}` } }),
     });
 
+    const upperAndLower = { Core: member("core"), lower: member("lower") };
+    const below = ["./packages/**"];
+
     test.concurrent.each([
       {
         entry: "a glob",
         workspaces: ["packages/*"],
-        files: { packages: { Core: member("core"), lower: member("lower") } },
-      },
-      {
-        entry: "a literal path",
-        workspaces: ["packages/Core", "packages/lower"],
-        files: { packages: { Core: member("core"), lower: member("lower") } },
+        files: { packages: upperAndLower },
+        paths: below,
       },
       {
         entry: "a nested glob",
         workspaces: ["packages/*/*"],
         files: { packages: { UPPER: { Inner: member("core") }, group: { lower: member("lower") } } },
+        paths: below,
       },
-      // The names of these file systems ignore case.
+      // Where names ignore case, what is written in lower case finds the directory.
       ...(isMacOS || isWindows
         ? [
             {
               entry: "a literal path in lower case",
               workspaces: ["./packages/core", "packages/lower"],
-              files: { packages: { Core: member("core"), lower: member("lower") } },
+              files: { packages: upperAndLower },
+              paths: ["./packages/core", "./packages/lower"],
             },
-          ]
-        : []),
-      ...(isLinux
-        ? [
             {
-              entry: "a literal path, next to the same name in lower case",
-              workspaces: ["packages/Core", "packages/core"],
-              files: { packages: { Core: member("core"), core: member("lower") } },
+              entry: "a glob below a directory in lower case",
+              workspaces: ["packages/*"],
+              files: { Packages: upperAndLower },
+              paths: below,
             },
           ]
-        : []),
-    ])("is found through $entry in workspaces", async ({ workspaces, files }) => {
+        : [
+            {
+              entry: "a literal path",
+              workspaces: ["packages/Core", "packages/lower"],
+              files: { packages: upperAndLower },
+              paths: below,
+            },
+          ]),
+    ])("is found through $entry in workspaces", async ({ workspaces, files, paths }) => {
       using dir = tempDir("filter-upper-case-dir", {
         ...files,
         "package.json": JSON.stringify({ name: "root", private: true, workspaces }),
@@ -888,7 +893,7 @@ describe("bun", () => {
         run("--filter", "*"),
         run("--workspaces"),
         run("--filter", "lower"),
-        run("--filter", "./packages/**"),
+        run(...paths.flatMap(path => ["--filter", path])),
       ]);
       const both = { ran: ["BUILD-core", "BUILD-lower"], errors: [], exitCode: 0 };
       expect({ all, everyWorkspace, byName, byPath }).toEqual({
diff --git a/test/cli/run/hide-paths.c b/test/cli/run/hide-paths.c
deleted file mode 100644
index ff11b335c710..000000000000
--- a/test/cli/run/hide-paths.c
+++ /dev/null
@@ -1,216 +0,0 @@
-// Test helper: run a command with some paths made to look absent.
-//
-//   hide-paths /bin/sh /bin/bash -- bun run start
-//
-// A mount namespace needs privileges that CI does not have. This uses seccomp
-// user notification instead: the child's path syscalls stop in the kernel, the
-// parent reads the path from the child's memory, and answers ENOENT for a
-// hidden path (the path itself or anything below it) or lets the syscall
-// continue. Exit code 77 means the kernel or the sandbox does not allow this.
-// The path check is racy by design, which does not matter for a test.
-#define _GNU_SOURCE
-#include <errno.h>
-#include <linux/audit.h>
-#include <linux/filter.h>
-#include <linux/seccomp.h>
-#include <poll.h>
-#include <signal.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/ioctl.h>
-#include <sys/prctl.h>
-#include <sys/socket.h>
-#include <sys/syscall.h>
-#include <sys/uio.h>
-#include <sys/wait.h>
-#include <unistd.h>
-
-#define SKIP 77
-
-#if defined(__x86_64__)
-#define HP_AUDIT_ARCH AUDIT_ARCH_X86_64
-#elif defined(__aarch64__)
-#define HP_AUDIT_ARCH AUDIT_ARCH_AARCH64
-#else
-#define HP_AUDIT_ARCH 0
-#endif
-
-// Linux 5.0 (listener) and 5.5 (continue). Declared here so that older kernel
-// headers still compile; an older kernel answers EINVAL and the helper skips.
-struct hp_notif { uint64_t id; uint32_t pid; uint32_t flags; struct seccomp_data data; };
-struct hp_notif_resp { uint64_t id; int64_t val; int32_t error; uint32_t flags; };
-struct hp_notif_sizes { uint16_t notif, resp, data; };
-#define HP_NEW_LISTENER (1UL << 3)
-#define HP_GET_NOTIF_SIZES 3
-#define HP_CONTINUE (1UL << 0)
-#define HP_NOTIF_RECV _IOWR('!', 0, struct hp_notif)
-#define HP_NOTIF_SEND _IOWR('!', 1, struct hp_notif_resp)
-#ifndef SECCOMP_RET_USER_NOTIF
-#define SECCOMP_RET_USER_NOTIF 0x7fc00000U
-#endif
-#ifndef __NR_faccessat2
-#define __NR_faccessat2 439
-#endif
-#ifndef __NR_openat2
-#define __NR_openat2 437
-#endif
-
-// Syscalls that take the path in args[0], then those that take it in args[1].
-static const int path_arg0[] = {
-#ifdef __NR_open
-  __NR_open, __NR_stat, __NR_lstat, __NR_readlink, __NR_access,
-#endif
-  __NR_execve,
-};
-static const int path_arg1[] = {
-  __NR_openat, __NR_openat2, __NR_newfstatat, __NR_statx, __NR_readlinkat, __NR_faccessat, __NR_faccessat2, __NR_execveat,
-};
-#define N0 ((int)(sizeof(path_arg0) / sizeof(path_arg0[0])))
-#define N1 ((int)(sizeof(path_arg1) / sizeof(path_arg1[0])))
-
-static int install_filter(void) {
-  struct sock_filter f[N0 + N1 + 6];
-  int n = 0, total = N0 + N1;
-  f[n++] = (struct sock_filter)BPF_STMT(BPF_LD | BPF_W | BPF_ABS, offsetof(struct seccomp_data, arch));
-  f[n++] = (struct sock_filter)BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, HP_AUDIT_ARCH, 1, 0);
-  f[n++] = (struct sock_filter)BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW);
-  f[n++] = (struct sock_filter)BPF_STMT(BPF_LD | BPF_W | BPF_ABS, offsetof(struct seccomp_data, nr));
-  for (int i = 0; i < total; i++) {
-    int nr = i < N0 ? path_arg0[i] : path_arg1[i - N0];
-    // On a match, jump over the remaining compares and the ALLOW to the NOTIF return.
-    f[n++] = (struct sock_filter)BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, nr, total - i, 0);
-  }
-  f[n++] = (struct sock_filter)BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW);
-  f[n++] = (struct sock_filter)BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_USER_NOTIF);
-  struct sock_fprog prog = {.len = (unsigned short)n, .filter = f};
-  return (int)syscall(__NR_seccomp, SECCOMP_SET_MODE_FILTER, HP_NEW_LISTENER, &prog);
-}
-
-static int send_fd(int sock, int fd) {
-  char control[CMSG_SPACE(sizeof(int))] = {0}, byte = 0;
-  struct iovec io = {.iov_base = &byte, .iov_len = 1};
-  struct msghdr msg = {.msg_iov = &io, .msg_iovlen = 1, .msg_control = control, .msg_controllen = sizeof(control)};
-  struct cmsghdr *c = CMSG_FIRSTHDR(&msg);
-  c->cmsg_level = SOL_SOCKET;
-  c->cmsg_type = SCM_RIGHTS;
-  c->cmsg_len = CMSG_LEN(sizeof(int));
-  memcpy(CMSG_DATA(c), &fd, sizeof(int));
-  return sendmsg(sock, &msg, 0) < 0 ? -1 : 0;
-}
-
-static int recv_fd(int sock) {
-  char control[CMSG_SPACE(sizeof(int))] = {0}, byte;
-  struct iovec io = {.iov_base = &byte, .iov_len = 1};
-  struct msghdr msg = {.msg_iov = &io, .msg_iovlen = 1, .msg_control = control, .msg_controllen = sizeof(control)};
-  if (recvmsg(sock, &msg, 0) <= 0) return -1;
-  struct cmsghdr *c = CMSG_FIRSTHDR(&msg);
-  if (!c) return -1;
-  int fd;
-  memcpy(&fd, CMSG_DATA(c), sizeof(int));
-  return fd;
-}
-
-static int is_hidden(const char *path, char **hidden, int count) {
-  for (int i = 0; i < count; i++) {
-    size_t len = strlen(hidden[i]);
-    if (strncmp(path, hidden[i], len) == 0 && (path[len] == 0 || path[len] == '/')) return 1;
-  }
-  return 0;
-}
-
-// Reads the NUL-terminated path at `addr` in the child. Returns 0, or -1 if the read is not permitted.
-static int read_path(pid_t pid, uint64_t addr, char *out, size_t cap) {
-  out[0] = 0;
-  if (!addr) return 0;
-  // Do not cross into the next page unless the string does: it may be unmapped.
-  size_t first = 4096 - (size_t)(addr & 4095);
-  if (first > cap - 1) first = cap - 1;
-  struct iovec local = {.iov_base = out, .iov_len = first};
-  struct iovec remote = {.iov_base = (void *)(uintptr_t)addr, .iov_len = first};
-  ssize_t got = process_vm_readv(pid, &local, 1, &remote, 1, 0);
-  if (got < 0) return errno == EPERM || errno == ENOSYS ? -1 : 0;
-  if (memchr(out, 0, (size_t)got) == NULL && (size_t)got < cap - 1) {
-    local.iov_base = out + got;
-    remote.iov_base = (void *)(uintptr_t)(addr + (uint64_t)got);
-    local.iov_len = remote.iov_len = cap - 1 - (size_t)got;
-    ssize_t more = process_vm_readv(pid, &local, 1, &remote, 1, 0);
-    got += more > 0 ? more : 0;
-  }
-  out[got] = 0;
-  return 0;
-}
-
-int main(int argc, char **argv) {
-  int sep = 0;
-  for (int i = 1; i < argc && !sep; i++)
-    if (strcmp(argv[i], "--") == 0) sep = i;
-  if (sep < 2 || sep + 1 >= argc) {
-    fprintf(stderr, "usage: %s <hidden path>... -- <command> [args...]\n", argv[0]);
-    return 2;
-  }
-  if (HP_AUDIT_ARCH == 0) return SKIP;
-
-  int pair[2];
-  if (socketpair(AF_UNIX, SOCK_STREAM, 0, pair) != 0) return SKIP;
-  pid_t child = fork();
-  if (child < 0) return SKIP;
-  if (child == 0) {
-    close(pair[0]);
-    if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) != 0) _exit(SKIP);
-    int listener = install_filter();
-    if (listener < 0 || send_fd(pair[1], listener) != 0) _exit(SKIP);
-    close(listener);
-    close(pair[1]);
-    execvp(argv[sep + 1], argv + sep + 1);
-    perror("execvp");
-    _exit(127);
-  }
-  close(pair[1]);
-  int listener = recv_fd(pair[0]);
-  close(pair[0]);
-
-  struct hp_notif_sizes sizes = {0};
-  if (listener < 0 || syscall(__NR_seccomp, HP_GET_NOTIF_SIZES, 0, &sizes) != 0) {
-    kill(child, SIGKILL);
-    return SKIP;
-  }
-  size_t notif_size = sizes.notif > sizeof(struct hp_notif) ? sizes.notif : sizeof(struct hp_notif);
-  size_t resp_size = sizes.resp > sizeof(struct hp_notif_resp) ? sizes.resp : sizeof(struct hp_notif_resp);
-  struct hp_notif *req = malloc(notif_size);
-  struct hp_notif_resp *resp = malloc(resp_size);
-
-  for (;;) {
-    struct pollfd pfd = {.fd = listener, .events = POLLIN};
-    int ready = poll(&pfd, 1, 100);
-    if (ready < 0 && errno != EINTR) break;
-    if (ready <= 0 || !(pfd.revents & POLLIN)) {
-      int status;
-      if (waitpid(child, &status, WNOHANG) == child)
-        return WIFSIGNALED(status) ? 128 + WTERMSIG(status) : WEXITSTATUS(status);
-      continue;
-    }
-    memset(req, 0, notif_size);
-    if (ioctl(listener, HP_NOTIF_RECV, req) != 0) {
-      if (errno == EINTR || errno == ENOENT) continue;
-      break;
-    }
-    int index = 1;
-    for (int i = 0; i < N0; i++)
-      if (path_arg0[i] == req->data.nr) index = 0;
-    char path[4096];
-    if (read_path((pid_t)req->pid, req->data.args[index], path, sizeof(path)) != 0) break;
-
-    memset(resp, 0, resp_size);
-    resp->id = req->id;
-    if (is_hidden(path, argv + 1, sep - 1)) resp->error = -ENOENT;
-    else resp->flags = HP_CONTINUE;
-    if (ioctl(listener, HP_NOTIF_SEND, resp) != 0 && errno != ENOENT) break;
-  }
-  // The kernel or the sandbox refused a step. Do not report a result.
-  kill(child, SIGKILL);
-  waitpid(child, NULL, 0);
-  return SKIP;
-}
diff --git a/test/cli/run/run-shell.test.ts b/test/cli/run/run-shell.test.ts
index 44214f99e781..34b1163a9ff1 100644
--- a/test/cli/run/run-shell.test.ts
+++ b/test/cli/run/run-shell.test.ts
@@ -1,8 +1,7 @@
-import { afterAll, describe, expect, test } from "bun:test";
-import { spawnSync } from "child_process";
-import { chmodSync, mkdirSync } from "fs";
+import { describe, expect, test } from "bun:test";
+import { chmodSync, mkdirSync, realpathSync } from "fs";
 import { bunEnv, bunExe, isLinux, isWindows, tempDir, tmpdirSync } from "harness";
-import { join } from "path";
+import { dirname, join } from "path";
 
 describe.concurrent("run-shell", () => {
   test("running a shell script works", async () => {
@@ -82,60 +81,39 @@ test.skipIf(isWindows)(
   },
 );
 
-// hide-paths.c makes chosen paths look absent (seccomp user notification). `bin` is the helper,
-// `skip` means this host cannot use it (no cc, missing headers, a kernel or sandbox that refuses
-// the filter), `error` is a compile failure of the helper itself.
-const hidePaths: { bin: string } | { skip: true } | { error: string } = (() => {
-  if (!isLinux) return { skip: true };
-  const dir = tempDir("hide-paths", {});
-  const result = ((): typeof hidePaths => {
-    const bin = join(String(dir), "hide-paths");
-    const compile = spawnSync("cc", ["-O0", "-o", bin, join(import.meta.dir, "hide-paths.c")], { stdio: "pipe" });
-    if ((compile.error as NodeJS.ErrnoException | undefined)?.code === "ENOENT") return { skip: true };
-    if (compile.status !== 0) {
-      const stderr = compile.stderr?.toString() ?? "";
-      // A missing header or libc means this host cannot build C. Anything else is a bug in the helper.
-      return stderr.includes("No such file or directory") ? { skip: true } : { error: stderr };
-    }
-    // Probe: the helper runs itself with no arguments, which prints the usage and exits 2. 77 means skip.
-    return spawnSync(bin, ["/hide-paths-probe", "--", bin], { stdio: "pipe" }).status === 2 ? { bin } : { skip: true };
-  })();
-  // The tests need the binary until the file ends. Every other outcome is done with the directory now.
-  if ("bin" in result) afterAll(() => dir[Symbol.dispose]());
-  else dir[Symbol.dispose]();
-  return result;
-})();
+// A root directory with no shell in it: a chroot in a private user and mount namespace.
+// Skipped where those are disabled, like in most containers.
+const canChangeRoot =
+  isLinux &&
+  Bun.which("unshare") !== null &&
+  Bun.spawnSync({ cmd: ["unshare", "-Urm", "true"], stdout: "ignore", stderr: "ignore" }).exitCode === 0;
 
-// A FROM-scratch or distroless image has no /bin/sh. `--shell=bun` must not need one. Every path
-// that the shell lookup probes looks absent, and PATH points at an empty directory.
-describe.skipIf("skip" in hidePaths)("bun run on a system with no shell", () => {
-  // Keep in sync with HARDCODED_POPULAR_ONES in src/runtime/cli/run_command.rs.
-  const shellPaths = [
-    "/bin/bash",
-    "/usr/bin/bash",
-    "/usr/local/bin/bash",
-    "/bin/sh",
-    "/usr/bin/sh",
-    "/usr/bin/zsh",
-    "/usr/local/bin/zsh",
-    "/system/bin/sh",
-  ];
+// A FROM-scratch or distroless image has no /bin/sh. `--shell=bun` must not need one.
+describe.skipIf(!canChangeRoot)("bun run on a system with no shell", () => {
+  const changeRoot = `set -e
+for dir in /lib /lib64 /usr/lib /proc "$BUN_DIR"; do
+  [ -d "$dir" ] || continue
+  mkdir -p "$NEW_ROOT$dir"
+  mount -o rbind "$dir" "$NEW_ROOT$dir"
+done
+PATH="$PATH:/usr/sbin:/sbin"
+exec chroot "$NEW_ROOT" "$@"`;
 
   async function runWithoutShells(files: Record<string, string>, args: string[]) {
     using dir = tempDir("run-no-shell", {
-      "package.json": JSON.stringify({
+      "app/package.json": JSON.stringify({
         name: "no-shell-fixture",
         version: "1.0.0",
         scripts: { prestart: "echo pre", start: "echo started", poststart: "echo post" },
       }),
-      "empty-path/.keep": "",
+      "home/.keep": "",
+      "tmp/.keep": "",
       ...files,
     });
-    if ("error" in hidePaths) throw new Error("failed to compile hide-paths.c:\n" + hidePaths.error);
+    const bun = realpathSync(bunExe());
     await using proc = Bun.spawn({
-      cmd: [(hidePaths as { bin: string }).bin, ...shellPaths, "--", bunExe(), "run", ...args],
-      env: { ...bunEnv, PATH: join(String(dir), "empty-path") },
-      cwd: String(dir),
+      cmd: ["unshare", "-Urm", "/bin/sh", "-c", changeRoot, "sh", bun, "--cwd=/app", "run", ...args],
+      env: { ...bunEnv, NEW_ROOT: String(dir), BUN_DIR: dirname(bun), HOME: "/home", TMPDIR: "/tmp" },
       stdout: "pipe",
       stderr: "pipe",
     });
@@ -150,7 +128,7 @@ describe.skipIf("skip" in hidePaths)("bun run on a system with no shell", () =>
   });
 
   test.concurrent('bunfig [run] shell = "bun" runs the scripts', async () => {
-    const { stdout, exitCode } = await runWithoutShells({ "bunfig.toml": '[run]\nshell = "bun"\n' }, ["start"]);
+    const { stdout, exitCode } = await runWithoutShells({ "app/bunfig.toml": '[run]\nshell = "bun"\n' }, ["start"]);
     expect(stdout).toBe("pre\nstarted\npost\n");
     expect(exitCode).toBe(0);
   });
diff --git a/test/cli/run/run_command.test.ts b/test/cli/run/run_command.test.ts
index 9bce69a96894..caf5da048765 100644
--- a/test/cli/run/run_command.test.ts
+++ b/test/cli/run/run_command.test.ts
@@ -41,12 +41,13 @@ describe("bun", () => {
     expect(exitCode).toBe(1);
   });
 
-  test("a package.json that fails to parse reports the parse error, not 'Script not found'", () => {
+  test("the parse error of the nearest package.json is printed before 'Script not found'", () => {
     using dir = tempDir("broken-package-json", {
-      "package.json": `{"name": "p", "scripts": {"s": "echo hi"`,
+      "package.json": `{"name": "top", "private": tru`,
+      "a/package.json": `{"name": "p", "scripts": {"s": "echo hi"`,
     });
     const { exitCode, stdout, stderr } = spawnSync({
-      cwd: String(dir),
+      cwd: join(String(dir), "a"),
       cmd: [bunExe(), "run", "s"],
       env: bunEnv,
       stdout: "pipe",
@@ -55,12 +56,13 @@ describe("bun", () => {
     expect(stdout.toString()).toBeEmpty();
     const err = stderr.toString();
     expect(err).toContain(`Expected "}" but found end of file`);
-    expect(err).toContain(join(String(dir), "package.json") + ":1:40");
-    expect(err).not.toContain("Script not found");
+    expect(err).toContain(join(String(dir), "a", "package.json") + ":1:40");
+    expect(err).not.toContain("Unexpected tru");
+    expect(err).toEndWith('error: Script not found "s"\n');
     expect(exitCode).toBe(1);
   });
 
-  test("a package.json that fails to parse in an ancestor is printed before 'Script not found'", () => {
+  test("a package.json that fails to parse above the nearest one is not reported", () => {
     using dir = tempDir("broken-ancestor-package-json", {
       "package.json": `{"name": "top", "private": tru`,
       "a/b/package.json": JSON.stringify({ name: "deep", scripts: { s: "echo hi" } }),
@@ -73,10 +75,7 @@ describe("bun", () => {
       stderr: "pipe",
     });
     expect(stdout.toString()).toBeEmpty();
-    const err = stderr.toString();
-    expect(err).toContain("Unexpected tru");
-    expect(err).toContain(join(String(dir), "package.json") + ":1:28");
-    expect(err).toContain('Script not found "nope"');
+    expect(stderr.toString()).toBe('error: Script not found "nope"\n');
     expect(exitCode).toBe(1);
   });
 
@@ -97,11 +96,11 @@ describe("bun", () => {
     };
 
     test("a package.json that fails to parse is an error", () => {
-      expect(run(`{\n<<<<<<< HEAD\n  "scripts": { "buildall": "echo a" }\n}`)).toEqual({
-        stdout: "",
-        stderr: expect.stringContaining(join("packages", "a", "package.json") + ":2:1"),
-        exitCode: 1,
-      });
+      const { stdout, stderr, exitCode } = run(`{\n<<<<<<< HEAD\n  "scripts": { "buildall": "echo a" }\n}`);
+      expect(stdout).toBe("");
+      expect(stderr).toContain(join("packages", "a", "package.json") + ":2:1");
+      expect(stderr).toEndWith('error: Script not found "buildall"\n');
+      expect(exitCode).toBe(1);
     });
 
     test.each(["\n", "[]"])("a package.json that is %j is no package.json", packageJson => {
diff --git a/test/cli/test/parallel-signal.test.ts b/test/cli/test/parallel-signal.test.ts
deleted file mode 100644
index 750e484e0492..000000000000
--- a/test/cli/test/parallel-signal.test.ts
+++ /dev/null
@@ -1,87 +0,0 @@
-// Kept separate from parallel.test.ts for the reason parallel-startup-failure.test.ts gives:
-// file-level pass/fail is what the surrounding tooling checks, and that file has cases that
-// depend on how fast a debug build starts its workers.
-
-import { expect, test } from "bun:test";
-import { readFileSync } from "fs";
-import { bunEnv, bunExe, isLinux, isWindows, tempDir } from "harness";
-
-// With every worker in the middle of a file, nothing arrives on the coordinator's loop, and the
-// poll it waits in is not ended by a signal: it retries on EINTR. A handler that only records
-// the signal is then acted on when something else turns the loop, which on Linux shows as the
-// coordinator's voluntary context switches. Wait for such a turn to pass, so that the signal
-// lands at the start of a quiet period and not just before the next turn.
-async function waitForCoordinatorToPark(pid: number) {
-  const switches = () =>
-    Number(/voluntary_ctxt_switches:\s+(\d+)/.exec(readFileSync(`/proc/${pid}/status`, "utf8"))![1]);
-  const deadline = Date.now() + 3000;
-  const before = switches();
-  while (switches() === before && Date.now() < deadline) await Bun.sleep(1);
-  let last = switches();
-  let quietSince = Date.now();
-  while (Date.now() - quietSince < 100 && Date.now() < deadline) {
-    await Bun.sleep(1);
-    const now = switches();
-    if (now !== last) {
-      last = now;
-      quietSince = Date.now();
-    }
-  }
-}
-
-test.skipIf(isWindows).concurrent.each([
-  ["SIGTERM", 143],
-  ["SIGINT", 130],
-] as const)(
-  "--parallel: the coordinator acts on %s at once while every worker is mid-file",
-  async (signal, code) => {
-    const fixture = `
-      import { test } from "bun:test";
-      import { appendFileSync } from "fs";
-      test("slow", async () => {
-        appendFileSync(process.env.PIDS, process.pid + "\\n");
-        await Bun.sleep(60000);
-      });
-    `;
-    using dir = tempDir("parallel-signal", { "a.test.ts": fixture, "b.test.ts": fixture });
-    const pids = String(dir) + "/pids.txt";
-
-    await using proc = Bun.spawn({
-      cmd: [bunExe(), "test", "--parallel=2", "--parallel-delay=0"],
-      env: { ...bunEnv, PIDS: pids },
-      cwd: String(dir),
-      stdout: "ignore",
-      stderr: "pipe",
-    });
-
-    const workersRunning = () => {
-      try {
-        return readFileSync(pids, "utf8").split("\n").filter(Boolean).length;
-      } catch {
-        return 0;
-      }
-    };
-    while (workersRunning() < 2 && proc.exitCode === null) await Bun.sleep(10);
-    expect(workersRunning()).toBe(2);
-    if (isLinux) await waitForCoordinatorToPark(proc.pid);
-
-    // "Interrupted" is the first thing the coordinator prints once it has seen the signal. The
-    // time up to that leaves out how long the processes take to go away.
-    const stderr = proc.stderr.getReader();
-    const decoder = new TextDecoder();
-    let seen = "";
-    const start = performance.now();
-    proc.kill(signal);
-    while (!seen.includes("Interrupted")) {
-      const { value, done } = await stderr.read();
-      if (done) break;
-      seen += decoder.decode(value, { stream: true });
-    }
-    const reactedAfterMs = performance.now() - start;
-
-    expect(seen).toContain("Interrupted");
-    expect(reactedAfterMs).toBeLessThan(500);
-    expect(await proc.exited).toBe(code);
-  },
-  30_000,
-);
diff --git a/test/config/bunfig/preload.test.ts b/test/config/bunfig/preload.test.ts
index 958f75ec4d2a..0c825339ec6d 100644
--- a/test/config/bunfig/preload.test.ts
+++ b/test/config/bunfig/preload.test.ts
@@ -1,5 +1,6 @@
 import { describe, expect, it, test } from "bun:test";
-import { bunEnv, bunExe, normalizeBunSnapshot, tempDir } from "harness";
+import { bunEnv, bunExe, isWindows, normalizeBunSnapshot, tempDir } from "harness";
+import { chmodSync, chownSync } from "node:fs";
 import { join, resolve } from "path";
 
 const fixturePath = (...segs: string[]) => resolve(import.meta.dirname, "fixtures", "preload", ...segs);
@@ -268,6 +269,21 @@ describe.concurrent("Given a working directory without a `bunfig.toml`", () => {
     expect(await run("index.ts", { args, cwd: join(String(dir), cwd) })).toEqual([out, "", 0]);
   });
 
+  it.skipIf(isWindows || process.getuid?.() !== 0)("the one of another user does not count", async () => {
+    using dir = tempDir("bunfig-above", monorepo);
+    chownSync(join(String(dir), "bunfig.toml"), 65534, 65534);
+    expect(await run("index.ts", { cwd: join(String(dir), "packages/a") })).toEqual([none, "", 0]);
+  });
+
+  it.skipIf(isWindows).each([
+    { name: "group-writable", mode: 0o775 },
+    { name: "sticky and world-writable", mode: 0o1777 },
+  ])("one's own counts in a $name directory", async ({ mode }) => {
+    using dir = tempDir("bunfig-above", monorepo);
+    chmodSync(String(dir), mode);
+    expect(await run("index.ts", { cwd: join(String(dir), "packages/a") })).toEqual([fromRoot, "", 0]);
+  });
+
   it("`bun <file>` in a workspace fails if the one of the workspace root cannot be parsed", async () => {
     using dir = tempDir("bunfig-above", { ...monorepo, "bunfig.toml": `[define\n` });
     const [out, err, code] = await run("index.ts", { cwd: join(String(dir), "packages/a") });
diff --git a/test/js/bun/resolve/resolve.test.ts b/test/js/bun/resolve/resolve.test.ts
index 802c61dfd77e..4903833359d2 100644
--- a/test/js/bun/resolve/resolve.test.ts
+++ b/test/js/bun/resolve/resolve.test.ts
@@ -2220,6 +2220,18 @@ describe.concurrent("--preserve-symlinks", () => {
       {},
       "app/dep.mjs true\n",
     ],
+    [
+      "with NODE_PRESERVE_SYMLINKS_MAIN=1 an entry point runs where the link points",
+      ["imported.mjs"],
+      { NODE_PRESERVE_SYMLINKS_MAIN: "1" },
+      `${atTheTarget} true\n`,
+    ],
+    [
+      "with NODE_PRESERVE_SYMLINKS_MAIN=1 an entry point given without its extension runs where the link points",
+      ["run", "./imported"],
+      { NODE_PRESERVE_SYMLINKS_MAIN: "1" },
+      `${atTheTarget} true\n`,
+    ],
   ])("%s", async (_, args, env, stdout) => {
     expect(await run(args, env)).toEqual({ stdout, stderr: "", exitCode: 0 });
   });
diff --git a/test/js/junit-reporter/junit.test.js b/test/js/junit-reporter/junit.test.js
index 7a5950c60d0d..2cd62cb0a861 100644
--- a/test/js/junit-reporter/junit.test.js
+++ b/test/js/junit-reporter/junit.test.js
@@ -612,6 +612,8 @@ describe("junit reporter", () => {
   it.each([
     [["--reporter=junit", "--reporter=dots", "--reporter-outfile=junit.xml"], true],
     [["--reporter-outfile=junit.xml"], false],
+    [["--reporter=junit", "--reporter=dots"], false],
+    [["--reporter=bogus", "--reporter=dots"], false],
   ])("%j writes the report: %p", async (flags, written) => {
     await using tmpDir = tempDir("junit-and-dots", {
       "package.json": "{}",

From aab462c6f3b23c9d1623832a6b00f2c23168bccf Mon Sep 17 00:00:00 2001
From: Jarred Sumner <jarred@jarredsumner.com>
Date: Mon, 19 Oct 2026 03:14:19 +0000
Subject: [PATCH 20/24] bunfig: compare owners on Windows too before reading a
 bunfig.toml above the cwd

---
 docs/runtime/bunfig.mdx    |  2 +-
 src/bunfig/arguments.rs    | 64 ++++++++++++++++++++++++++++++++++++--
 src/windows_sys/externs.rs | 30 ++++++++++++++++--
 3 files changed, 90 insertions(+), 6 deletions(-)

diff --git a/docs/runtime/bunfig.mdx b/docs/runtime/bunfig.mdx
index e82ac6a717d5..72244e460641 100644
--- a/docs/runtime/bunfig.mdx
+++ b/docs/runtime/bunfig.mdx
@@ -11,7 +11,7 @@ Bun relies on pre-existing configuration files like `package.json` and `tsconfig
 
 Put `bunfig.toml` in your project root, alongside your `package.json`.
 
-`bun <file>`, `bun run`, `bun test`, and `bun build` read the `bunfig.toml` in the working directory. If there is none, they read the nearest one in a parent directory of the same project. The search stops at the directory of the nearest `package.json`, or at the workspace root whose `workspaces` lists that directory. Bun reads only one of these files and does not merge them. It skips a file in a parent directory that belongs to another user than the working directory, and it does not search parent directories when the working directory is inside `node_modules`.
+`bun <file>`, `bun run`, `bun test`, and `bun build` read the `bunfig.toml` in the working directory. If there is none, they read the nearest one in a parent directory of the same project. The search stops at the directory of the nearest `package.json`, or at the workspace root whose `workspaces` lists that directory. Bun reads only one of these files and does not merge them. It skips a file in a parent directory that belongs to another user than the working directory (on Windows, also one that is a symbolic link), and it does not search parent directories when the working directory is inside `node_modules`.
 
 To configure Bun's package manager globally, you can also create a `.bunfig.toml` file at one of the following paths:
 
diff --git a/src/bunfig/arguments.rs b/src/bunfig/arguments.rs
index 8b05ba4f3ee6..8011e93653a9 100644
--- a/src/bunfig/arguments.rs
+++ b/src/bunfig/arguments.rs
@@ -187,9 +187,67 @@ fn has_owner_of(path: &ZStr, cwd: &[u8]) -> bool {
     bun_sys::lstat(&bun_core::ZBox::from_bytes(cwd)).is_ok_and(|dir| dir.st_uid == file.st_uid)
 }
 
-#[cfg(not(unix))]
-fn has_owner_of(path: &ZStr, _: &[u8]) -> bool {
-    bun_sys::exists_z(path)
+/// The owner of a file or directory.
+#[cfg(windows)]
+struct Owner {
+    /// Points into `descriptor`.
+    sid: *mut core::ffi::c_void,
+    descriptor: *mut core::ffi::c_void,
+}
+
+#[cfg(windows)]
+impl Owner {
+    fn of(path: &[u8]) -> Option<Owner> {
+        use bun_sys::windows::advapi32;
+        use core::ptr::null_mut;
+
+        let mut wbuf = bun_paths::w_path_buffer_pool::get();
+        let wpath = bun_paths::string_paths::to_kernel32_path(&mut wbuf, path);
+        let mut owner = Owner {
+            sid: null_mut(),
+            descriptor: null_mut(),
+        };
+        // SAFETY: `wpath` is NUL-terminated, the two out-pointers are valid, and the others may be null.
+        let status = unsafe {
+            advapi32::GetNamedSecurityInfoW(
+                wpath.as_ptr(),
+                advapi32::SE_FILE_OBJECT,
+                advapi32::OWNER_SECURITY_INFORMATION,
+                &raw mut owner.sid,
+                null_mut(),
+                null_mut(),
+                null_mut(),
+                &raw mut owner.descriptor,
+            )
+        };
+        (status == 0 && !owner.sid.is_null()).then_some(owner)
+    }
+}
+
+#[cfg(windows)]
+impl Drop for Owner {
+    fn drop(&mut self) {
+        // SAFETY: `descriptor` is null or what `GetNamedSecurityInfoW` allocated, and nothing else frees it.
+        unsafe { bun_sys::windows::kernel32::LocalFree(self.descriptor) };
+    }
+}
+
+#[cfg(windows)]
+fn has_owner_of(path: &ZStr, cwd: &[u8]) -> bool {
+    // `Owner::of` follows a link, and another user can make one to a file of the owner of `cwd`.
+    if bun_sys::get_file_attributes(path).is_none_or(|it| it.is_reparse_point) {
+        return false;
+    }
+    let (Some(file), Some(dir)) = (Owner::of(path.as_bytes()), Owner::of(cwd)) else {
+        return false;
+    };
+    // SAFETY: both are valid SIDs in descriptors that `file` and `dir` keep alive.
+    unsafe { bun_sys::windows::advapi32::EqualSid(file.sid, dir.sid) != 0 }
+}
+
+#[cfg(not(any(unix, windows)))]
+fn has_owner_of(_: &ZStr, _: &[u8]) -> bool {
+    false
 }
 
 /// The nearest bunfig.toml above `cwd` that is in the same project: not above the nearest package.json, or the workspace root that lists it.
diff --git a/src/windows_sys/externs.rs b/src/windows_sys/externs.rs
index 990071300015..0da72b6d0bdc 100644
--- a/src/windows_sys/externs.rs
+++ b/src/windows_sys/externs.rs
@@ -797,8 +797,32 @@ pub use ntdll::NtClose;
 
 /// `user32` namespace (subset placeholder; fill in as needed).
 pub mod user32 {}
-/// `advapi32` namespace (subset placeholder; fill in as needed).
-pub mod advapi32 {}
+/// `advapi32` namespace (subset).
+pub mod advapi32 {
+    use super::*;
+
+    /// `SE_OBJECT_TYPE::SE_FILE_OBJECT` (`accctrl.h`).
+    pub const SE_FILE_OBJECT: c_int = 1;
+    /// `OWNER_SECURITY_INFORMATION` (`winnt.h`).
+    pub const OWNER_SECURITY_INFORMATION: DWORD = 0x0000_0001;
+
+    #[cfg_attr(windows, link(name = "advapi32"))]
+    unsafe extern "system" {
+        /// `GetNamedSecurityInfoW` (`aclapi.h`). The SIDs and ACLs point into `*ppSecurityDescriptor`, which the caller `LocalFree`s.
+        pub fn GetNamedSecurityInfoW(
+            pObjectName: LPCWSTR,
+            ObjectType: c_int,
+            SecurityInfo: DWORD,
+            ppsidOwner: *mut *mut c_void,
+            ppsidGroup: *mut *mut c_void,
+            ppDacl: *mut *mut c_void,
+            ppSacl: *mut *mut c_void,
+            ppSecurityDescriptor: *mut *mut c_void,
+        ) -> DWORD;
+        /// `EqualSid` (`securitybaseapi.h`).
+        pub fn EqualSid(pSid1: *mut c_void, pSid2: *mut c_void) -> BOOL;
+    }
+}
 
 // `bun.windows.libuv` is exposed from the higher-tier `bun_sys::windows`
 // module, NOT here — `bun_windows_sys` is the leaf Win32 externs crate and
@@ -886,6 +910,8 @@ pub mod kernel32 {
         pub fn GetExitCodeProcess(hProcess: HANDLE, lpExitCode: *mut DWORD) -> BOOL;
         /// `FlushFileBuffers` — fsync(2)-equivalent for HANDLE-backed files.
         pub fn FlushFileBuffers(hFile: HANDLE) -> BOOL;
+        /// `LocalFree` (`winbase.h`). Ignores null.
+        pub fn LocalFree(hMem: *mut c_void) -> *mut c_void;
         /// `lpOverlapped` is required even for synchronous handles: its `Offset` is the range start.
         pub fn LockFileEx(
             hFile: HANDLE,

From a775e737b954aadb6f0116b4b46bb4a42d84fe3e Mon Sep 17 00:00:00 2001
From: Jarred Sumner <jarred@jarredsumner.com>
Date: Mon, 19 Oct 2026 03:32:42 +0000
Subject: [PATCH 21/24] Remove helpers that bun init's dead code was the last
 user of; pass ConfigFile to Bunfig::parse

---
 src/ast/expr.rs               | 31 ------------
 src/bunfig/arguments.rs       | 14 +-----
 src/bunfig/bunfig.rs          | 19 +++-----
 src/collections/bit_set.rs    | 88 -----------------------------------
 src/collections/hive_array.rs |  6 +--
 5 files changed, 10 insertions(+), 148 deletions(-)

diff --git a/src/ast/expr.rs b/src/ast/expr.rs
index 056ca92028e8..dc92bf852941 100644
--- a/src/ast/expr.rs
+++ b/src/ast/expr.rs
@@ -337,37 +337,6 @@ impl Expr {
 // Expr — property/object/string accessor methods.
 
 impl Expr {
-    pub fn has_any_property_named(&self, names: &'static [&'static [u8]]) -> bool {
-        if let Data::EObjectJSON(obj) = &self.data {
-            return obj
-                .get()
-                .properties()
-                .iter()
-                .any(|p| bun_core::eql_any_comptime(p.key.slice(), names));
-        }
-        let Data::EObject(obj) = &self.data else {
-            return false;
-        };
-        if obj.properties.len_u32() == 0 {
-            return false;
-        }
-
-        for prop in obj.properties.slice() {
-            if prop.value.is_none() {
-                continue;
-            }
-            let Some(key) = &prop.key else { continue };
-            let Data::EString(key_str) = &key.data else {
-                continue;
-            };
-            if bun_core::eql_any_comptime(&key_str.data, names) {
-                return true;
-            }
-        }
-
-        false
-    }
-
     // toJS alias deleted — `to_js` lives in `bun_js_parser_jsc::expr_jsc` extension trait.
 
     /// Don't use this if you care about performance.
diff --git a/src/bunfig/arguments.rs b/src/bunfig/arguments.rs
index 8011e93653a9..22986ec269f4 100644
--- a/src/bunfig/arguments.rs
+++ b/src/bunfig/arguments.rs
@@ -76,7 +76,7 @@ fn unreadable_config(
 }
 
 #[derive(Copy, Clone, PartialEq, Eq)]
-enum ConfigFile {
+pub(crate) enum ConfigFile {
     /// `$XDG_CONFIG_HOME/.bunfig.toml` or `$HOME/.bunfig.toml`
     User,
     /// `./bunfig.toml`
@@ -138,17 +138,7 @@ fn load_bunfig(
         log: log_ptr,
         level: original_level,
     };
-    let is_above_cwd = file == ConfigFile::ProjectAbove;
-    let is_project_file = is_above_cwd || file == ConfigFile::Project;
-    Bunfig::parse(
-        cmd,
-        &source,
-        is_project_file,
-        is_above_cwd,
-        ctx,
-        tool,
-        counts,
-    )
+    Bunfig::parse(cmd, &source, file, ctx, tool, counts)
 }
 
 /// Whether the package.json in `root` lists `dir`, which is below `root`, as a workspace. `None` if it has no `workspaces`.
diff --git a/src/bunfig/bunfig.rs b/src/bunfig/bunfig.rs
index 0e162de12dc6..f5e902712c56 100644
--- a/src/bunfig/bunfig.rs
+++ b/src/bunfig/bunfig.rs
@@ -8,6 +8,7 @@
 
 #![allow(clippy::collapsible_if)]
 
+use crate::arguments::ConfigFile;
 use bun_collections::VecExt;
 use core::sync::atomic::Ordering;
 
@@ -1245,8 +1246,7 @@ impl Bunfig {
     pub(crate) fn parse(
         cmd: CommandTag,
         source: &bun_ast::Source,
-        is_project_file: bool,
-        is_above_cwd: bool,
+        file: ConfigFile,
         ctx: &mut ContextData,
         tool: Option<&mut crate::ToolReader<'_>>,
         counts: Counts,
@@ -1321,8 +1321,8 @@ impl Bunfig {
             source,
             ctx,
             bump: &bump,
-            is_project_file,
-            is_above_cwd,
+            is_project_file: matches!(file, ConfigFile::Project | ConfigFile::ProjectAbove),
+            is_above_cwd: file == ConfigFile::ProjectAbove,
             tool,
             counts,
         };
@@ -1353,15 +1353,8 @@ impl Bunfig {
             ..Default::default()
         };
         let cmd = CommandTag::InstallCommand;
-        Self::parse(
-            cmd,
-            source,
-            true,
-            false,
-            &mut ctx,
-            None,
-            Counts::OnlyInstall,
-        )?;
+        let file = ConfigFile::Project;
+        Self::parse(cmd, source, file, &mut ctx, None, Counts::OnlyInstall)?;
         Ok(ctx.install)
     }
 }
diff --git a/src/collections/bit_set.rs b/src/collections/bit_set.rs
index 824ac200118b..c83c0fcde8f5 100644
--- a/src/collections/bit_set.rs
+++ b/src/collections/bit_set.rs
@@ -146,50 +146,12 @@ impl<const SIZE: usize> IntegerBitSet<SIZE> {
         (self.mask & Self::mask_bit(index)) != 0
     }
 
-    /// Returns the total number of set bits in this bit set.
-    pub const fn count(self) -> usize {
-        self.mask.count_ones() as usize
-    }
-
     /// Adds a specific bit to the bit set
     pub fn set(&mut self, index: usize) {
         debug_assert!(index < Self::BIT_LENGTH);
         self.mask |= Self::mask_bit(index);
     }
 
-    /// Changes the value of all bits in the specified range to
-    /// match the passed boolean.
-    pub fn set_range_value(&mut self, range: Range, value: bool) {
-        debug_assert!(range.end <= Self::BIT_LENGTH);
-        debug_assert!(range.start <= range.end);
-        if range.start == range.end {
-            return;
-        }
-        if SIZE == 0 {
-            return;
-        }
-
-        let start_bit = u32::try_from(range.start).expect("int cast");
-
-        let mut mask = bool_mask_usize(true) << start_bit;
-        if range.end != Self::BIT_LENGTH {
-            let end_bit = u32::try_from(range.end).expect("int cast");
-            // `~0 >> (usize::BITS - end_bit)` yields the low `end_bit` bits.
-            mask &= bool_mask_usize(true) >> (usize::BITS - end_bit);
-        }
-        // also clear bits above SIZE since the backing `usize` may be wider than SIZE bits
-        mask &= Self::FULL_MASK;
-        self.mask &= !mask;
-
-        let mut mask = bool_mask_usize(value) << start_bit;
-        if range.end != Self::BIT_LENGTH {
-            let end_bit = u32::try_from(range.end).expect("int cast");
-            mask &= bool_mask_usize(value) >> (usize::BITS - end_bit);
-        }
-        mask &= Self::FULL_MASK;
-        self.mask |= mask;
-    }
-
     /// Removes a specific bit from the bit set
     pub fn unset(&mut self, index: usize) {
         debug_assert!(index < Self::BIT_LENGTH);
@@ -210,29 +172,6 @@ impl<const SIZE: usize> IntegerBitSet<SIZE> {
         Some(mask.trailing_zeros() as usize)
     }
 
-    /// Iterates through the items in the set, according to the options.
-    /// The default options (.{}) will iterate indices of set bits in
-    /// ascending order.  Modifications to the underlying bit set may
-    /// or may not be observed by the iterator.
-    pub fn iterator<const KIND_SET: bool, const DIR_FWD: bool>(
-        self,
-    ) -> SingleWordIterator<SIZE, DIR_FWD> {
-        SingleWordIterator {
-            bits_remain: if KIND_SET {
-                self.mask
-            } else {
-                !self.mask & Self::FULL_MASK
-            },
-        }
-    }
-
-    /// Iterate indices of set bits in ascending order.
-    /// Convenience wrapper for `iterator::<true, true>()`.
-    #[inline]
-    pub fn iter_set(self) -> SingleWordIterator<SIZE, true> {
-        self.iterator::<true, true>()
-    }
-
     #[inline(always)]
     fn mask_bit(index: usize) -> usize {
         if SIZE == 0 {
@@ -242,33 +181,6 @@ impl<const SIZE: usize> IntegerBitSet<SIZE> {
     }
 }
 
-/// Iterator over a single-word `IntegerBitSet`.
-pub struct SingleWordIterator<const SIZE: usize, const DIR_FWD: bool> {
-    // all bits which have not yet been iterated over
-    bits_remain: usize,
-}
-
-impl<const SIZE: usize, const DIR_FWD: bool> SingleWordIterator<SIZE, DIR_FWD> {
-    /// Returns the index of the next unvisited set bit
-    /// in the bit set, in ascending order.
-    pub fn next(&mut self) -> Option<usize> {
-        if self.bits_remain == 0 {
-            return None;
-        }
-
-        if DIR_FWD {
-            let next_index = self.bits_remain.trailing_zeros() as usize;
-            self.bits_remain &= self.bits_remain - 1;
-            Some(next_index)
-        } else {
-            let leading_zeroes = self.bits_remain.leading_zeros();
-            let top_bit = (usize::BITS - 1 - leading_zeroes) as usize;
-            self.bits_remain &= (1usize << top_bit) - 1;
-            Some(top_bit)
-        }
-    }
-}
-
 // ───────────────────────────── ArrayBitSet ─────────────────────────────
 
 /// Number of `usize` masks needed to hold `bit_length` bits.
diff --git a/src/collections/hive_array.rs b/src/collections/hive_array.rs
index 51cfe23d8f23..108f0a5a376a 100644
--- a/src/collections/hive_array.rs
+++ b/src/collections/hive_array.rs
@@ -113,15 +113,13 @@ impl<const CAPACITY: usize> HiveBitSet<CAPACITY> {
         None
     }
 
-    /// Forward iterator over set bits. Mirrors `IntegerBitSet::iter_set`.
+    /// Forward iterator over set bits.
     #[inline]
     pub fn iter_set(&self) -> HiveBitSetIter<CAPACITY> {
         self.iterator::<true, true>()
     }
 
-    /// Signature mirrors `IntegerBitSet::iterator` so existing
-    /// `hive.used.iterator::<true, true>()` callers compile unchanged. Only
-    /// the `<KIND_SET=true, DIR_FWD=true>` combination is implemented (the
+    /// Only the `<KIND_SET=true, DIR_FWD=true>` combination is implemented (the
     /// only one used in-tree); other params assert.
     #[inline]
     pub fn iterator<const KIND_SET: bool, const DIR_FWD: bool>(&self) -> HiveBitSetIter<CAPACITY> {

From f8a9f16eaf5306386f70646beeb6253f72e4235e Mon Sep 17 00:00:00 2001
From: Jarred Sumner <jarred@jarredsumner.com>
Date: Mon, 19 Oct 2026 04:03:20 +0000
Subject: [PATCH 22/24] Review fixes: forward --jsx-side-effects to --parallel
 workers, complete file names with spaces in bash

---
 completions/bun.bash                        |  4 +-
 src/parsers/json.rs                         |  7 ---
 src/runtime/cli/test/parallel/runner.rs     |  6 +--
 test/cli/bun.test.ts                        |  3 +-
 test/cli/test/parallel.test.ts              | 21 ++++++++
 test/js/bun/spawn/bun-ipc-inherit.test.ts   | 53 ++++++++++++++++++++-
 test/js/bun/spawn/ipc-channel-scrub.test.ts | 51 --------------------
 7 files changed, 79 insertions(+), 66 deletions(-)
 delete mode 100644 test/js/bun/spawn/ipc-channel-scrub.test.ts

diff --git a/completions/bun.bash b/completions/bun.bash
index 2072b438b655..06d0832f6445 100644
--- a/completions/bun.bash
+++ b/completions/bun.bash
@@ -3,14 +3,14 @@ _file_arguments() {
     local pattern="${1}";
     local file;
 
-    for file in $(compgen -f -- "${cur_word}"); do
+    while IFS= read -r file; do
         if [[ -d "${file}" ]]; then
             # a subcommand goes before a directory of the same name: `bun te<TAB>` gives `bun test `
             [[ " ${COMPREPLY[*]} " == *" ${file} "* ]] || COMPREPLY+=( "${file}/" );
         elif [[ "${file}" == ${pattern} ]]; then
             COMPREPLY+=( "${file}" );
         fi
-    done
+    done < <(compgen -f -- "${cur_word}")
 
     # no space after a directory, so that the next <TAB> lists what is in it
     [[ "${#COMPREPLY[@]}" -eq 1 && "${COMPREPLY[0]}" == */ ]] && compopt -o nospace 2>/dev/null;
diff --git a/src/parsers/json.rs b/src/parsers/json.rs
index 19ec1e1b6bc9..d9c68d2667e1 100644
--- a/src/parsers/json.rs
+++ b/src/parsers/json.rs
@@ -1942,13 +1942,6 @@ mod tests {
                 root.get_object(b"name").is_some()
             )
             .unwrap();
-            writeln!(
-                out,
-                "has_any={} {}",
-                root.has_any_property_named(&[b"zzz", b"private"]),
-                root.has_any_property_named(&[b"zzz"])
-            )
-            .unwrap();
 
             let deps = root.get(b"deps").unwrap();
             assert!(deps.is_object());
diff --git a/src/runtime/cli/test/parallel/runner.rs b/src/runtime/cli/test/parallel/runner.rs
index 69dbe6aae56a..96201c1bcee9 100644
--- a/src/runtime/cli/test/parallel/runner.rs
+++ b/src/runtime/cli/test/parallel/runner.rs
@@ -420,9 +420,9 @@ fn build_worker_argv(ctx: &Command::ContextData) -> crate::Result<Box<[bun_spawn
             "--jsx-runtime={}",
             jsx_runtime_tag_name(jsx.runtime)
         ))?);
-        if jsx.side_effects {
-            argv.push(lit(b"--jsx-side-effects\0"));
-        }
+    }
+    if ctx.args.jsx_side_effects {
+        argv.push(lit(b"--jsx-side-effects\0"));
     }
     if opts.coverage.enabled {
         argv.push(lit(b"--coverage\0"));
diff --git a/test/cli/bun.test.ts b/test/cli/bun.test.ts
index 3a4db607451e..ce9bff41eb1d 100644
--- a/test/cli/bun.test.ts
+++ b/test/cli/bun.test.ts
@@ -491,7 +491,7 @@ describe("bun", () => {
         : 0;
 
       test.concurrent.skipIf(bashVersion < 4)("bash offers files and scripts, also after a flag", async () => {
-        using dir = tempDir("completions-bash", { ...project, "bun.bash": await script("bash") });
+        using dir = tempDir("completions-bash", { ...project, "two words.ts": "", "bun.bash": await script("bash") });
         const expected = {
           "bun sr": ["src/"],
           "bun src/": ["src/index.ts", "src/other.ts"],
@@ -503,6 +503,7 @@ describe("bun", () => {
           "bun --cwd . run src/o": ["src/other.ts"],
           "bun test te": ["test/"],
           "bun myscript.ts fo": ["foo.txt"],
+          "bun tw": ["two words.ts"],
           "bun --silent add --p": ["--peer", "--production"],
           // As before.
           "bun add --p": ["--peer", "--production"],
diff --git a/test/cli/test/parallel.test.ts b/test/cli/test/parallel.test.ts
index 0a628a4438d5..95ed5a8c2829 100644
--- a/test/cli/test/parallel.test.ts
+++ b/test/cli/test/parallel.test.ts
@@ -1251,6 +1251,27 @@ test("--parallel forwards --conditions to workers", async () => {
   expect(exitCode).toBe(0);
 });
 
+test("--parallel forwards --jsx-side-effects to workers", async () => {
+  const fixture = `import {test,expect} from "bun:test"; let calls = 0; const h = () => void calls++; test("t",()=>{ <div />; expect(calls).toBe(1); });`;
+  using dir = tempDir("parallel-jsx-side-effects", {
+    "tsconfig.json": JSON.stringify({ compilerOptions: { jsx: "react", jsxFactory: "h" } }),
+    "a.test.tsx": fixture,
+    "b.test.tsx": fixture,
+  });
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), "test", "--parallel=2", "--jsx-side-effects"],
+    env: { ...bunEnv, BUN_TEST_PARALLEL_SCALE_MS: "0" },
+    cwd: String(dir),
+    stderr: "pipe",
+    stdout: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+  expect(stdout).toContain("PARALLEL");
+  expect(stderr).toContain("2 pass");
+  expect(stderr).toContain("0 fail");
+  expect(exitCode).toBe(0);
+});
+
 test("--parallel: workers get the --env-file values and skip the default .env", async () => {
   const fixture = `import {test,expect} from "bun:test"; test("env", () => { expect(process.env.BUNTEST_CUSTOM).toBe("1"); expect(process.env.BUNTEST_DOTENV).toBeUndefined(); });`;
   using dir = tempDir("parallel-env-file", {
diff --git a/test/js/bun/spawn/bun-ipc-inherit.test.ts b/test/js/bun/spawn/bun-ipc-inherit.test.ts
index 00a4ca8988c0..a834434f2274 100644
--- a/test/js/bun/spawn/bun-ipc-inherit.test.ts
+++ b/test/js/bun/spawn/bun-ipc-inherit.test.ts
@@ -1,6 +1,6 @@
 import { spawn } from "bun";
-import { expect, it } from "bun:test";
-import { bunExe, isWindows, tmpdirSync } from "harness";
+import { expect, it, test } from "bun:test";
+import { bunEnv, bunExe, isWindows, tempDir, tmpdirSync } from "harness";
 import fs from "node:fs/promises";
 import path from "path";
 
@@ -28,3 +28,52 @@ it.todoIf(isWindows)("spawning a bun package script should inherit the ipc fd",
   await child.exited;
   expect(testMessage).toBe("hello");
 });
+
+// A bun CLI process that inherits an IPC channel (NODE_CHANNEL_FD) must not
+// forward that channel to the scripts and tools it spawns, the way Node sets
+// the channel fd close-on-exec and deletes the variables before it spawns.
+//
+// The grandchild is a POSIX shell, not bun or node: bun and node remove
+// NODE_CHANNEL_FD from `process.env` while they adopt the channel, so only a
+// shell reports the raw inherited value.
+const SHOW_CHANNEL = [
+  "#!/bin/sh",
+  `printf 'NODE_CHANNEL_FD=[%s]\\n' "\${NODE_CHANNEL_FD:-}"`,
+  `printf 'NODE_CHANNEL_SERIALIZATION_MODE=[%s]\\n' "\${NODE_CHANNEL_SERIALIZATION_MODE:-}"`,
+  "",
+].join("\n");
+
+const NO_CHANNEL = "NODE_CHANNEL_FD=[]\nNODE_CHANNEL_SERIALIZATION_MODE=[]\n";
+
+// Spawn `bun <args>` with an IPC channel (`ipc` makes Bun.spawn create one and
+// set NODE_CHANNEL_FD for the direct child) and report what the grandchild saw.
+async function runWithChannel(args: string[], cwd: string) {
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), ...args],
+    env: bunEnv,
+    cwd,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+    ipc() {},
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+  return { stdout, stderr, exitCode };
+}
+
+test.concurrent.skipIf(isWindows)("bun exec does not forward the inherited IPC channel", async () => {
+  using dir = tempDir("ipc-scrub-exec", { "show.sh": SHOW_CHANNEL });
+  const { stdout, stderr, exitCode } = await runWithChannel(["exec", "sh show.sh"], String(dir));
+  expect(stdout).toBe(NO_CHANNEL);
+  expect({ stderr, exitCode }).toEqual({ stderr: "", exitCode: 0 });
+});
+
+test.concurrent.skipIf(isWindows)("bun run --shell=bun does not forward the inherited IPC channel", async () => {
+  using dir = tempDir("ipc-scrub-bunshell", {
+    "package.json": JSON.stringify({ name: "x", version: "1.0.0", scripts: { show: "sh show.sh" } }),
+    "show.sh": SHOW_CHANNEL,
+  });
+  const { stdout, stderr, exitCode } = await runWithChannel(["run", "--silent", "--shell=bun", "show"], String(dir));
+  expect(stdout).toBe(NO_CHANNEL);
+  expect({ stderr, exitCode }).toEqual({ stderr: "", exitCode: 0 });
+});
diff --git a/test/js/bun/spawn/ipc-channel-scrub.test.ts b/test/js/bun/spawn/ipc-channel-scrub.test.ts
deleted file mode 100644
index 962d01247bf7..000000000000
--- a/test/js/bun/spawn/ipc-channel-scrub.test.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import { expect, test } from "bun:test";
-import { bunEnv, bunExe, isWindows, tempDir } from "harness";
-
-// A bun CLI process that inherits an IPC channel (NODE_CHANNEL_FD) must not
-// forward that channel to the scripts and tools it spawns, the way Node sets
-// the channel fd close-on-exec and deletes the variables before it spawns.
-//
-// The grandchild is a POSIX shell, not bun or node: bun and node remove
-// NODE_CHANNEL_FD from `process.env` while they adopt the channel, so only a
-// shell reports the raw inherited value.
-const SHOW_CHANNEL = [
-  "#!/bin/sh",
-  `printf 'NODE_CHANNEL_FD=[%s]\\n' "\${NODE_CHANNEL_FD:-}"`,
-  `printf 'NODE_CHANNEL_SERIALIZATION_MODE=[%s]\\n' "\${NODE_CHANNEL_SERIALIZATION_MODE:-}"`,
-  "",
-].join("\n");
-
-const NO_CHANNEL = "NODE_CHANNEL_FD=[]\nNODE_CHANNEL_SERIALIZATION_MODE=[]\n";
-
-// Spawn `bun <args>` with an IPC channel (`ipc` makes Bun.spawn create one and
-// set NODE_CHANNEL_FD for the direct child) and report what the grandchild saw.
-async function runWithChannel(args: string[], cwd: string) {
-  await using proc = Bun.spawn({
-    cmd: [bunExe(), ...args],
-    env: bunEnv,
-    cwd,
-    stdin: "ignore",
-    stdout: "pipe",
-    stderr: "pipe",
-    ipc() {},
-  });
-  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
-  return { stdout, stderr, exitCode };
-}
-
-test.concurrent.skipIf(isWindows)("bun exec does not forward the inherited IPC channel", async () => {
-  using dir = tempDir("ipc-scrub-exec", { "show.sh": SHOW_CHANNEL });
-  const { stdout, stderr, exitCode } = await runWithChannel(["exec", "sh show.sh"], String(dir));
-  expect(stdout).toBe(NO_CHANNEL);
-  expect({ stderr, exitCode }).toEqual({ stderr: "", exitCode: 0 });
-});
-
-test.concurrent.skipIf(isWindows)("bun run --shell=bun does not forward the inherited IPC channel", async () => {
-  using dir = tempDir("ipc-scrub-bunshell", {
-    "package.json": JSON.stringify({ name: "x", version: "1.0.0", scripts: { show: "sh show.sh" } }),
-    "show.sh": SHOW_CHANNEL,
-  });
-  const { stdout, stderr, exitCode } = await runWithChannel(["run", "--silent", "--shell=bun", "show"], String(dir));
-  expect(stdout).toBe(NO_CHANNEL);
-  expect({ stderr, exitCode }).toEqual({ stderr: "", exitCode: 0 });
-});

From be203b5262a383077f9bb1834380881f68f64d17 Mon Sep 17 00:00:00 2001
From: Jarred Sumner <jarred@jarredsumner.com>
Date: Mon, 19 Oct 2026 04:08:48 +0000
Subject: [PATCH 23/24] isolated-install.test.ts: bun can wait for a lifecycle
 script when SIGCHLD is ignored

---
 test/cli/install/isolated-install.test.ts | 28 ++++-------------------
 1 file changed, 5 insertions(+), 23 deletions(-)

diff --git a/test/cli/install/isolated-install.test.ts b/test/cli/install/isolated-install.test.ts
index 91fc99bb6fdb..ac96f9eb21f3 100644
--- a/test/cli/install/isolated-install.test.ts
+++ b/test/cli/install/isolated-install.test.ts
@@ -5434,23 +5434,6 @@ describe.each(["isolated", "hoisted"] as const)("failed script of an optional de
     },
   );
 
-  // With SIGCHLD ignored, Linux reaps the script itself and bun cannot wait for it. Bun then
-  // treats a script that exited 0 as failed, through a second exit path.
-  test.concurrent.skipIf(!isLinux)("workspace: the folder is kept when bun can't wait for the script", async () => {
-    const { packageDir } = await registry.createTestDir({ bunfigOpts: { linker }, files: workspaceFiles() });
-    const verb = linker === "hoisted" ? "deleting" : "skipping";
-
-    const { stderr, exitCode } = await installCounted(packageDir, {
-      argv0: ["bash", "-c", 'trap "" CHLD; exec "$0" "$@"'],
-      args: ["--filter", "y", "--verbose"],
-      pass: true,
-    });
-    expect(stderr).not.toContain("error:");
-    expect(stderr).toContain(`${verb} optional dependency 'x' due to failed 'postinstall' script`);
-    expect(await workspaceState(packageDir)).toEqual({ runs: ["x"], ...kept });
-    expect(exitCode).toBe(0);
-  });
-
   test.concurrent("file: folder: the copy is removed, also in a workspace's node_modules", async () => {
     const { packageDir } = await registry.createTestDir({
       bunfigOpts: { linker },
@@ -6121,14 +6104,13 @@ describe.concurrent("bin links of a failed optional dependency (hoisted)", () =>
     expect(trusted.exitCode).toBe(0);
   });
 
-  // With SIGCHLD ignored, Linux reaps the script itself and bun cannot wait for it. Bun then
-  // treats a script that exited 0 as failed, through a second exit path.
-  test.concurrent.skipIf(!isLinux)("a script that bun cannot wait for", async () => {
+  // If SIGCHLD stayed ignored, Linux would reap the script itself, and bun would take a script that exited 0 for a failed one.
+  test.concurrent.skipIf(!isLinux)("a script that exits 0 while the parent process ignores SIGCHLD", async () => {
     const { packageDir } = await registry.createTestDir({
       bunfigOpts: { linker: "hoisted" },
       files: {
         "package.json": JSON.stringify({
-          name: "optional-bin-cannot-wait",
+          name: "optional-bin-sigchld-ignored",
           optionalDependencies: { x: "file:./x" },
           trustedDependencies: ["x"],
         }),
@@ -6149,11 +6131,11 @@ describe.concurrent("bin links of a failed optional dependency (hoisted)", () =>
     });
 
     expect(stderr).not.toContain("error:");
-    expect(stderr).toContain("deleting optional dependency 'x' due to failed 'postinstall' script");
+    expect(stderr).not.toContain("failed 'postinstall' script");
     expect({
       bins: await linkedBins(join(nodeModules, ".bin")),
       installed: existsSync(join(nodeModules, "x")),
-    }).toEqual({ bins: [], installed: false });
+    }).toEqual({ bins: ["xbin"], installed: true });
     expect(exitCode).toBe(0);
   });
 

From 04b8877f6babe4a128d91cb747205d359a0cac13 Mon Sep 17 00:00:00 2001
From: Jarred Sumner <jarred@jarredsumner.com>
Date: Mon, 19 Oct 2026 06:22:25 +0000
Subject: [PATCH 24/24] bunfig: the directory of a bunfig.toml above the cwd
 must have the cwd's owner too; don't apply its [test] root

---
 docs/runtime/bunfig.mdx            |  6 +++---
 src/bun_core/util.rs               |  1 +
 src/bunfig/arguments.rs            | 25 ++++++++++++++++---------
 src/bunfig/bunfig.rs               |  3 ++-
 test/config/bunfig/preload.test.ts | 24 ++++++++++++++++++++++--
 5 files changed, 44 insertions(+), 15 deletions(-)

diff --git a/docs/runtime/bunfig.mdx b/docs/runtime/bunfig.mdx
index 72244e460641..49c9a7d07292 100644
--- a/docs/runtime/bunfig.mdx
+++ b/docs/runtime/bunfig.mdx
@@ -11,7 +11,7 @@ Bun relies on pre-existing configuration files like `package.json` and `tsconfig
 
 Put `bunfig.toml` in your project root, alongside your `package.json`.
 
-`bun <file>`, `bun run`, `bun test`, and `bun build` read the `bunfig.toml` in the working directory. If there is none, they read the nearest one in a parent directory of the same project. The search stops at the directory of the nearest `package.json`, or at the workspace root whose `workspaces` lists that directory. Bun reads only one of these files and does not merge them. It skips a file in a parent directory that belongs to another user than the working directory (on Windows, also one that is a symbolic link), and it does not search parent directories when the working directory is inside `node_modules`.
+`bun <file>`, `bun run`, `bun test`, and `bun build` read the `bunfig.toml` in the working directory. If there is none, they read the nearest one in a parent directory of the same project. The search stops at the directory of the nearest `package.json`, or at the workspace root whose `workspaces` lists that directory. Bun reads only one of these files and does not merge them. It skips a file in a parent directory unless the file and its directory have the same owner as the working directory (on Windows, it also skips a symbolic link), and it does not search parent directories when the working directory is inside `node_modules`.
 
 To configure Bun's package manager globally, you can also create a `.bunfig.toml` file at one of the following paths:
 
@@ -38,7 +38,7 @@ An array of scripts/plugins to execute before running a file or script.
 preload = ["./preload.ts"]
 ```
 
-Relative paths are relative to the directory of the `bunfig.toml` that Bun found. With `--config`, they are relative to the working directory.
+A relative path in `preload` or [`test.preload`](#test-preload) is relative to the directory of the `bunfig.toml` that Bun found. With `--config`, it is relative to the working directory. In a `bunfig.toml` that Bun found in a parent directory, only these two and the paths in [`[install]`](#package-manager) are relative to that file's directory, and [`test.root`](#test-root) is not applied.
 
 ### `jsx`
 
@@ -192,7 +192,7 @@ The `[test]` section of `bunfig.toml` configures the test runner.
 
 ### `test.root`
 
-The root directory to run tests from, relative to the working directory. Default `.`.
+The root directory to run tests from, relative to the working directory. Default `.`. Bun ignores it in a `bunfig.toml` that it found in a parent directory.
 
 ```toml title="bunfig.toml" icon="settings"
 [test]
diff --git a/src/bun_core/util.rs b/src/bun_core/util.rs
index 540147bc13ca..42e0c150d10f 100644
--- a/src/bun_core/util.rs
+++ b/src/bun_core/util.rs
@@ -4578,6 +4578,7 @@ pub fn keep_children_waitable() {
                 && current.sa_sigaction == libc::SIG_IGN
             {
                 current.sa_sigaction = libc::SIG_DFL;
+                current.sa_flags = 0;
                 libc::sigaction(libc::SIGCHLD, &raw const current, core::ptr::null_mut());
             }
         }
diff --git a/src/bunfig/arguments.rs b/src/bunfig/arguments.rs
index 22986ec269f4..9cdb42c68b6e 100644
--- a/src/bunfig/arguments.rs
+++ b/src/bunfig/arguments.rs
@@ -168,13 +168,15 @@ fn lists_workspace(root: &[u8], dir: &[u8], buf: &mut PathBuffer) -> Option<bool
     })))
 }
 
-/// Whether `path` exists and, not following a link, has the owner of `cwd`, who could put the same file into `cwd`.
+/// Whether `path`, not following a link, and its directory `dir` belong to the owner of `cwd`; a hard link gives `path` alone that owner.
 #[cfg(unix)]
-fn has_owner_of(path: &ZStr, cwd: &[u8]) -> bool {
+fn has_owner_of(path: &ZStr, dir: &[u8], cwd: &[u8]) -> bool {
     let Ok(file) = bun_sys::lstat(path) else {
         return false;
     };
-    bun_sys::lstat(&bun_core::ZBox::from_bytes(cwd)).is_ok_and(|dir| dir.st_uid == file.st_uid)
+    [dir, cwd].into_iter().all(|it| {
+        bun_sys::lstat(&bun_core::ZBox::from_bytes(it)).is_ok_and(|it| it.st_uid == file.st_uid)
+    })
 }
 
 /// The owner of a file or directory.
@@ -223,20 +225,24 @@ impl Drop for Owner {
 }
 
 #[cfg(windows)]
-fn has_owner_of(path: &ZStr, cwd: &[u8]) -> bool {
+fn has_owner_of(path: &ZStr, dir: &[u8], cwd: &[u8]) -> bool {
+    use bun_sys::windows::advapi32::EqualSid;
+
     // `Owner::of` follows a link, and another user can make one to a file of the owner of `cwd`.
     if bun_sys::get_file_attributes(path).is_none_or(|it| it.is_reparse_point) {
         return false;
     }
-    let (Some(file), Some(dir)) = (Owner::of(path.as_bytes()), Owner::of(cwd)) else {
+    let (Some(file), Some(dir), Some(cwd)) =
+        (Owner::of(path.as_bytes()), Owner::of(dir), Owner::of(cwd))
+    else {
         return false;
     };
-    // SAFETY: both are valid SIDs in descriptors that `file` and `dir` keep alive.
-    unsafe { bun_sys::windows::advapi32::EqualSid(file.sid, dir.sid) != 0 }
+    // SAFETY: all are valid SIDs in descriptors that `file`, `dir` and `cwd` keep alive.
+    unsafe { EqualSid(file.sid, cwd.sid) != 0 && EqualSid(dir.sid, cwd.sid) != 0 }
 }
 
 #[cfg(not(any(unix, windows)))]
-fn has_owner_of(_: &ZStr, _: &[u8]) -> bool {
+fn has_owner_of(_: &ZStr, _: &[u8], _: &[u8]) -> bool {
     false
 }
 
@@ -251,7 +257,8 @@ fn find_config_above<'buf>(cwd: &[u8], buf: &'buf mut PathBuffer) -> Option<&'bu
     let mut config_dir = cwd;
     loop {
         config_dir = bun_core::dirname(config_dir)?;
-        if has_owner_of(join_config_path(config_dir, b"bunfig.toml", buf)?, cwd) {
+        let path = join_config_path(config_dir, b"bunfig.toml", buf)?;
+        if has_owner_of(path, config_dir, cwd) {
             break;
         }
     }
diff --git a/src/bunfig/bunfig.rs b/src/bunfig/bunfig.rs
index f5e902712c56..bd3ebf947787 100644
--- a/src/bunfig/bunfig.rs
+++ b/src/bunfig/bunfig.rs
@@ -469,7 +469,8 @@ impl<'a> Parser<'a, '_> {
         // The flags of `bun test` are applied already, and they win over these keys.
         if cmd == CommandTag::TestCommand {
             if let Some(test) = json.get(b"test") {
-                if let Some(root) = test.get(b"root") {
+                // `root` is relative to the working directory, not to the directory of a file found above it.
+                if let Some(root) = test.get(b"root").filter(|_| !self.is_above_cwd) {
                     self.ctx.debug.test_directory = root.as_string(self.bump).unwrap_or(b"").into();
                 }
 
diff --git a/test/config/bunfig/preload.test.ts b/test/config/bunfig/preload.test.ts
index 0c825339ec6d..a6bedf881736 100644
--- a/test/config/bunfig/preload.test.ts
+++ b/test/config/bunfig/preload.test.ts
@@ -269,9 +269,12 @@ describe.concurrent("Given a working directory without a `bunfig.toml`", () => {
     expect(await run("index.ts", { args, cwd: join(String(dir), cwd) })).toEqual([out, "", 0]);
   });
 
-  it.skipIf(isWindows || process.getuid?.() !== 0)("the one of another user does not count", async () => {
+  it.skipIf(isWindows || process.getuid?.() !== 0).each([
+    { name: "the one of another user does not count", path: "bunfig.toml" },
+    { name: "one's own in a directory of another user does not count", path: "." },
+  ])("$name", async ({ path }) => {
     using dir = tempDir("bunfig-above", monorepo);
-    chownSync(join(String(dir), "bunfig.toml"), 65534, 65534);
+    chownSync(join(String(dir), path), 65534, 65534);
     expect(await run("index.ts", { cwd: join(String(dir), "packages/a") })).toEqual([none, "", 0]);
   });
 
@@ -299,6 +302,23 @@ describe.concurrent("Given a working directory without a `bunfig.toml`", () => {
     expect(code).toBe(0);
   });
 
+  it.each([
+    { name: "`bun test` in a workspace", args: [], cwd: "packages/a" },
+    { name: "`bun run --filter a test`", args: ["run", "--filter", "a"], cwd: "." },
+  ])(
+    "$name runs the workspace's tests when the one of the workspace root sets `[test] root`",
+    async ({ args, cwd }) => {
+      using dir = tempDir("bunfig-above", {
+        ...monorepo,
+        "bunfig.toml": rootBunfig + `root = "./tests"\n`,
+        "packages/a/package.json": JSON.stringify({ name: "a", scripts: { test: `${bunExe()} test` } }),
+      });
+      const [out, , code] = await run("test", { args, cwd: join(String(dir), cwd) });
+      expect(out).toContain("number undefined");
+      expect(code).toBe(0);
+    },
+  );
+
   it("`bun build` in a workspace reads the one of the workspace root", async () => {
     using dir = tempDir("bunfig-above", monorepo);
     const [out, err, code] = await run("index.ts", { args: ["build"], cwd: join(String(dir), "packages/a") });