fix(ext/node): return real OS file descriptors from node:fs APIs

[bartlomieju]

Summary

Fixes #32995
Fixes #33117

• node:fs now returns real OS file descriptors instead of Deno Resource IDs. fs.openSync() returns e.g. fd 21 (a real POSIX fd) rather than a small internal RID like 3. This fixes tty.isatty() returning wrong results for opened files, since libc::isatty() now receives the actual OS fd.
• Bypasses the resource table entirely for node:fs fd operations. NodeFsState stores Rc<dyn File> directly (was HashMap<fd, ResourceId>), eliminating the fd -> rid -> resource_table -> FileResource -> File indirection.
• Positioned reads/writes use pread/pwrite (single syscall, no cursor mutation) via new read_at_sync/write_at_sync methods on the File trait, backed by FileExt::read_at/write_at (Unix) and FileExt::seek_read/seek_write (Windows). The old code used 3 seeks per positioned I/O (save+seek+restore) which was slow and produced wrong error codes.
• Partial writes handled in Rust: write_with_position loops internally until all bytes are written, so JS callers make a single op call.
• On Windows, uses DuplicateHandle to give CRT fds independent OS handle copies, preventing double-close between the File Drop and libc::close(crt_fd).
• Removes dependency on FsFile from ext:deno_fs/30_fs.js and io.* from ext:deno_io/12_io.js in the node polyfills.

This is the foundation for native addon compatibility, cross-process fd passing, and correct POSIX fd semantics in Node.js compatibility mode.

Test plan

• New unit tests: 19 tests covering real OS fd values, positioned read/write cursor preservation (pread/pwrite semantics), interleaved positioned + sequential I/O, fstat/ftruncate/fsync/fdatasync on fds, multiple independent fds, async lifecycle
• Node compat tests: test-fs-readfile-fd, test-fs-read-stream-fd, test-fs-read-stream-fd-leak, test-fs-read-stream-pos, test-fs-read-type, test-fs-promises-readfile-with-fd, test-fs-promises-writefile-with-fd, test-fs-writefile-with-fd, test-fs-write-no-fd
• Spec tests pass
• Unit tests pass
• Lint + format clean

🤖 Generated with Claude Code

[littledivy]

Is this crt_fd fd closed anywhere?

[kajukitli]

found one correctness issue here.

in ext/node/polyfills/_fs/_fs_read.ts, the async fs.read() path for position >= 0 now does:

• save current offset
• seek to position
• call op_node_fs_read_deferred(...)
• restore the old offset only in the success branch

if the read rejects, the error branch calls the callback but never seeks back to currentPosition, so a failed positioned read can permanently mutate the fd cursor. node keeps the file position unchanged for positional reads, even on failure.

that also lines up with test-fs-read-stream-pos.js getting ignored — this feels like a real regression rather than just timing sensitivity.

please restore the original offset in a finally/shared cleanup path before landing this.

[bartlomieju]

op_node_file_from_fd should be removed before landing this PR

EDIT: actually will do in a follow up PR to make this one smaller

[kajukitli]

re-review update: the earlier fs.read() cursor-restoration issue looks fixed.

found one remaining correctness bug in the write path:

in ext/node/polyfills/fs.ts, both writeSync() and async write() now implement positioned writes by doing a plain seek to position and then writing, but they never restore the original file offset afterward.

that means fs.write(fd, buf, off, len, position, cb) / fs.writeSync(fd, buf, off, len, position) mutates the fd cursor when position >= 0. node treats positional writes like pwrite-style operations: they should not change the current file position (except for the usual linux append-mode caveat).

so this still regresses code that mixes positioned and non-positioned writes on the same fd.

also worth checking the string overloads since they funnel through the same innerWrite*() helper and inherit the same behavior.

[kajukitli]

found one more correctness edge case.

file_for_fd() special-cases every fd in 0..=2 to the resource table:

if (0..=2).contains(&fd) {
  return FileResource::get_file(state, fd as ResourceId)
    .map_err(|_| ebadf());
}

but op_node_open[_sync]() now returns the real OS fd from raw_fd_for_file(file.clone()) and stores the opened file in NodeFsState.

that means if stdio has been closed and the OS reuses fd 0/1/2 for a later fs.openSync(), node will hand JS back 0, 1, or 2, but every later fd-based op (read, write, fstat, close, etc.) will target the pre-registered stdio resource instead of the newly opened file.

so this breaks valid POSIX behavior like:

fs.closeSync(0);
const fd = fs.openSync(path, "r"); // can legitimately be 0
fs.readSync(fd, ...); // would hit stdin, not the opened file

seems like file_for_fd() needs to consult NodeFsState first (including for 0/1/2), and only fall back to the resource table for actual stdio fds that were never reopened.

[littledivy]

LGTM

[bartlomieju]

Should be able to reland #33017 after this one

[littledivy]

The deferred read op does read_at_sync on the main thread for positioned reads but read_byob (truly async) for non-positioned. Any reason we can't use the async path for both? Slow I/O at a large offset could block the event loop.

[littledivy]

LGTM