Implement writev & readv (#3419)

* [node:fs] Implement `writev` and `readv`

* writev & readv tests

* cast to const type

* woops

* cast

---------

Co-authored-by: Jarred Sumner <709451+Jarred-Sumner@users.noreply.github.com>

9 files changed, 546 insertions, 12 deletions

diff --git a/src/bun.js/node/node_fs.zig b/src/bun.js/node/node_fs.zig
index 13d785e97..fa33a575b 100644
--- a/src/bun.js/node/node_fs.zig
+++ b/src/bun.js/node/node_fs.zig
@@ -135,6 +135,154 @@ pub const Arguments = struct {
         }
     };
 
+    pub const Writev = struct {
+        fd: FileDescriptor,
+        buffers: JSC.Node.VectorArrayBuffer,
+        position: ?u52 = 0,
+
+        pub fn deinit(_: *const @This()) void {}
+
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Writev {
+            const fd_value = arguments.nextEat() orelse {
+                if (exception.* == null) {
+                    JSC.throwInvalidArguments(
+                        "file descriptor is required",
+                        .{},
+                        ctx,
+                        exception,
+                    );
+                }
+                return null;
+            };
+
+            const fd = JSC.Node.fileDescriptorFromJS(ctx, fd_value, exception) orelse {
+                if (exception.* == null) {
+                    JSC.throwInvalidArguments(
+                        "file descriptor must be a number",
+                        .{},
+                        ctx,
+                        exception,
+                    );
+                }
+                return null;
+            };
+
+            const buffers = JSC.Node.VectorArrayBuffer.fromJS(
+                ctx,
+                arguments.protectEatNext() orelse {
+                    JSC.throwInvalidArguments("Expected an ArrayBufferView[]", .{}, ctx, exception);
+                    return null;
+                },
+                exception,
+                arguments.arena.allocator(),
+            ) orelse {
+                if (exception.* == null) {
+                    JSC.throwInvalidArguments(
+                        "buffers must be an array of TypedArray",
+                        .{},
+                        ctx,
+                        exception,
+                    );
+                }
+                return null;
+            };
+
+            var position: ?u52 = null;
+
+            if (arguments.nextEat()) |pos_value| {
+                if (!pos_value.isUndefinedOrNull()) {
+                    if (pos_value.isNumber()) {
+                        position = pos_value.to(u52);
+                    } else {
+                        JSC.throwInvalidArguments(
+                            "position must be a number",
+                            .{},
+                            ctx,
+                            exception,
+                        );
+                        return null;
+                    }
+                }
+            }
+
+            return Writev{ .fd = fd, .buffers = buffers, .position = position };
+        }
+    };
+
+    pub const Readv = struct {
+        fd: FileDescriptor,
+        buffers: JSC.Node.VectorArrayBuffer,
+        position: ?u52 = 0,
+
+        pub fn deinit(_: *const @This()) void {}
+
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Readv {
+            const fd_value = arguments.nextEat() orelse {
+                if (exception.* == null) {
+                    JSC.throwInvalidArguments(
+                        "file descriptor is required",
+                        .{},
+                        ctx,
+                        exception,
+                    );
+                }
+                return null;
+            };
+
+            const fd = JSC.Node.fileDescriptorFromJS(ctx, fd_value, exception) orelse {
+                if (exception.* == null) {
+                    JSC.throwInvalidArguments(
+                        "file descriptor must be a number",
+                        .{},
+                        ctx,
+                        exception,
+                    );
+                }
+                return null;
+            };
+
+            const buffers = JSC.Node.VectorArrayBuffer.fromJS(
+                ctx,
+                arguments.protectEatNext() orelse {
+                    JSC.throwInvalidArguments("Expected an ArrayBufferView[]", .{}, ctx, exception);
+                    return null;
+                },
+                exception,
+                arguments.arena.allocator(),
+            ) orelse {
+                if (exception.* == null) {
+                    JSC.throwInvalidArguments(
+                        "buffers must be an array of TypedArray",
+                        .{},
+                        ctx,
+                        exception,
+                    );
+                }
+                return null;
+            };
+
+            var position: ?u52 = null;
+
+            if (arguments.nextEat()) |pos_value| {
+                if (!pos_value.isUndefinedOrNull()) {
+                    if (pos_value.isNumber()) {
+                        position = pos_value.to(u52);
+                    } else {
+                        JSC.throwInvalidArguments(
+                            "position must be a number",
+                            .{},
+                            ctx,
+                            exception,
+                        );
+                        return null;
+                    }
+                }
+            }
+
+            return Readv{ .fd = fd, .buffers = buffers, .position = position };
+        }
+    };
+
     pub const FTruncate = struct {
         fd: FileDescriptor,
         len: ?JSC.WebCore.Blob.SizeType = null,
@@ -2372,6 +2520,7 @@ const Return = struct {
     pub const Mkdtemp = JSC.ZigString;
     pub const Open = FileDescriptor;
     pub const WriteFile = void;
+    pub const Readv = Read;
     pub const Read = struct {
         bytes_read: u52,
 
@@ -2480,6 +2629,8 @@ const Return = struct {
 
     pub const Chown = void;
     pub const Lutimes = void;
+
+    pub const Writev = Write;
 };
 
 /// Bun's implementation of the Node.js "fs" module
@@ -3256,6 +3407,14 @@ pub const NodeFS = struct {
             );
     }
 
+    pub fn readv(this: *NodeFS, args: Arguments.Readv, comptime flavor: Flavor) Maybe(Return.Read) {
+        return if (args.position != null) _preadv(this, args, flavor) else _readv(this, args, flavor);
+    }
+
+    pub fn writev(this: *NodeFS, args: Arguments.Writev, comptime flavor: Flavor) Maybe(Return.Write) {
+        return if (args.position != null) _pwritev(this, args, flavor) else _writev(this, args, flavor);
+    }
+
     pub fn write(this: *NodeFS, args: Arguments.Write, comptime flavor: Flavor) Maybe(Return.Write) {
         return if (args.position != null) _pwrite(this, args, flavor) else _write(this, args, flavor);
     }
@@ -3307,6 +3466,82 @@ pub const NodeFS = struct {
         return Maybe(Return.Write).todo;
     }
 
+    fn _preadv(_: *NodeFS, args: Arguments.Readv, comptime flavor: Flavor) Maybe(Return.Readv) {
+        const position = args.position.?;
+
+        switch (comptime flavor) {
+            .sync => {
+                return switch (Syscall.preadv(args.fd, args.buffers.buffers.items, position)) {
+                    .err => |err| .{
+                        .err = err,
+                    },
+                    .result => |amt| .{ .result = .{
+                        .bytes_read = @truncate(u52, amt),
+                    } },
+                };
+            },
+            else => {},
+        }
+
+        return Maybe(Return.Write).todo;
+    }
+
+    fn _readv(_: *NodeFS, args: Arguments.Readv, comptime flavor: Flavor) Maybe(Return.Readv) {
+        switch (comptime flavor) {
+            .sync => {
+                return switch (Syscall.readv(args.fd, args.buffers.buffers.items)) {
+                    .err => |err| .{
+                        .err = err,
+                    },
+                    .result => |amt| .{ .result = .{
+                        .bytes_read = @truncate(u52, amt),
+                    } },
+                };
+            },
+            else => {},
+        }
+
+        return Maybe(Return.Write).todo;
+    }
+
+    fn _pwritev(_: *NodeFS, args: Arguments.Writev, comptime flavor: Flavor) Maybe(Return.Write) {
+        const position = args.position.?;
+
+        switch (comptime flavor) {
+            .sync => {
+                return switch (Syscall.pwritev(args.fd, args.buffers.buffers.items, position)) {
+                    .err => |err| .{
+                        .err = err,
+                    },
+                    .result => |amt| .{ .result = .{
+                        .bytes_written = @truncate(u52, amt),
+                    } },
+                };
+            },
+            else => {},
+        }
+
+        return Maybe(Return.Write).todo;
+    }
+
+    fn _writev(_: *NodeFS, args: Arguments.Writev, comptime flavor: Flavor) Maybe(Return.Write) {
+        switch (comptime flavor) {
+            .sync => {
+                return switch (Syscall.writev(args.fd, args.buffers.buffers.items)) {
+                    .err => |err| .{
+                        .err = err,
+                    },
+                    .result => |amt| .{ .result = .{
+                        .bytes_written = @truncate(u52, amt),
+                    } },
+                };
+            },
+            else => {},
+        }
+
+        return Maybe(Return.Write).todo;
+    }
+
     pub fn readdir(this: *NodeFS, args: Arguments.Readdir, comptime flavor: Flavor) Maybe(Return.Readdir) {
         return switch (args.encoding) {
             .buffer => _readdir(
diff --git a/src/bun.js/node/node_fs_binding.zig b/src/bun.js/node/node_fs_binding.zig
index f178f0355..a4cc62cd3 100644
--- a/src/bun.js/node/node_fs_binding.zig
+++ b/src/bun.js/node/node_fs_binding.zig
@@ -229,6 +229,10 @@ pub const NodeJSFS = struct {
     pub const lutimesSync = callSync(.lutimes);
     pub const rmSync = callSync(.rm);
     pub const rmdirSync = callSync(.rmdir);
+    pub const writev = call(.writev);
+    pub const writevSync = callSync(.writev);
+    pub const readv = call(.readv);
+    pub const readvSync = callSync(.readv);
 
     pub const fdatasyncSync = callSync(.fdatasync);
     pub const fdatasync = call(.fdatasync);
@@ -247,8 +251,4 @@ pub const NodeJSFS = struct {
     const notimpl = fdatasync;
     pub const opendir = notimpl;
     pub const opendirSync = notimpl;
-    pub const readv = notimpl;
-    pub const readvSync = notimpl;
-    pub const writev = notimpl;
-    pub const writevSync = notimpl;
 };
diff --git a/src/bun.js/node/syscall.zig b/src/bun.js/node/syscall.zig
index 77bd5b13d..48c5b1305 100644
--- a/src/bun.js/node/syscall.zig
+++ b/src/bun.js/node/syscall.zig
@@ -106,6 +106,10 @@ pub const Tag = enum(u8) {
     waitpid,
     posix_spawn,
     getaddrinfo,
+    writev,
+    pwritev,
+    readv,
+    preadv,
     pub var strings = std.EnumMap(Tag, JSC.C.JSStringRef).initFull(null);
 };
 const PathString = @import("root").bun.PathString;
@@ -302,6 +306,154 @@ pub fn write(fd: os.fd_t, bytes: []const u8) Maybe(usize) {
     }
 }
 
+fn veclen(buffers: anytype) usize {
+    var len: usize = 0;
+    for (buffers) |buffer| {
+        len += buffer.iov_len;
+    }
+    return len;
+}
+
+pub fn writev(fd: os.fd_t, buffers: []std.os.iovec) Maybe(usize) {
+    if (comptime Environment.isMac) {
+        const rc = writev_sym(fd, @ptrCast([*]std.os.iovec_const, buffers.ptr), @intCast(i32, buffers.len));
+        if (comptime Environment.allow_assert)
+            log("writev({d}, {d}) = {d}", .{ fd, veclen(buffers), rc });
+
+        if (Maybe(usize).errnoSysFd(rc, .writev, fd)) |err| {
+            return err;
+        }
+
+        return Maybe(usize){ .result = @intCast(usize, rc) };
+    } else {
+        while (true) {
+            const rc = writev_sym(fd, @ptrCast([*]std.os.iovec_const, buffers.ptr), buffers.len);
+            if (comptime Environment.allow_assert)
+                log("writev({d}, {d}) = {d}", .{ fd, veclen(buffers), rc });
+
+            if (Maybe(usize).errnoSysFd(rc, .writev, fd)) |err| {
+                if (err.getErrno() == .INTR) continue;
+                return err;
+            }
+
+            return Maybe(usize){ .result = @intCast(usize, rc) };
+        }
+        unreachable;
+    }
+}
+
+pub fn pwritev(fd: os.fd_t, buffers: []std.os.iovec, position: isize) Maybe(usize) {
+    if (comptime Environment.isMac) {
+        const rc = pwritev_sym(fd, @ptrCast([*]std.os.iovec_const, buffers.ptr), @intCast(i32, buffers.len), position);
+        if (comptime Environment.allow_assert)
+            log("pwritev({d}, {d}) = {d}", .{ fd, veclen(buffers), rc });
+
+        if (Maybe(usize).errnoSysFd(rc, .pwritev, fd)) |err| {
+            return err;
+        }
+
+        return Maybe(usize){ .result = @intCast(usize, rc) };
+    } else {
+        while (true) {
+            const rc = pwritev_sym(fd, @ptrCast([*]std.os.iovec_const, buffers.ptr), buffers.len, position);
+            if (comptime Environment.allow_assert)
+                log("pwritev({d}, {d}) = {d}", .{ fd, veclen(buffers), rc });
+
+            if (Maybe(usize).errnoSysFd(rc, .pwritev, fd)) |err| {
+                if (err.getErrno() == .INTR) continue;
+                return err;
+            }
+
+            return Maybe(usize){ .result = @intCast(usize, rc) };
+        }
+        unreachable;
+    }
+}
+
+pub fn readv(fd: os.fd_t, buffers: []std.os.iovec) Maybe(usize) {
+    if (comptime Environment.isMac) {
+        const rc = readv_sym(fd, buffers.ptr, @intCast(i32, buffers.len));
+        if (comptime Environment.allow_assert)
+            log("readv({d}, {d}) = {d}", .{ fd, veclen(buffers), rc });
+
+        if (Maybe(usize).errnoSysFd(rc, .readv, fd)) |err| {
+            return err;
+        }
+
+        return Maybe(usize){ .result = @intCast(usize, rc) };
+    } else {
+        while (true) {
+            const rc = readv_sym(fd, buffers.ptr, buffers.len);
+            if (comptime Environment.allow_assert)
+                log("readv({d}, {d}) = {d}", .{ fd, veclen(buffers), rc });
+
+            if (Maybe(usize).errnoSysFd(rc, .readv, fd)) |err| {
+                if (err.getErrno() == .INTR) continue;
+                return err;
+            }
+
+            return Maybe(usize){ .result = @intCast(usize, rc) };
+        }
+        unreachable;
+    }
+}
+
+pub fn preadv(fd: os.fd_t, buffers: []std.os.iovec, position: isize) Maybe(usize) {
+    if (comptime Environment.isMac) {
+        const rc = preadv_sym(fd, buffers.ptr, @intCast(i32, buffers.len), position);
+        if (comptime Environment.allow_assert)
+            log("preadv({d}, {d}) = {d}", .{ fd, veclen(buffers), rc });
+
+        if (Maybe(usize).errnoSysFd(rc, .preadv, fd)) |err| {
+            return err;
+        }
+
+        return Maybe(usize){ .result = @intCast(usize, rc) };
+    } else {
+        while (true) {
+            const rc = preadv_sym(fd, buffers.ptr, buffers.len, position);
+            if (comptime Environment.allow_assert)
+                log("preadv({d}, {d}) = {d}", .{ fd, veclen(buffers), rc });
+
+            if (Maybe(usize).errnoSysFd(rc, .preadv, fd)) |err| {
+                if (err.getErrno() == .INTR) continue;
+                return err;
+            }
+
+            return Maybe(usize){ .result = @intCast(usize, rc) };
+        }
+        unreachable;
+    }
+}
+
+const preadv_sym = if (builtin.os.tag == .linux and builtin.link_libc)
+    std.os.linux.preadv
+else if (builtin.os.tag.isDarwin())
+    system.@"preadv$NOCANCEL"
+else
+    system.preadv;
+
+const readv_sym = if (builtin.os.tag == .linux and builtin.link_libc)
+    std.os.linux.readv
+else if (builtin.os.tag.isDarwin())
+    system.@"readv$NOCANCEL"
+else
+    system.readv;
+
+const pwritev_sym = if (builtin.os.tag == .linux and builtin.link_libc)
+    std.os.linux.pwritev
+else if (builtin.os.tag.isDarwin())
+    system.@"pwritev$NOCANCEL"
+else
+    system.pwritev;
+
+const writev_sym = if (builtin.os.tag == .linux and builtin.link_libc)
+    std.os.linux.writev
+else if (builtin.os.tag.isDarwin())
+    system.@"writev$NOCANCEL"
+else
+    system.writev;
+
 const pread_sym = if (builtin.os.tag == .linux and builtin.link_libc)
     sys.pread64
 else if (builtin.os.tag.isDarwin())
diff --git a/src/bun.js/node/types.zig b/src/bun.js/node/types.zig
index 659ac31bb..b01eca8e0 100644
--- a/src/bun.js/node/types.zig
+++ b/src/bun.js/node/types.zig
@@ -813,6 +813,50 @@ pub const Valid = struct {
     }
 };
 
+pub const VectorArrayBuffer = struct {
+    value: JSC.JSValue,
+    buffers: std.ArrayList(std.os.iovec),
+
+    pub fn toJS(this: VectorArrayBuffer, _: *JSC.JSGlobalObject) JSC.JSValue {
+        return this.value;
+    }
+
+    pub fn fromJS(globalObject: *JSC.JSGlobalObject, val: JSC.JSValue, exception: JSC.C.ExceptionRef, allocator: std.mem.Allocator) ?VectorArrayBuffer {
+        if (!val.jsType().isArrayLike()) {
+            JSC.throwInvalidArguments("Expected ArrayBufferView[]", .{}, globalObject, exception);
+            return null;
+        }
+
+        var bufferlist = std.ArrayList(std.os.iovec).init(allocator);
+        var i: usize = 0;
+        const len = val.getLength(globalObject);
+        bufferlist.ensureTotalCapacityPrecise(len) catch @panic("Failed to allocate memory for ArrayBuffer[]");
+
+        while (i < len) {
+            const element = val.getIndex(globalObject, @truncate(u32, i));
+
+            if (!element.isCell()) {
+                JSC.throwInvalidArguments("Expected ArrayBufferView[]", .{}, globalObject, exception);
+                return null;
+            }
+
+            const array_buffer = element.asArrayBuffer(globalObject) orelse {
+                JSC.throwInvalidArguments("Expected ArrayBufferView[]", .{}, globalObject, exception);
+                return null;
+            };
+
+            var buf = array_buffer.byteSlice();
+            bufferlist.append(std.os.iovec{
+                .iov_base = buf.ptr,
+                .iov_len = buf.len,
+            }) catch @panic("Failed to allocate memory for ArrayBuffer[]");
+            i += 1;
+        }
+
+        return VectorArrayBuffer{ .value = val, .buffers = bufferlist };
+    }
+};
+
 pub const ArgumentsSlice = struct {
     remaining: []const JSC.JSValue,
     vm: *JSC.VirtualMachine,
diff --git a/src/io/io_darwin.zig b/src/io/io_darwin.zig
index 8045cbdf6..9ebc6f4d6 100644
--- a/src/io/io_darwin.zig
+++ b/src/io/io_darwin.zig
@@ -274,7 +274,11 @@ pub const darwin = struct {
     pub extern "c" fn @"openat$NOCANCEL"(fd: c.fd_t, path: [*:0]const u8, oflag: c_uint, ...) c_int;
     pub extern "c" fn @"read$NOCANCEL"(fd: c.fd_t, buf: [*]u8, nbyte: usize) isize;
     pub extern "c" fn @"pread$NOCANCEL"(fd: c.fd_t, buf: [*]u8, nbyte: usize, offset: c.off_t) isize;
+    pub extern "c" fn @"preadv$NOCANCEL"(fd: c.fd_t, uf: [*]std.os.iovec, count: i32, offset: c.off_t) isize;
+    pub extern "c" fn @"readv$NOCANCEL"(fd: c.fd_t, uf: [*]std.os.iovec, count: i32) isize;
     pub extern "c" fn @"write$NOCANCEL"(fd: c.fd_t, buf: [*]const u8, nbyte: usize) isize;
+    pub extern "c" fn @"writev$NOCANCEL"(fd: c.fd_t, buf: [*]std.os.iovec_const, count: i32) isize;
+    pub extern "c" fn @"pwritev$NOCANCEL"(fd: c.fd_t, buf: [*]std.os.iovec_const, count: i32, offset: c.off_t) isize;
 };
 pub const OpenError = error{
     /// In WASI, this error may occur when the file descriptor does
diff --git a/src/js/node/fs.js b/src/js/node/fs.js
index 8d9f0d235..072102c35 100644
--- a/src/js/node/fs.js
+++ b/src/js/node/fs.js
@@ -5,9 +5,8 @@ import { EventEmitter } from "node:events";
 
 // Hardcoded module "node:fs"
 var { direct, isPromise, isCallable } = globalThis[Symbol.for("Bun.lazy")]("primordials");
-export { default as promises } from "node:fs/promises";
 import promises from "node:fs/promises";
-
+export { default as promises } from "node:fs/promises";
 import * as Stream from "node:stream";
 
 var fs = Bun.fs();
@@ -213,6 +212,40 @@ export var access = function access(...args) {
   lutimesSync = fs.lutimesSync.bind(fs),
   rmSync = fs.rmSync.bind(fs),
   rmdirSync = fs.rmdirSync.bind(fs),
+  writev = (fd, buffers, position, callback) => {
+    if (typeof position === "function") {
+      callback = position;
+      position = null;
+    }
+
+    queueMicrotask(() => {
+      try {
+        var written = fs.writevSync(fd, buffers, position);
+      } catch (e) {
+        callback(e);
+      }
+
+      callback(null, written, buffers);
+    });
+  },
+  writevSync = fs.writevSync.bind(fs),
+  readv = (fd, buffers, position, callback) => {
+    if (typeof position === "function") {
+      callback = position;
+      position = null;
+    }
+
+    queueMicrotask(() => {
+      try {
+        var written = fs.readvSync(fd, buffers, position);
+      } catch (e) {
+        callback(e);
+      }
+
+      callback(null, written, buffers);
+    });
+  },
+  readvSync = fs.readvSync.bind(fs),
   Dirent = fs.Dirent,
   Stats = fs.Stats,
   watch = function watch(path, options, listener) {
@@ -1069,6 +1102,10 @@ export default {
   ReadStream,
   watch,
   FSWatcher,
+  writev,
+  writevSync,
+  readv,
+  readvSync,
   [Symbol.for("::bunternal::")]: {
     ReadStreamClass,
     WriteStreamClass,
diff --git a/src/js/node/fs.promises.ts b/src/js/node/fs.promises.ts
index 7df446ccb..12278ef53 100644
--- a/src/js/node/fs.promises.ts
+++ b/src/js/node/fs.promises.ts
@@ -123,7 +123,37 @@ export var access = promisify(fs.accessSync),
   utimes = promisify(fs.utimesSync),
   lutimes = promisify(fs.lutimesSync),
   rm = promisify(fs.rmSync),
-  rmdir = promisify(fs.rmdirSync);
+  rmdir = promisify(fs.rmdirSync),
+  writev = (fd, buffers, position) => {
+    return new Promise((resolve, reject) => {
+      try {
+        var bytesWritten = fs.writevSync(fd, buffers, position);
+      } catch (err) {
+        reject(err);
+        return;
+      }
+
+      resolve({
+        bytesWritten,
+        buffers,
+      });
+    });
+  },
+  readv = (fd, buffers, position) => {
+    return new Promise((resolve, reject) => {
+      try {
+        var bytesRead = fs.readvSync(fd, buffers, position);
+      } catch (err) {
+        reject(err);
+        return;
+      }
+
+      resolve({
+        bytesRead,
+        buffers,
+      });
+    });
+  };
 
 export default {
   access,
@@ -163,6 +193,8 @@ export default {
   rm,
   rmdir,
   watch,
+  writev,
+  readv,
   constants,
   [Symbol.for("CommonJS")]: 0,
 };
diff --git a/src/js/out/modules/node/fs.js b/src/js/out/modules/node/fs.js
index 6c8269d59..b7457f104 100644
--- a/src/js/out/modules/node/fs.js
+++ b/src/js/out/modules/node/fs.js
@@ -1,6 +1,6 @@
 import {EventEmitter} from "node:events";
-import {default as default2} from "node:fs/promises";
 import promises2 from "node:fs/promises";
+import {default as default2} from "node:fs/promises";
 import * as Stream from "node:stream";
 var callbackify = function(fsFunction, args) {
   try {
@@ -133,7 +133,29 @@ var access = function access2(...args) {
   callbackify(fs.utimesSync, args);
 }, lutimes = function lutimes2(...args) {
   callbackify(fs.lutimesSync, args);
-}, accessSync = fs.accessSync.bind(fs), appendFileSync = fs.appendFileSync.bind(fs), closeSync = fs.closeSync.bind(fs), copyFileSync = fs.copyFileSync.bind(fs), existsSync = fs.existsSync.bind(fs), chownSync = fs.chownSync.bind(fs), chmodSync = fs.chmodSync.bind(fs), fchmodSync = fs.fchmodSync.bind(fs), fchownSync = fs.fchownSync.bind(fs), fstatSync = fs.fstatSync.bind(fs), fsyncSync = fs.fsyncSync.bind(fs), ftruncateSync = fs.ftruncateSync.bind(fs), futimesSync = fs.futimesSync.bind(fs), lchmodSync = fs.lchmodSync.bind(fs), lchownSync = fs.lchownSync.bind(fs), linkSync = fs.linkSync.bind(fs), lstatSync = fs.lstatSync.bind(fs), mkdirSync = fs.mkdirSync.bind(fs), mkdtempSync = fs.mkdtempSync.bind(fs), openSync = fs.openSync.bind(fs), readSync = fs.readSync.bind(fs), writeSync = fs.writeSync.bind(fs), readdirSync = fs.readdirSync.bind(fs), readFileSync = fs.readFileSync.bind(fs), writeFileSync = fs.writeFileSync.bind(fs), readlinkSync = fs.readlinkSync.bind(fs), realpathSync = fs.realpathSync.bind(fs), renameSync = fs.renameSync.bind(fs), statSync = fs.statSync.bind(fs), symlinkSync = fs.symlinkSync.bind(fs), truncateSync = fs.truncateSync.bind(fs), unlinkSync = fs.unlinkSync.bind(fs), utimesSync = fs.utimesSync.bind(fs), lutimesSync = fs.lutimesSync.bind(fs), rmSync = fs.rmSync.bind(fs), rmdirSync = fs.rmdirSync.bind(fs), Dirent = fs.Dirent, Stats = fs.Stats, watch = function watch2(path, options, listener) {
+}, accessSync = fs.accessSync.bind(fs), appendFileSync = fs.appendFileSync.bind(fs), closeSync = fs.closeSync.bind(fs), copyFileSync = fs.copyFileSync.bind(fs), existsSync = fs.existsSync.bind(fs), chownSync = fs.chownSync.bind(fs), chmodSync = fs.chmodSync.bind(fs), fchmodSync = fs.fchmodSync.bind(fs), fchownSync = fs.fchownSync.bind(fs), fstatSync = fs.fstatSync.bind(fs), fsyncSync = fs.fsyncSync.bind(fs), ftruncateSync = fs.ftruncateSync.bind(fs), futimesSync = fs.futimesSync.bind(fs), lchmodSync = fs.lchmodSync.bind(fs), lchownSync = fs.lchownSync.bind(fs), linkSync = fs.linkSync.bind(fs), lstatSync = fs.lstatSync.bind(fs), mkdirSync = fs.mkdirSync.bind(fs), mkdtempSync = fs.mkdtempSync.bind(fs), openSync = fs.openSync.bind(fs), readSync = fs.readSync.bind(fs), writeSync = fs.writeSync.bind(fs), readdirSync = fs.readdirSync.bind(fs), readFileSync = fs.readFileSync.bind(fs), writeFileSync = fs.writeFileSync.bind(fs), readlinkSync = fs.readlinkSync.bind(fs), realpathSync = fs.realpathSync.bind(fs), renameSync = fs.renameSync.bind(fs), statSync = fs.statSync.bind(fs), symlinkSync = fs.symlinkSync.bind(fs), truncateSync = fs.truncateSync.bind(fs), unlinkSync = fs.unlinkSync.bind(fs), utimesSync = fs.utimesSync.bind(fs), lutimesSync = fs.lutimesSync.bind(fs), rmSync = fs.rmSync.bind(fs), rmdirSync = fs.rmdirSync.bind(fs), writev = (fd, buffers, position, callback) => {
+  if (typeof position === "function")
+    callback = position, position = null;
+  queueMicrotask(() => {
+    try {
+      var written = fs.writevSync(fd, buffers, position);
+    } catch (e) {
+      callback(e);
+    }
+    callback(null, written, buffers);
+  });
+}, writevSync = fs.writevSync.bind(fs), readv = (fd, buffers, position, callback) => {
+  if (typeof position === "function")
+    callback = position, position = null;
+  queueMicrotask(() => {
+    try {
+      var written = fs.readvSync(fd, buffers, position);
+    } catch (e) {
+      callback(e);
+    }
+    callback(null, written, buffers);
+  });
+}, readvSync = fs.readvSync.bind(fs), Dirent = fs.Dirent, Stats = fs.Stats, watch = function watch2(path, options, listener) {
   return new FSWatcher(path, options, listener);
 }, readStreamPathFastPathSymbol = Symbol.for("Bun.Node.readStreamPathFastPath"), readStreamSymbol = Symbol.for("Bun.NodeReadStream"), readStreamPathOrFdSymbol = Symbol.for("Bun.NodeReadStreamPathOrFd"), writeStreamSymbol = Symbol.for("Bun.NodeWriteStream"), writeStreamPathFastPathSymbol = Symbol.for("Bun.NodeWriteStreamFastPath"), writeStreamPathFastPathCallSymbol = Symbol.for("Bun.NodeWriteStreamFastPathCall"), kIoDone = Symbol.for("kIoDone"), defaultReadStreamOptions = {
   file: void 0,
@@ -366,8 +388,8 @@ WriteStream = function(InternalWriteStream) {
   return WriteStreamClass = InternalWriteStream, Object.defineProperty(WriteStreamClass.prototype, Symbol.toStringTag, {
     value: "WritesStream",
     enumerable: !1
-  }), Object.defineProperty(function WriteStream(options) {
-    return new InternalWriteStream(options);
+  }), Object.defineProperty(function WriteStream(path, options) {
+    return new InternalWriteStream(path, options);
   }, Symbol.hasInstance, {
     value(instance) {
       return instance instanceof InternalWriteStream;
@@ -642,12 +664,18 @@ var fs_default = {
   ReadStream,
   watch,
   FSWatcher,
+  writev,
+  writevSync,
+  readv,
+  readvSync,
   [Symbol.for("::bunternal::")]: {
     ReadStreamClass,
     WriteStreamClass
   }
 };
 export {
+  writevSync,
+  writev,
   writeSync,
   writeFileSync,
   writeFile,
@@ -671,6 +699,8 @@ export {
   rename,
   realpathSync,
   realpath,
+  readvSync,
+  readv,
   readlinkSync,
   readlink,
   readdirSync,
diff --git a/src/js/out/modules/node/fs.promises.js b/src/js/out/modules/node/fs.promises.js
index ef3330771..549ba0c9c 100644
--- a/src/js/out/modules/node/fs.promises.js
+++ b/src/js/out/modules/node/fs.promises.js
@@ -1 +1 @@
-function H(S,C={}){const J=[];if(S instanceof URL)throw new TypeError("Watch URLs are not supported yet");else if(Buffer.isBuffer(S))S=S.toString();else if(typeof S!=="string")throw new TypeError("Expected path to be a string or Buffer");let b=null;if(typeof C==="string")C={encoding:C};return D.watch(S,C||{},(q,z)=>{if(J.push({eventType:q,filename:z}),b){const A=b;b=null,A()}}),{async*[Symbol.asyncIterator](){let q=!1;while(!q){while(J.length){let z=J.shift();if(z.eventType==="close"){q=!0;break}if(z.eventType==="error")throw q=!0,z.filename;yield z}await new Promise((z)=>b=z)}}}}var D=Bun.fs(),B="::bunternal::",G={[B]:(S)=>{var C={[B]:function(J,b,q){var z;try{z=S.apply(D,q),q=void 0}catch(A){q=void 0,b(A);return}J(z)}}[B];return async function(...J){return await new Promise((b,q)=>{process.nextTick(C,b,q,J)})}}}[B],I=G(D.accessSync),K=G(D.appendFileSync),L=G(D.closeSync),M=G(D.copyFileSync),N=G(D.existsSync),O=G(D.chownSync),P=G(D.chmodSync),Q=G(D.fchmodSync),U=G(D.fchownSync),V=G(D.fstatSync),W=G(D.fsyncSync),X=G(D.ftruncateSync),Y=G(D.futimesSync),Z=G(D.lchmodSync),_=G(D.lchownSync),$=G(D.linkSync),T=G(D.lstatSync),E=G(D.mkdirSync),j=G(D.mkdtempSync),R=G(D.openSync),k=G(D.readSync),x=G(D.writeSync),F=G(D.readdirSync),u=G(D.readFileSync),w=G(D.writeFileSync),g=G(D.readlinkSync),h=G(D.realpathSync),d=G(D.renameSync),c=G(D.statSync),v=G(D.symlinkSync),a=G(D.truncateSync),y=G(D.unlinkSync),l=G(D.utimesSync),t=G(D.lutimesSync),p=G(D.rmSync),n=G(D.rmdirSync),m={access:I,appendFile:K,close:L,copyFile:M,exists:N,chown:O,chmod:P,fchmod:Q,fchown:U,fstat:V,fsync:W,ftruncate:X,futimes:Y,lchmod:Z,lchown:_,link:$,lstat:T,mkdir:E,mkdtemp:j,open:R,read:k,write:x,readdir:F,readFile:u,writeFile:w,readlink:g,realpath:h,rename:d,stat:c,symlink:v,truncate:a,unlink:y,utimes:l,lutimes:t,rm:p,rmdir:n,watch:H,constants,[Symbol.for("CommonJS")]:0};export{w as writeFile,x as write,H as watch,l as utimes,y as unlink,a as truncate,v as symlink,c as stat,n as rmdir,p as rm,d as rename,h as realpath,g as readlink,F as readdir,u as readFile,k as read,R as open,j as mkdtemp,E as mkdir,t as lutimes,T as lstat,$ as link,_ as lchown,Z as lchmod,Y as futimes,X as ftruncate,W as fsync,V as fstat,U as fchown,Q as fchmod,N as exists,m as default,M as copyFile,L as close,O as chown,P as chmod,K as appendFile,I as access};
+function J(S,q={}){const z=[];if(S instanceof URL)throw new TypeError("Watch URLs are not supported yet");else if(Buffer.isBuffer(S))S=S.toString();else if(typeof S!=="string")throw new TypeError("Expected path to be a string or Buffer");let A=null;if(typeof q==="string")q={encoding:q};return H.watch(S,q||{},(B,C)=>{if(z.push({eventType:B,filename:C}),A){const D=A;A=null,D()}}),{async*[Symbol.asyncIterator](){let B=!1;while(!B){while(z.length){let C=z.shift();if(C.eventType==="close"){B=!0;break}if(C.eventType==="error")throw B=!0,C.filename;yield C}await new Promise((C)=>A=C)}}}}var H=Bun.fs(),G="::bunternal::",I={[G]:(S)=>{var q={[G]:function(z,A,B){var C;try{C=S.apply(H,B),B=void 0}catch(D){B=void 0,A(D);return}z(C)}}[G];return async function(...z){return await new Promise((A,B)=>{process.nextTick(q,A,B,z)})}}}[G],K=I(H.accessSync),L=I(H.appendFileSync),M=I(H.closeSync),N=I(H.copyFileSync),O=I(H.existsSync),P=I(H.chownSync),Q=I(H.chmodSync),U=I(H.fchmodSync),V=I(H.fchownSync),X=I(H.fstatSync),Y=I(H.fsyncSync),Z=I(H.ftruncateSync),_=I(H.futimesSync),$=I(H.lchmodSync),T=I(H.lchownSync),W=I(H.linkSync),k=I(H.lstatSync),E=I(H.mkdirSync),x=I(H.mkdtempSync),F=I(H.openSync),R=I(H.readSync),g=I(H.writeSync),h=I(H.readdirSync),j=I(H.readFileSync),w=I(H.writeFileSync),b=I(H.readlinkSync),u=I(H.realpathSync),d=I(H.renameSync),c=I(H.statSync),v=I(H.symlinkSync),a=I(H.truncateSync),y=I(H.unlinkSync),l=I(H.utimesSync),p=I(H.lutimesSync),m=I(H.rmSync),n=I(H.rmdirSync),t=(S,q,z)=>{return new Promise((A,B)=>{try{var C=H.writevSync(S,q,z)}catch(D){B(D);return}A({bytesWritten:C,buffers:q})})},o=(S,q,z)=>{return new Promise((A,B)=>{try{var C=H.readvSync(S,q,z)}catch(D){B(D);return}A({bytesRead:C,buffers:q})})},r={access:K,appendFile:L,close:M,copyFile:N,exists:O,chown:P,chmod:Q,fchmod:U,fchown:V,fstat:X,fsync:Y,ftruncate:Z,futimes:_,lchmod:$,lchown:T,link:W,lstat:k,mkdir:E,mkdtemp:x,open:F,read:R,write:g,readdir:h,readFile:j,writeFile:w,readlink:b,realpath:u,rename:d,stat:c,symlink:v,truncate:a,unlink:y,utimes:l,lutimes:p,rm:m,rmdir:n,watch:J,writev:t,readv:o,constants,[Symbol.for("CommonJS")]:0};export{t as writev,w as writeFile,g as write,J as watch,l as utimes,y as unlink,a as truncate,v as symlink,c as stat,n as rmdir,m as rm,d as rename,u as realpath,o as readv,b as readlink,h as readdir,j as readFile,R as read,F as open,x as mkdtemp,E as mkdir,p as lutimes,k as lstat,W as link,T as lchown,$ as lchmod,_ as futimes,Z as ftruncate,Y as fsync,X as fstat,V as fchown,U as fchmod,O as exists,r as default,N as copyFile,M as close,P as chown,Q as chmod,L as appendFile,K as access};