Update node_fs_binding.zig

src/bun.js/bindings/bindings.zig

@@ -2162,6 +2162,67 @@ pub const AbortSignal = extern opaque {
     pub const Extern = [_][]const u8{ "create", "ref", "unref", "signal", "abortReason", "aborted", "addListener", "fromJS", "toJS", "cleanNativeBindings" };
 };
 
+pub const AsyncTask = union(Type) {
+    promise: JSPromise.Strong,
+    callback: JSC.Strong,
+
+    pub const Type = enum {
+        promise,
+        callback,
+    };
+
+    pub const Argument = union(Type) {
+        promise: void,
+        callback: JSValue,
+    };
+
+    pub const empty = AsyncTask{ .promise = .{} };
+
+    pub fn init(global: *JSC.JSGlobalObject, k: Argument) AsyncTask {
+        return switch (k) {
+            .promise => AsyncTask{ .promise = JSPromise.Strong.init(global) },
+            .callback => |callback| AsyncTask{ .callback = JSC.Strong.create(callback, global) },
+        };
+    }
+
+    pub fn value(this: *const AsyncTask) JSValue {
+        switch (this.*) {
+            .promise => |*promise| return promise.value(),
+            .callback => |*callback| return callback.get() orelse .zero,
+        }
+    }
+
+    pub fn deinit(this: *AsyncTask) void {
+        switch (this.*) {
+            .promise => |*promise| promise.deinit(),
+            .callback => |*callback| callback.deinit(),
+        }
+    }
+
+    pub fn reject(this: *AsyncTask, globalThis: *JSC.JSGlobalObject, val: JSC.JSValue) void {
+        switch (this.*) {
+            .promise => |*promise| promise.reject(globalThis, val),
+            .callback => |*callback| {
+                callback.swap().call(globalThis, .undefined, &.{
+                    val,
+                }) catch |err| globalThis.takeException(err);
+            },
+        }
+    }
+
+    pub fn resolve(this: *AsyncTask, globalThis: *JSC.JSGlobalObject, val: JSC.JSValue) void {
+        switch (this.*) {
+            .promise => |*promise| promise.resolve(globalThis, val),
+            .callback => |*callback| {
+                callback.swap().call(globalThis, .undefined, &.{
+                    .null,
+                    val,
+                }) catch |err| globalThis.takeException(err);
+            },
+        }
+    }
+};
+
 pub const JSPromise = extern struct {
     pub const shim = Shimmer("JSC", "JSPromise", @This());
     bytes: shim.Bytes,

src/bun.js/node/node_fs.zig

@@ -160,7 +160,7 @@ pub const Async = struct {
 
         comptime bun.assert(Environment.isWindows);
         return struct {
-            promise: JSC.JSPromise.Strong,
+            async_task: JSC.AsyncTask,
             args: ArgumentType,
             globalObject: *JSC.JSGlobalObject,
             req: uv.fs_t = std.mem.zeroes(uv.fs_t),
@@ -174,9 +174,9 @@ pub const Async = struct {
 
             pub usingnamespace bun.New(@This());
 
-            pub fn create(globalObject: *JSC.JSGlobalObject, this: *JSC.Node.NodeJSFS, args: ArgumentType, vm: *JSC.VirtualMachine) JSC.JSValue {
+            pub fn create(globalObject: *JSC.JSGlobalObject, this: *JSC.Node.NodeJSFS, args: ArgumentType, vm: *JSC.VirtualMachine, callback_argument: JSC.JSValue) JSC.JSValue {
                 var task = Task.new(.{
-                    .promise = JSC.JSPromise.Strong.init(globalObject),
+                    .async_task = JSC.AsyncTask.init(globalObject, if (this.is_callback_api) .{ .callback = callback_argument } else .promise),
                     .args = args,
                     .result = undefined,
                     .globalObject = globalObject,
@@ -213,7 +213,7 @@ pub const Async = struct {
                             log("uv close({}) SKIPPED", .{fd});
                             task.result = Maybe(Return.Close).success;
                             task.globalObject.bunVM().eventLoop().enqueueTask(JSC.Task.init(task));
-                            return task.promise.value();
+                            return task.async_task.value();
                         }
 
                         const rc = uv.uv_fs_close(loop, &task.req, fd, &uv_callback);
@@ -267,7 +267,7 @@ pub const Async = struct {
                     else => comptime unreachable,
                 }
 
-                return task.promise.value();
+                return task.async_task.value();
             }
 
             fn uv_callback(req: *uv.fs_t) callconv(.C) void {
@@ -296,8 +296,10 @@ pub const Async = struct {
                         break :brk out;
                     },
                 };
-                var promise_value = this.promise.value();
-                var promise = this.promise.get();
+                var promise_value = this.async_task.value();
+                var promise = this.async_task;
+                this.async_task = JSC.AsyncTask.empty;
+                defer promise.deinit();
                 promise_value.ensureStillAlive();
 
                 const tracker = this.tracker;
@@ -326,7 +328,7 @@ pub const Async = struct {
                 } else {
                     this.args.deinit();
                 }
-                this.promise.deinit();
+                this.async_task.deinit();
                 this.destroy();
             }
         };
@@ -334,7 +336,7 @@ pub const Async = struct {
 
     fn NewAsyncFSTask(comptime ReturnType: type, comptime ArgumentType: type, comptime Function: anytype) type {
         return struct {
-            promise: JSC.JSPromise.Strong,
+            async_task: JSC.AsyncTask,
             args: ArgumentType,
             globalObject: *JSC.JSGlobalObject,
             task: JSC.WorkPoolTask = .{ .callback = &workPoolCallback },
@@ -348,14 +350,15 @@ pub const Async = struct {
 
             pub fn create(
                 globalObject: *JSC.JSGlobalObject,
-                _: *JSC.Node.NodeJSFS,
+                node_fs: *JSC.Node.NodeJSFS,
                 args: ArgumentType,
                 vm: *JSC.VirtualMachine,
+                callback_argument: JSC.JSValue,
             ) JSC.JSValue {
                 var task = bun.new(
                     Task,
                     Task{
-                        .promise = JSC.JSPromise.Strong.init(globalObject),
+                        .async_task = JSC.AsyncTask.init(globalObject, if (node_fs.is_callback_api) .{ .callback = callback_argument } else .promise),
                         .args = args,
                         .result = undefined,
                         .globalObject = globalObject,
@@ -367,7 +370,7 @@ pub const Async = struct {
                 task.tracker.didSchedule(globalObject);
                 JSC.WorkPool.schedule(&task.task);
 
-                return task.promise.value();
+                return task.async_task.value();
             }
 
             fn workPoolCallback(task: *JSC.WorkPoolTask) void {
@@ -396,8 +399,10 @@ pub const Async = struct {
                         break :brk out;
                     },
                 };
-                var promise_value = this.promise.value();
-                var promise = this.promise.get();
+                var promise_value = this.async_task.value();
+                var promise = this.async_task;
+                defer promise.deinit();
+                this.async_task = JSC.AsyncTask.empty;
                 promise_value.ensureStillAlive();
 
                 const tracker = this.tracker;
@@ -426,7 +431,7 @@ pub const Async = struct {
                 } else {
                     this.args.deinit();
                 }
-                this.promise.deinit();
+                this.async_task.deinit();
                 bun.destroy(this);
             }
         };
@@ -440,7 +445,7 @@ pub fn NewAsyncCpTask(comptime is_shell: bool) type {
     const ShellTask = bun.shell.Interpreter.Builtin.Cp.ShellCpTask;
     const ShellTaskT = if (is_shell) *ShellTask else u0;
     return struct {
-        promise: JSC.JSPromise.Strong = .{},
+        async_task: JSC.AsyncTask = JSC.AsyncTask.empty,
         args: Arguments.Cp,
         evtloop: JSC.EventLoopHandle,
         task: JSC.WorkPoolTask = .{ .callback = &workPoolCallback },
@@ -547,13 +552,14 @@ pub fn NewAsyncCpTask(comptime is_shell: bool) type {
 
         pub fn create(
             globalObject: *JSC.JSGlobalObject,
-            _: *JSC.Node.NodeJSFS,
+            node_fs: *JSC.Node.NodeJSFS,
             cp_args: Arguments.Cp,
             vm: *JSC.VirtualMachine,
             arena: bun.ArenaAllocator,
+            callback_argument: JSC.JSValue,
         ) JSC.JSValue {
-            const task = createWithShellTask(globalObject, cp_args, vm, arena, 0, true);
-            return task.promise.value();
+            const task = createWithShellTask(globalObject, cp_args, vm, arena, 0, if (node_fs.is_callback_api) .{ .callback = callback_argument } else .promise);
+            return task.async_task.value();
         }
 
         pub fn createWithShellTask(
@@ -562,12 +568,12 @@ pub fn NewAsyncCpTask(comptime is_shell: bool) type {
             vm: *JSC.VirtualMachine,
             arena: bun.ArenaAllocator,
             shelltask: ShellTaskT,
-            comptime enable_promise: bool,
+            async_task_type: ?JSC.AsyncTask.Argument,
         ) *ThisAsyncCpTask {
             var task = bun.new(
                 ThisAsyncCpTask,
                 ThisAsyncCpTask{
-                    .promise = if (comptime enable_promise) JSC.JSPromise.Strong.init(globalObject) else .{},
+                    .async_task = if (async_task_type) |task_type| JSC.AsyncTask.init(globalObject, task_type) else JSC.AsyncTask.empty,
                     .args = cp_args,
                     .has_result = .{ .raw = false },
                     .result = undefined,
@@ -665,8 +671,10 @@ pub fn NewAsyncCpTask(comptime is_shell: bool) type {
                     break :brk out;
                 },
             };
-            var promise_value = this.promise.value();
-            var promise = this.promise.get();
+            var promise_value = this.async_task.value();
+            var promise = this.async_task;
+            defer promise.deinit();
+            this.async_task = JSC.AsyncTask.empty;
             promise_value.ensureStillAlive();
 
             const tracker = this.tracker;
@@ -689,7 +697,7 @@ pub fn NewAsyncCpTask(comptime is_shell: bool) type {
             this.deinitialized = true;
             if (comptime !is_shell) this.ref.unref(this.evtloop);
             this.args.deinit();
-            this.promise.deinit();
+            this.async_task.deinit();
             this.arena.deinit();
             bun.destroy(this);
         }
@@ -920,7 +928,7 @@ pub fn NewAsyncCpTask(comptime is_shell: bool) type {
 }
 
 pub const AsyncReaddirRecursiveTask = struct {
-    promise: JSC.JSPromise.Strong,
+    async_task: JSC.AsyncTask,
     args: Arguments.Readdir,
     globalObject: *JSC.JSGlobalObject,
     task: JSC.WorkPoolTask = .{ .callback = &workPoolCallback },
@@ -1024,11 +1032,19 @@ pub const AsyncReaddirRecursiveTask = struct {
 
     pub fn create(
         globalObject: *JSC.JSGlobalObject,
+        node_fs: *JSC.Node.NodeJSFS,
         args: Arguments.Readdir,
         vm: *JSC.VirtualMachine,
+        callback_argument: JSC.JSValue,
     ) JSC.JSValue {
         var task = AsyncReaddirRecursiveTask.new(.{
-            .promise = JSC.JSPromise.Strong.init(globalObject),
+            .async_task = JSC.AsyncTask.init(
+                globalObject,
+                if (node_fs.is_callback_api)
+                    .{ .callback = callback_argument }
+                else
+                    .promise,
+            ),
             .args = args,
             .has_result = .{ .raw = false },
             .globalObject = globalObject,
@@ -1047,7 +1063,7 @@ pub const AsyncReaddirRecursiveTask = struct {
 
         JSC.WorkPool.schedule(&task.task);
 
-        return task.promise.value();
+        return task.async_task.value();
     }
 
     pub fn performWork(this: *AsyncReaddirRecursiveTask, basename: [:0]const u8, buf: *bun.PathBuffer, comptime is_root: bool) void {
@@ -1223,8 +1239,10 @@ pub const AsyncReaddirRecursiveTask = struct {
 
             break :brk out;
         };
-        var promise_value = this.promise.value();
-        var promise = this.promise.get();
+        var promise_value = this.async_task.value();
+        var promise = this.async_task;
+        defer promise.deinit();
+        this.async_task = JSC.AsyncTask.empty;
         promise_value.ensureStillAlive();
 
         const tracker = this.tracker;
@@ -1252,7 +1270,7 @@ pub const AsyncReaddirRecursiveTask = struct {
         this.args.deinit();
         bun.default_allocator.free(this.root_path.slice());
         this.clearResultList();
-        this.promise.deinit();
+        this.async_task.deinit();
         this.destroy();
     }
 };

src/bun.js/node/node_fs_binding.zig

@@ -90,9 +90,17 @@ fn call(comptime FunctionEnum: NodeFSFunctionEnum) NodeFSFunction {
     const Arguments = comptime function.params[1].type.?;
     const NodeBindingClosure = struct {
         pub fn bind(this: *JSC.Node.NodeJSFS, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
-            var arguments = callframe.arguments(8);
+            var arguments = callframe.arguments(9);
+            var arguments_slice = arguments.slice();
+            var callback_argument = JSC.JSValue.zero;
+            if (this.is_callback_api) {
+                if (arguments_slice.len > 0) {
+                    callback_argument = arguments_slice[arguments_slice.len - 1].withAsyncContextIfNeeded(globalObject);
+                    arguments_slice = arguments_slice[0 .. arguments_slice.len - 1];
+                }
+            }
 
-            var slice = ArgumentsSlice.init(globalObject.bunVM(), arguments.slice());
+            var slice = ArgumentsSlice.init(globalObject.bunVM(), arguments_slice);
             slice.will_be_async = true;
             var exceptionref: JSC.C.JSValueRef = null;
             const args = if (comptime Arguments != void)
@@ -119,15 +127,15 @@ fn call(comptime FunctionEnum: NodeFSFunctionEnum) NodeFSFunction {
 
             const Task = @field(JSC.Node.Async, @tagName(FunctionEnum));
             if (comptime FunctionEnum == .cp) {
-                return Task.create(globalObject, this, args, globalObject.bunVM(), slice.arena);
+                return Task.create(globalObject, this, args, globalObject.bunVM(), slice.arena, callback_argument);
             } else {
                 if (comptime FunctionEnum == .readdir) {
                     if (args.recursive) {
-                        return JSC.Node.Async.readdir_recursive.create(globalObject, args, globalObject.bunVM());
+                        return JSC.Node.Async.readdir_recursive.create(globalObject, this, args, globalObject.bunVM(), callback_argument);
                     }
                 }
 
-                return Task.create(globalObject, this, args, globalObject.bunVM());
+                return Task.create(globalObject, this, args, globalObject.bunVM(), callback_argument);
             }
         }
     };
@@ -136,6 +144,7 @@ fn call(comptime FunctionEnum: NodeFSFunctionEnum) NodeFSFunction {
 
 pub const NodeJSFS = struct {
     node_fs: JSC.Node.NodeFS = .{},
+    is_callback_api: bool = false,
 
     pub usingnamespace JSC.Codegen.JSNodeJSFS;
     pub usingnamespace bun.New(@This());
@@ -256,13 +265,21 @@ pub const NodeJSFS = struct {
 };
 
 pub fn createBinding(globalObject: *JSC.JSGlobalObject) JSC.JSValue {
-    const module = NodeJSFS.new(.{});
-
+    const promises = NodeJSFS.new(.{
+        .is_callback_api = false,
+    });
+    const callbacks = NodeJSFS.new(.{
+        .is_callback_api = true,
+    });
     const vm = globalObject.bunVM();
-    if (vm.standalone_module_graph != null)
-        module.node_fs.vm = vm;
+    if (vm.standalone_module_graph != null) {
+        promises.node_fs.vm = vm;
+    }
 
-    return module.toJS(globalObject);
+    const array = JSC.JSValue.createEmptyObject(globalObject, 2);
+    array.putIndex(globalObject, 0, promises.toJS(globalObject));
+    array.putIndex(globalObject, 1, callbacks.toJS(globalObject));
+    return array;
 }
 
 pub fn createMemfdForTesting(globalObject: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) JSC.JSValue {

src/js/node/fs.promises.ts

@@ -1,7 +1,9 @@
 // Hardcoded module "node:fs/promises"
 import type { Dirent } from "fs";
 const EventEmitter = require("node:events");
-const fs = $zig("node_fs_binding.zig", "createBinding");
+const internalBinding = $zig("node_fs_binding.zig", "createBinding");
+
+const { 0: fs, 1: fsCallbacks } = internalBinding;
 const constants = $processBindingConstants.fs;
 
 var PromisePrototypeFinally = Promise.prototype.finally; //TODO
@@ -151,6 +153,7 @@ const private_symbols = {
   kFd,
   FileHandle: null,
   fs,
+  fsCallbacks,
 };
 
 const _readFile = fs.readFile.bind(fs);

src/js/node/fs.ts

@@ -12,7 +12,7 @@ const isDate = types.isDate;
 const ObjectSetPrototypeOf = Object.setPrototypeOf;
 
 // Private exports
-const { FileHandle, kRef, kUnref, kFd, fs } = promises.$data;
+const { FileHandle, kRef, kUnref, kFd, fs, fsCallbacks } = promises.$data;
 
 // reusing a different private symbol
 // this points to `node_fs_binding.zig`'s `createBinding` function.
@@ -156,7 +156,7 @@ var access = function access(path, mode, callback) {
 
     ensureCallback(callback);
 
-    fs.access(path, mode).then(nullcallback(callback), callback);
+    fsCallbacks.access(path, mode, callback);
   },
   appendFile = function appendFile(path, data, options, callback) {
     if (!$isCallable(callback)) {
@@ -166,13 +166,13 @@ var access = function access(path, mode, callback) {
 
     ensureCallback(callback);
 
-    fs.appendFile(path, data, options).then(nullcallback(callback), callback);
+    fsCallbacks.appendFile(path, data, options, callback);
   },
   close = function close(fd, callback) {
     if ($isCallable(callback)) {
-      fs.close(fd).then(() => callback(), callback);
+      fsCallbacks.close(fd, callback);
     } else if (callback == undefined) {
-      fs.close(fd).then(() => {});
+      fsCallbacks.close(fd, () => {});
     } else {
       callback = ensureCallback(callback);
     }
@@ -184,7 +184,7 @@ var access = function access(path, mode, callback) {
     }
 
     ensureCallback(callback);
-    fs.rm(path, options).then(nullcallback(callback), callback);
+    fsCallbacks.rm(path, options, callback);
   },
   rmdir = function rmdir(path, options, callback) {
     if ($isCallable(options)) {
@@ -192,7 +192,7 @@ var access = function access(path, mode, callback) {
       options = undefined;
     }
 
-    fs.rmdir(path, options).then(nullcallback(callback), callback);
+    fsCallbacks.rmdir(path, options, callback);
   },
   copyFile = function copyFile(src, dest, mode, callback) {
     if ($isCallable(mode)) {
@@ -202,16 +202,13 @@ var access = function access(path, mode, callback) {
 
     ensureCallback(callback);
 
-    fs.copyFile(src, dest, mode).then(nullcallback(callback), callback);
+    fsCallbacks.copyFile(src, dest, mode, callback);
   },
   exists = function exists(path, callback) {
     ensureCallback(callback);
 
     try {
-      fs.exists.$apply(fs, [path]).then(
-        existed => callback(existed),
-        _ => callback(false),
-      );
+      fsCallbacks.exists(path, callback);
     } catch (e) {
       callback(false);
     }
@@ -219,22 +216,22 @@ var access = function access(path, mode, callback) {
   chown = function chown(path, uid, gid, callback) {
     ensureCallback(callback);
 
-    fs.chown(path, uid, gid).then(nullcallback(callback), callback);
+    fsCallbacks.chown(path, uid, gid, callback);
   },
   chmod = function chmod(path, mode, callback) {
     ensureCallback(callback);
 
-    fs.chmod(path, mode).then(nullcallback(callback), callback);
+    fsCallbacks.chmod(path, mode, callback);
   },
   fchmod = function fchmod(fd, mode, callback) {
     ensureCallback(callback);
 
-    fs.fchmod(fd, mode).then(nullcallback(callback), callback);
+    fsCallbacks.fchmod(fd, mode, callback);
   },
   fchown = function fchown(fd, uid, gid, callback) {
     ensureCallback(callback);
 
-    fs.fchown(fd, uid, gid).then(nullcallback(callback), callback);
+    fsCallbacks.fchown(fd, uid, gid, callback);
   },
   fstat = function fstat(fd, options, callback) {
     if ($isCallable(options)) {
@@ -242,14 +239,12 @@ var access = function access(path, mode, callback) {
       options = undefined;
     }
 
-    fs.fstat(fd, options).then(function (stats) {
-      callback(null, stats);
-    }, callback);
+    fsCallbacks.fstat(fd, options, callback);
   },
   fsync = function fsync(fd, callback) {
     ensureCallback(callback);
 
-    fs.fsync(fd).then(nullcallback(callback), callback);
+    fsCallbacks.fsync(fd, callback);
   },
   ftruncate = function ftruncate(fd, len, callback) {
     if ($isCallable(len)) {
@@ -259,27 +254,27 @@ var access = function access(path, mode, callback) {
 
     ensureCallback(callback);
 
-    fs.ftruncate(fd, len).then(nullcallback(callback), callback);
+    fsCallbacks.ftruncate(fd, len, callback);
   },
   futimes = function futimes(fd, atime, mtime, callback) {
     ensureCallback(callback);
 
-    fs.futimes(fd, atime, mtime).then(nullcallback(callback), callback);
+    fsCallbacks.futimes(fd, atime, mtime, callback);
   },
   lchmod = function lchmod(path, mode, callback) {
     ensureCallback(callback);
 
-    fs.lchmod(path, mode).then(nullcallback(callback), callback);
+    fsCallbacks.lchmod(path, mode, callback);
   },
   lchown = function lchown(path, uid, gid, callback) {
     ensureCallback(callback);
 
-    fs.lchown(path, uid, gid).then(nullcallback(callback), callback);
+    fsCallbacks.lchown(path, uid, gid, callback);
   },
   link = function link(existingPath, newPath, callback) {
     ensureCallback(callback);
 
-    fs.link(existingPath, newPath).then(nullcallback(callback), callback);
+    fsCallbacks.link(existingPath, newPath, callback);
   },
   mkdir = function mkdir(path, options, callback) {
     if ($isCallable(options)) {
@@ -289,7 +284,7 @@ var access = function access(path, mode, callback) {
 
     ensureCallback(callback);
 
-    fs.mkdir(path, options).then(nullcallback(callback), callback);
+    fsCallbacks.mkdir(path, options, callback);
   },
   mkdtemp = function mkdtemp(prefix, options, callback) {
     if ($isCallable(options)) {
@@ -299,9 +294,7 @@ var access = function access(path, mode, callback) {
 
     ensureCallback(callback);
 
-    fs.mkdtemp(prefix, options).then(function (folder) {
-      callback(null, folder);
-    }, callback);
+    fsCallbacks.mkdtemp(prefix, options, callback);
   },
   open = function open(path, flags, mode, callback) {
     if (arguments.length < 3) {
@@ -313,14 +306,12 @@ var access = function access(path, mode, callback) {
 
     ensureCallback(callback);
 
-    fs.open(path, flags, mode).then(function (fd) {
-      callback(null, fd);
-    }, callback);
+    fsCallbacks.open(path, flags, mode, callback);
   },
   fdatasync = function fdatasync(fd, callback) {
     ensureCallback(callback);
 
-    fs.fdatasync(fd).then(nullcallback(callback), callback);
+    fsCallbacks.fdatasync(fd, callback);
   },
   read = function read(fd, buffer, offsetOrOptions, length, position, callback) {
     let offset = offsetOrOptions;
@@ -346,12 +337,9 @@ var access = function access(path, mode, callback) {
       }
       ({ offset = 0, length = buffer?.byteLength - offset, position = null } = params ?? {});
     }
-    fs.read(fd, buffer, offset, length, position).then(
-      bytesRead => {
-        callback(null, bytesRead, buffer);
-      },
-      err => callback(err),
-    );
+    fsCallbacks.read(fd, buffer, offset, length, position, (err, bytesRead) => {
+      callback(err, bytesRead, buffer);
+    });
   },
   write = function write(fd, buffer, offsetOrOptions, length, position, callback) {
     function wrapper(bytesWritten) {
@@ -362,7 +350,7 @@ var access = function access(path, mode, callback) {
       callback ||= position || length || offsetOrOptions;
       ensureCallback(callback);
 
-      fs.write(fd, buffer, offsetOrOptions, length, position).then(wrapper, callback);
+      fsCallbacks.write(fd, buffer, offsetOrOptions, length, position, wrapper);
       return;
     }
 
@@ -379,7 +367,7 @@ var access = function access(path, mode, callback) {
     callback = position;
     ensureCallback(callback);
 
-    fs.write(fd, buffer, offsetOrOptions, length).then(wrapper, callback);
+    fsCallbacks.write(fd, buffer, offsetOrOptions, length, wrapper);
   },
   readdir = function readdir(path, options, callback) {
     if ($isCallable(options)) {
@@ -389,23 +377,19 @@ var access = function access(path, mode, callback) {
 
     ensureCallback(callback);
 
-    fs.readdir(path, options).then(function (files) {
-      callback(null, files);
-    }, callback);
+    fsCallbacks.readdir(path, options, callback);
   },
   readFile = function readFile(path, options, callback) {
     callback ||= options;
     ensureCallback(callback);
 
-    fs.readFile(path, options).then(function (data) {
-      callback(null, data);
-    }, callback);
+    fsCallbacks.readFile(path, options, callback);
   },
   writeFile = function writeFile(path, data, options, callback) {
     callback ||= options;
     ensureCallback(callback);
 
-    fs.writeFile(path, data, options).then(nullcallback(callback), callback);
+    fsCallbacks.writeFile(path, data, options, callback);
   },
   readlink = function readlink(path, options, callback) {
     if ($isCallable(options)) {
@@ -415,9 +399,7 @@ var access = function access(path, mode, callback) {
 
     ensureCallback(callback);
 
-    fs.readlink(path, options).then(function (linkString) {
-      callback(null, linkString);
-    }, callback);
+    fsCallbacks.readlink(path, options, callback);
   },
   realpath = function realpath(p, options, callback) {
     if ($isCallable(options)) {
@@ -427,14 +409,12 @@ var access = function access(path, mode, callback) {
 
     ensureCallback(callback);
 
-    fs.realpath(p, options).then(function (resolvedPath) {
-      callback(null, resolvedPath);
-    }, callback);
+    fsCallbacks.realpath(p, options, callback);
   },
   rename = function rename(oldPath, newPath, callback) {
     ensureCallback(callback);
 
-    fs.rename(oldPath, newPath).then(nullcallback(callback), callback);
+    fsCallbacks.rename(oldPath, newPath, callback);
   },
   lstat = function lstat(path, options, callback) {
     if ($isCallable(options)) {
@@ -444,9 +424,7 @@ var access = function access(path, mode, callback) {
 
     ensureCallback(callback);
 
-    fs.lstat(path, options).then(function (stats) {
-      callback(null, stats);
-    }, callback);
+    fsCallbacks.lstat(path, options, callback);
   },
   stat = function stat(path, options, callback) {
     if ($isCallable(options)) {
@@ -456,9 +434,7 @@ var access = function access(path, mode, callback) {
 
     ensureCallback(callback);
 
-    fs.stat(path, options).then(function (stats) {
-      callback(null, stats);
-    }, callback);
+    fsCallbacks.stat(path, options, callback);
   },
   symlink = function symlink(target, path, type, callback) {
     if (callback === undefined) {
@@ -467,7 +443,7 @@ var access = function access(path, mode, callback) {
       type = undefined;
     }
 
-    fs.symlink(target, path, type).then(callback, callback);
+    fsCallbacks.symlink(target, path, type, callback);
   },
   truncate = function truncate(path, len, callback) {
     if (typeof path === "number") {
@@ -482,22 +458,22 @@ var access = function access(path, mode, callback) {
     }
 
     ensureCallback(callback);
-    fs.truncate(path, len).then(nullcallback(callback), callback);
+    fsCallbacks.truncate(path, len, callback);
   },
   unlink = function unlink(path, callback) {
     ensureCallback(callback);
 
-    fs.unlink(path).then(nullcallback(callback), callback);
+    fsCallbacks.unlink(path, callback);
   },
   utimes = function utimes(path, atime, mtime, callback) {
     ensureCallback(callback);
 
-    fs.utimes(path, atime, mtime).then(nullcallback(callback), callback);
+    fsCallbacks.utimes(path, atime, mtime, callback);
   },
   lutimes = function lutimes(path, atime, mtime, callback) {
     ensureCallback(callback);
 
-    fs.lutimes(path, atime, mtime).then(nullcallback(callback), callback);
+    fsCallbacks.lutimes(path, atime, mtime, callback);
   },
   accessSync = fs.accessSync.bind(fs),
   appendFileSync = fs.appendFileSync.bind(fs),
@@ -552,7 +528,7 @@ var access = function access(path, mode, callback) {
 
     callback = ensureCallback(callback);
 
-    fs.writev(fd, buffers, position).$then(bytesWritten => callback(null, bytesWritten, buffers), callback);
+    fsCallbacks.writev(fd, buffers, position, (err, bytesWritten) => callback(err, bytesWritten, buffers));
   },
   writevSync = fs.writevSync.bind(fs),
   readv = function readv(fd, buffers, position, callback) {
@@ -563,7 +539,7 @@ var access = function access(path, mode, callback) {
 
     callback = ensureCallback(callback);
 
-    fs.readv(fd, buffers, position).$then(bytesRead => callback(null, bytesRead, buffers), callback);
+    fsCallbacks.readv(fd, buffers, position, (err, bytesRead) => callback(err, bytesRead, buffers));
   },
   readvSync = fs.readvSync.bind(fs),
   Dirent = fs.Dirent,

src/shell/interpreter.zig

@@ -11068,7 +11068,7 @@ pub const Interpreter = struct {
                             vm,
                             bun.ArenaAllocator.init(bun.default_allocator),
                             this,
-                            false,
+                            null,
                         );
                     } else {
                         _ = JSC.Node.ShellAsyncCpTask.createMini(