From a636adaf74ce2400aeb79c35eeab794f9242f138 Mon Sep 17 00:00:00 2001
From: robobun <117481402+robobun@users.noreply.github.com>
Date: Fri, 30 Oct 2026 13:42:07 +0000
Subject: [PATCH 1/5] test: a Windows working directory spelled with the `\\?\`
 prefix

Windows-only tests for a process that starts in, or changes into, a
directory spelled `\\?\C:\dir` or `\\?\UNC\server\share\dir`:

- `bun -e`, `--preload`, `--cwd`, `bun run <file>` and `bun test` name
  every path from the plain spelling of the directory.
- `process.chdir()` into each spelling gives the plain `process.cwd()`.
- `bun build --app` builds.

Each case also runs from the plain spelling, as a control. The cases
with the prefix fail until the working directory readers drop it.

Co-authored-by: Dylan Conway <dylan.conway567@gmail.com>
---
 test/bake/dev/production.test.ts     |  59 ++++++++---
 test/js/node/process/process.test.js | 148 +++++++++++++++++++++++++++
 2 files changed, 190 insertions(+), 17 deletions(-)

diff --git a/test/bake/dev/production.test.ts b/test/bake/dev/production.test.ts
index 6771c0f96261..c5400b945591 100644
--- a/test/bake/dev/production.test.ts
+++ b/test/bake/dev/production.test.ts
@@ -456,24 +456,27 @@ export default function () {
     expect(exitCode).toBe(1);
   });
 
+  // A framework without dependencies. The page is "homepage" and names the chunk of the client entry point.
+  const customFramework = {
+    "client.ts": `console.log("client loaded");`,
+    "server.ts": `
+      export function render(req, meta) {
+        return new Response(String(meta.pageModule.default()));
+      }
+      export async function prerender(meta) {
+        const scripts = meta.modules.map(m => '<script type="module" src="' + m + '"></script>').join("");
+        return { files: { "index.html": "<body>" + meta.pageModule.default() + scripts + "</body>" } };
+      }
+    `,
+    "routes/index.ts": `export default () => "homepage";`,
+    "app.ts": `
+      const fsr = { root: "routes", style: "nextjs-pages", serverEntryPoint: "./server.ts", clientEntryPoint: "./client.ts" };
+      export default { app: { framework: { fileSystemRouterTypes: [fsr] } } };
+    `,
+  };
+
   test("builds a framework without server components and keeps its client entry point", async () => {
-    using dir = tempDir("bake-production-custom-framework", {
-      "client.ts": `console.log("client loaded");`,
-      "server.ts": `
-        export function render(req, meta) {
-          return new Response(String(meta.pageModule.default()));
-        }
-        export async function prerender(meta) {
-          const scripts = meta.modules.map(m => '<script type="module" src="' + m + '"></script>').join("");
-          return { files: { "index.html": "<body>" + meta.pageModule.default() + scripts + "</body>" } };
-        }
-      `,
-      "routes/index.ts": `export default () => "homepage";`,
-      "app.ts": `
-        const fsr = { root: "routes", style: "nextjs-pages", serverEntryPoint: "./server.ts", clientEntryPoint: "./client.ts" };
-        export default { app: { framework: { fileSystemRouterTypes: [fsr] } } };
-      `,
-    });
+    using dir = tempDir("bake-production-custom-framework", customFramework);
 
     const { exitCode, stderr } = await Bun.$`${bunExe()} build --app ./app.ts`
       .cwd(String(dir))
@@ -489,6 +492,28 @@ export default function () {
     expect(exitCode).toBe(0);
   });
 
+  // Windows keeps a `\\?\` prefix in the working directory of a process that starts in a directory spelled with one.
+  test.skipIf(!isWindows)("builds from a working directory spelled with the \\\\?\\ prefix", async () => {
+    using dir = tempDir("bake-production-verbatim-cwd", customFramework);
+
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "build", "--app", "./app.ts"],
+      env: bunEnv,
+      cwd: "\\\\?\\" + String(dir),
+      stdout: "ignore",
+      stderr: "pipe",
+    });
+    const [stderr, exitCode] = await Promise.all([proc.stderr.text(), proc.exited]);
+    const html = await Bun.file(path.join(String(dir), "dist", "index.html"))
+      .text()
+      .catch(() => stderr);
+    expect(html).toContain("homepage");
+    const script = html.match(/<script type="module" src="\/([^"]*_bun[^"]*\.js)"><\/script>/);
+    expect(script).toBeTruthy();
+    expect(existsSync(path.join(String(dir), "dist", script![1]))).toBe(true);
+    expect(exitCode).toBe(0);
+  });
+
   test("fails the build for a route file with an invalid name", async () => {
     using dir = tempDir("bake-production-invalid-route", {
       "app.ts": `export default { app: { framework: ${JSON.stringify(minimalFramework)} } };`,
diff --git a/test/js/node/process/process.test.js b/test/js/node/process/process.test.js
index b9a738958f7c..6d3df8909965 100644
--- a/test/js/node/process/process.test.js
+++ b/test/js/node/process/process.test.js
@@ -3,7 +3,9 @@ import { CString, dlopen, ptr } from "bun:ffi";
 import { memoryUsage as jscMemoryUsage } from "bun:jsc";
 import { describe, expect, it } from "bun:test";
 import { familySync } from "detect-libc";
+import { existsSync } from "fs";
 import { bunEnv, bunExe, isASAN, isDebug, isLinux, isMacOS, isRoot, isWindows, tempDir, tmpdirSync } from "harness";
+import { tmpdir } from "os";
 import { basename, join, resolve } from "path";
 import { getHeapStatistics } from "v8";
 
@@ -360,6 +362,152 @@ it("process.chdir() on root dir", () => {
   }
 });
 
+// Windows keeps a `\\?\` prefix in the working directory of a process that starts in, or changes into, a directory
+// spelled with one. Bun names every path from the plain spelling of that directory.
+describe.skipIf(!isWindows)("a working directory spelled with the \\\\?\\ prefix", () => {
+  // Each line names a path from the working directory. A line that throws reports why.
+  const script = `
+    const out = {};
+    const report = async (name, read) => {
+      try {
+        out[name] = await read();
+      } catch (error) {
+        out[name] = "threw " + (error?.message ?? error);
+      }
+    };
+    await report("cwd", () => process.cwd());
+    await report("pathResolve", () => require("node:path").resolve());
+    await report("main", () => Bun.main);
+    await report("metaDir", () => import.meta.dir);
+    await report("resolveSync", () => Bun.resolveSync("./dep.ts", "."));
+    await report("import", async () => (await import("./dep.ts")).default);
+    await report("require", () => require("./dep.cjs"));
+    await report("worker", () => new Promise((resolve, reject) => {
+      const worker = new Worker("./worker.ts");
+      worker.onmessage = event => (worker.terminate(), resolve(event.data));
+      worker.onerror = event => reject(new Error(event.message));
+    }));
+    await report("shell", async () => (await Bun.$\`echo shell\`.text()).trim());
+    await report("preloaded", () => globalThis.preloaded ?? false);
+    console.log(JSON.stringify(out));
+  `;
+  const files = {
+    "dep.ts": `export default "dep.ts";`,
+    "dep.cjs": `module.exports = "dep.cjs";`,
+    "worker.ts": `postMessage("worker.ts");`,
+    "preload.ts": `globalThis.preloaded = true;`,
+    "entry.mjs": script,
+    "a.test.ts": `
+      import { expect, test } from "bun:test";
+      import dep from "./dep.ts";
+      test("reads the working directory", () => {
+        expect(dep).toBe("dep.ts");
+        console.log(JSON.stringify({ cwd: process.cwd(), metaDir: import.meta.dir }));
+      });
+    `,
+    "elsewhere/keep": "",
+  };
+  const parse = text => {
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  };
+  async function run(cwd, args, env = bunEnv) {
+    await using proc = Bun.spawn({ cmd: [bunExe(), ...args], 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 };
+  }
+
+  // The administrative share of a drive names the same directories on the server `localhost`.
+  const share = dir => "\\\\localhost\\" + dir[0] + "$" + dir.slice(2);
+  const hasShare = isWindows && existsSync(share(tmpdir()));
+
+  describe.each([
+    ["plain", dir => dir],
+    ["\\\\?\\", dir => "\\\\?\\" + dir],
+  ])("the %s spelling", (_, spell) => {
+    it.concurrent.each([
+      ["bun -e", "[eval]", false, dir => [spell(dir), "-e", script]],
+      ["bun --preload -e", "[eval]", true, dir => [spell(dir), "--preload", "./preload.ts", "-e", script]],
+      [
+        "bun --cwd -e, from another directory",
+        "[eval]",
+        false,
+        dir => [join(dir, "elsewhere"), "--cwd", spell(dir), "-e", script],
+      ],
+      ["bun run entry.mjs", "entry.mjs", false, dir => [spell(dir), "run", "entry.mjs"]],
+    ])("%s", async (_, main, preloaded, start) => {
+      using dir = tempDir("process-cwd-verbatim", files);
+      const root = String(dir);
+      const [cwd, ...args] = start(root);
+      const { stdout, stderr, exitCode } = await run(cwd, args);
+      expect({ out: parse(stdout), stderr }).toEqual({
+        out: {
+          cwd: root,
+          pathResolve: root,
+          main: join(root, main),
+          metaDir: root,
+          resolveSync: join(root, "dep.ts"),
+          import: "dep.ts",
+          require: "dep.cjs",
+          worker: "worker.ts",
+          shell: "shell",
+          preloaded,
+        },
+        stderr: "",
+      });
+      expect(exitCode).toBe(0);
+    });
+
+    it.concurrent("bun test", async () => {
+      using dir = tempDir("process-cwd-verbatim-test", files);
+      const root = String(dir);
+      const { stdout, stderr, exitCode } = await run(spell(root), ["test"]);
+      expect({ stdout, stderr }).toEqual({
+        stdout: expect.stringContaining(JSON.stringify({ cwd: root, metaDir: root })),
+        stderr: expect.stringContaining(" 1 pass"),
+      });
+      expect(exitCode).toBe(0);
+    });
+  });
+
+  it.concurrent("process.chdir() into each spelling", async () => {
+    using dir = tempDir("process-chdir-verbatim", {});
+    const root = String(dir);
+    const spellings = { plain: root, verbatim: "\\\\?\\" + root };
+    const expected = { plain: root, verbatim: root };
+    if (hasShare) {
+      Object.assign(spellings, { share: share(root), verbatimShare: "\\\\?\\UNC\\" + share(root).slice(2) });
+      Object.assign(expected, { share: share(root), verbatimShare: share(root) });
+    }
+    const script = `
+      const out = {};
+      for (const [name, to] of Object.entries(JSON.parse(process.env.SPELLINGS))) {
+        process.chdir(to);
+        out[name] = process.cwd();
+      }
+      console.log(JSON.stringify(out));
+    `;
+    const env = { ...bunEnv, SPELLINGS: JSON.stringify(spellings) };
+    const { stdout, stderr, exitCode } = await run(root, ["-e", script], env);
+    expect({ out: parse(stdout), stderr }).toEqual({ out: expected, stderr: "" });
+    expect(exitCode).toBe(0);
+  });
+
+  it.concurrent.skipIf(!hasShare).each([
+    ["plain", unc => unc],
+    ["\\\\?\\UNC\\", unc => "\\\\?\\UNC\\" + unc.slice(2)],
+  ])("process.cwd() of a process that starts in the %s spelling of a share", async (_, spell) => {
+    using dir = tempDir("process-cwd-share", {});
+    const unc = share(String(dir));
+    const { stdout, stderr, exitCode } = await run(spell(unc), ["-p", "process.cwd()"]);
+    expect({ stdout: stdout.trim(), stderr }).toEqual({ stdout: unc, stderr: "" });
+    expect(exitCode).toBe(0);
+  });
+});
+
 it("process.hrtime()", async () => {
   const start = process.hrtime();
   const end = process.hrtime(start);

From d9237bdd87b222bc84098f2f89f65be757c2d914 Mon Sep 17 00:00:00 2001
From: robobun <117481402+robobun@users.noreply.github.com>
Date: Fri, 30 Oct 2026 19:58:15 +0000
Subject: [PATCH 2/5] getcwd: drop the `\\?\` prefix of a Windows working
 directory in one reader

Windows keeps a `\\?\` prefix in the working directory of a process
that starts in, or changes into, a directory spelled with one.
`bun_core::getcwd` returned the prefix. `bun_sys::getcwd` dropped its
four units from any path, so `\\?\UNC\server\share` became
`UNC\server\share`. The start directory and `process.cwd()` disagreed
in one process, and a module path made from the start directory was
cut at the `?` by the module loader.

Both now read through `bun_core::getcwd_w`. It gives `C:\dir` for
`\\?\C:\dir` and `\\server\share` for `\\?\UNC\server\share`, and it
leaves a path that has no plain spelling as the OS gives it.

`fs.symlink` with the type `junction` joined a relative target to the
working directory and put `\\?\` in front. It now keeps a prefix that
the joined path already has.

A source lint names the three places that call `GetCurrentDirectoryW`.

Co-authored-by: Dylan Conway <dylan.conway567@gmail.com>
---
 src/bun_core/util.rs                          | 70 +++++++++++++++----
 src/paths/string_paths.rs                     | 47 +++++++++++++
 src/runtime/node/node_fs.rs                   |  6 +-
 src/runtime/node/node_process.rs              |  1 +
 src/sys/lib.rs                                | 29 ++++----
 .../source-lints/windows-cwd-readers.test.ts  | 40 +++++++++++
 6 files changed, 163 insertions(+), 30 deletions(-)
 create mode 100644 test/internal/source-lints/windows-cwd-readers.test.ts

diff --git a/src/bun_core/util.rs b/src/bun_core/util.rs
index 960ebce9d66a..e31d03ce1690 100644
--- a/src/bun_core/util.rs
+++ b/src/bun_core/util.rs
@@ -4053,23 +4053,14 @@ fn getcwd_len(buf: &mut PathBuffer) -> crate::CrateResult<usize> {
     }
     #[cfg(windows)]
     {
-        // Windows: wrap
-        // `kernel32.GetCurrentDirectoryW` and transcode WTF-16 → WTF-8.
-        unsafe extern "system" {
-            fn GetCurrentDirectoryW(nBufferLength: u32, lpBuffer: *mut u16) -> u32;
-        }
         let mut wbuf = WPathBuffer::ZEROED;
-        // SAFETY: `wbuf` has `PATH_MAX_WIDE` writable u16 units.
-        let n = unsafe { GetCurrentDirectoryW(wbuf.0.len() as u32, wbuf.0.as_mut_ptr()) } as usize;
-        if n == 0 {
-            return Err(crate::CrateError::Unexpected);
-        }
-        if n >= wbuf.0.len() {
-            return Err(crate::CrateError::NameTooLong);
-        }
+        let src: &[u16] = match getcwd_w(&mut wbuf.0) {
+            Ok(cwd) => cwd,
+            Err(GetcwdError::Os) => return Err(crate::CrateError::Unexpected),
+            Err(GetcwdError::NameTooLong) => return Err(crate::CrateError::NameTooLong),
+        };
         // WTF-16 → WTF-8 into the caller's `PathBuffer`. Surrogate pairs are
         // combined; unpaired surrogates are encoded as 3-byte WTF-8.
-        let src = &wbuf.0[..n];
         let out = &mut buf.0;
         let mut wi = 0usize;
         let mut bi = 0usize;
@@ -4094,6 +4085,57 @@ fn getcwd_len(buf: &mut PathBuffer) -> crate::CrateResult<usize> {
     }
 }
 
+/// Why [`getcwd_w`] has no working directory to give.
+#[cfg(windows)]
+pub enum GetcwdError {
+    /// `GetCurrentDirectoryW` failed, and `GetLastError` still says why.
+    Os,
+    NameTooLong,
+}
+
+/// The working directory. Windows keeps a `\\?\` prefix from a start in, or a chdir into, `\\?\C:\dir`. Unlike `uv_cwd`, this drops it.
+#[cfg(windows)]
+pub fn getcwd_w(buf: &mut [u16]) -> Result<&mut [u16], GetcwdError> {
+    unsafe extern "system" {
+        fn GetCurrentDirectoryW(nBufferLength: u32, lpBuffer: *mut u16) -> u32;
+    }
+    // SAFETY: `buf` has `buf.len()` writable u16 units.
+    let len = unsafe { GetCurrentDirectoryW(buf.len() as u32, buf.as_mut_ptr()) } as usize;
+    if len == 0 {
+        return Err(GetcwdError::Os);
+    }
+    // A buffer that is too small gets the length it needs, NUL included.
+    if len >= buf.len() {
+        return Err(GetcwdError::NameTooLong);
+    }
+    Ok(without_verbatim_prefix_w(&mut buf[..len]))
+}
+
+/// `\\?\C:\dir` is `C:\dir` and `\\?\UNC\server\share` is `\\server\share`, in place. Any other path comes back whole.
+pub fn without_verbatim_prefix_w(path: &mut [u16]) -> &mut [u16] {
+    const SEP: u16 = b'\\' as u16;
+    const QUESTION: u16 = b'?' as u16;
+    const COLON: u16 = b':' as u16;
+    let is = |unit: u16, letter: u8| {
+        u8::try_from(unit).is_ok_and(|unit| unit.eq_ignore_ascii_case(&letter))
+    };
+    match *path {
+        [SEP, SEP, QUESTION, SEP, drive, COLON, SEP, ..]
+            if u8::try_from(drive).is_ok_and(|drive| drive.is_ascii_alphabetic()) =>
+        {
+            &mut path[4..]
+        }
+        [SEP, SEP, QUESTION, SEP, u, n, c, SEP, server, ..]
+            if is(u, b'U') && is(n, b'N') && is(c, b'C') && server != SEP =>
+        {
+            // The `C` of `UNC` becomes the second `\` of `\\server`.
+            path[6] = SEP;
+            &mut path[6..]
+        }
+        _ => path,
+    }
+}
+
 // ── which ─────────────────────────────────────────────────────────────────
 // `bun.which` lives in the `bun_which` crate (tier-2, full Windows PATHEXT
 // support). bun_core cannot re-export it (bun_which → bun_core dep cycle), so
diff --git a/src/paths/string_paths.rs b/src/paths/string_paths.rs
index df2d6284094d..5e8da8d60c99 100644
--- a/src/paths/string_paths.rs
+++ b/src/paths/string_paths.rs
@@ -705,4 +705,51 @@ mod tests {
         assert!(fits_in_wide_path_buffer(&vec![0x80u8; 32758]));
         assert!(fits_in_wide_path_buffer(&vec![0x80u8; 32757]));
     }
+
+    #[test]
+    fn without_verbatim_prefix_w_gives_the_plain_spelling() {
+        let plain = |path: &str| {
+            let mut wide: Vec<u16> = path.encode_utf16().collect();
+            String::from_utf16(bun_core::without_verbatim_prefix_w(&mut wide)).unwrap()
+        };
+        for (path, spelled) in [
+            (r"\\?\C:\", r"C:\"),
+            (r"\\?\c:\dir\file.ts", r"c:\dir\file.ts"),
+            (r"\\?\UNC\server\share", r"\\server\share"),
+            (r"\\?\unc\server\share\dir", r"\\server\share\dir"),
+        ] {
+            assert_eq!(plain(path), spelled);
+        }
+        for whole in [
+            // Plain already.
+            "",
+            r"C:\dir",
+            r"\\server\share\dir",
+            // No plain spelling.
+            r"\\?\Volume{b75e2c83-0000-0000-0000-602f00000000}\dir",
+            r"\\?\GLOBALROOT\Device\HarddiskVolume1\dir",
+            r"\\.\C:\dir",
+            r"\??\C:\dir",
+            // Not a directory of a drive or of a share.
+            r"\\?\",
+            r"\\?\C:",
+            r"\\?\C:dir",
+            r"\\?\1:\dir",
+            r"\\?\UNC",
+            r"\\?\UNC\",
+            r"\\?\UNC\\share",
+            r"\\?\UNCserver\share",
+            r"\\?\XNC\server\share",
+            r"\\?\UXC\server\share",
+            r"\\?\UNX\server\share",
+            // A unit above U+00FF whose low byte is `C`, and three whose low bytes are `UNC`.
+            "\\\\?\\\u{0143}:\\dir",
+            "\\\\?\\\u{0155}\u{014E}\u{0143}\\server\\share",
+            // Only `\` is a separator after the prefix.
+            "//?/C:/dir",
+            r"\\?\C:/dir",
+        ] {
+            assert_eq!(plain(whole), whole);
+        }
+    }
 }
diff --git a/src/runtime/node/node_fs.rs b/src/runtime/node/node_fs.rs
index c5af7c0cd798..61fa1f9dc4d9 100644
--- a/src/runtime/node/node_fs.rs
+++ b/src/runtime/node/node_fs.rs
@@ -8449,8 +8449,12 @@ impl NodeFS {
                             &[dir, target_path],
                         )
                         .len();
-                    self.sync_error_buf[0..4].copy_from_slice(&paths::windows::LONG_PATH_PREFIX_U8);
                     self.sync_error_buf[4 + target_len] = 0;
+                    // A working directory with no plain spelling (a volume GUID) keeps its `\\?\`.
+                    if self.sync_error_buf[4..].starts_with(&paths::windows::LONG_PATH_PREFIX_U8) {
+                        break 'target ZStr::from_buf(&self.sync_error_buf[4..], target_len);
+                    }
+                    self.sync_error_buf[0..4].copy_from_slice(&paths::windows::LONG_PATH_PREFIX_U8);
                     break 'target ZStr::from_buf(&self.sync_error_buf[..], 4 + target_len);
                 }
                 if paths::is_absolute(target_path) {
diff --git a/src/runtime/node/node_process.rs b/src/runtime/node/node_process.rs
index 69356228f768..c6188fac247f 100644
--- a/src/runtime/node/node_process.rs
+++ b/src/runtime/node/node_process.rs
@@ -488,6 +488,7 @@ mod _impl {
         }
         // Real syscall (not the resolver's cached top_level_dir): Node's
         // process.cwd() calls uv_cwd() so a deleted cwd must surface here.
+        // Unlike uv_cwd(), it drops the `\\?\` prefix of a Windows working directory (`bun_core::getcwd_w`).
         let mut buf = bun_paths::path_buffer_pool::get();
         match bun_sys::getcwd(&mut buf[..]) {
             bun_sys::Result::Ok(len) => {
diff --git a/src/sys/lib.rs b/src/sys/lib.rs
index 903d7ed2fadd..15b5a4f82b11 100644
--- a/src/sys/lib.rs
+++ b/src/sys/lib.rs
@@ -4108,22 +4108,21 @@ mod windows_impl {
         Ok(Fd::from_native(target as _))
     }
     pub fn getcwd(buf: &mut [u8]) -> Maybe<usize> {
-        // GetCurrentDirectoryW + WTF16→UTF8.
         let mut wbuf = bun_paths::w_path_buffer_pool::get();
-        let len =
-            unsafe { w::kernel32::GetCurrentDirectoryW(wbuf.len() as u32, wbuf.as_mut_ptr()) };
-        if len == 0 {
-            return Err(Error::from_win32(w::Win32Error::get(), Tag::getcwd));
-        }
-        // MSDN: when `nBufferLength` is too small `GetCurrentDirectoryW`
-        // returns the *required* size (incl. NUL), which can exceed
-        // `wbuf.len()` under long-path opt-in. Guard so the slice below
-        // surfaces ENAMETOOLONG instead of panicking on OOB.
-        if len as usize > wbuf.len() {
-            return Err(Error::new(E::ENAMETOOLONG, Tag::getcwd));
-        }
-        let utf8 = bun_paths::string_paths::from_w_path(buf, &wbuf[..len as usize]);
-        Ok(utf8.len())
+        let cwd = match bun_core::getcwd_w(&mut wbuf[..]) {
+            Ok(cwd) => cwd,
+            Err(bun_core::GetcwdError::Os) => {
+                return Err(Error::from_win32(w::Win32Error::get(), Tag::getcwd));
+            }
+            Err(bun_core::GetcwdError::NameTooLong) => {
+                return Err(Error::new(E::ENAMETOOLONG, Tag::getcwd));
+            }
+        };
+        // Not `from_w_path`: it also drops the `\\?\` of a path that has no plain spelling.
+        let last = buf.len() - 1;
+        let written = bun_core::strings::copy_utf16_into_utf8(&mut buf[..last], cwd).written;
+        buf[written] = 0;
+        Ok(written)
     }
     pub fn mkdirat(dir: impl AsFd, path: &ZStr, _mode: Mode) -> Maybe<()> {
         let dir = dir.as_fd();
diff --git a/test/internal/source-lints/windows-cwd-readers.test.ts b/test/internal/source-lints/windows-cwd-readers.test.ts
new file mode 100644
index 000000000000..2e977ddfc18b
--- /dev/null
+++ b/test/internal/source-lints/windows-cwd-readers.test.ts
@@ -0,0 +1,40 @@
+import { Glob } from "bun";
+import { expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+
+// Windows keeps a `\\?\` prefix in the working directory of a process that starts in, or changes into, a directory
+// spelled with one. `bun_core::getcwd_w` reads the working directory without that prefix, and `bun_core::getcwd` and
+// `bun_sys::getcwd` both read through it. A second reader of `GetCurrentDirectoryW` gives one process two spellings of
+// its working directory. A module path made from the spelling with the prefix is cut at the `?`
+// (https://github.com/oven-sh/bun/issues/11953).
+//
+// Read the working directory with `bun_core::getcwd` or `bun_sys::getcwd`.
+test("the Windows working directory has one reader", async () => {
+  const repoRoot = path.resolve(import.meta.dir, "..", "..", "..");
+  const call = /(?<!\bfn\s+)\bGetCurrentDirectoryW\s*\(/;
+
+  const known = new Map([
+    // `getcwd_w`.
+    ["src/bun_core/util.rs", 1],
+    // The `.bunx` fast path of `bun run <bin>`. Its path does not open with the prefix, and the slower path, which
+    // starts the program in the directory as Bun names it, takes over.
+    ["src/runtime/cli/run_command.rs", 1],
+    // `process.report()` says what the OS says.
+    ["src/jsc/bindings/BunProcessReportObjectWindows.cpp", 1],
+  ]);
+
+  const found = new Map<string, number>();
+  let scanned = 0;
+  for await (const rel of new Glob("**/*.{rs,c,cpp,h}").scan({ cwd: path.join(repoRoot, "src") })) {
+    const file = path.join("src", rel).replaceAll("\\", "/");
+    scanned++;
+    const source = readFileSync(path.join(repoRoot, file), "utf8");
+    if (!source.includes("GetCurrentDirectoryW")) continue;
+    const count = source.split("\n").filter(line => !/^\s*\/\//.test(line) && call.test(line)).length;
+    if (count > 0) found.set(file, count);
+  }
+  // Guard against repoRoot resolving wrong, which would make the lint pass vacuously.
+  expect(scanned).toBeGreaterThan(1000);
+  expect(Object.fromEntries([...found].sort())).toEqual(Object.fromEntries([...known].sort()));
+});

From 2afff40ef5f2bb4e8e0086420b2579e70d23f6be Mon Sep 17 00:00:00 2001
From: robobun <117481402+robobun@users.noreply.github.com>
Date: Fri, 30 Oct 2026 19:58:16 +0000
Subject: [PATCH 3/5] test: more of a Windows working directory spelled with
 the `\\?\` prefix

- Each case reads the working directory of the OS through
  `GetCurrentDirectoryW`, so that a pass shows that the prefix arrived.
- New cases: a package.json script, a child without `cwd`,
  `bun install` with both linkers, a volume GUID spelling, and a
  junction to a relative target.
- The `bun build --app` case no longer moves the fixture of the test
  before it.
---
 test/bake/dev/production.test.ts     |  64 ++++++++------
 test/cli/install/bun-install.test.ts |  39 +++++++++
 test/js/node/process/process.test.js | 124 ++++++++++++++++++++-------
 3 files changed, 168 insertions(+), 59 deletions(-)

diff --git a/test/bake/dev/production.test.ts b/test/bake/dev/production.test.ts
index c5400b945591..95f071532261 100644
--- a/test/bake/dev/production.test.ts
+++ b/test/bake/dev/production.test.ts
@@ -456,27 +456,24 @@ export default function () {
     expect(exitCode).toBe(1);
   });
 
-  // A framework without dependencies. The page is "homepage" and names the chunk of the client entry point.
-  const customFramework = {
-    "client.ts": `console.log("client loaded");`,
-    "server.ts": `
-      export function render(req, meta) {
-        return new Response(String(meta.pageModule.default()));
-      }
-      export async function prerender(meta) {
-        const scripts = meta.modules.map(m => '<script type="module" src="' + m + '"></script>').join("");
-        return { files: { "index.html": "<body>" + meta.pageModule.default() + scripts + "</body>" } };
-      }
-    `,
-    "routes/index.ts": `export default () => "homepage";`,
-    "app.ts": `
-      const fsr = { root: "routes", style: "nextjs-pages", serverEntryPoint: "./server.ts", clientEntryPoint: "./client.ts" };
-      export default { app: { framework: { fileSystemRouterTypes: [fsr] } } };
-    `,
-  };
-
   test("builds a framework without server components and keeps its client entry point", async () => {
-    using dir = tempDir("bake-production-custom-framework", customFramework);
+    using dir = tempDir("bake-production-custom-framework", {
+      "client.ts": `console.log("client loaded");`,
+      "server.ts": `
+        export function render(req, meta) {
+          return new Response(String(meta.pageModule.default()));
+        }
+        export async function prerender(meta) {
+          const scripts = meta.modules.map(m => '<script type="module" src="' + m + '"></script>').join("");
+          return { files: { "index.html": "<body>" + meta.pageModule.default() + scripts + "</body>" } };
+        }
+      `,
+      "routes/index.ts": `export default () => "homepage";`,
+      "app.ts": `
+        const fsr = { root: "routes", style: "nextjs-pages", serverEntryPoint: "./server.ts", clientEntryPoint: "./client.ts" };
+        export default { app: { framework: { fileSystemRouterTypes: [fsr] } } };
+      `,
+    });
 
     const { exitCode, stderr } = await Bun.$`${bunExe()} build --app ./app.ts`
       .cwd(String(dir))
@@ -493,8 +490,23 @@ export default function () {
   });
 
   // Windows keeps a `\\?\` prefix in the working directory of a process that starts in a directory spelled with one.
+  // https://github.com/oven-sh/bun/issues/11953
   test.skipIf(!isWindows)("builds from a working directory spelled with the \\\\?\\ prefix", async () => {
-    using dir = tempDir("bake-production-verbatim-cwd", customFramework);
+    using dir = tempDir("bake-production-verbatim-cwd", {
+      "server.ts": `
+        export function render() {
+          return new Response("");
+        }
+        export async function prerender(meta) {
+          return { files: { "index.html": meta.pageModule.default() } };
+        }
+      `,
+      "routes/index.ts": `export default () => "homepage";`,
+      "app.ts": `
+        const fsr = { root: "routes", style: "nextjs-pages", serverEntryPoint: "./server.ts" };
+        export default { app: { framework: { fileSystemRouterTypes: [fsr] } } };
+      `,
+    });
 
     await using proc = Bun.spawn({
       cmd: [bunExe(), "build", "--app", "./app.ts"],
@@ -504,14 +516,10 @@ export default function () {
       stderr: "pipe",
     });
     const [stderr, exitCode] = await Promise.all([proc.stderr.text(), proc.exited]);
-    const html = await Bun.file(path.join(String(dir), "dist", "index.html"))
+    const page = await Bun.file(path.join(String(dir), "dist", "index.html"))
       .text()
-      .catch(() => stderr);
-    expect(html).toContain("homepage");
-    const script = html.match(/<script type="module" src="\/([^"]*_bun[^"]*\.js)"><\/script>/);
-    expect(script).toBeTruthy();
-    expect(existsSync(path.join(String(dir), "dist", script![1]))).toBe(true);
-    expect(exitCode).toBe(0);
+      .catch(() => null);
+    expect({ page, stderr, exitCode }).toEqual({ page: "homepage", stderr: expect.any(String), exitCode: 0 });
   });
 
   test("fails the build for a route file with an invalid name", async () => {
diff --git a/test/cli/install/bun-install.test.ts b/test/cli/install/bun-install.test.ts
index 011399d13c7a..6adff1f4d5c7 100644
--- a/test/cli/install/bun-install.test.ts
+++ b/test/cli/install/bun-install.test.ts
@@ -9715,6 +9715,45 @@ describe.concurrent("bun-install", () => {
     });
   });
 
+  // https://github.com/oven-sh/bun/issues/11953
+  //
+  // Windows keeps a `\\?\` prefix in the working directory of a process that starts in a directory spelled with one.
+  // Rust's `fs::canonicalize` gives that spelling, and a Rust program then starts `bun install` in it.
+  describe.skipIf(!isWindows)("project in a directory spelled with the \\\\?\\ prefix", () => {
+    it.each(["hoisted", "isolated"] as const)("bun install with the %s linker", async linker => {
+      await withContext({ linker }, async ctx => {
+        setContextHandler(ctx, dummyRegistryForContext(ctx, []));
+        await writeFile(
+          join(ctx.package_dir, "package.json"),
+          JSON.stringify({
+            name: "foo",
+            version: "0.0.1",
+            dependencies: { bar: "^0" },
+            scripts: { postinstall: "echo INIT_CWD=$INIT_CWD" },
+          }),
+        );
+
+        await using proc = spawn({
+          cmd: [bunExe(), "install"],
+          cwd: "\\\\?\\" + ctx.package_dir,
+          stdout: "pipe",
+          stdin: "ignore",
+          stderr: "pipe",
+          env,
+        });
+        const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+        expect(stderr).toContain("Saved lockfile");
+        expect(stdout).toContain("+ bar@0.0.2");
+        expect(stdout.split(/\r?\n/)).toContain(`INIT_CWD=${ctx.package_dir}`);
+        expect(await file(join(ctx.package_dir, "node_modules", "bar", "package.json")).json()).toEqual({
+          name: "bar",
+          version: "0.0.2",
+        });
+        expect(exitCode).toBe(0);
+      });
+    });
+  });
+
   // https://github.com/oven-sh/bun/issues/19088
   //
   // Workspace package.jsons are parsed without the root's duplicate check, so a name listed in
diff --git a/test/js/node/process/process.test.js b/test/js/node/process/process.test.js
index 6d3df8909965..59c2bbd5c16d 100644
--- a/test/js/node/process/process.test.js
+++ b/test/js/node/process/process.test.js
@@ -363,10 +363,22 @@ it("process.chdir() on root dir", () => {
 });
 
 // Windows keeps a `\\?\` prefix in the working directory of a process that starts in, or changes into, a directory
-// spelled with one. Bun names every path from the plain spelling of that directory.
+// spelled with one. Bun derives paths from that directory without the prefix. Node keeps the prefix in `process.cwd()`.
+// https://github.com/oven-sh/bun/issues/11953
 describe.skipIf(!isWindows)("a working directory spelled with the \\\\?\\ prefix", () => {
-  // Each line names a path from the working directory. A line that throws reports why.
+  // What the OS names as the working directory, so that a case knows that its prefix arrived.
+  const osCwd = `
+    const osCwd = () => {
+      const { symbols } = require("bun:ffi").dlopen("kernel32.dll", {
+        GetCurrentDirectoryW: { args: ["u32", "ptr"], returns: "u32" },
+      });
+      const units = new Uint16Array(32768);
+      return String.fromCharCode(...units.subarray(0, symbols.GetCurrentDirectoryW(units.length, units)));
+    };
+  `;
+  // Each line derives a path from the working directory. A line that throws reports why.
   const script = `
+    ${osCwd}
     const out = {};
     const report = async (name, read) => {
       try {
@@ -375,6 +387,7 @@ describe.skipIf(!isWindows)("a working directory spelled with the \\\\?\\ prefix
         out[name] = "threw " + (error?.message ?? error);
       }
     };
+    await report("osCwd", osCwd);
     await report("cwd", () => process.cwd());
     await report("pathResolve", () => require("node:path").resolve());
     await report("main", () => Bun.main);
@@ -388,6 +401,7 @@ describe.skipIf(!isWindows)("a working directory spelled with the \\\\?\\ prefix
       worker.onerror = event => reject(new Error(event.message));
     }));
     await report("shell", async () => (await Bun.$\`echo shell\`.text()).trim());
+    await report("child", () => Bun.spawnSync([process.execPath, "-p", "process.cwd()"]).stdout.toString().trim());
     await report("preloaded", () => globalThis.preloaded ?? false);
     console.log(JSON.stringify(out));
   `;
@@ -397,12 +411,14 @@ describe.skipIf(!isWindows)("a working directory spelled with the \\\\?\\ prefix
     "worker.ts": `postMessage("worker.ts");`,
     "preload.ts": `globalThis.preloaded = true;`,
     "entry.mjs": script,
+    "package.json": JSON.stringify({ name: "process-cwd-verbatim", scripts: { entry: `'${bunExe()}' entry.mjs` } }),
     "a.test.ts": `
       import { expect, test } from "bun:test";
       import dep from "./dep.ts";
-      test("reads the working directory", () => {
+      ${osCwd}
+      test("derives paths from the working directory", () => {
         expect(dep).toBe("dep.ts");
-        console.log(JSON.stringify({ cwd: process.cwd(), metaDir: import.meta.dir }));
+        console.log(JSON.stringify({ osCwd: osCwd(), cwd: process.cwd(), metaDir: import.meta.dir }));
       });
     `,
     "elsewhere/keep": "",
@@ -423,28 +439,37 @@ describe.skipIf(!isWindows)("a working directory spelled with the \\\\?\\ prefix
   // The administrative share of a drive names the same directories on the server `localhost`.
   const share = dir => "\\\\localhost\\" + dir[0] + "$" + dir.slice(2);
   const hasShare = isWindows && existsSync(share(tmpdir()));
+  // The volume of `dir` by its GUID, `\\?\Volume{...}\`: a spelling with no plain form.
+  function volume(dir) {
+    const { symbols } = dlopen("kernel32.dll", {
+      GetVolumeNameForVolumeMountPointW: { args: ["ptr", "ptr", "u32"], returns: "i32" },
+    });
+    const mountPoint = Uint16Array.from(dir.slice(0, 3) + "\0", unit => unit.charCodeAt(0));
+    const name = new Uint16Array(64);
+    if (!symbols.GetVolumeNameForVolumeMountPointW(mountPoint, name, name.length)) return null;
+    return String.fromCharCode(...name.subarray(0, name.indexOf(0))) + dir.slice(3);
+  }
 
   describe.each([
     ["plain", dir => dir],
     ["\\\\?\\", dir => "\\\\?\\" + dir],
   ])("the %s spelling", (_, spell) => {
     it.concurrent.each([
-      ["bun -e", "[eval]", false, dir => [spell(dir), "-e", script]],
-      ["bun --preload -e", "[eval]", true, dir => [spell(dir), "--preload", "./preload.ts", "-e", script]],
-      [
-        "bun --cwd -e, from another directory",
-        "[eval]",
-        false,
-        dir => [join(dir, "elsewhere"), "--cwd", spell(dir), "-e", script],
-      ],
-      ["bun run entry.mjs", "entry.mjs", false, dir => [spell(dir), "run", "entry.mjs"]],
-    ])("%s", async (_, main, preloaded, start) => {
+      ["bun -e", "[eval]", {}, ["-e", script]],
+      ["bun --preload -e", "[eval]", { preloaded: true }, ["--preload", "./preload.ts", "-e", script]],
+      ["bun --cwd -e, from another directory", "[eval]", { elsewhere: true }, ["-e", script]],
+      ["bun run entry.mjs", "entry.mjs", {}, ["run", "entry.mjs"]],
+      // `bun run` starts the script in the directory as Bun names it.
+      ["bun run <script>", "entry.mjs", { startsPlain: true }, ["run", "--silent", "entry"]],
+    ])("%s", async (_, main, { preloaded = false, elsewhere = false, startsPlain = false }, args) => {
       using dir = tempDir("process-cwd-verbatim", files);
       const root = String(dir);
-      const [cwd, ...args] = start(root);
-      const { stdout, stderr, exitCode } = await run(cwd, args);
-      expect({ out: parse(stdout), stderr }).toEqual({
+      const { stdout, stderr, exitCode } = elsewhere
+        ? await run(join(root, "elsewhere"), ["--cwd", spell(root), ...args])
+        : await run(spell(root), args);
+      expect({ out: parse(stdout), stderr, exitCode }).toEqual({
         out: {
+          osCwd: startsPlain ? root : spell(root),
           cwd: root,
           pathResolve: root,
           main: join(root, main),
@@ -454,46 +479,79 @@ describe.skipIf(!isWindows)("a working directory spelled with the \\\\?\\ prefix
           require: "dep.cjs",
           worker: "worker.ts",
           shell: "shell",
+          child: root,
           preloaded,
         },
         stderr: "",
+        exitCode: 0,
       });
-      expect(exitCode).toBe(0);
     });
 
     it.concurrent("bun test", async () => {
       using dir = tempDir("process-cwd-verbatim-test", files);
       const root = String(dir);
       const { stdout, stderr, exitCode } = await run(spell(root), ["test"]);
-      expect({ stdout, stderr }).toEqual({
-        stdout: expect.stringContaining(JSON.stringify({ cwd: root, metaDir: root })),
+      expect({ stdout, stderr, exitCode }).toEqual({
+        stdout: expect.stringContaining(JSON.stringify({ osCwd: spell(root), cwd: root, metaDir: root })),
         stderr: expect.stringContaining(" 1 pass"),
+        exitCode: 0,
       });
-      expect(exitCode).toBe(0);
     });
   });
 
   it.concurrent("process.chdir() into each spelling", async () => {
     using dir = tempDir("process-chdir-verbatim", {});
     const root = String(dir);
-    const spellings = { plain: root, verbatim: "\\\\?\\" + root };
-    const expected = { plain: root, verbatim: root };
+    // [what `process.chdir()` gets, what `process.cwd()` then gives]
+    const spellings = { plain: [root, root], verbatim: ["\\\\?\\" + root, root] };
     if (hasShare) {
-      Object.assign(spellings, { share: share(root), verbatimShare: "\\\\?\\UNC\\" + share(root).slice(2) });
-      Object.assign(expected, { share: share(root), verbatimShare: share(root) });
+      spellings.share = [share(root), share(root)];
+      spellings.verbatimShare = ["\\\\?\\UNC\\" + share(root).slice(2), share(root)];
     }
+    if (volume(root)) spellings.volume = [volume(root), volume(root)];
     const script = `
+      ${osCwd}
+      const out = {};
+      for (const [name, [to]] of Object.entries(JSON.parse(process.env.SPELLINGS))) {
+        process.chdir(to);
+        out[name] = { os: osCwd(), cwd: process.cwd() };
+      }
+      console.log(JSON.stringify(out));
+    `;
+    const env = { ...bunEnv, SPELLINGS: JSON.stringify(spellings) };
+    const { stdout, stderr, exitCode } = await run(root, ["-e", script], env);
+    expect({ out: parse(stdout), stderr, exitCode }).toEqual({
+      out: Object.fromEntries(Object.entries(spellings).map(([name, [os, cwd]]) => [name, { os, cwd }])),
+      stderr: "",
+      exitCode: 0,
+    });
+  });
+
+  // The target of a junction is absolute, so a relative one is joined to the working directory.
+  it.concurrent("fs.symlinkSync() makes a junction to a relative target in each spelling", async () => {
+    using dir = tempDir("process-cwd-junction", {});
+    const root = String(dir);
+    const spellings = { plain: root, verbatim: "\\\\?\\" + root };
+    if (volume(root)) spellings.volume = volume(root);
+    const script = `
+      const fs = require("node:fs");
       const out = {};
       for (const [name, to] of Object.entries(JSON.parse(process.env.SPELLINGS))) {
         process.chdir(to);
-        out[name] = process.cwd();
+        fs.mkdirSync(name + "/target", { recursive: true });
+        fs.writeFileSync(name + "/target/file", name);
+        fs.symlinkSync("target", name + "/link", "junction");
+        out[name] = fs.readFileSync(name + "/link/file", "utf8");
       }
       console.log(JSON.stringify(out));
     `;
     const env = { ...bunEnv, SPELLINGS: JSON.stringify(spellings) };
     const { stdout, stderr, exitCode } = await run(root, ["-e", script], env);
-    expect({ out: parse(stdout), stderr }).toEqual({ out: expected, stderr: "" });
-    expect(exitCode).toBe(0);
+    expect({ out: parse(stdout), stderr, exitCode }).toEqual({
+      out: Object.fromEntries(Object.keys(spellings).map(name => [name, name])),
+      stderr: "",
+      exitCode: 0,
+    });
   });
 
   it.concurrent.skipIf(!hasShare).each([
@@ -502,9 +560,13 @@ describe.skipIf(!isWindows)("a working directory spelled with the \\\\?\\ prefix
   ])("process.cwd() of a process that starts in the %s spelling of a share", async (_, spell) => {
     using dir = tempDir("process-cwd-share", {});
     const unc = share(String(dir));
-    const { stdout, stderr, exitCode } = await run(spell(unc), ["-p", "process.cwd()"]);
-    expect({ stdout: stdout.trim(), stderr }).toEqual({ stdout: unc, stderr: "" });
-    expect(exitCode).toBe(0);
+    const script = `${osCwd}\nconsole.log(JSON.stringify({ os: osCwd(), cwd: process.cwd() }));`;
+    const { stdout, stderr, exitCode } = await run(spell(unc), ["-e", script]);
+    expect({ out: parse(stdout), stderr, exitCode }).toEqual({
+      out: { os: spell(unc), cwd: unc },
+      stderr: "",
+      exitCode: 0,
+    });
   });
 });
 

From 11bebddf0e9ae5ad05a6e589628d0499f5b2e6aa Mon Sep 17 00:00:00 2001
From: robobun <117481402+robobun@users.noreply.github.com>
Date: Fri, 30 Oct 2026 21:19:14 +0000
Subject: [PATCH 4/5] test: make the share and volume GUID cases tests of their
 own

A case that needs the administrative share or the GUID name of the
volume is now a separate test with `skipIf`. A run then shows in its
skip count whether these cases ran.
---
 test/js/node/process/process.test.js | 78 ++++++++++++++++------------
 1 file changed, 44 insertions(+), 34 deletions(-)

diff --git a/test/js/node/process/process.test.js b/test/js/node/process/process.test.js
index 59c2bbd5c16d..5def0e4976b6 100644
--- a/test/js/node/process/process.test.js
+++ b/test/js/node/process/process.test.js
@@ -449,6 +449,7 @@ describe.skipIf(!isWindows)("a working directory spelled with the \\\\?\\ prefix
     if (!symbols.GetVolumeNameForVolumeMountPointW(mountPoint, name, name.length)) return null;
     return String.fromCharCode(...name.subarray(0, name.indexOf(0))) + dir.slice(3);
   }
+  const hasVolume = isWindows && volume(tmpdir()) !== null;
 
   describe.each([
     ["plain", dir => dir],
@@ -499,60 +500,69 @@ describe.skipIf(!isWindows)("a working directory spelled with the \\\\?\\ prefix
     });
   });
 
-  it.concurrent("process.chdir() into each spelling", async () => {
+  // `spellings` gives pairs: what `process.chdir()` gets, and what `process.cwd()` then gives.
+  async function expectChdir(spellings) {
     using dir = tempDir("process-chdir-verbatim", {});
     const root = String(dir);
-    // [what `process.chdir()` gets, what `process.cwd()` then gives]
-    const spellings = { plain: [root, root], verbatim: ["\\\\?\\" + root, root] };
-    if (hasShare) {
-      spellings.share = [share(root), share(root)];
-      spellings.verbatimShare = ["\\\\?\\UNC\\" + share(root).slice(2), share(root)];
-    }
-    if (volume(root)) spellings.volume = [volume(root), volume(root)];
+    const pairs = spellings(root);
     const script = `
       ${osCwd}
-      const out = {};
-      for (const [name, [to]] of Object.entries(JSON.parse(process.env.SPELLINGS))) {
+      const out = [];
+      for (const to of JSON.parse(process.env.SPELLINGS)) {
         process.chdir(to);
-        out[name] = { os: osCwd(), cwd: process.cwd() };
+        out.push({ os: osCwd(), cwd: process.cwd() });
       }
       console.log(JSON.stringify(out));
     `;
-    const env = { ...bunEnv, SPELLINGS: JSON.stringify(spellings) };
+    const env = { ...bunEnv, SPELLINGS: JSON.stringify(pairs.map(([to]) => to)) };
     const { stdout, stderr, exitCode } = await run(root, ["-e", script], env);
     expect({ out: parse(stdout), stderr, exitCode }).toEqual({
-      out: Object.fromEntries(Object.entries(spellings).map(([name, [os, cwd]]) => [name, { os, cwd }])),
+      out: pairs.map(([os, cwd]) => ({ os, cwd })),
       stderr: "",
       exitCode: 0,
     });
-  });
+  }
+  it.concurrent("process.chdir() into a drive, plain and with \\\\?\\", () =>
+    expectChdir(dir => [
+      [dir, dir],
+      ["\\\\?\\" + dir, dir],
+    ]),
+  );
+  it.concurrent.skipIf(!hasShare)("process.chdir() into a share, plain and with \\\\?\\UNC\\", () =>
+    expectChdir(dir => [
+      [share(dir), share(dir)],
+      ["\\\\?\\UNC\\" + share(dir).slice(2), share(dir)],
+    ]),
+  );
+  // A volume GUID has no plain spelling, so `process.cwd()` gives what the OS gives.
+  it.concurrent.skipIf(!hasVolume)("process.chdir() into a volume GUID", () =>
+    expectChdir(dir => [[volume(dir), volume(dir)]]),
+  );
 
   // The target of a junction is absolute, so a relative one is joined to the working directory.
-  it.concurrent("fs.symlinkSync() makes a junction to a relative target in each spelling", async () => {
+  async function expectJunction(spell) {
     using dir = tempDir("process-cwd-junction", {});
     const root = String(dir);
-    const spellings = { plain: root, verbatim: "\\\\?\\" + root };
-    if (volume(root)) spellings.volume = volume(root);
     const script = `
       const fs = require("node:fs");
-      const out = {};
-      for (const [name, to] of Object.entries(JSON.parse(process.env.SPELLINGS))) {
-        process.chdir(to);
-        fs.mkdirSync(name + "/target", { recursive: true });
-        fs.writeFileSync(name + "/target/file", name);
-        fs.symlinkSync("target", name + "/link", "junction");
-        out[name] = fs.readFileSync(name + "/link/file", "utf8");
-      }
-      console.log(JSON.stringify(out));
+      process.chdir(process.env.SPELLED);
+      fs.mkdirSync("sub/target", { recursive: true });
+      fs.writeFileSync("sub/target/file", "through the junction");
+      fs.symlinkSync("target", "sub/link", "junction");
+      console.log(fs.readFileSync("sub/link/file", "utf8"));
     `;
-    const env = { ...bunEnv, SPELLINGS: JSON.stringify(spellings) };
-    const { stdout, stderr, exitCode } = await run(root, ["-e", script], env);
-    expect({ out: parse(stdout), stderr, exitCode }).toEqual({
-      out: Object.fromEntries(Object.keys(spellings).map(name => [name, name])),
-      stderr: "",
-      exitCode: 0,
-    });
-  });
+    const { stdout, stderr, exitCode } = await run(root, ["-e", script], { ...bunEnv, SPELLED: spell(root) });
+    expect({ stdout, stderr, exitCode }).toEqual({ stdout: "through the junction\n", stderr: "", exitCode: 0 });
+  }
+  it.concurrent.each([
+    ["plain", dir => dir],
+    ["\\\\?\\", dir => "\\\\?\\" + dir],
+  ])("fs.symlinkSync() makes a junction to a relative target from the %s spelling", (_, spell) =>
+    expectJunction(spell),
+  );
+  it.concurrent.skipIf(!hasVolume)("fs.symlinkSync() makes a junction to a relative target from a volume GUID", () =>
+    expectJunction(volume),
+  );
 
   it.concurrent.skipIf(!hasShare).each([
     ["plain", unc => unc],

From 09b5ef8ef8dc40420813ed3953c85b1bfc58c5fd Mon Sep 17 00:00:00 2001
From: robobun <117481402+robobun@users.noreply.github.com>
Date: Sat, 31 Oct 2026 04:19:39 +0000
Subject: [PATCH 5/5] test: junction targets that have the `\\?\` prefix, and a
 Node.js reference run

`fs.symlink` keeps a `\\?\` prefix that a junction target already has.
The new rows in fs.test.ts cover a target and a link path spelled with
the prefix. On main the target gets a second prefix.

A row in process.test.js runs Node.js in a `\\?\` working directory.
Node.js keeps the prefix in `process.cwd()` and `path.resolve()`, and
Bun drops it.

The source lint counts each call of `GetCurrentDirectoryW`, not each
line that has one. Two comments name the spellings that the reader
changes.
---
 src/bun_core/util.rs                          |  2 +-
 src/runtime/node/node_process.rs              |  2 +-
 test/cli/install/bun-install.test.ts          |  3 +-
 .../source-lints/windows-cwd-readers.test.ts  |  5 ++-
 test/js/node/fs/fs.test.ts                    | 19 +++++++++
 test/js/node/process/process.test.js          | 40 ++++++++++++++++++-
 6 files changed, 65 insertions(+), 6 deletions(-)

diff --git a/src/bun_core/util.rs b/src/bun_core/util.rs
index e31d03ce1690..707f4eb2429c 100644
--- a/src/bun_core/util.rs
+++ b/src/bun_core/util.rs
@@ -4093,7 +4093,7 @@ pub enum GetcwdError {
     NameTooLong,
 }
 
-/// The working directory. Windows keeps a `\\?\` prefix from a start in, or a chdir into, `\\?\C:\dir`. Unlike `uv_cwd`, this drops it.
+/// The working directory, in the spelling of [`without_verbatim_prefix_w`]. Windows keeps a `\\?\` prefix from a start in, or a chdir into, `\\?\C:\dir`, and `uv_cwd` gives that prefix back.
 #[cfg(windows)]
 pub fn getcwd_w(buf: &mut [u16]) -> Result<&mut [u16], GetcwdError> {
     unsafe extern "system" {
diff --git a/src/runtime/node/node_process.rs b/src/runtime/node/node_process.rs
index c6188fac247f..03076963683f 100644
--- a/src/runtime/node/node_process.rs
+++ b/src/runtime/node/node_process.rs
@@ -488,7 +488,7 @@ mod _impl {
         }
         // Real syscall (not the resolver's cached top_level_dir): Node's
         // process.cwd() calls uv_cwd() so a deleted cwd must surface here.
-        // Unlike uv_cwd(), it drops the `\\?\` prefix of a Windows working directory (`bun_core::getcwd_w`).
+        // Unlike uv_cwd(), it gives `\\?\C:\dir` as `C:\dir` and `\\?\UNC\server\share` as `\\server\share` (`bun_core::getcwd_w`).
         let mut buf = bun_paths::path_buffer_pool::get();
         match bun_sys::getcwd(&mut buf[..]) {
             bun_sys::Result::Ok(len) => {
diff --git a/test/cli/install/bun-install.test.ts b/test/cli/install/bun-install.test.ts
index 6adff1f4d5c7..b3bfb7dd54f1 100644
--- a/test/cli/install/bun-install.test.ts
+++ b/test/cli/install/bun-install.test.ts
@@ -9718,7 +9718,8 @@ describe.concurrent("bun-install", () => {
   // https://github.com/oven-sh/bun/issues/11953
   //
   // Windows keeps a `\\?\` prefix in the working directory of a process that starts in a directory spelled with one.
-  // Rust's `fs::canonicalize` gives that spelling, and a Rust program then starts `bun install` in it.
+  // Rust's `fs::canonicalize` gives that spelling, and `Command::current_dir` of Rust before 1.88 starts `bun install`
+  // in it.
   describe.skipIf(!isWindows)("project in a directory spelled with the \\\\?\\ prefix", () => {
     it.each(["hoisted", "isolated"] as const)("bun install with the %s linker", async linker => {
       await withContext({ linker }, async ctx => {
diff --git a/test/internal/source-lints/windows-cwd-readers.test.ts b/test/internal/source-lints/windows-cwd-readers.test.ts
index 2e977ddfc18b..752918924114 100644
--- a/test/internal/source-lints/windows-cwd-readers.test.ts
+++ b/test/internal/source-lints/windows-cwd-readers.test.ts
@@ -12,7 +12,7 @@ import path from "node:path";
 // Read the working directory with `bun_core::getcwd` or `bun_sys::getcwd`.
 test("the Windows working directory has one reader", async () => {
   const repoRoot = path.resolve(import.meta.dir, "..", "..", "..");
-  const call = /(?<!\bfn\s+)\bGetCurrentDirectoryW\s*\(/;
+  const call = /(?<!\bfn\s+)\bGetCurrentDirectoryW\s*\(/g;
 
   const known = new Map([
     // `getcwd_w`.
@@ -31,7 +31,8 @@ test("the Windows working directory has one reader", async () => {
     scanned++;
     const source = readFileSync(path.join(repoRoot, file), "utf8");
     if (!source.includes("GetCurrentDirectoryW")) continue;
-    const count = source.split("\n").filter(line => !/^\s*\/\//.test(line) && call.test(line)).length;
+    const code = source.split("\n").filter(line => !/^\s*\/\//.test(line));
+    const count = code.join("\n").match(call)?.length ?? 0;
     if (count > 0) found.set(file, count);
   }
   // Guard against repoRoot resolving wrong, which would make the lint pass vacuously.
diff --git a/test/js/node/fs/fs.test.ts b/test/js/node/fs/fs.test.ts
index 8d019e5fa85e..d94aad7a9ba6 100644
--- a/test/js/node/fs/fs.test.ts
+++ b/test/js/node/fs/fs.test.ts
@@ -3688,6 +3688,25 @@ it.if(isWindows)("symlink on windows with forward slashes", async () => {
   expect(await fs.promises.readlink(join(r, "file-sym.txt"))).toBe("files\\2024\\123.txt");
 });
 
+// `fs.symlink` puts the `\\?\` prefix in front of the target of a junction. A target that has the prefix already keeps
+// it, as `path.toNamespacedPath()` keeps it. A relative target is joined to the directory of the link.
+describe.skipIf(!isWindows)("junction on windows", () => {
+  it.each([
+    ["a plain target", (real: string, link: string) => [real, link]],
+    ["a target that has the \\\\?\\ prefix", (real: string, link: string) => ["\\\\?\\" + real, link]],
+    [
+      "a link path that has the \\\\?\\ prefix, and a relative target",
+      (_: string, link: string) => ["real", "\\\\?\\" + link],
+    ],
+  ])("with %s", (_, spell) => {
+    using dir = tempDir("fs-junction-prefix", { "real/inner.txt": "through the junction" });
+    const link = join(String(dir), "link");
+    const [target, linkPath] = spell(join(String(dir), "real"), link);
+    symlinkSync(target, linkPath, "junction");
+    expect(readFileSync(join(link, "inner.txt"), "utf8")).toBe("through the junction");
+  });
+});
+
 it("realpath async", async () => {
   const actual = join(tmpdirSync(), "fs-realpath.txt");
   try {
diff --git a/test/js/node/process/process.test.js b/test/js/node/process/process.test.js
index 5def0e4976b6..56449dae788c 100644
--- a/test/js/node/process/process.test.js
+++ b/test/js/node/process/process.test.js
@@ -4,7 +4,19 @@ import { memoryUsage as jscMemoryUsage } from "bun:jsc";
 import { describe, expect, it } from "bun:test";
 import { familySync } from "detect-libc";
 import { existsSync } from "fs";
-import { bunEnv, bunExe, isASAN, isDebug, isLinux, isMacOS, isRoot, isWindows, tempDir, tmpdirSync } from "harness";
+import {
+  bunEnv,
+  bunExe,
+  isASAN,
+  isDebug,
+  isLinux,
+  isMacOS,
+  isRoot,
+  isWindows,
+  nodeExe,
+  tempDir,
+  tmpdirSync,
+} from "harness";
 import { tmpdir } from "os";
 import { basename, join, resolve } from "path";
 import { getHeapStatistics } from "v8";
@@ -578,6 +590,32 @@ describe.skipIf(!isWindows)("a working directory spelled with the \\\\?\\ prefix
       exitCode: 0,
     });
   });
+
+  // Node.js gives the working directory as the OS gives it. Bun differs on purpose.
+  it.concurrent.skipIf(!nodeExe())("Node.js keeps the prefix in process.cwd() and path.resolve()", async () => {
+    using dir = tempDir("process-cwd-verbatim-node", {});
+    const root = String(dir);
+    const print = `console.log(JSON.stringify({ cwd: process.cwd(), pathResolve: require("node:path").resolve() }));`;
+    async function read(exe) {
+      await using proc = Bun.spawn({
+        cmd: [exe, "-e", print],
+        env: bunEnv,
+        cwd: "\\\\?\\" + root,
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+      const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+      return { out: parse(stdout), stderr, exitCode };
+    }
+    expect({ node: await read(nodeExe()), bun: await read(bunExe()) }).toEqual({
+      node: {
+        out: { cwd: "\\\\?\\" + root, pathResolve: "\\\\?\\" + root },
+        stderr: expect.any(String),
+        exitCode: 0,
+      },
+      bun: { out: { cwd: root, pathResolve: root }, stderr: "", exitCode: 0 },
+    });
+  });
 });
 
 it("process.hrtime()", async () => {