fs.realpath: a backslash is part of the file name on POSIX, and each variant reads its path as Node does

src/js/node/fs.promises.ts

@@ -326,7 +326,7 @@ const exports = {
     return _writeFile(fileHandleOrFdOrPath, ...args);
   },
   readlink: asyncWrap(fs.readlink, "readlink"),
-  realpath: asyncWrap(fs.realpath, "realpath"),
+  realpath: asyncWrap(fs.realpathNative, "realpath"),
   rename: asyncWrap(fs.rename, "rename"),
   stat: asyncWrap(fs.stat, "stat"),
   symlink: asyncWrap(fs.symlink, "symlink"),

src/node_path/lib.rs

@@ -188,7 +188,11 @@ fn without_trailing_slash(s: &[u8]) -> &[u8] {
 #[cfg(not(windows))]
 #[inline]
 fn without_trailing_slash(s: &[u8]) -> &[u8] {
-    strings::without_trailing_slash(s)
+    let mut end = s.len();
+    while end > 1 && s[end - 1] == CHAR_FORWARD_SLASH {
+        end -= 1;
+    }
+    &s[..end]
 }
 
 fn get_cwd_u8(buf: &mut [u8]) -> MaybeBuf<'_, u8> {

src/runtime/node/node_fs.rs

@@ -213,8 +213,6 @@ pub(crate) use super::node_fs_binding::Binding;
 use bun_jsc::JSPromiseStrong;
 
 use super::dir_iterator as DirIterator;
-#[cfg(not(windows))]
-use bun_resolver::fs::FileSystem;
 
 // On POSIX the libuv-backed code paths (`UVFSRequest`, `uv_fs_*`) are absent:
 // `UVFSRequest` aliases `AsyncFSTask` and every `uv::*` reference is gated
@@ -7562,7 +7560,7 @@ impl NodeFS {
     // For `fs.realpath`, Node.js uses `lstat`, exposing the native system call under
     // `fs.realpath.native`. In Bun, the system call is the default, but the error
     // code must be changed to make it seem like it is using lstat (tests expect this),
-    // in addition, some more subtle things depend on the variant.
+    // and the path goes through `path.resolve` first, as it does in Node.js.
     pub(crate) fn realpath_inner(
         &mut self,
         args: &args::Realpath,
@@ -7595,17 +7593,8 @@ impl NodeFS {
                     ..Default::default()
                 });
             }
-            let mut buf = unsafe { bun_core::ffi::cstr(ptr) }.to_bytes();
-            if variant == RealpathVariant::Emulated {
-                // remove the trailing slash
-                //
-                // `buf` is an immutable view and every consumer below copies by
-                // length, so just shrink the slice — writing a NUL back through
-                // `ptr.cast_mut()` while `buf` is live would be Stacked-Borrows UB.
-                if buf.last() == Some(&b'\\') {
-                    buf = &buf[..buf.len() - 1];
-                }
-            }
+            let buf = unsafe { bun_core::ffi::cstr(ptr) }.to_bytes();
+            let _ = variant;
             if args.encoding == Encoding::Utf8 {
                 if let PathLike::String(s) = &args.path {
                     if strings::eql_long(s.slice(), buf, true) {
@@ -7620,27 +7609,26 @@ impl NodeFS {
         {
             let mut outbuf = bun_paths::path_buffer_pool::get();
             let inbuf = &mut self.sync_error_buf;
-            // SAFETY: single-threaded init flag (resolver/fs.rs).
-            debug_assert!(
-                bun_resolver::fs::INSTANCE_LOADED.load(core::sync::atomic::Ordering::Relaxed)
-            );
 
-            let path_slice = args.path.slice();
-            // SAFETY: instance() returns the leaked singleton; INSTANCE_LOADED checked above.
-            let fs = FileSystem::get();
-            let parts = [fs.top_level_dir, path_slice];
-            let inbuf_len = inbuf.len();
-            let Some(joined) = fs.abs_buf_checked(&parts, &mut inbuf[..inbuf_len - 1]) else {
-                return Err(sys::Error {
-                    errno: E::ENAMETOOLONG as _,
-                    syscall: sys::Tag::realpath,
-                    path: args.path.slice().into(),
-                    ..Default::default()
-                });
+            let path = match variant {
+                RealpathVariant::Native => args.path.slice_z(inbuf),
+                RealpathVariant::Emulated => {
+                    let parts = [args.path.slice()];
+                    let len = bun_node_path::resolve_buf_len(false, &parts);
+                    let mut bufs = vec![0u8; 2 * len];
+                    let (buf, buf2) = bufs.split_at_mut(len);
+                    let resolved = bun_node_path::resolve_posix_t(&parts, buf, buf2)?;
+                    if resolved.len() >= inbuf.len() {
+                        return Err(sys::Error {
+                            errno: E::ENAMETOOLONG as _,
+                            syscall: sys::Tag::realpath,
+                            path: args.path.slice().into(),
+                            ..Default::default()
+                        });
+                    }
+                    paths::resolve_path::z(resolved, inbuf)
+                }
             };
-            let path_len = joined.len();
-            inbuf[path_len] = 0;
-            let path = ZStr::from_buf(&inbuf[..], path_len);
 
             #[cfg(any(target_os = "linux", target_os = "android"))]
             let flags = sys::O::PATH; // O_PATH is faster
@@ -7658,7 +7646,6 @@ impl NodeFS {
                 Ok(buf_) => buf_,
             };
 
-            let _ = variant;
             if args.encoding == Encoding::Utf8 {
                 if let PathLike::String(s) = &args.path {
                     if strings::eql_long(s.slice(), buf, true) {

src/sys/lib.rs

@@ -7685,7 +7685,13 @@ pub fn get_fd_path<'a>(fd: Fd, out: &'a mut bun_paths::PathBuffer) -> Maybe<&'a
     #[cfg(target_os = "macos")]
     {
         out.0.fill(0);
-        fcntl(fd, libc::F_GETPATH, out.0.as_mut_ptr() as isize)?;
+        if let Err(mut err) = fcntl(fd, libc::F_GETPATH, out.0.as_mut_ptr() as isize) {
+            // `F_GETPATH` reports a path longer than `MAXPATHLEN` as `ENOSPC`.
+            if err.get_errno() == E::ENOSPC {
+                err.errno = E::ENAMETOOLONG as _;
+            }
+            return Err(err);
+        }
         // SAFETY: F_GETPATH writes a NUL-terminated string into `out`.
         let len = unsafe { libc::strlen(out.0.as_ptr().cast()) };
         return Ok(&mut out.0[..len]);

test/js/node/fs/fs.test.ts

@@ -3238,6 +3238,105 @@ it.if(isPosix)("realpathSync resolves root, regular files, and symlinks", () =>
   expect(realpathSync(linkPath)).toBe(self);
 });
 
+it.if(isPosix)("realpath reads its path the way Node does", async () => {
+  using dir = tempDir("fs-realpath-path", {
+    "file": "",
+    "y": "",
+    "dir/y": "",
+    "dir/sub/x": "",
+    "a\\b": "",
+    "a/b": "",
+    "\\c": "",
+    "C:\\d": "",
+    "w\\d/z": "",
+    "e\\/z": "",
+    "e/z": "",
+  });
+  symlinkSync("dir/sub", join(String(dir), "link"));
+
+  // fs.realpath starts from path.resolve(path). fs.realpath.native and
+  // fs.promises.realpath leave the whole path to the system.
+  const cases: [path: string, resolved: string, native: string][] = [
+    ["a\\b", "/a\\b", "/a\\b"],
+    ["\\c", "/\\c", "/\\c"],
+    ["C:\\d", "/C:\\d", "/C:\\d"],
+    ["w\\d/z", "/w\\d/z", "/w\\d/z"],
+    ["w\\d/../file", "/file", "/file"],
+    ["a\\..\\file", "ENOENT lstat", "ENOENT realpath"],
+    ["file/", "/file", "ENOTDIR realpath"],
+    ["file/..", "", "ENOTDIR realpath"],
+    ["nope/../file", "/file", "ENOENT realpath"],
+    ["link/../y", "/y", "/dir/y"],
+  ];
+
+  const script = `
+    import fs from "node:fs";
+    import { promisify } from "node:util";
+    const cwd = process.cwd();
+    const impls = [
+      fs.realpathSync,
+      promisify(fs.realpath),
+      fs.realpathSync.native,
+      promisify(fs.realpath.native),
+      fs.promises.realpath,
+    ];
+    async function run(path) {
+      const results = [];
+      for (const impl of impls) {
+        try {
+          results.push((await impl(path)).slice(cwd.length));
+        } catch (err) {
+          results.push(err.code + " " + err.syscall);
+        }
+      }
+      return results;
+    }
+    const out = [];
+    for (const path of ${JSON.stringify(cases.map(([path]) => path))}) {
+      out.push(await run(path), await run(cwd + "/" + path), await run(Buffer.from(path)));
+    }
+    out.push(await run(""));
+    process.chdir("w\\\\d");
+    out.push(await run("."), await run("z"));
+    process.chdir("../e\\\\");
+    out.push(await run("."), await run("z"));
+    console.log(JSON.stringify(out));
+  `;
+
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), "-e", script],
+    env: bunEnv,
+    cwd: String(dir),
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+
+  const row = (resolved: string, native: string) => [resolved, resolved, native, native, native];
+  expect(stderr).toBe("");
+  expect(JSON.parse(stdout)).toEqual([
+    ...cases.flatMap(([, resolved, native]) => Array(3).fill(row(resolved, native))),
+    row("", "ENOENT realpath"),
+    row("/w\\d", "/w\\d"),
+    row("/w\\d/z", "/w\\d/z"),
+    row("/e\\", "/e\\"),
+    row("/e\\/z", "/e\\/z"),
+  ]);
+  expect(exitCode).toBe(0);
+});
+
+it("promises.realpath is realpath.native", async () => {
+  const { root } = path.parse(process.cwd());
+  expect(await promises.realpath(root)).toBe(realpathSync.native(root));
+  expect(await promises.realpath(root)).toEndWith(path.sep);
+
+  using dir = tempDir("fs-promises-realpath", {});
+  await expect(promises.realpath(join(String(dir), "nope"))).rejects.toMatchObject({
+    code: "ENOENT",
+    syscall: "realpath",
+  });
+});
+
 // src/sys/sys.zig getFdPath has an exhaustive per-OS switch: .windows
 // (GetFinalPathNameByHandle), .mac (F_GETPATH), .linux (/proc/self/fd, also
 // covers Android), .freebsd (fcntl F_KINFO + struct_kinfo_file). On every
@@ -6896,13 +6995,12 @@ it("sync fs calls read a Buffer path captured at call time when an option getter
   expect(exitCode).toBe(0);
 });
 
-it.if(isPosix)("realpathSync reports ENAMETOOLONG when cwd plus the path exceeds the system path limit", async () => {
+it.if(isPosix)("realpath reports ENAMETOOLONG when cwd plus the path exceeds the system path limit", async () => {
   using dir = tempDir("fs-realpath-too-long", {});
 
-  // The relative path argument is within the per-argument limit, but joining
-  // it onto the (non-root) cwd overflows the internal fixed-size path buffer.
-  // Both realpath variants must surface this as a clean ENAMETOOLONG error
-  // instead of aborting the process.
+  // Each relative path is within the per-argument limit and only its absolute
+  // form is too long. `longPath` does not exist. `deep` does, so the native
+  // variants open it and find out when they ask for the path of the descriptor.
   const script = `
     const fs = require("node:fs");
     const longPath = "a".repeat(4090);
@@ -6914,6 +7012,24 @@ it.if(isPosix)("realpathSync reports ENAMETOOLONG when cwd plus the path exceeds
         console.log(err.code);
       }
     }
+
+    const levels = ${isLinux ? 12 : 3};
+    const nested = n => Array(n).fill(Buffer.alloc(200, "d").toString()).join("/");
+    const deep = nested(levels);
+    fs.mkdirSync(deep, { recursive: true });
+    process.chdir(deep);
+    fs.mkdirSync(deep, { recursive: true });
+    (async () => {
+      for (const impl of [fs.realpathSync, fs.realpathSync.native, fs.promises.realpath]) {
+        try {
+          await impl(deep);
+          console.log("resolved");
+        } catch (err) {
+          console.log(err.code, err.syscall);
+        }
+      }
+      for (let n = levels; n > 0; n--) fs.rmdirSync(nested(n));
+    })();
   `;
 
   await using proc = Bun.spawn({
@@ -6926,7 +7042,13 @@ it.if(isPosix)("realpathSync reports ENAMETOOLONG when cwd plus the path exceeds
   const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
 
   expect(stderr).toBe("");
-  expect(stdout.trim().split("\n")).toEqual(["ENAMETOOLONG", "ENAMETOOLONG"]);
+  expect(stdout.trim().split("\n")).toEqual([
+    "ENAMETOOLONG",
+    "ENAMETOOLONG",
+    "ENAMETOOLONG lstat",
+    "ENAMETOOLONG realpath",
+    "ENAMETOOLONG realpath",
+  ]);
   expect(exitCode).toBe(0);
 });
 

test/js/node/path/resolve.test.js

@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test";
-import { bunEnv, bunExe, isWindows } from "harness";
+import { bunEnv, bunExe, isWindows, tempDir } from "harness";
 import assert from "node:assert";
+import fs from "node:fs";
 // import child from "node:child_process";
 import path from "node:path";
 // import fixtures from "./common/fixtures.js";
@@ -200,4 +201,27 @@ describe("path.resolve", () => {
     const expectedEnding = isWindows ? "\\c" : "/c";
     assert.ok(result.endsWith(expectedEnding));
   });
+
+  test.skipIf(isWindows)("a backslash at the end of the cwd is part of its name", async () => {
+    using dir = tempDir("resolve-backslash-cwd", { "e\\/z": "" });
+
+    await using proc = Bun.spawn({
+      cmd: [
+        bunExe(),
+        "-e",
+        `const path = require("node:path");
+         console.log(JSON.stringify([path.resolve("z"), path.resolve("."), path.relative("..", "z")]));`,
+      ],
+      env: bunEnv,
+      cwd: path.join(String(dir), "e\\"),
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+
+    const cwd = fs.realpathSync(String(dir)) + "/e\\";
+    expect(stderr).toBe("");
+    expect(JSON.parse(stdout)).toEqual([cwd + "/z", cwd, "e\\/z"]);
+    expect(exitCode).toBe(0);
+  });
 });