Errors must return 0 instead of undefined

4 files changed, 135 insertions, 48 deletions

diff --git a/src/bun.js/api/bun/subprocess.zig b/src/bun.js/api/bun/subprocess.zig
index ce64f3787..638c8ffef 100644
--- a/src/bun.js/api/bun/subprocess.zig
+++ b/src/bun.js/api/bun/subprocess.zig
@@ -241,14 +241,14 @@ pub const Subprocess = struct {
 
         if (!(sig > -1 and sig < std.math.maxInt(u8))) {
             globalThis.throwInvalidArguments("Invalid signal: must be > -1 and < 255", .{});
-            return JSValue.jsUndefined();
+            return .zero;
         }
 
         switch (this.tryKill(sig)) {
             .result => {},
             .err => |err| {
                 globalThis.throwValue(err.toJSC(globalThis));
-                return JSValue.jsUndefined();
+                return .zero;
             },
         }
 
@@ -832,7 +832,7 @@ pub const Subprocess = struct {
         {
             if (args.isEmptyOrUndefinedOrNull()) {
                 globalThis.throwInvalidArguments("cmds must be an array", .{});
-                return JSValue.jsUndefined();
+                return .zero;
             }
 
             const args_type = args.jsType();
@@ -843,24 +843,24 @@ pub const Subprocess = struct {
                 cmd_value = cmd_value_;
             } else {
                 globalThis.throwInvalidArguments("cmds must be an array", .{});
-                return JSValue.jsUndefined();
+                return .zero;
             }
 
             {
                 var cmds_array = cmd_value.arrayIterator(globalThis);
                 argv = @TypeOf(argv).initCapacity(allocator, cmds_array.len) catch {
                     globalThis.throw("out of memory", .{});
-                    return JSValue.jsUndefined();
+                    return .zero;
                 };
 
                 if (cmd_value.isEmptyOrUndefinedOrNull()) {
                     globalThis.throwInvalidArguments("cmd must be an array of strings", .{});
-                    return JSValue.jsUndefined();
+                    return .zero;
                 }
 
                 if (cmds_array.len == 0) {
                     globalThis.throwInvalidArguments("cmd must not be empty", .{});
-                    return JSValue.jsUndefined();
+                    return .zero;
                 }
 
                 {
@@ -870,24 +870,24 @@ pub const Subprocess = struct {
                     var path_buf: [bun.MAX_PATH_BYTES]u8 = undefined;
                     var resolved = Which.which(&path_buf, PATH, cwd, arg0.slice()) orelse {
                         globalThis.throwInvalidArguments("cmd not in $PATH: {s}", .{arg0});
-                        return JSValue.jsUndefined();
+                        return .zero;
                     };
                     argv.appendAssumeCapacity(allocator.dupeZ(u8, bun.span(resolved)) catch {
                         globalThis.throw("out of memory", .{});
-                        return JSValue.jsUndefined();
+                        return .zero;
                     });
                 }
 
                 while (cmds_array.next()) |value| {
                     argv.appendAssumeCapacity(value.getZigString(globalThis).toOwnedSliceZ(allocator) catch {
                         globalThis.throw("out of memory", .{});
-                        return JSValue.jsUndefined();
+                        return .zero;
                     });
                 }
 
                 if (argv.items.len == 0) {
                     globalThis.throwInvalidArguments("cmd must be an array of strings", .{});
-                    return JSValue.jsUndefined();
+                    return .zero;
                 }
             }
 
@@ -896,7 +896,7 @@ pub const Subprocess = struct {
                     if (!cwd_.isEmptyOrUndefinedOrNull()) {
                         cwd = cwd_.getZigString(globalThis).toOwnedSliceZ(allocator) catch {
                             globalThis.throw("out of memory", .{});
-                            return JSValue.jsUndefined();
+                            return .zero;
                         };
                     }
                 }
@@ -905,7 +905,7 @@ pub const Subprocess = struct {
                     if (!onExit_.isEmptyOrUndefinedOrNull()) {
                         if (!onExit_.isCell() or !onExit_.isCallable(globalThis.vm())) {
                             globalThis.throwInvalidArguments("onExit must be a function or undefined", .{});
-                            return JSValue.jsUndefined();
+                            return .zero;
                         }
                         on_exit_callback = onExit_;
                     }
@@ -915,7 +915,7 @@ pub const Subprocess = struct {
                     if (!object.isEmptyOrUndefinedOrNull()) {
                         if (!object.isObject()) {
                             globalThis.throwInvalidArguments("env must be an object", .{});
-                            return JSValue.jsUndefined();
+                            return .zero;
                         }
 
                         var object_iter = JSC.JSPropertyIterator(.{
@@ -925,14 +925,14 @@ pub const Subprocess = struct {
                         defer object_iter.deinit();
                         env_array.ensureTotalCapacityPrecise(allocator, object_iter.len) catch {
                             globalThis.throw("out of memory", .{});
-                            return JSValue.jsUndefined();
+                            return .zero;
                         };
 
                         while (object_iter.next()) |key| {
                             var value = object_iter.value;
                             var line = std.fmt.allocPrintZ(allocator, "{}={}", .{ key, value.getZigString(globalThis) }) catch {
                                 globalThis.throw("out of memory", .{});
-                                return JSValue.jsUndefined();
+                                return .zero;
                             };
 
                             if (key.eqlComptime("PATH")) {
@@ -940,7 +940,7 @@ pub const Subprocess = struct {
                             }
                             env_array.append(allocator, line) catch {
                                 globalThis.throw("out of memory", .{});
-                                return JSValue.jsUndefined();
+                                return .zero;
                             };
                         }
                     }
@@ -958,23 +958,23 @@ pub const Subprocess = struct {
                             }
                         } else {
                             globalThis.throwInvalidArguments("stdio must be an array", .{});
-                            return JSValue.jsUndefined();
+                            return .zero;
                         }
                     }
                 } else {
                     if (args.get(globalThis, "stdin")) |value| {
                         if (!extractStdio(globalThis, std.os.STDIN_FILENO, value, &stdio))
-                            return JSC.JSValue.jsUndefined();
+                            return .zero;
                     }
 
                     if (args.get(globalThis, "stderr")) |value| {
                         if (!extractStdio(globalThis, std.os.STDERR_FILENO, value, &stdio))
-                            return JSC.JSValue.jsUndefined();
+                            return .zero;
                     }
 
                     if (args.get(globalThis, "stdout")) |value| {
                         if (!extractStdio(globalThis, std.os.STDOUT_FILENO, value, &stdio))
-                            return JSC.JSValue.jsUndefined();
+                            return .zero;
                     }
                 }
             }
@@ -982,7 +982,7 @@ pub const Subprocess = struct {
 
         var attr = PosixSpawn.Attr.init() catch {
             globalThis.throw("out of memory", .{});
-            return JSValue.jsUndefined();
+            return .zero;
         };
 
         defer attr.deinit();
@@ -1005,19 +1005,19 @@ pub const Subprocess = struct {
 
         const stdin_pipe = if (stdio[0].isPiped()) os.pipe2(0) catch |err| {
             globalThis.throw("failed to create stdin pipe: {s}", .{err});
-            return JSValue.jsUndefined();
+            return .zero;
         } else undefined;
         errdefer if (stdio[0].isPiped()) destroyPipe(stdin_pipe);
 
         const stdout_pipe = if (stdio[1].isPiped()) os.pipe2(0) catch |err| {
             globalThis.throw("failed to create stdout pipe: {s}", .{err});
-            return JSValue.jsUndefined();
+            return .zero;
         } else undefined;
         errdefer if (stdio[1].isPiped()) destroyPipe(stdout_pipe);
 
         const stderr_pipe = if (stdio[2].isPiped()) os.pipe2(0) catch |err| {
             globalThis.throw("failed to create stderr pipe: {s}", .{err});
-            return JSValue.jsUndefined();
+            return .zero;
         } else undefined;
         errdefer if (stdio[2].isPiped()) destroyPipe(stderr_pipe);
 
@@ -1043,13 +1043,13 @@ pub const Subprocess = struct {
 
         argv.append(allocator, null) catch {
             globalThis.throw("out of memory", .{});
-            return JSValue.jsUndefined();
+            return .zero;
         };
 
         if (env_array.items.len > 0) {
             env_array.append(allocator, null) catch {
                 globalThis.throw("out of memory", .{});
-                return JSValue.jsUndefined();
+                return .zero;
             };
             env = @ptrCast(@TypeOf(env), env_array.items.ptr);
         }
@@ -1091,7 +1091,7 @@ pub const Subprocess = struct {
 
         var subprocess = globalThis.allocator().create(Subprocess) catch {
             globalThis.throw("out of memory", .{});
-            return JSValue.jsUndefined();
+            return .zero;
         };
 
         // When run synchronously, subprocess isn't garbage collected
@@ -1101,7 +1101,7 @@ pub const Subprocess = struct {
             .pidfd = pidfd,
             .stdin = Writable.init(stdio[std.os.STDIN_FILENO], stdin_pipe[1], globalThis) catch {
                 globalThis.throw("out of memory", .{});
-                return JSValue.jsUndefined();
+                return .zero;
             },
             .stdout = Readable.init(stdio[std.os.STDOUT_FILENO], stdout_pipe[0], globalThis),
             .stderr = Readable.init(stdio[std.os.STDERR_FILENO], stderr_pipe[0], globalThis),
diff --git a/src/bun.js/api/server.zig b/src/bun.js/api/server.zig
index f3b9425ef..8c51074fa 100644
--- a/src/bun.js/api/server.zig
+++ b/src/bun.js/api/server.zig
@@ -2722,7 +2722,7 @@ pub const ServerWebSocket = struct {
         defer topic_slice.deinit();
         if (topic_slice.len == 0) {
             globalThis.throw("publish requires a non-empty topic", .{});
-            return JSValue.jsNumber(0);
+            return .zero;
         }
 
         const compress = args.len > 1 and compress_value.toBoolean();
@@ -3737,6 +3737,7 @@ pub fn NewServer(comptime ssl_enabled_: bool, comptime debug_mode_: bool) type {
                     var upgrader = this.allocator.create(ServerWebSocket) catch @panic("Out of memory");
                     upgrader.* = .{
                         .handler = websocket_handler,
+                        .this_value = .zero,
                     };
                     resp.upgrade(
                         *ServerWebSocket,
diff --git a/src/bun.js/bindings/ZigGeneratedClasses.cpp b/src/bun.js/bindings/ZigGeneratedClasses.cpp
index 9fbc436ac..93e69455b 100644
--- a/src/bun.js/bindings/ZigGeneratedClasses.cpp
+++ b/src/bun.js/bindings/ZigGeneratedClasses.cpp
@@ -446,7 +446,12 @@ JSSubprocess* JSSubprocess::create(JSC::VM& vm, JSC::JSGlobalObject* globalObjec
 }
 
 extern "C" void* Subprocess__fromJS(JSC::EncodedJSValue value) {
-  JSSubprocess* object = JSC::jsDynamicCast<JSSubprocess*>(JSValue::decode(value));
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (!decodedValue || decodedValue.isUndefinedOrNull()) 
+    return nullptr;
+
+  JSSubprocess* object = JSC::jsDynamicCast<JSSubprocess*>(decodedValue);
+
   if (!object)
       return nullptr;
       
@@ -694,7 +699,12 @@ JSSHA1* JSSHA1::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Stru
 }
 
 extern "C" void* SHA1__fromJS(JSC::EncodedJSValue value) {
-  JSSHA1* object = JSC::jsDynamicCast<JSSHA1*>(JSValue::decode(value));
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (!decodedValue || decodedValue.isUndefinedOrNull()) 
+    return nullptr;
+
+  JSSHA1* object = JSC::jsDynamicCast<JSSHA1*>(decodedValue);
+
   if (!object)
       return nullptr;
       
@@ -927,7 +937,12 @@ JSMD5* JSMD5::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Struct
 }
 
 extern "C" void* MD5__fromJS(JSC::EncodedJSValue value) {
-  JSMD5* object = JSC::jsDynamicCast<JSMD5*>(JSValue::decode(value));
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (!decodedValue || decodedValue.isUndefinedOrNull()) 
+    return nullptr;
+
+  JSMD5* object = JSC::jsDynamicCast<JSMD5*>(decodedValue);
+
   if (!object)
       return nullptr;
       
@@ -1160,7 +1175,12 @@ JSMD4* JSMD4::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Struct
 }
 
 extern "C" void* MD4__fromJS(JSC::EncodedJSValue value) {
-  JSMD4* object = JSC::jsDynamicCast<JSMD4*>(JSValue::decode(value));
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (!decodedValue || decodedValue.isUndefinedOrNull()) 
+    return nullptr;
+
+  JSMD4* object = JSC::jsDynamicCast<JSMD4*>(decodedValue);
+
   if (!object)
       return nullptr;
       
@@ -1393,7 +1413,12 @@ JSSHA224* JSSHA224::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::
 }
 
 extern "C" void* SHA224__fromJS(JSC::EncodedJSValue value) {
-  JSSHA224* object = JSC::jsDynamicCast<JSSHA224*>(JSValue::decode(value));
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (!decodedValue || decodedValue.isUndefinedOrNull()) 
+    return nullptr;
+
+  JSSHA224* object = JSC::jsDynamicCast<JSSHA224*>(decodedValue);
+
   if (!object)
       return nullptr;
       
@@ -1626,7 +1651,12 @@ JSSHA512* JSSHA512::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::
 }
 
 extern "C" void* SHA512__fromJS(JSC::EncodedJSValue value) {
-  JSSHA512* object = JSC::jsDynamicCast<JSSHA512*>(JSValue::decode(value));
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (!decodedValue || decodedValue.isUndefinedOrNull()) 
+    return nullptr;
+
+  JSSHA512* object = JSC::jsDynamicCast<JSSHA512*>(decodedValue);
+
   if (!object)
       return nullptr;
       
@@ -1859,7 +1889,12 @@ JSSHA384* JSSHA384::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::
 }
 
 extern "C" void* SHA384__fromJS(JSC::EncodedJSValue value) {
-  JSSHA384* object = JSC::jsDynamicCast<JSSHA384*>(JSValue::decode(value));
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (!decodedValue || decodedValue.isUndefinedOrNull()) 
+    return nullptr;
+
+  JSSHA384* object = JSC::jsDynamicCast<JSSHA384*>(decodedValue);
+
   if (!object)
       return nullptr;
       
@@ -2092,7 +2127,12 @@ JSSHA256* JSSHA256::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::
 }
 
 extern "C" void* SHA256__fromJS(JSC::EncodedJSValue value) {
-  JSSHA256* object = JSC::jsDynamicCast<JSSHA256*>(JSValue::decode(value));
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (!decodedValue || decodedValue.isUndefinedOrNull()) 
+    return nullptr;
+
+  JSSHA256* object = JSC::jsDynamicCast<JSSHA256*>(decodedValue);
+
   if (!object)
       return nullptr;
       
@@ -2325,7 +2365,12 @@ JSSHA512_256* JSSHA512_256::create(JSC::VM& vm, JSC::JSGlobalObject* globalObjec
 }
 
 extern "C" void* SHA512_256__fromJS(JSC::EncodedJSValue value) {
-  JSSHA512_256* object = JSC::jsDynamicCast<JSSHA512_256*>(JSValue::decode(value));
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (!decodedValue || decodedValue.isUndefinedOrNull()) 
+    return nullptr;
+
+  JSSHA512_256* object = JSC::jsDynamicCast<JSSHA512_256*>(decodedValue);
+
   if (!object)
       return nullptr;
       
@@ -2369,6 +2414,10 @@ extern "C" JSC::EncodedJSValue ServerWebSocketPrototype__getData(void* ptr, JSC:
 JSC_DECLARE_CUSTOM_GETTER(ServerWebSocketPrototype__dataGetterWrap);
 
 
+extern "C" bool ServerWebSocketPrototype__setData(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::EncodedJSValue value);
+JSC_DECLARE_CUSTOM_SETTER(ServerWebSocketPrototype__dataSetterWrap);
+
+
 extern "C" EncodedJSValue ServerWebSocketPrototype__getBufferedAmount(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ServerWebSocketPrototype__getBufferedAmountCallback);
 
@@ -2406,7 +2455,7 @@ STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSServerWebSocketPrototype, JSServerWebSocke
 
   static const HashTableValue JSServerWebSocketPrototypeTableValues[] = {
 { "close"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, ServerWebSocketPrototype__closeCallback, 1 } }  ,
-{ "data"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { HashTableValue::GetterSetterType, ServerWebSocketPrototype__dataGetterWrap, 0 } }  ,
+{ "data"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { HashTableValue::GetterSetterType, ServerWebSocketPrototype__dataGetterWrap, ServerWebSocketPrototype__dataSetterWrap } }  ,
 { "getBufferedAmount"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, ServerWebSocketPrototype__getBufferedAmountCallback, 0 } }  ,
 { "isSubscribed"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, ServerWebSocketPrototype__isSubscribedCallback, 1 } }  ,
 { "publish"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, ServerWebSocketPrototype__publishCallback, 3 } }  ,
@@ -2479,6 +2528,18 @@ extern "C" void ServerWebSocketPrototype__dataSetCachedValue(JSC::EncodedJSValue
 }
 
 
+JSC_DEFINE_CUSTOM_SETTER(ServerWebSocketPrototype__dataSetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    JSServerWebSocket* thisObject = jsCast<JSServerWebSocket*>(JSValue::decode(thisValue));
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    auto result = ServerWebSocketPrototype__setData(thisObject->wrapped(), lexicalGlobalObject, encodedValue);
+
+    RELEASE_AND_RETURN(throwScope, result);
+}
+
+
 JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__getBufferedAmountCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
 {
     auto& vm = lexicalGlobalObject->vm();
@@ -2721,7 +2782,12 @@ JSServerWebSocket* JSServerWebSocket::create(JSC::VM& vm, JSC::JSGlobalObject* g
 }
 
 extern "C" void* ServerWebSocket__fromJS(JSC::EncodedJSValue value) {
-  JSServerWebSocket* object = JSC::jsDynamicCast<JSServerWebSocket*>(JSValue::decode(value));
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (!decodedValue || decodedValue.isUndefinedOrNull()) 
+    return nullptr;
+
+  JSServerWebSocket* object = JSC::jsDynamicCast<JSServerWebSocket*>(decodedValue);
+
   if (!object)
       return nullptr;
       
@@ -2968,7 +3034,12 @@ JSTextDecoder* JSTextDecoder::create(JSC::VM& vm, JSC::JSGlobalObject* globalObj
 }
 
 extern "C" void* TextDecoder__fromJS(JSC::EncodedJSValue value) {
-  JSTextDecoder* object = JSC::jsDynamicCast<JSTextDecoder*>(JSValue::decode(value));
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (!decodedValue || decodedValue.isUndefinedOrNull()) 
+    return nullptr;
+
+  JSTextDecoder* object = JSC::jsDynamicCast<JSTextDecoder*>(decodedValue);
+
   if (!object)
       return nullptr;
       
@@ -3530,7 +3601,12 @@ JSRequest* JSRequest::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC
 }
 
 extern "C" void* Request__fromJS(JSC::EncodedJSValue value) {
-  JSRequest* object = JSC::jsDynamicCast<JSRequest*>(JSValue::decode(value));
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (!decodedValue || decodedValue.isUndefinedOrNull()) 
+    return nullptr;
+
+  JSRequest* object = JSC::jsDynamicCast<JSRequest*>(decodedValue);
+
   if (!object)
       return nullptr;
       
@@ -4045,7 +4121,12 @@ JSResponse* JSResponse::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, J
 }
 
 extern "C" void* Response__fromJS(JSC::EncodedJSValue value) {
-  JSResponse* object = JSC::jsDynamicCast<JSResponse*>(JSValue::decode(value));
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (!decodedValue || decodedValue.isUndefinedOrNull()) 
+    return nullptr;
+
+  JSResponse* object = JSC::jsDynamicCast<JSResponse*>(decodedValue);
+
   if (!object)
       return nullptr;
       
@@ -4409,7 +4490,12 @@ JSBlob* JSBlob::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Stru
 }
 
 extern "C" void* Blob__fromJS(JSC::EncodedJSValue value) {
-  JSBlob* object = JSC::jsDynamicCast<JSBlob*>(JSValue::decode(value));
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (!decodedValue || decodedValue.isUndefinedOrNull()) 
+    return nullptr;
+
+  JSBlob* object = JSC::jsDynamicCast<JSBlob*>(decodedValue);
+
   if (!object)
       return nullptr;
       
diff --git a/src/bun.js/event_loop.zig b/src/bun.js/event_loop.zig
index b395e8377..e17652754 100644
--- a/src/bun.js/event_loop.zig
+++ b/src/bun.js/event_loop.zig
@@ -176,7 +176,7 @@ pub const AnyTask = struct {
 pub const CppTask = opaque {
     extern fn Bun__performTask(globalObject: *JSGlobalObject, task: *CppTask) void;
     pub fn run(this: *CppTask, global: *JSGlobalObject) void {
-        JSC.markBinding();
+        JSC.markBinding(@src());
         Bun__performTask(global, this);
     }
 };
@@ -423,7 +423,7 @@ pub const EventLoop = struct {
     }
 
     pub fn ensureWaker(this: *EventLoop) void {
-        JSC.markBinding();
+        JSC.markBinding(@src());
         if (this.virtual_machine.uws_event_loop == null) {
             var actual = uws.Loop.get().?;
             this.virtual_machine.uws_event_loop = actual;
@@ -433,7 +433,7 @@ pub const EventLoop = struct {
     }
 
     pub fn enqueueTaskConcurrent(this: *EventLoop, task: *ConcurrentTask) void {
-        JSC.markBinding();
+        JSC.markBinding(@src());
 
         this.concurrent_tasks.push(task);