From 0afbbdfcaa85822295e85e6f52ea3383f3bd7a88 Mon Sep 17 00:00:00 2001
From: robobun <117481402+robobun@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:01:45 +0000
Subject: [PATCH 01/10] bunfig: load global ~/.bunfig.toml for runtime
 commands; fall back to $HOME when XDG path has no config

Two long-standing gaps between docs and behavior:

1. read_global_config() only matched install-family commands plus bunx.
   The global ~/.bunfig.toml's top-level fields (preload, define) and
   [test] section were never applied to bun <file>, bun -e, bun run, or
   bun test.

2. get_home_config_path() returned the $XDG_CONFIG_HOME path whenever
   the env var was set, without checking if the file existed. On
   desktops where XDG_CONFIG_HOME is set by default, $HOME/.bunfig.toml
   was silently ignored.

The global config is now loaded for every command that loads a local
bunfig (read_global_config() == LOADS_CONFIG[cmd]), and the XDG path is
only used when the file actually exists there.

The loaded_bunfig flag moves from load_bunfig (set on any successful
parse) to load_config_path (set when the local-config load is attempted)
so the run_command.rs fallbacks still fire for bun run / bun <script>
after the global file has been read.
---
 src/bunfig/arguments.rs                       |  31 ++--
 src/options_types/command_tag.rs              |  18 +-
 test/cli/install/bun-run-bunfig.test.ts       |  10 +-
 .../bunfig/global-bunfig-runtime.test.ts      | 155 ++++++++++++++++++
 4 files changed, 184 insertions(+), 30 deletions(-)
 create mode 100644 test/config/bunfig/global-bunfig-runtime.test.ts

diff --git a/src/bunfig/arguments.rs b/src/bunfig/arguments.rs
index d0a388d3ef7c..8605d7041ebf 100644
--- a/src/bunfig/arguments.rs
+++ b/src/bunfig/arguments.rs
@@ -20,13 +20,20 @@ use crate::bunfig::Bunfig;
 fn get_home_config_path(buf: &mut PathBuffer) -> Option<&ZStr> {
     let paths: [&[u8]; 1] = [b".bunfig.toml"];
 
-    if let Some(data_dir) = env_var::XDG_CONFIG_HOME.get() {
-        return Some(resolve_path::join_abs_string_buf_z::<platform::Auto>(
-            data_dir, &mut **buf, &paths,
-        ));
+    // `$XDG_CONFIG_HOME/.bunfig.toml` takes precedence, but only when the file
+    // actually exists there; otherwise fall through to `$HOME/.bunfig.toml`.
+    if let Some(data_dir) = env_var::XDG_CONFIG_HOME.get_not_empty() {
+        let len = {
+            let path =
+                resolve_path::join_abs_string_buf_z::<platform::Auto>(data_dir, &mut **buf, &paths);
+            if bun_sys::exists_z(path) { path.len() } else { 0 }
+        };
+        if len > 0 {
+            return Some(ZStr::from_buf(&buf[..], len));
+        }
     }
 
-    if let Some(home_dir) = env_var::HOME.get() {
+    if let Some(home_dir) = env_var::HOME.get_not_empty() {
         return Some(resolve_path::join_abs_string_buf_z::<platform::Auto>(
             home_dir, &mut **buf, &paths,
         ));
@@ -76,7 +83,6 @@ fn load_bunfig(
         // SAFETY: same as above; runs on the same thread.
         unsafe { (*log_ptr).level = lvl };
     });
-    ctx.debug.loaded_bunfig = true;
     Bunfig::parse(cmd, &source, ctx)
 }
 
@@ -118,6 +124,9 @@ pub fn load_config_path(
         }
     }
 
+    // `loaded_bunfig` tracks whether the local-config load has been attempted
+    // so the `run_command.rs`/`repl_command.rs` fallbacks don't repeat it.
+    ctx.debug.loaded_bunfig = true;
     load_bunfig(cmd, auto_loaded, config_path, ctx)
 }
 
@@ -153,14 +162,8 @@ pub fn load_config(
 
     let mut config_buf = PathBuffer::uninit();
     if cmd.read_global_config() {
-        if !ctx.has_loaded_global_config {
-            ctx.has_loaded_global_config = true;
-
-            if let Some(path) = get_home_config_path(&mut config_buf) {
-                if let Err(err) = load_config_path(cmd, true, path, ctx) {
-                    report_bunfig_load_failure(ctx.log, err);
-                }
-            }
+        if let Err(err) = load_global_bunfig(cmd, ctx) {
+            report_bunfig_load_failure(ctx.log, err);
         }
     }
 
diff --git a/src/options_types/command_tag.rs b/src/options_types/command_tag.rs
index f667abf1fa50..c743463af754 100644
--- a/src/options_types/command_tag.rs
+++ b/src/options_types/command_tag.rs
@@ -87,20 +87,10 @@ impl Tag {
     }
 
     pub fn read_global_config(self) -> bool {
-        matches!(
-            self,
-            Tag::BunxCommand
-                | Tag::PackageManagerCommand
-                | Tag::InstallCommand
-                | Tag::AddCommand
-                | Tag::RemoveCommand
-                | Tag::UpdateCommand
-                | Tag::PatchCommand
-                | Tag::PatchCommitCommand
-                | Tag::OutdatedCommand
-                | Tag::PublishCommand
-                | Tag::AuditCommand
-        )
+        // Every command that loads a local `bunfig.toml` also loads the global
+        // one first so the documented shallow merge (local overrides global)
+        // applies uniformly to runtime and install settings alike.
+        LOADS_CONFIG[self]
     }
 
     pub fn is_npm_related(self) -> bool {
diff --git a/test/cli/install/bun-run-bunfig.test.ts b/test/cli/install/bun-run-bunfig.test.ts
index c3a90d514c45..e02697cad267 100644
--- a/test/cli/install/bun-run-bunfig.test.ts
+++ b/test/cli/install/bun-run-bunfig.test.ts
@@ -209,7 +209,7 @@ describe.each(["bun run", "bun"])(`%s`, cmd => {
     expect(result.success).toBeTrue();
   });
 
-  test("NOT autoload home bunfig.toml", async () => {
+  test("autoload home .bunfig.toml", async () => {
     const runCmd = cmd === "bun" ? ["run"] : [];
 
     const bunfig = toTOMLString({
@@ -236,6 +236,8 @@ describe.each(["bun run", "bun"])(`%s`, cmd => {
       env: {
         ...bunEnv,
         HOME: pathJoin(cwd, "./my-home"),
+        USERPROFILE: pathJoin(cwd, "./my-home"),
+        XDG_CONFIG_HOME: undefined,
       },
       stderr: "inherit",
       stdout: "pipe",
@@ -244,7 +246,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();
   });
 });
diff --git a/test/config/bunfig/global-bunfig-runtime.test.ts b/test/config/bunfig/global-bunfig-runtime.test.ts
new file mode 100644
index 000000000000..d57292fbd1a8
--- /dev/null
+++ b/test/config/bunfig/global-bunfig-runtime.test.ts
@@ -0,0 +1,155 @@
+// The global `.bunfig.toml` must apply to runtime commands (`bun <file>`,
+// `bun -e`, `bun run`, `bun test`) and must fall back to `$HOME/.bunfig.toml`
+// when `$XDG_CONFIG_HOME` is set but contains no config.
+import { describe, expect, test } from "bun:test";
+import { bunEnv, bunExe, tempDir } from "harness";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+function baseEnv(home: string, xdg?: string) {
+  const env: Record<string, string> = { ...bunEnv };
+  // Isolate from the host's global config.
+  delete env.HOME;
+  delete env.USERPROFILE;
+  delete env.XDG_CONFIG_HOME;
+  // `bun pm cache` precedence: strip vars that would mask `[install.cache].dir`.
+  delete env.BUN_INSTALL_CACHE_DIR;
+  delete env.BUN_INSTALL;
+  delete env.XDG_CACHE_HOME;
+  env.HOME = home;
+  env.USERPROFILE = home;
+  if (xdg !== undefined) env.XDG_CONFIG_HOME = xdg;
+  return env;
+}
+
+async function run(cmd: string[], cwd: string, env: Record<string, string>) {
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), ...cmd],
+    env,
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+  return { stdout: stdout.trim(), stderr: stderr.trim(), exitCode };
+}
+
+const toml = (s: string) => s.replace(/\\/g, "/");
+
+describe("global ~/.bunfig.toml applies to runtime commands", () => {
+  function layout() {
+    const dir = tempDir("global-bunfig-rt", {
+      "preload.ts": `(globalThis as any).__G = "preload-ran";\n`,
+      "app/main.ts": `console.log((globalThis as any).__G ?? "preload NOT run");\nconsole.log(process.env.GLOBAL_BUNFIG_SENTINEL ?? "define NOT applied");\n`,
+      "app/main.test.ts": `import { test, expect } from "bun:test";\ntest("preload", () => { expect((globalThis as any).__G).toBe("preload-ran"); });\n`,
+    });
+    const home = String(dir);
+    writeFileSync(
+      join(home, ".bunfig.toml"),
+      toml(
+        `preload = ["${join(home, "preload.ts")}"]\n` +
+          `define = { "process.env.GLOBAL_BUNFIG_SENTINEL" = "'sentinel'" }\n` +
+          `[test]\npreload = ["${join(home, "preload.ts")}"]\n`,
+      ),
+    );
+    return { dir, home, app: join(home, "app") };
+  }
+
+  test.concurrent("bun <file>", async () => {
+    const { dir, home, app } = layout();
+    using _ = dir;
+    const { stdout, stderr, exitCode } = await run(["main.ts"], app, baseEnv(home));
+    expect(stderr).toBe("");
+    expect(stdout).toBe("preload-ran\nsentinel");
+    expect(exitCode).toBe(0);
+  });
+
+  test.concurrent("bun -e", async () => {
+    const { dir, home, app } = layout();
+    using _ = dir;
+    const { stdout, exitCode } = await run(
+      ["-e", `console.log((globalThis as any).__G ?? "preload NOT run")`],
+      app,
+      baseEnv(home),
+    );
+    expect(stdout).toBe("preload-ran");
+    expect(exitCode).toBe(0);
+  });
+
+  test.concurrent("bun run <file>", async () => {
+    const { dir, home, app } = layout();
+    using _ = dir;
+    const { stdout, stderr, exitCode } = await run(["run", "./main.ts"], app, baseEnv(home));
+    expect(stderr).toBe("");
+    expect(stdout).toBe("preload-ran\nsentinel");
+    expect(exitCode).toBe(0);
+  });
+
+  test.concurrent("bun test", async () => {
+    const { dir, home, app } = layout();
+    using _ = dir;
+    const { stderr, exitCode } = await run(["test", "main.test.ts"], app, baseEnv(home));
+    expect(stderr).toContain("1 pass");
+    expect(exitCode).toBe(0);
+  });
+
+  test.concurrent("local bunfig overrides global for bun run (shallow merge)", async () => {
+    using dir = tempDir("global-bunfig-merge", {
+      "g.ts": `(globalThis as any).__G = "global";\n`,
+      "l.ts": `(globalThis as any).__G = "local";\n`,
+      "app/main.ts": `console.log((globalThis as any).__G ?? "none");\n`,
+    });
+    const home = String(dir);
+    writeFileSync(join(home, ".bunfig.toml"), toml(`preload = ["${join(home, "g.ts")}"]\n`));
+    writeFileSync(join(home, "app", "bunfig.toml"), toml(`preload = ["${join(home, "l.ts")}"]\n`));
+    const { stdout, exitCode } = await run(["run", "./main.ts"], join(home, "app"), baseEnv(home));
+    expect(stdout).toBe("local");
+    expect(exitCode).toBe(0);
+  });
+});
+
+describe("XDG_CONFIG_HOME lookup falls back to $HOME/.bunfig.toml", () => {
+  test.concurrent("XDG set but no config there -> $HOME/.bunfig.toml still applies (runtime)", async () => {
+    using dir = tempDir("global-bunfig-xdg-fallback", {
+      "preload.ts": `(globalThis as any).__G = "preload-ran";\n`,
+      "xdg/.keep": "",
+      "app/main.ts": `console.log((globalThis as any).__G ?? "preload NOT run");\n`,
+    });
+    const home = String(dir);
+    const xdg = join(home, "xdg");
+    writeFileSync(join(home, ".bunfig.toml"), toml(`preload = ["${join(home, "preload.ts")}"]\n`));
+    const { stdout, exitCode } = await run(["main.ts"], join(home, "app"), baseEnv(home, xdg));
+    expect(stdout).toBe("preload-ran");
+    expect(exitCode).toBe(0);
+  });
+
+  test.concurrent("XDG set but no config there -> $HOME/.bunfig.toml still applies (bun pm cache)", async () => {
+    using dir = tempDir("global-bunfig-xdg-fallback-pm", {
+      "xdg/.keep": "",
+      "app/package.json": `{"name":"app"}\n`,
+    });
+    const home = String(dir);
+    const xdg = join(home, "xdg");
+    const cacheDir = join(home, "sentinel-cache");
+    writeFileSync(join(home, ".bunfig.toml"), toml(`[install.cache]\ndir = "${cacheDir}"\n`));
+    const { stdout, exitCode } = await run(["pm", "cache"], join(home, "app"), baseEnv(home, xdg));
+    expect(stdout).toContain("sentinel-cache");
+    expect(exitCode).toBe(0);
+  });
+
+  test.concurrent("XDG config present -> it wins over $HOME/.bunfig.toml", async () => {
+    using dir = tempDir("global-bunfig-xdg-wins", {
+      "h.ts": `(globalThis as any).__G = "home";\n`,
+      "x.ts": `(globalThis as any).__G = "xdg";\n`,
+      "app/main.ts": `console.log((globalThis as any).__G ?? "none");\n`,
+    });
+    const home = String(dir);
+    const xdg = join(home, "xdg");
+    mkdirSync(xdg, { recursive: true });
+    writeFileSync(join(home, ".bunfig.toml"), toml(`preload = ["${join(home, "h.ts")}"]\n`));
+    writeFileSync(join(xdg, ".bunfig.toml"), toml(`preload = ["${join(home, "x.ts")}"]\n`));
+    const { stdout, exitCode } = await run(["main.ts"], join(home, "app"), baseEnv(home, xdg));
+    expect(stdout).toBe("xdg");
+    expect(exitCode).toBe(0);
+  });
+});

From 07a6ea1ef115fa84530c320e638fc94ed8f8c9c3 Mon Sep 17 00:00:00 2001
From: "autofix-ci[bot]" <114827586+autofix-ci[bot]@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:04:07 +0000
Subject: [PATCH 02/10] [autofix.ci] apply automated fixes

---
 src/bunfig/arguments.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/bunfig/arguments.rs b/src/bunfig/arguments.rs
index 8605d7041ebf..73e4be6af1e4 100644
--- a/src/bunfig/arguments.rs
+++ b/src/bunfig/arguments.rs
@@ -26,7 +26,11 @@ fn get_home_config_path(buf: &mut PathBuffer) -> Option<&ZStr> {
         let len = {
             let path =
                 resolve_path::join_abs_string_buf_z::<platform::Auto>(data_dir, &mut **buf, &paths);
-            if bun_sys::exists_z(path) { path.len() } else { 0 }
+            if bun_sys::exists_z(path) {
+                path.len()
+            } else {
+                0
+            }
         };
         if len > 0 {
             return Some(ZStr::from_buf(&buf[..], len));

From 8a990aee62372a443d764ad1f36bb44c6169e7d8 Mon Sep 17 00:00:00 2001
From: robobun <117481402+robobun@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:31:48 +0000
Subject: [PATCH 03/10] apply review: report malformed global bunfig from
 load_config_path; isolate bun-run-bunfig.test.ts from host ~/.bunfig.toml;
 drop strict stderr assertions

Also extend the XDG->HOME fallback to the user-level .npmrc lookup in
PackageManager (fixes #23128).
---
 src/bunfig/arguments.rs                       | 13 ++---
 src/install/PackageManager.rs                 | 50 +++++++++++--------
 test/cli/install/bun-run-bunfig.test.ts       | 14 ++++--
 .../bunfig/global-bunfig-runtime.test.ts      | 21 ++++++--
 4 files changed, 57 insertions(+), 41 deletions(-)

diff --git a/src/bunfig/arguments.rs b/src/bunfig/arguments.rs
index 73e4be6af1e4..d6f617753666 100644
--- a/src/bunfig/arguments.rs
+++ b/src/bunfig/arguments.rs
@@ -115,16 +115,9 @@ pub fn load_config_path(
     // lookup so the dead arm is still a single branch.
     if cmd.read_global_config() {
         if let Err(err) = load_global_bunfig(cmd, ctx) {
-            if auto_loaded {
-                return Ok(());
-            }
-
-            bun_core::pretty_errorln!(
-                "{}\nreading global config \"{}\"",
-                err,
-                BStr::new(config_path.as_bytes()),
-            );
-            Global::exit(1);
+            // A malformed global config is reported the same way `load_config`
+            // would; swallowing it here would also skip the local load below.
+            report_bunfig_load_failure(ctx.log, err);
         }
     }
 
diff --git a/src/install/PackageManager.rs b/src/install/PackageManager.rs
index 929dd885bc4b..f8cd6cd6b2b9 100644
--- a/src/install/PackageManager.rs
+++ b/src/install/PackageManager.rs
@@ -1841,35 +1841,41 @@ pub fn init(
 
     initialize_store();
 
-    if let Some(data_dir) = bun_core::env_var::XDG_CONFIG_HOME
-        .get()
-        .or_else(|| bun_core::env_var::HOME.get())
-    {
-        let mut buf = PathBuffer::uninit();
+    let install_ref = ctx.install.get_or_insert_with(|| {
+        // `Api::BunInstall` derives `Default` (all fields `None`/empty).
+        // Own via `Box` — never `Box::leak`.
+        Box::new(Api::BunInstall::default())
+    });
+    let npmrc_local = ZBox::from_bytes(b".npmrc");
+    let mut buf = PathBuffer::uninit();
+    // `$XDG_CONFIG_HOME/.npmrc` if it exists, else `$HOME/.npmrc`.
+    let global_npmrc_len = {
         let parts = [b"./.npmrc" as &[u8]];
-
-        let install_ref = ctx.install.get_or_insert_with(|| {
-            // `Api::BunInstall` derives `Default` (all fields `None`/empty).
-            // Own via `Box` — never `Box::leak`.
-            Box::new(Api::BunInstall::default())
-        });
-        let npmrc_local = ZBox::from_bytes(b".npmrc");
+        let mut len = 0usize;
+        if let Some(data_dir) = bun_core::env_var::XDG_CONFIG_HOME.get_not_empty() {
+            let p = resolve_path::join_abs_string_buf_z::<platform::Auto>(data_dir, &mut buf, &parts);
+            if bun_sys::exists_z(p) {
+                len = p.len();
+            }
+        }
+        if len == 0 {
+            if let Some(home_dir) = bun_core::env_var::HOME.get_not_empty() {
+                len = resolve_path::join_abs_string_buf_z::<platform::Auto>(
+                    home_dir, &mut buf, &parts,
+                )
+                .len();
+            }
+        }
+        len
+    };
+    if global_npmrc_len > 0 {
         ini::load_npmrc_config(
             &mut **install_ref,
             env,
             true,
-            &[
-                resolve_path::join_abs_string_buf_z::<platform::Auto>(data_dir, &mut buf, &parts),
-                &*npmrc_local,
-            ],
+            &[ZStr::from_buf(&buf[..], global_npmrc_len), &*npmrc_local],
         );
     } else {
-        let install_ref = ctx.install.get_or_insert_with(|| {
-            // `Api::BunInstall` derives `Default` (all fields `None`/empty).
-            // Own via `Box` — never `Box::leak`.
-            Box::new(Api::BunInstall::default())
-        });
-        let npmrc_local = ZBox::from_bytes(b".npmrc");
         ini::load_npmrc_config(&mut **install_ref, env, true, &[&*npmrc_local]);
     }
     let cpu_count: u32 = u32::from(bun_core::get_thread_count());
diff --git a/test/cli/install/bun-run-bunfig.test.ts b/test/cli/install/bun-run-bunfig.test.ts
index e02697cad267..c4822fcecdec 100644
--- a/test/cli/install/bun-run-bunfig.test.ts
+++ b/test/cli/install/bun-run-bunfig.test.ts
@@ -3,6 +3,10 @@ import { realpathSync } from "fs";
 import { bunEnv, bunExe, isWindows, tempDirWithFiles, toTOMLString } from "harness";
 import { join as pathJoin } from "node:path";
 
+// `bun run` / `bun <script>` now read the global `~/.bunfig.toml`; keep these
+// assertions independent of whatever the developer has in theirs.
+const isolatedEnv = { ...bunEnv, HOME: undefined, USERPROFILE: undefined, XDG_CONFIG_HOME: undefined };
+
 describe.each(["bun run", "bun"])(`%s`, cmd => {
   const runCmd = cmd === "bun" ? ["-c=bunfig.toml", "run"] : ["-c=bunfig.toml"];
   const node = Bun.which("node")!;
@@ -33,7 +37,7 @@ describe.each(["bun run", "bun"])(`%s`, cmd => {
 
       const result = Bun.spawnSync({
         cmd: [bunExe(), "--silent", ...bunFlag, ...runCmd, "where-node"],
-        env: bunEnv,
+        env: isolatedEnv,
         stderr: "inherit",
         stdout: "pipe",
         stdin: "ignore",
@@ -83,7 +87,7 @@ describe.each(["bun run", "bun"])(`%s`, cmd => {
 
       const result = Bun.spawnSync({
         cmd: [bunExe(), ...runCmd, "startScript"],
-        env: bunEnv,
+        env: isolatedEnv,
         stderr: "pipe",
         stdout: "pipe",
         stdin: "ignore",
@@ -119,7 +123,7 @@ describe.each(["bun run", "bun"])(`%s`, cmd => {
 
       const result = Bun.spawnSync({
         cmd: [bunExe(), "--silent", ...runCmd, "start"],
-        env: bunEnv,
+        env: isolatedEnv,
         stderr: "pipe",
         stdout: "inherit",
         stdin: "ignore",
@@ -157,7 +161,7 @@ describe.each(["bun run", "bun"])(`%s`, cmd => {
 
     const result = Bun.spawnSync({
       cmd: [bunExe(), "--silent", ...runCmd, "where-node"],
-      env: bunEnv,
+      env: isolatedEnv,
       stderr: "inherit",
       stdout: "pipe",
       stdin: "ignore",
@@ -197,7 +201,7 @@ describe.each(["bun run", "bun"])(`%s`, cmd => {
 
     const result = Bun.spawnSync({
       cmd: [bunExe(), "--silent", ...runCmd, "where-node"],
-      env: bunEnv,
+      env: isolatedEnv,
       stderr: "inherit",
       stdout: "pipe",
       stdin: "ignore",
diff --git a/test/config/bunfig/global-bunfig-runtime.test.ts b/test/config/bunfig/global-bunfig-runtime.test.ts
index d57292fbd1a8..80f2079a846a 100644
--- a/test/config/bunfig/global-bunfig-runtime.test.ts
+++ b/test/config/bunfig/global-bunfig-runtime.test.ts
@@ -58,8 +58,7 @@ describe("global ~/.bunfig.toml applies to runtime commands", () => {
   test.concurrent("bun <file>", async () => {
     const { dir, home, app } = layout();
     using _ = dir;
-    const { stdout, stderr, exitCode } = await run(["main.ts"], app, baseEnv(home));
-    expect(stderr).toBe("");
+    const { stdout, exitCode } = await run(["main.ts"], app, baseEnv(home));
     expect(stdout).toBe("preload-ran\nsentinel");
     expect(exitCode).toBe(0);
   });
@@ -79,8 +78,7 @@ describe("global ~/.bunfig.toml applies to runtime commands", () => {
   test.concurrent("bun run <file>", async () => {
     const { dir, home, app } = layout();
     using _ = dir;
-    const { stdout, stderr, exitCode } = await run(["run", "./main.ts"], app, baseEnv(home));
-    expect(stderr).toBe("");
+    const { stdout, exitCode } = await run(["run", "./main.ts"], app, baseEnv(home));
     expect(stdout).toBe("preload-ran\nsentinel");
     expect(exitCode).toBe(0);
   });
@@ -137,6 +135,21 @@ describe("XDG_CONFIG_HOME lookup falls back to $HOME/.bunfig.toml", () => {
     expect(exitCode).toBe(0);
   });
 
+  // #23128: same fallback for the user-level .npmrc.
+  test.concurrent("XDG set but no config there -> $HOME/.npmrc still applies (bun pm cache)", async () => {
+    using dir = tempDir("global-npmrc-xdg-fallback-pm", {
+      "xdg/.keep": "",
+      "app/package.json": `{"name":"app"}\n`,
+    });
+    const home = String(dir);
+    const xdg = join(home, "xdg");
+    const cacheDir = join(home, "npmrc-sentinel-cache");
+    writeFileSync(join(home, ".npmrc"), toml(`cache=${cacheDir}\n`));
+    const { stdout, exitCode } = await run(["pm", "cache"], join(home, "app"), baseEnv(home, xdg));
+    expect(stdout).toContain("npmrc-sentinel-cache");
+    expect(exitCode).toBe(0);
+  });
+
   test.concurrent("XDG config present -> it wins over $HOME/.bunfig.toml", async () => {
     using dir = tempDir("global-bunfig-xdg-wins", {
       "h.ts": `(globalThis as any).__G = "home";\n`,

From d60363bb386a2e392a4fd39b33b1ff5cf922cd73 Mon Sep 17 00:00:00 2001
From: "autofix-ci[bot]" <114827586+autofix-ci[bot]@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:34:00 +0000
Subject: [PATCH 04/10] [autofix.ci] apply automated fixes

---
 src/install/PackageManager.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/install/PackageManager.rs b/src/install/PackageManager.rs
index f8cd6cd6b2b9..5d35e9d4001d 100644
--- a/src/install/PackageManager.rs
+++ b/src/install/PackageManager.rs
@@ -1853,7 +1853,8 @@ pub fn init(
         let parts = [b"./.npmrc" as &[u8]];
         let mut len = 0usize;
         if let Some(data_dir) = bun_core::env_var::XDG_CONFIG_HOME.get_not_empty() {
-            let p = resolve_path::join_abs_string_buf_z::<platform::Auto>(data_dir, &mut buf, &parts);
+            let p =
+                resolve_path::join_abs_string_buf_z::<platform::Auto>(data_dir, &mut buf, &parts);
             if bun_sys::exists_z(p) {
                 len = p.len();
             }

From 89523b4f495618b1d45054a8e0160dbab8ab942d Mon Sep 17 00:00:00 2001
From: robobun <117481402+robobun@users.noreply.github.com>
Date: Tue, 21 Jul 2026 18:39:34 +0000
Subject: [PATCH 05/10] test: cover XDG .npmrc precedence over $HOME/.npmrc

---
 test/config/bunfig/global-bunfig-runtime.test.ts | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/test/config/bunfig/global-bunfig-runtime.test.ts b/test/config/bunfig/global-bunfig-runtime.test.ts
index 80f2079a846a..bc75e5cff7b1 100644
--- a/test/config/bunfig/global-bunfig-runtime.test.ts
+++ b/test/config/bunfig/global-bunfig-runtime.test.ts
@@ -165,4 +165,19 @@ describe("XDG_CONFIG_HOME lookup falls back to $HOME/.bunfig.toml", () => {
     expect(stdout).toBe("xdg");
     expect(exitCode).toBe(0);
   });
+
+  test.concurrent("XDG .npmrc present -> it wins over $HOME/.npmrc", async () => {
+    using dir = tempDir("global-npmrc-xdg-wins", {
+      "app/package.json": `{"name":"app"}\n`,
+    });
+    const home = String(dir);
+    const xdg = join(home, "xdg");
+    mkdirSync(xdg, { recursive: true });
+    writeFileSync(join(home, ".npmrc"), toml(`cache=${join(home, "npmrc-home-cache")}\n`));
+    writeFileSync(join(xdg, ".npmrc"), toml(`cache=${join(home, "npmrc-xdg-cache")}\n`));
+    const { stdout, exitCode } = await run(["pm", "cache"], join(home, "app"), baseEnv(home, xdg));
+    expect(stdout).toContain("npmrc-xdg-cache");
+    expect(stdout).not.toContain("npmrc-home-cache");
+    expect(exitCode).toBe(0);
+  });
 });

From a5803c5b82b98e4b2c3cbcf5e34ad6aabf82eb97 Mon Sep 17 00:00:00 2001
From: robobun <bot@oven.sh>
Date: Tue, 21 Jul 2026 19:18:44 +0000
Subject: [PATCH 06/10] apply review: RunAsNodeCommand reads runtime bunfig
 keys; share XDG/HOME config-path helper

- bunfig.rs gates for preload/serve/telemetry/smol and [run]/[install] now
  match RunAsNodeCommand so the global bunfig parsed during
  load_config(RunAsNodeCommand, ...) applies those keys. The two adjacent
  RunCommand/AutoCommand blocks are merged.
- New home_config_path(buf, name) in bun_bunfig::arguments is shared by the
  .bunfig.toml and .npmrc lookups; PackageManager.rs drops its inline copy.
- Added a node-shim (argv0=node) test to global-bunfig-runtime.test.ts.
---
 src/bunfig/arguments.rs                       | 17 +++++++----
 src/bunfig/bunfig.rs                          |  8 +++--
 src/bunfig/lib.rs                             |  2 +-
 src/install/PackageManager.rs                 | 30 ++-----------------
 .../bunfig/global-bunfig-runtime.test.ts      | 16 ++++++++++
 5 files changed, 35 insertions(+), 38 deletions(-)

diff --git a/src/bunfig/arguments.rs b/src/bunfig/arguments.rs
index d6f617753666..d41aca1aafb6 100644
--- a/src/bunfig/arguments.rs
+++ b/src/bunfig/arguments.rs
@@ -17,15 +17,16 @@ use crate::bunfig::Bunfig;
 
 // ─── bunfig loading ──────────────────────────────────────────────────────────
 
-fn get_home_config_path(buf: &mut PathBuffer) -> Option<&ZStr> {
-    let paths: [&[u8]; 1] = [b".bunfig.toml"];
+/// Resolve `$XDG_CONFIG_HOME/<name>` when it exists, otherwise
+/// `$HOME/<name>` (`$USERPROFILE` on Windows). Used for both the user-level
+/// `.bunfig.toml` and `.npmrc`; `None` when neither env var is set.
+pub fn home_config_path<'a>(buf: &'a mut PathBuffer, name: &[u8]) -> Option<&'a ZStr> {
+    let parts: [&[u8]; 1] = [name];
 
-    // `$XDG_CONFIG_HOME/.bunfig.toml` takes precedence, but only when the file
-    // actually exists there; otherwise fall through to `$HOME/.bunfig.toml`.
     if let Some(data_dir) = env_var::XDG_CONFIG_HOME.get_not_empty() {
         let len = {
             let path =
-                resolve_path::join_abs_string_buf_z::<platform::Auto>(data_dir, &mut **buf, &paths);
+                resolve_path::join_abs_string_buf_z::<platform::Auto>(data_dir, &mut **buf, &parts);
             if bun_sys::exists_z(path) {
                 path.len()
             } else {
@@ -39,13 +40,17 @@ fn get_home_config_path(buf: &mut PathBuffer) -> Option<&ZStr> {
 
     if let Some(home_dir) = env_var::HOME.get_not_empty() {
         return Some(resolve_path::join_abs_string_buf_z::<platform::Auto>(
-            home_dir, &mut **buf, &paths,
+            home_dir, &mut **buf, &parts,
         ));
     }
 
     None
 }
 
+fn get_home_config_path(buf: &mut PathBuffer) -> Option<&ZStr> {
+    home_config_path(buf, b".bunfig.toml")
+}
+
 fn load_bunfig(
     cmd: CommandTag,
     auto_loaded: bool,
diff --git a/src/bunfig/bunfig.rs b/src/bunfig/bunfig.rs
index e7636ca1c4eb..c2a6afc5be5e 100644
--- a/src/bunfig/bunfig.rs
+++ b/src/bunfig/bunfig.rs
@@ -380,7 +380,10 @@ impl<'a> Parser<'a> {
             self.load_env_config(&env_expr)?;
         }
 
-        if cmd == CommandTag::RunCommand || cmd == CommandTag::AutoCommand {
+        if matches!(
+            cmd,
+            CommandTag::RunCommand | CommandTag::AutoCommand | CommandTag::RunAsNodeCommand
+        ) {
             if let Some(expr) = json.get(b"serve") {
                 if let Some(port) = expr.get(b"port") {
                     self.expect(&port, ExprTag::ENumber)?;
@@ -401,9 +404,7 @@ impl<'a> Parser<'a> {
                     bun_analytics::TriState::No
                 });
             }
-        }
 
-        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");
@@ -715,6 +716,7 @@ impl<'a> Parser<'a> {
         if cmd.is_npm_related()
             || cmd == CommandTag::RunCommand
             || cmd == CommandTag::AutoCommand
+            || cmd == CommandTag::RunAsNodeCommand
             || cmd == CommandTag::TestCommand
         {
             if let Some(install_obj) = json.get_object(b"install") {
diff --git a/src/bunfig/lib.rs b/src/bunfig/lib.rs
index 224bba7f64ad..553ce6becaa1 100644
--- a/src/bunfig/lib.rs
+++ b/src/bunfig/lib.rs
@@ -12,6 +12,6 @@ pub mod arguments;
 pub mod bunfig;
 pub mod error;
 
-pub use arguments::{load_config, load_config_path, load_config_with_cmd_args};
+pub use arguments::{home_config_path, load_config, load_config_path, load_config_with_cmd_args};
 pub use bunfig::Bunfig;
 pub use error::{Error, Result};
diff --git a/src/install/PackageManager.rs b/src/install/PackageManager.rs
index 5d35e9d4001d..2295828d83c2 100644
--- a/src/install/PackageManager.rs
+++ b/src/install/PackageManager.rs
@@ -1848,34 +1848,8 @@ pub fn init(
     });
     let npmrc_local = ZBox::from_bytes(b".npmrc");
     let mut buf = PathBuffer::uninit();
-    // `$XDG_CONFIG_HOME/.npmrc` if it exists, else `$HOME/.npmrc`.
-    let global_npmrc_len = {
-        let parts = [b"./.npmrc" as &[u8]];
-        let mut len = 0usize;
-        if let Some(data_dir) = bun_core::env_var::XDG_CONFIG_HOME.get_not_empty() {
-            let p =
-                resolve_path::join_abs_string_buf_z::<platform::Auto>(data_dir, &mut buf, &parts);
-            if bun_sys::exists_z(p) {
-                len = p.len();
-            }
-        }
-        if len == 0 {
-            if let Some(home_dir) = bun_core::env_var::HOME.get_not_empty() {
-                len = resolve_path::join_abs_string_buf_z::<platform::Auto>(
-                    home_dir, &mut buf, &parts,
-                )
-                .len();
-            }
-        }
-        len
-    };
-    if global_npmrc_len > 0 {
-        ini::load_npmrc_config(
-            &mut **install_ref,
-            env,
-            true,
-            &[ZStr::from_buf(&buf[..], global_npmrc_len), &*npmrc_local],
-        );
+    if let Some(global_npmrc) = ::bun_bunfig::home_config_path(&mut buf, b".npmrc") {
+        ini::load_npmrc_config(&mut **install_ref, env, true, &[global_npmrc, &*npmrc_local]);
     } else {
         ini::load_npmrc_config(&mut **install_ref, env, true, &[&*npmrc_local]);
     }
diff --git a/test/config/bunfig/global-bunfig-runtime.test.ts b/test/config/bunfig/global-bunfig-runtime.test.ts
index bc75e5cff7b1..cb960d1e67bf 100644
--- a/test/config/bunfig/global-bunfig-runtime.test.ts
+++ b/test/config/bunfig/global-bunfig-runtime.test.ts
@@ -91,6 +91,22 @@ describe("global ~/.bunfig.toml applies to runtime commands", () => {
     expect(exitCode).toBe(0);
   });
 
+  test.concurrent("node shim (argv0=node)", async () => {
+    const { dir, home, app } = layout();
+    using _ = dir;
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "main.ts"],
+      argv0: "node",
+      env: baseEnv(home),
+      cwd: app,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, exitCode] = await Promise.all([proc.stdout.text(), proc.exited]);
+    expect(stdout.trim()).toBe("preload-ran\nsentinel");
+    expect(exitCode).toBe(0);
+  });
+
   test.concurrent("local bunfig overrides global for bun run (shallow merge)", async () => {
     using dir = tempDir("global-bunfig-merge", {
       "g.ts": `(globalThis as any).__G = "global";\n`,

From f1836bb6fe797ca6693d029bec6a588c0aa60116 Mon Sep 17 00:00:00 2001
From: "autofix-ci[bot]" <114827586+autofix-ci[bot]@users.noreply.github.com>
Date: Tue, 21 Jul 2026 19:20:54 +0000
Subject: [PATCH 07/10] [autofix.ci] apply automated fixes

---
 src/install/PackageManager.rs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/install/PackageManager.rs b/src/install/PackageManager.rs
index 2295828d83c2..6caf4ba2175b 100644
--- a/src/install/PackageManager.rs
+++ b/src/install/PackageManager.rs
@@ -1849,7 +1849,12 @@ pub fn init(
     let npmrc_local = ZBox::from_bytes(b".npmrc");
     let mut buf = PathBuffer::uninit();
     if let Some(global_npmrc) = ::bun_bunfig::home_config_path(&mut buf, b".npmrc") {
-        ini::load_npmrc_config(&mut **install_ref, env, true, &[global_npmrc, &*npmrc_local]);
+        ini::load_npmrc_config(
+            &mut **install_ref,
+            env,
+            true,
+            &[global_npmrc, &*npmrc_local],
+        );
     } else {
         ini::load_npmrc_config(&mut **install_ref, env, true, &[&*npmrc_local]);
     }

From f8d9ef5d2a9c891c6deac0d7b377987e759935ea Mon Sep 17 00:00:00 2001
From: robobun <bot@oven.sh>
Date: Tue, 21 Jul 2026 19:45:57 +0000
Subject: [PATCH 08/10] apply review: gate jsx.runtime/development on key
 presence; thread argv0 through run() helper

---
 src/bunfig/bunfig.rs                             |  7 +++++--
 test/config/bunfig/global-bunfig-runtime.test.ts | 15 ++++-----------
 2 files changed, 9 insertions(+), 13 deletions(-)

diff --git a/src/bunfig/bunfig.rs b/src/bunfig/bunfig.rs
index c2a6afc5be5e..69198c0ad72c 100644
--- a/src/bunfig/bunfig.rs
+++ b/src/bunfig/bunfig.rs
@@ -989,6 +989,7 @@ impl<'a> Parser<'a> {
                 jsx_factory = Box::<[u8]>::from(value);
             }
         }
+        let jsx_present = json.get(b"jsx").is_some();
         {
             if let Some(jsx) = self.ctx.args.jsx.as_mut() {
                 if !jsx_factory.is_empty() {
@@ -1000,8 +1001,10 @@ impl<'a> Parser<'a> {
                 if !jsx_import_source.is_empty() {
                     jsx.import_source = jsx_import_source;
                 }
-                jsx.runtime = jsx_runtime;
-                jsx.development = jsx_dev;
+                if jsx_present {
+                    jsx.runtime = jsx_runtime;
+                    jsx.development = jsx_dev;
+                }
             } else {
                 self.ctx.args.jsx = Some(api::Jsx {
                     factory: jsx_factory,
diff --git a/test/config/bunfig/global-bunfig-runtime.test.ts b/test/config/bunfig/global-bunfig-runtime.test.ts
index cb960d1e67bf..f8dd8cfe08ac 100644
--- a/test/config/bunfig/global-bunfig-runtime.test.ts
+++ b/test/config/bunfig/global-bunfig-runtime.test.ts
@@ -22,9 +22,10 @@ function baseEnv(home: string, xdg?: string) {
   return env;
 }
 
-async function run(cmd: string[], cwd: string, env: Record<string, string>) {
+async function run(cmd: string[], cwd: string, env: Record<string, string>, argv0?: string) {
   await using proc = Bun.spawn({
     cmd: [bunExe(), ...cmd],
+    argv0,
     env,
     cwd,
     stdout: "pipe",
@@ -94,16 +95,8 @@ describe("global ~/.bunfig.toml applies to runtime commands", () => {
   test.concurrent("node shim (argv0=node)", async () => {
     const { dir, home, app } = layout();
     using _ = dir;
-    await using proc = Bun.spawn({
-      cmd: [bunExe(), "main.ts"],
-      argv0: "node",
-      env: baseEnv(home),
-      cwd: app,
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-    const [stdout, exitCode] = await Promise.all([proc.stdout.text(), proc.exited]);
-    expect(stdout.trim()).toBe("preload-ran\nsentinel");
+    const { stdout, exitCode } = await run(["main.ts"], app, baseEnv(home), "node");
+    expect(stdout).toBe("preload-ran\nsentinel");
     expect(exitCode).toBe(0);
   });
 

From 093701a03c28515d84f71b5d8647715385a61c65 Mon Sep 17 00:00:00 2001
From: robobun <bot@oven.sh>
Date: Tue, 21 Jul 2026 20:10:11 +0000
Subject: [PATCH 09/10] ci: retrigger


From eae02b4d4c7cdb87da72d5514f078ea36ea2257d Mon Sep 17 00:00:00 2001
From: robobun <bot@oven.sh>
Date: Tue, 21 Jul 2026 20:26:35 +0000
Subject: [PATCH 10/10] apply review: skip global bunfig for standalone
 executables; tighten two dual-parse merges

- load_global_bunfig returns early when StandaloneModuleGraph::get() is
  Some: a compiled --compile binary must not apply the end user's
  ~/.bunfig.toml preload/define to the shipped app (nor crash on a
  malformed one). The autoloadBunfig compile flag continues to gate the
  cwd-local bunfig.toml only.
- [test].retry/rerunEach mutual-exclusion now checks the sibling key in
  the current file and zeroes the counterpart on assignment, so a local
  file can cleanly switch a global retry to rerunEach (or vice versa).
- [serve.static].bunfig_path is written alongside serve_plugins so a
  relative plugin path from a global [serve.static] resolves against the
  file that declared it.
---
 src/bunfig/arguments.rs | 7 +++++++
 src/bunfig/bunfig.rs    | 8 +++++---
 2 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/src/bunfig/arguments.rs b/src/bunfig/arguments.rs
index d41aca1aafb6..87c4f04e76e5 100644
--- a/src/bunfig/arguments.rs
+++ b/src/bunfig/arguments.rs
@@ -101,6 +101,13 @@ fn load_global_bunfig(cmd: CommandTag, ctx: Context<'_>) -> Result<(), crate::Er
     }
     ctx.has_loaded_global_config = true;
 
+    // A compiled standalone executable never reads the end user's
+    // `~/.bunfig.toml`; the `autoloadBunfig` compile flag only opts into
+    // the cwd-local `bunfig.toml`.
+    if StandaloneModuleGraph::get().is_some() {
+        return Ok(());
+    }
+
     let mut config_buf = PathBuffer::uninit();
     if let Some(path) = get_home_config_path(&mut config_buf) {
         load_bunfig(cmd, true, path, ctx)?;
diff --git a/src/bunfig/bunfig.rs b/src/bunfig/bunfig.rs
index 69198c0ad72c..342abfc6433a 100644
--- a/src/bunfig/bunfig.rs
+++ b/src/bunfig/bunfig.rs
@@ -565,20 +565,22 @@ impl<'a> Parser<'a> {
 
                 if let Some(expr) = test_.get(b"rerunEach") {
                     self.expect(&expr, ExprTag::ENumber)?;
-                    if self.ctx.test_options.retry != 0 {
+                    if test_.get(b"retry").is_some() {
                         self.add_error(expr.loc, b"\"rerunEach\" cannot be used with \"retry\"")?;
                         return Ok(());
                     }
+                    self.ctx.test_options.retry = 0;
                     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 {
+                    if test_.get(b"rerunEach").is_some() {
                         self.add_error(expr.loc, b"\"retry\" cannot be used with \"rerunEach\"")?;
                         return Ok(());
                     }
+                    self.ctx.test_options.repeat_count = 0;
                     self.ctx.test_options.retry =
                         num_to_u32(expr.as_number().expect("infallible: type checked"));
                 }
@@ -1588,6 +1590,7 @@ impl<'a> Parser<'a> {
             };
             // TODO: accept entire config object.
             self.ctx.args.serve_plugins = plugins;
+            self.ctx.args.bunfig_path = Box::<[u8]>::from(self.source.path.text);
         }
 
         if let Some(hmr) = serve_obj.get(b"hmr") {
@@ -1621,7 +1624,6 @@ impl<'a> Parser<'a> {
         if let Some(expr) = serve_obj.get(b"define") {
             self.ctx.args.serve_define = Some(self.parse_define_map(&expr)?);
         }
-        self.ctx.args.bunfig_path = Box::<[u8]>::from(self.source.path.text);
 
         if let Some(public_path) = serve_obj.get(b"publicPath") {
             if let Some(v) = public_path.as_string(self.bump) {