[bun:ffi] Implement `JSCallback` so C can call into JS

5 files changed, 460 insertions, 86 deletions

diff --git a/src/bun.js/api/FFI.h b/src/bun.js/api/FFI.h
index 1233e3e2e..4763c90a3 100644
--- a/src/bun.js/api/FFI.h
+++ b/src/bun.js/api/FFI.h
@@ -101,9 +101,16 @@ typedef void* JSContext;
 
 
 #ifdef IS_CALLBACK
-extern int64_t bun_call(JSContext, void* func,  void* thisValue, size_t len, const EncodedJSValue args[], void* exception);
-JSContext cachedJSContext;
-void* cachedCallbackFunction;
+ZIG_REPR_TYPE FFI_Callback_call(void* ctx, size_t argCount, ZIG_REPR_TYPE* args);
+// We wrap 
+static EncodedJSValue _FFI_Callback_call(void* ctx, size_t argCount, ZIG_REPR_TYPE* args)  __attribute__((__always_inline__));
+static EncodedJSValue _FFI_Callback_call(void* ctx, size_t argCount, ZIG_REPR_TYPE* args) {
+  EncodedJSValue return_value;
+  return_value.asZigRepr = FFI_Callback_call(ctx, argCount, args);
+  return return_value;
+}
+static ZIG_REPR_TYPE arguments[100];
+
 #endif
 
 static bool JSVALUE_IS_CELL(EncodedJSValue val) __attribute__((__always_inline__));
@@ -115,10 +122,10 @@ static int64_t  JSVALUE_TO_INT64(EncodedJSValue value) __attribute__((__always_i
 uint64_t JSVALUE_TO_UINT64_SLOW(EncodedJSValue value);
 int64_t  JSVALUE_TO_INT64_SLOW(EncodedJSValue value);
 
-EncodedJSValue UINT64_TO_JSVALUE_SLOW(void* globalObject, uint64_t val);
-EncodedJSValue INT64_TO_JSVALUE_SLOW(void* globalObject, int64_t val);
-static EncodedJSValue UINT64_TO_JSVALUE(void* globalObject, uint64_t val) __attribute__((__always_inline__));
-static EncodedJSValue INT64_TO_JSVALUE(void* globalObject, int64_t val) __attribute__((__always_inline__));
+EncodedJSValue UINT64_TO_JSVALUE_SLOW(void* jsGlobalObject, uint64_t val);
+EncodedJSValue INT64_TO_JSVALUE_SLOW(void* jsGlobalObject, int64_t val);
+static EncodedJSValue UINT64_TO_JSVALUE(void* jsGlobalObject, uint64_t val) __attribute__((__always_inline__));
+static EncodedJSValue INT64_TO_JSVALUE(void* jsGlobalObject, int64_t val) __attribute__((__always_inline__));
 
 
 static EncodedJSValue INT32_TO_JSVALUE(int32_t val) __attribute__((__always_inline__));
@@ -240,7 +247,7 @@ static int64_t JSVALUE_TO_INT64(EncodedJSValue value) {
   return JSVALUE_TO_INT64_SLOW(value);
 }
 
-static EncodedJSValue UINT64_TO_JSVALUE(void* globalObject, uint64_t val) {
+static EncodedJSValue UINT64_TO_JSVALUE(void* jsGlobalObject, uint64_t val) {
   if (val < MAX_INT32) {
     return INT32_TO_JSVALUE((int32_t)val);
   }
@@ -249,10 +256,10 @@ static EncodedJSValue UINT64_TO_JSVALUE(void* globalObject, uint64_t val) {
     return DOUBLE_TO_JSVALUE((double)val);
   }
 
-  return UINT64_TO_JSVALUE_SLOW(globalObject, val);
+  return UINT64_TO_JSVALUE_SLOW(jsGlobalObject, val);
 }
 
-static EncodedJSValue INT64_TO_JSVALUE(void* globalObject, int64_t val) {
+static EncodedJSValue INT64_TO_JSVALUE(void* jsGlobalObject, int64_t val) {
   if (val >= -MAX_INT32 && val <= MAX_INT32) {
     return INT32_TO_JSVALUE((int32_t)val);
   }
@@ -261,11 +268,11 @@ static EncodedJSValue INT64_TO_JSVALUE(void* globalObject, int64_t val) {
     return DOUBLE_TO_JSVALUE((double)val);
   }
 
-  return INT64_TO_JSVALUE_SLOW(globalObject, val);
+  return INT64_TO_JSVALUE_SLOW(jsGlobalObject, val);
 }
 
 #ifndef IS_CALLBACK
-ZIG_REPR_TYPE JSFunctionCall(void* globalObject, void* callFrame);
+ZIG_REPR_TYPE JSFunctionCall(void* jsGlobalObject, void* callFrame);
 
 #endif
 
diff --git a/src/bun.js/api/bun.zig b/src/bun.js/api/bun.zig
index 5189da1a7..324a6f9db 100644
--- a/src/bun.js/api/bun.zig
+++ b/src/bun.js/api/bun.zig
@@ -2603,6 +2603,9 @@ pub const FFI = struct {
             .toArrayBuffer = .{
                 .rfn = JSC.wrapWithHasContainer(@This(), "toArrayBuffer", false, false, true),
             },
+            .closeCallback = .{
+                .rfn = JSC.wrapWithHasContainer(JSC.FFI, "closeCallback", false, false, false),
+            },
         },
         .{
             .read = .{
diff --git a/src/bun.js/api/ffi.zig b/src/bun.js/api/ffi.zig
index b9053de47..e9ee4d1ab 100644
--- a/src/bun.js/api/ffi.zig
+++ b/src/bun.js/api/ffi.zig
@@ -91,6 +91,12 @@ pub const FFI = struct {
         .{},
     );
 
+    pub fn closeCallback(globalThis: *JSGlobalObject, ctx: JSValue) JSValue {
+        var function = ctx.asPtr(Function);
+        function.deinit(globalThis, bun.default_allocator);
+        return JSValue.jsUndefined();
+    }
+
     pub fn callback(globalThis: *JSGlobalObject, interface: JSC.JSValue, js_callback: JSC.JSValue) JSValue {
         JSC.markBinding(@src());
         if (!interface.isObject()) {
@@ -110,13 +116,12 @@ pub const FFI = struct {
         }
 
         // TODO: WeakRefHandle that automatically frees it?
-        JSC.C.JSValueProtect(globalThis, js_callback.asObjectRef());
         func.base_name = "";
+        js_callback.ensureStillAlive();
 
-        func.compileCallback(allocator, globalThis, js_callback.asObjectRef().?) catch return ZigString.init("Out of memory").toErrorInstance(globalThis);
+        func.compileCallback(allocator, globalThis, js_callback) catch return ZigString.init("Out of memory").toErrorInstance(globalThis);
         switch (func.step) {
             .failed => |err| {
-                JSC.C.JSValueUnprotect(globalThis, js_callback.asObjectRef());
                 const message = ZigString.init(err.msg).toErrorInstance(globalThis);
 
                 func.deinit(globalThis, allocator);
@@ -124,14 +129,19 @@ pub const FFI = struct {
                 return message;
             },
             .pending => {
-                JSC.C.JSValueUnprotect(globalThis, js_callback.asObjectRef());
                 func.deinit(globalThis, allocator);
                 return ZigString.init("Failed to compile, but not sure why. Please report this bug").toErrorInstance(globalThis);
             },
             .compiled => {
                 var function_ = bun.default_allocator.create(Function) catch unreachable;
                 function_.* = func.*;
-                return JSC.JSValue.fromPtrAddress(@ptrToInt(function_.step.compiled.ptr));
+                return JSValue.createObject2(
+                    globalThis,
+                    ZigString.static("ptr"),
+                    ZigString.static("ctx"),
+                    JSC.JSValue.fromPtrAddress(@ptrToInt(function_.step.compiled.ptr)),
+                    JSC.JSValue.fromPtrAddress(@ptrToInt(function_)),
+                );
             },
         }
     }
@@ -179,7 +189,7 @@ pub const FFI = struct {
 
         function.base_name = "my_callback_function";
 
-        function.printCallbackSourceCode(&writer) catch {
+        function.printCallbackSourceCode(null, null, &writer) catch {
             return ZigString.init("Error while printing code").toErrorInstance(global);
         };
         return ZigString.init(arraylist.items).toValueGC(global);
@@ -628,6 +638,8 @@ pub const FFI = struct {
 
         pub var lib_dirZ: [*:0]const u8 = "";
 
+        extern "C" fn FFICallbackFunctionWrapper_destroy(*anyopaque) void;
+
         pub fn deinit(val: *Function, globalThis: *JSC.JSGlobalObject, allocator: std.mem.Allocator) void {
             if (val.base_name) |base_name| {
                 if (std.mem.span(base_name).len > 0) {
@@ -649,6 +661,11 @@ pub const FFI = struct {
                     // _ = JSC.untrackFunction(globalThis, val.step.compiled.js_function);
                     val.step.compiled.js_function = .zero;
                 }
+
+                if (val.step.compiled.ffi_callback_function_wrapper) |wrapper| {
+                    FFICallbackFunctionWrapper_destroy(wrapper);
+                    val.step.compiled.ffi_callback_function_wrapper = null;
+                }
             }
 
             if (val.step == .failed and val.step.failed.allocated) {
@@ -660,10 +677,10 @@ pub const FFI = struct {
             pending: void,
             compiled: struct {
                 ptr: *anyopaque,
-                fast_path_ptr: ?*anyopaque = null,
                 buf: []u8,
                 js_function: JSValue = JSValue.zero,
                 js_context: ?*anyopaque = null,
+                ffi_callback_function_wrapper: ?*anyopaque = null,
             },
             failed: struct {
                 msg: []const u8,
@@ -796,7 +813,8 @@ pub const FFI = struct {
             }
 
             if (relocation_size < 0) {
-                this.step = .{ .failed = .{ .msg = "tcc_relocate returned a negative value" } };
+                if (this.step != .failed)
+                    this.step = .{ .failed = .{ .msg = "tcc_relocate returned a negative value" } };
                 return;
             }
 
@@ -891,14 +909,13 @@ pub const FFI = struct {
         pub fn compileCallback(
             this: *Function,
             allocator: std.mem.Allocator,
-            js_context: *anyopaque,
-            js_function: *anyopaque,
+            js_context: *JSC.JSGlobalObject,
+            js_function: JSValue,
         ) !void {
-            Output.debug("welcome", .{});
             var source_code = std.ArrayList(u8).init(allocator);
             var source_code_writer = source_code.writer();
-            try this.printCallbackSourceCode(&source_code_writer);
-            Output.debug("helllooo", .{});
+            var ffi_wrapper = Bun__createFFICallbackFunction(js_context, js_function);
+            try this.printCallbackSourceCode(js_context, ffi_wrapper, &source_code_writer);
             try source_code.append(0);
             // defer source_code.deinit();
             var state = TCC.tcc_new() orelse return error.TCCMissing;
@@ -920,7 +937,6 @@ pub const FFI = struct {
                 state,
                 source_code.items.ptr,
             );
-            Output.debug("compile", .{});
             // did tcc report an error?
             if (this.step == .failed) {
                 return;
@@ -934,13 +950,30 @@ pub const FFI = struct {
             }
 
             CompilerRT.inject(state);
-            Output.debug("here", .{});
-            _ = TCC.tcc_add_symbol(state, "bun_call", workaround.bun_call.*);
-            _ = TCC.tcc_add_symbol(state, "cachedJSContext", js_context);
-            _ = TCC.tcc_add_symbol(state, "cachedCallbackFunction", js_function);
-
+            _ = TCC.tcc_add_symbol(
+                state,
+                "FFI_Callback_call",
+                // TODO: stage2 - make these ptrs
+                switch (this.arg_types.items.len) {
+                    0 => FFI_Callback_call_0,
+                    1 => FFI_Callback_call_1,
+                    2 => FFI_Callback_call_2,
+                    3 => FFI_Callback_call_3,
+                    4 => FFI_Callback_call_4,
+                    5 => FFI_Callback_call_5,
+                    6 => FFI_Callback_call_6,
+                    7 => FFI_Callback_call_7,
+                    else => FFI_Callback_call,
+                },
+            );
             var relocation_size = TCC.tcc_relocate(state, null);
-            if (relocation_size == 0) return;
+
+            if (relocation_size < 0) {
+                if (this.step != .failed)
+                    this.step = .{ .failed = .{ .msg = "tcc_relocate returned a negative value" } };
+                return;
+            }
+
             var bytes: []u8 = try allocator.rawAlloc(@intCast(usize, relocation_size), 16, 16, 0);
             defer {
                 if (this.step == .failed) {
@@ -966,8 +999,9 @@ pub const FFI = struct {
                 .compiled = .{
                     .ptr = symbol,
                     .buf = bytes,
-                    .js_function = JSC.JSValue.fromPtr(js_function),
+                    .js_function = js_function,
                     .js_context = js_context,
+                    .ffi_callback_function_wrapper = ffi_wrapper,
                 },
             };
         }
@@ -1021,7 +1055,7 @@ pub const FFI = struct {
                 \\
                 \\
                 \\/* ---- Your Wrapper Function ---- */
-                \\ZIG_REPR_TYPE JSFunctionCall(void* globalObject, void* callFrame) {
+                \\ZIG_REPR_TYPE JSFunctionCall(void* JS_GLOBAL_OBJECT, void* callFrame) {
                 \\
             );
 
@@ -1125,10 +1159,24 @@ pub const FFI = struct {
             try writer.writeAll(";\n}\n\n");
         }
 
+        extern fn FFI_Callback_call(*anyopaque, usize, [*]JSValue) JSValue;
+        extern fn FFI_Callback_call_0(*anyopaque, usize, [*]JSValue) JSValue;
+        extern fn FFI_Callback_call_1(*anyopaque, usize, [*]JSValue) JSValue;
+        extern fn FFI_Callback_call_2(*anyopaque, usize, [*]JSValue) JSValue;
+        extern fn FFI_Callback_call_3(*anyopaque, usize, [*]JSValue) JSValue;
+        extern fn FFI_Callback_call_4(*anyopaque, usize, [*]JSValue) JSValue;
+        extern fn FFI_Callback_call_5(*anyopaque, usize, [*]JSValue) JSValue;
+        extern fn FFI_Callback_call_6(*anyopaque, usize, [*]JSValue) JSValue;
+        extern fn FFI_Callback_call_7(*anyopaque, usize, [*]JSValue) JSValue;
+        extern fn Bun__createFFICallbackFunction(*JSC.JSGlobalObject, JSValue) *anyopaque;
+
         pub fn printCallbackSourceCode(
             this: *Function,
+            globalObject: ?*JSC.JSGlobalObject,
+            context_ptr: ?*anyopaque,
             writer: anytype,
         ) !void {
+            try writer.print("#define JS_GLOBAL_OBJECT (void*)0x{X}UL\n", .{@ptrToInt(globalObject)});
             try writer.writeAll("#define IS_CALLBACK 1\n");
 
             brk: {
@@ -1193,44 +1241,40 @@ pub const FFI = struct {
             first = true;
 
             if (this.arg_types.items.len > 0) {
-                try writer.print("  EncodedJSValue arguments[{d}] = {{\n", .{this.arg_types.items.len});
-
                 var arg_buf: [512]u8 = undefined;
                 arg_buf[0.."arg".len].* = "arg".*;
                 for (this.arg_types.items) |arg, i| {
                     const printed = std.fmt.bufPrintIntToSlice(arg_buf["arg".len..], i, 10, .lower, .{});
                     const arg_name = arg_buf[0 .. "arg".len + printed.len];
-                    try writer.print("    {}", .{arg.toJS(arg_name)});
-                    if (i < this.arg_types.items.len - 1) {
-                        try writer.writeAll(",\n");
-                    }
+                    try writer.print("arguments[{d}] = {}.asZigRepr;\n", .{ i, arg.toJS(arg_name) });
                 }
-                try writer.writeAll("\n  };\n");
-            } else {
-                try writer.writeAll(" EncodedJSValue arguments[1] = {{0}};\n");
             }
 
             try writer.writeAll("  ");
-            if (!(this.return_type == .void)) {
-                try writer.writeAll("EncodedJSValue return_value = {");
-            }
-            // JSC.C.JSObjectCallAsFunction(
-            //     ctx,
-            //     object,
-            //     thisObject,
-            //     argumentCount,
-            //     arguments,
-            //     exception,
-            // );
-            try writer.writeAll("bun_call(cachedJSContext, cachedCallbackFunction, (void*)0, ");
+            var inner_buf_: [372]u8 = undefined;
+            var inner_buf: []u8 = &.{};
             if (this.arg_types.items.len > 0) {
-                try writer.print("{d}, &arguments[0], (void*)0)", .{this.arg_types.items.len});
+                inner_buf = try std.fmt.bufPrint(
+                    inner_buf_[1..],
+                    "FFI_Callback_call((void*)0x{X}UL, {d}, arguments)",
+                    .{ @ptrToInt(context_ptr), this.arg_types.items.len },
+                );
             } else {
-                try writer.writeAll("0, &arguments[0], (void*)0)");
+                inner_buf = try std.fmt.bufPrint(
+                    inner_buf_[1..],
+                    "FFI_Callback_call((void*)0x{X}UL, 0, (ZIG_REPR_TYPE*)0)",
+                    .{
+                        @ptrToInt(context_ptr),
+                    },
+                );
             }
-
-            if (this.return_type != .void) {
-                try writer.print("}};\n  return {}", .{this.return_type.toC("return_value")});
+            if (this.return_type == .void) {
+                try writer.writeAll(inner_buf);
+            } else {
+                const len = inner_buf.len + 1;
+                inner_buf = inner_buf_[0..len];
+                inner_buf[0] = '_';
+                try writer.print("return {s}", .{this.return_type.toCExact(inner_buf)});
             }
 
             try writer.writeAll(";\n}\n\n");
@@ -1267,6 +1311,8 @@ pub const FFI = struct {
         i64_fast = 15,
         u64_fast = 16,
 
+        function = 17,
+
         /// Types that we can directly pass through as an `int64_t`
         pub fn needsACastInC(this: ABIType) bool {
             return switch (this) {
@@ -1311,6 +1357,9 @@ pub const FFI = struct {
             .{ "cstring", ABIType.@"cstring" },
             .{ "i64_fast", ABIType.i64_fast },
             .{ "u64_fast", ABIType.u64_fast },
+            .{ "function", ABIType.function },
+            .{ "callback", ABIType.callback },
+            .{ "fn", ABIType.function },
         };
         pub const label = ComptimeStringMap(ABIType, map);
         const EnumMapFormatter = struct {
@@ -1362,32 +1411,58 @@ pub const FFI = struct {
         const ToCFormatter = struct {
             symbol: string,
             tag: ABIType,
+            exact: bool = false,
 
             pub fn format(self: ToCFormatter, comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
                 switch (self.tag) {
-                    .void => {},
+                    .void => {
+                        return;
+                    },
                     .bool => {
-                        try writer.print("JSVALUE_TO_BOOL({s})", .{self.symbol});
+                        if (self.exact)
+                            try writer.writeAll("(bool)");
+                        try writer.writeAll("JSVALUE_TO_BOOL(");
                     },
                     .char, .int8_t, .uint8_t, .int16_t, .uint16_t, .int32_t, .uint32_t => {
-                        try writer.print("JSVALUE_TO_INT32({s})", .{self.symbol});
+                        if (self.exact)
+                            try writer.print("({s})", .{std.mem.span(@tagName(self.tag))});
+
+                        try writer.writeAll("JSVALUE_TO_INT32(");
                     },
                     .i64_fast, .int64_t => {
-                        try writer.print("JSVALUE_TO_INT64({s})", .{self.symbol});
+                        if (self.exact)
+                            try writer.writeAll("(int64_t)");
+                        try writer.writeAll("JSVALUE_TO_INT64(");
                     },
                     .u64_fast, .uint64_t => {
-                        try writer.print("JSVALUE_TO_UINT64({s})", .{self.symbol});
+                        if (self.exact)
+                            try writer.writeAll("(uint64_t)");
+                        try writer.writeAll("JSVALUE_TO_UINT64(");
                     },
-                    .cstring, .ptr => {
-                        try writer.print("JSVALUE_TO_PTR({s})", .{self.symbol});
+                    .function, .cstring, .ptr => {
+                        if (self.exact)
+                            try writer.writeAll("(void*)");
+                        try writer.writeAll("JSVALUE_TO_PTR(");
                     },
                     .double => {
-                        try writer.print("JSVALUE_TO_DOUBLE({s})", .{self.symbol});
+                        if (self.exact)
+                            try writer.writeAll("(double)");
+                        try writer.writeAll("JSVALUE_TO_DOUBLE(");
                     },
                     .float => {
-                        try writer.print("JSVALUE_TO_FLOAT({s})", .{self.symbol});
+                        if (self.exact)
+                            try writer.writeAll("(float)");
+                        try writer.writeAll("JSVALUE_TO_FLOAT(");
                     },
                 }
+                // if (self.fromi64) {
+                //     try writer.writeAll("EncodedJSValue{ ");
+                // }
+                try writer.writeAll(self.symbol);
+                // if (self.fromi64) {
+                //     try writer.writeAll(", }");
+                // }
+                try writer.writeAll(")");
             }
         };
 
@@ -1401,22 +1476,22 @@ pub const FFI = struct {
                     .bool => {
                         try writer.print("BOOLEAN_TO_JSVALUE({s})", .{self.symbol});
                     },
-                    .char, .int8_t, .uint8_t, .int16_t, .uint16_t, .int32_t, .uint32_t => {
-                        try writer.print("INT32_TO_JSVALUE({s})", .{self.symbol});
+                    .char, .int8_t, .uint8_t, .int16_t, .uint16_t, .int32_t => {
+                        try writer.print("INT32_TO_JSVALUE((int32_t){s})", .{self.symbol});
                     },
-                    .i64_fast => {
-                        try writer.print("INT64_TO_JSVALUE(globalObject, {s})", .{self.symbol});
+                    .uint32_t, .i64_fast => {
+                        try writer.print("INT64_TO_JSVALUE(JS_GLOBAL_OBJECT, (int64_t){s})", .{self.symbol});
                     },
                     .int64_t => {
-                        try writer.print("INT64_TO_JSVALUE_SLOW(globalObject, {s})", .{self.symbol});
+                        try writer.print("INT64_TO_JSVALUE_SLOW(JS_GLOBAL_OBJECT, {s})", .{self.symbol});
                     },
                     .u64_fast => {
-                        try writer.print("UINT64_TO_JSVALUE(globalObject, {s})", .{self.symbol});
+                        try writer.print("UINT64_TO_JSVALUE(JS_GLOBAL_OBJECT, {s})", .{self.symbol});
                     },
                     .uint64_t => {
-                        try writer.print("UINT64_TO_JSVALUE_SLOW(globalObject, {s})", .{self.symbol});
+                        try writer.print("UINT64_TO_JSVALUE_SLOW(JS_GLOBAL_OBJECT, {s})", .{self.symbol});
                     },
-                    .cstring, .ptr => {
+                    .function, .cstring, .ptr => {
                         try writer.print("PTR_TO_JSVALUE({s})", .{self.symbol});
                     },
                     .double => {
@@ -1433,6 +1508,10 @@ pub const FFI = struct {
             return ToCFormatter{ .tag = this, .symbol = symbol };
         }
 
+        pub fn toCExact(this: ABIType, symbol: string) ToCFormatter {
+            return ToCFormatter{ .tag = this, .symbol = symbol, .exact = true };
+        }
+
         pub fn toJS(
             this: ABIType,
             symbol: string,
@@ -1449,7 +1528,7 @@ pub const FFI = struct {
 
         pub fn typenameLabel(this: ABIType) []const u8 {
             return switch (this) {
-                .cstring, .ptr => "void*",
+                .function, .cstring, .ptr => "void*",
                 .bool => "bool",
                 .int8_t => "int8_t",
                 .uint8_t => "uint8_t",
diff --git a/src/bun.js/bindings/JSFFIFunction.cpp b/src/bun.js/bindings/JSFFIFunction.cpp
index 07fefac1f..66fdc701d 100644
--- a/src/bun.js/bindings/JSFFIFunction.cpp
+++ b/src/bun.js/bindings/JSFFIFunction.cpp
@@ -36,6 +36,40 @@
 #include "DOMJITIDLTypeFilter.h"
 #include "DOMJITHelpers.h"
 
+class FFICallbackFunctionWrapper {
+
+    WTF_MAKE_FAST_ALLOCATED;
+
+public:
+    JSC::Strong<JSC::JSFunction> m_function;
+    JSC::Strong<Zig::GlobalObject> globalObject;
+    ~FFICallbackFunctionWrapper() = default;
+
+    FFICallbackFunctionWrapper(JSC::JSFunction* function, Zig::GlobalObject* globalObject)
+        : m_function(globalObject->vm(), function)
+        , globalObject(globalObject->vm(), globalObject)
+    {
+    }
+};
+extern "C" void FFICallbackFunctionWrapper_destroy(FFICallbackFunctionWrapper* wrapper)
+{
+    delete wrapper;
+}
+
+extern "C" FFICallbackFunctionWrapper* Bun__createFFICallbackFunction(
+    Zig::GlobalObject* globalObject,
+    JSC::EncodedJSValue callbackFn)
+{
+    auto* vm = &globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(*vm);
+
+    auto* callbackFunction = jsCast<JSC::JSFunction*>(JSC::JSValue::decode(callbackFn));
+
+    auto* wrapper = new FFICallbackFunctionWrapper(callbackFunction, globalObject);
+
+    return wrapper;
+}
+
 extern "C" Zig::JSFFIFunction* Bun__CreateFFIFunction(Zig::GlobalObject* globalObject, const ZigString* symbolName, unsigned argCount, Zig::FFIFunction functionPointer, bool strong)
 {
     JSC::VM& vm = globalObject->vm();
@@ -96,3 +130,208 @@ JSFFIFunction* JSFFIFunction::create(VM& vm, Zig::GlobalObject* globalObject, un
 }
 
 } // namespace JSC
+
+extern "C" JSC::EncodedJSValue
+FFI_Callback_call(FFICallbackFunctionWrapper& wrapper, size_t argCount, JSC::EncodedJSValue* args)
+{
+    auto* function = wrapper.m_function.get();
+    auto* globalObject = wrapper.globalObject.get();
+    auto& vm = globalObject->vm();
+    JSC::MarkedArgumentBuffer arguments;
+    for (size_t i = 0; i < argCount; ++i)
+        arguments.appendWithCrashOnOverflow(JSC::JSValue::decode(args[i]));
+    WTF::NakedPtr<JSC::Exception> exception;
+    auto result = JSC::call(globalObject, function, JSC::getCallData(function), JSC::jsUndefined(), arguments, exception);
+    if (UNLIKELY(exception)) {
+        auto scope = DECLARE_THROW_SCOPE(vm);
+        scope.throwException(globalObject, exception);
+        return JSC::JSValue::encode(JSC::jsNull());
+    }
+
+    return JSC::JSValue::encode(result);
+}
+
+extern "C" JSC::EncodedJSValue
+FFI_Callback_call_0(FFICallbackFunctionWrapper& wrapper, size_t argCount, JSC::EncodedJSValue* args)
+{
+    auto* function = wrapper.m_function.get();
+    auto* globalObject = wrapper.globalObject.get();
+    auto& vm = globalObject->vm();
+
+    JSC::MarkedArgumentBuffer arguments;
+
+    WTF::NakedPtr<JSC::Exception> exception;
+    auto result = JSC::call(globalObject, function, JSC::getCallData(function), JSC::jsUndefined(), arguments, exception);
+    if (UNLIKELY(exception)) {
+        auto scope = DECLARE_THROW_SCOPE(vm);
+        scope.throwException(globalObject, exception);
+        return JSC::JSValue::encode(JSC::jsNull());
+    }
+
+    return JSC::JSValue::encode(result);
+}
+
+extern "C" JSC::EncodedJSValue
+FFI_Callback_call_1(FFICallbackFunctionWrapper& wrapper, size_t argCount, JSC::EncodedJSValue* args)
+{
+    auto* function = wrapper.m_function.get();
+    auto* globalObject = wrapper.globalObject.get();
+    auto& vm = globalObject->vm();
+
+    JSC::MarkedArgumentBuffer arguments;
+    arguments.append(JSC::JSValue::decode(args[0]));
+
+    WTF::NakedPtr<JSC::Exception> exception;
+    auto result = JSC::call(globalObject, function, JSC::getCallData(function), JSC::jsUndefined(), arguments, exception);
+    if (UNLIKELY(exception)) {
+        auto scope = DECLARE_THROW_SCOPE(vm);
+        scope.throwException(globalObject, exception);
+        return JSC::JSValue::encode(JSC::jsNull());
+    }
+
+    return JSC::JSValue::encode(result);
+}
+
+extern "C" JSC::EncodedJSValue
+FFI_Callback_call_2(FFICallbackFunctionWrapper& wrapper, size_t argCount, JSC::EncodedJSValue* args)
+{
+    auto* function = wrapper.m_function.get();
+    auto* globalObject = wrapper.globalObject.get();
+    auto& vm = globalObject->vm();
+
+    JSC::MarkedArgumentBuffer arguments;
+    arguments.append(JSC::JSValue::decode(args[0]));
+    arguments.append(JSC::JSValue::decode(args[1]));
+
+    WTF::NakedPtr<JSC::Exception> exception;
+    auto result = JSC::call(globalObject, function, JSC::getCallData(function), JSC::jsUndefined(), arguments, exception);
+    if (UNLIKELY(exception)) {
+        auto scope = DECLARE_THROW_SCOPE(vm);
+        scope.throwException(globalObject, exception);
+        return JSC::JSValue::encode(JSC::jsNull());
+    }
+
+    return JSC::JSValue::encode(result);
+}
+
+extern "C" JSC::EncodedJSValue FFI_Callback_call_3(FFICallbackFunctionWrapper& wrapper, size_t argCount, JSC::EncodedJSValue* args)
+{
+    auto* function = wrapper.m_function.get();
+    auto* globalObject = wrapper.globalObject.get();
+    auto& vm = globalObject->vm();
+
+    JSC::MarkedArgumentBuffer arguments;
+    arguments.append(JSC::JSValue::decode(args[0]));
+    arguments.append(JSC::JSValue::decode(args[1]));
+    arguments.append(JSC::JSValue::decode(args[2]));
+
+    WTF::NakedPtr<JSC::Exception> exception;
+    auto result = JSC::call(globalObject, function, JSC::getCallData(function), JSC::jsUndefined(), arguments, exception);
+    if (UNLIKELY(exception)) {
+        auto scope = DECLARE_THROW_SCOPE(vm);
+        scope.throwException(globalObject, exception);
+        return JSC::JSValue::encode(JSC::jsNull());
+    }
+
+    return JSC::JSValue::encode(result);
+}
+
+extern "C" JSC::EncodedJSValue FFI_Callback_call_4(FFICallbackFunctionWrapper& wrapper, size_t argCount, JSC::EncodedJSValue* args)
+{
+    auto* function = wrapper.m_function.get();
+    auto* globalObject = wrapper.globalObject.get();
+    auto& vm = globalObject->vm();
+
+    JSC::MarkedArgumentBuffer arguments;
+    arguments.append(JSC::JSValue::decode(args[0]));
+    arguments.append(JSC::JSValue::decode(args[1]));
+    arguments.append(JSC::JSValue::decode(args[2]));
+    arguments.append(JSC::JSValue::decode(args[3]));
+
+    WTF::NakedPtr<JSC::Exception> exception;
+    auto result = JSC::call(globalObject, function, JSC::getCallData(function), JSC::jsUndefined(), arguments, exception);
+    if (UNLIKELY(exception)) {
+        auto scope = DECLARE_THROW_SCOPE(vm);
+        scope.throwException(globalObject, exception);
+        return JSC::JSValue::encode(JSC::jsNull());
+    }
+
+    return JSC::JSValue::encode(result);
+}
+
+extern "C" JSC::EncodedJSValue FFI_Callback_call_5(FFICallbackFunctionWrapper& wrapper, size_t argCount, JSC::EncodedJSValue* args)
+{
+    auto* function = wrapper.m_function.get();
+    auto* globalObject = wrapper.globalObject.get();
+    auto& vm = globalObject->vm();
+
+    JSC::MarkedArgumentBuffer arguments;
+    arguments.append(JSC::JSValue::decode(args[0]));
+    arguments.append(JSC::JSValue::decode(args[1]));
+    arguments.append(JSC::JSValue::decode(args[2]));
+    arguments.append(JSC::JSValue::decode(args[3]));
+    arguments.append(JSC::JSValue::decode(args[4]));
+
+    WTF::NakedPtr<JSC::Exception> exception;
+    auto result = JSC::call(globalObject, function, JSC::getCallData(function), JSC::jsUndefined(), arguments, exception);
+    if (UNLIKELY(exception)) {
+        auto scope = DECLARE_THROW_SCOPE(vm);
+        scope.throwException(globalObject, exception);
+        return JSC::JSValue::encode(JSC::jsNull());
+    }
+
+    return JSC::JSValue::encode(result);
+}
+
+extern "C" JSC::EncodedJSValue
+FFI_Callback_call_6(FFICallbackFunctionWrapper& wrapper, size_t argCount, JSC::EncodedJSValue* args)
+{
+    auto* function = wrapper.m_function.get();
+    auto* globalObject = wrapper.globalObject.get();
+    auto& vm = globalObject->vm();
+
+    JSC::MarkedArgumentBuffer arguments;
+    arguments.append(JSC::JSValue::decode(args[0]));
+    arguments.append(JSC::JSValue::decode(args[1]));
+    arguments.append(JSC::JSValue::decode(args[2]));
+    arguments.append(JSC::JSValue::decode(args[3]));
+    arguments.append(JSC::JSValue::decode(args[4]));
+    arguments.append(JSC::JSValue::decode(args[5]));
+
+    WTF::NakedPtr<JSC::Exception> exception;
+    auto result = JSC::call(globalObject, function, JSC::getCallData(function), JSC::jsUndefined(), arguments, exception);
+    if (UNLIKELY(exception)) {
+        auto scope = DECLARE_THROW_SCOPE(vm);
+        scope.throwException(globalObject, exception);
+        return JSC::JSValue::encode(JSC::jsNull());
+    }
+
+    return JSC::JSValue::encode(result);
+}
+
+extern "C" JSC::EncodedJSValue
+FFI_Callback_call_7(FFICallbackFunctionWrapper& wrapper, size_t argCount, JSC::EncodedJSValue* args)
+{
+    auto* function = wrapper.m_function.get();
+    auto* globalObject = wrapper.globalObject.get();
+    auto& vm = globalObject->vm();
+
+    JSC::MarkedArgumentBuffer arguments;
+    arguments.append(JSC::JSValue::decode(args[0]));
+    arguments.append(JSC::JSValue::decode(args[1]));
+    arguments.append(JSC::JSValue::decode(args[2]));
+    arguments.append(JSC::JSValue::decode(args[3]));
+    arguments.append(JSC::JSValue::decode(args[4]));
+    arguments.append(JSC::JSValue::decode(args[5]));
+    arguments.append(JSC::JSValue::decode(args[6]));
+
+    WTF::NakedPtr<JSC::Exception> exception;
+    auto result = JSC::call(globalObject, function, JSC::getCallData(function), JSC::jsUndefined(), arguments, exception);
+    if (UNLIKELY(exception)) {
+        auto scope = DECLARE_THROW_SCOPE(vm);
+        scope.throwException(globalObject, exception);
+        return JSC::JSValue::encode(JSC::jsNull());
+    }
+
+    return JSC::JSValue::encode(result);
+}
diff --git a/src/bun.js/ffi.exports.js b/src/bun.js/ffi.exports.js
index 737b7204b..faf74d1b8 100644
--- a/src/bun.js/ffi.exports.js
+++ b/src/bun.js/ffi.exports.js
@@ -9,6 +9,36 @@ export const viewSource = ffi.viewSource;
 
 const BunCString = ffi.CString;
 const nativeLinkSymbols = ffi.linkSymbols;
+const nativeDLOpen = ffi.dlopen;
+const nativeCallback = ffi.callback;
+const closeCallback = ffi.closeCallback;
+delete ffi.callback;
+delete ffi.closeCallback;
+
+export class JSCallback {
+  constructor(options, cb) {
+    const { ctx, ptr } = nativeCallback(options, cb);
+    this.#ctx = ctx;
+    this.ptr = ptr;
+  }
+
+  ptr;
+  #ctx;
+
+  [Symbol.toPrimitive]() {
+    return this.ptr;
+  }
+
+  close() {
+    const ctx = this.#ctx;
+    this.ptr = null;
+    this.#ctx = null;
+
+    if (ctx) {
+      closeCallback(ctx);
+    }
+  }
+}
 
 export class CString extends String {
   constructor(ptr, byteOffset, byteLength) {
@@ -55,7 +85,8 @@ Object.defineProperty(globalThis, "__GlobalBunCString", {
   configurable: false,
 });
 
-const ffiWrappers = new Array(16);
+const ffiWrappers = new Array(18);
+
 var char = (val) => val | 0;
 ffiWrappers.fill(char);
 ffiWrappers[FFIType.uint8_t] = function uint8(val) {
@@ -195,6 +226,25 @@ function cstringReturnType(val) {
   return new __GlobalBunCString(val);
 }
 
+ffiWrappers[FFIType.function] = function functionType(val) {
+  if (typeof val === "number") {
+    return val;
+  }
+
+  if (typeof val === "bigint") {
+    return Number(val);
+  }
+
+  // we overwrote Symbol.toPrimitive
+  var ptr = +val;
+
+  if (!Number.isFinite(ptr) || ptr === 0) {
+    throw new Error("Expected function to be a JSCallback or a number");
+  }
+
+  return ptr;
+};
+
 function FFIBuilder(params, returnType, functionToCall, name) {
   const hasReturnType =
     typeof FFIType[returnType] === "number" &&
@@ -293,11 +343,11 @@ function FFIBuilder(params, returnType, functionToCall, name) {
   return wrap;
 }
 
-const nativeDLOpen = ffi.dlopen;
-const nativeCallback = ffi.callback;
 export const native = {
   dlopen: nativeDLOpen,
-  callback: nativeCallback,
+  callback: () => {
+    throw new Error("Deprecated. Use new JSCallback(options, fn) instead");
+  },
 };
 
 export function dlopen(path, options) {
@@ -383,8 +433,4 @@ export function CFunction(options) {
   return result.symbols[identifier];
 }
 
-export function callback(options, cb) {
-  return nativeCallback(options, cb);
-}
-
 export const read = ffi.read;