Merge branch 'main' into nektro-patch-29434

scripts/build-jsc.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 import { spawnSync } from "child_process";
-import { existsSync, mkdirSync } from "fs";
+import { existsSync, mkdirSync, rmSync } from "fs";
 import { arch, platform } from "os";
 import { join, resolve } from "path";
 
@@ -205,6 +205,10 @@ function buildJSC() {
     env,
   });
 
+  rmSync("vendor/WebKit/WebKitBuild/Debug/JavaScriptCore/DerivedSources/inspector/InspectorProtocolObjects.h", {
+    force: true,
+  });
+
   console.log(`\n✅ JSC build completed successfully!`);
   console.log(`Build output: ${buildDir}`);
 }

src/bun.js/SavedSourceMap.zig

@@ -2,7 +2,7 @@ const SavedSourceMap = @This();
 
 /// This is a pointer to the map located on the VirtualMachine struct
 map: *HashTable,
-mutex: bun.Mutex = .{},
+mutex: bun.Mutex,
 
 pub const vlq_offset = 24;
 
@@ -15,12 +15,12 @@ pub fn init(this: *SavedSourceMap, map: *HashTable) void {
     this.map.lockPointers();
 }
 
-pub inline fn lock(map: *SavedSourceMap) void {
+pub fn lock(map: *SavedSourceMap) void {
     map.mutex.lock();
     map.map.unlockPointers();
 }
 
-pub inline fn unlock(map: *SavedSourceMap) void {
+pub fn unlock(map: *SavedSourceMap) void {
     map.map.lockPointers();
     map.mutex.unlock();
 }
@@ -35,7 +35,7 @@ pub const SavedMappings = struct {
         return this.data[vlq_offset..this.len()];
     }
 
-    pub inline fn len(this: SavedMappings) usize {
+    pub fn len(this: SavedMappings) usize {
         return @as(u64, @bitCast(this.data[0..8].*));
     }
 

src/bun.js/api/bun/socket.zig

@@ -1435,7 +1435,7 @@ pub fn NewSocket(comptime ssl: bool) type {
             const options = socket_config.asUSockets();
             const ext_size = @sizeOf(WrappedSocket);
 
-            var handlers_ptr = bun.handleOom(bun.default_allocator.create(Handlers));
+            var handlers_ptr = bun.new(Handlers, undefined);
             handlers.withAsyncContextIfNeeded(globalObject);
             handlers_ptr.* = handlers;
             handlers_ptr.protect();
@@ -1516,7 +1516,7 @@ pub fn NewSocket(comptime ssl: bool) type {
             tls.ref();
             const vm = handlers.vm;
 
-            var raw_handlers_ptr = bun.handleOom(bun.default_allocator.create(Handlers));
+            var raw_handlers_ptr = bun.new(Handlers, undefined);
             raw_handlers_ptr.* = blk: {
                 const this_handlers = this.getHandlers();
                 break :blk .{
@@ -1933,7 +1933,7 @@ pub fn jsUpgradeDuplexToTLS(globalObject: *jsc.JSGlobalObject, callframe: *jsc.C
         return globalObject.throw("Expected \"socket\" option", .{});
     };
 
-    var handlers = try Handlers.fromJS(globalObject, socket_obj, false);
+    const handlers = try Handlers.fromJS(globalObject, socket_obj, false);
 
     var ssl_opts: ?jsc.API.ServerConfig.SSLConfig = null;
     if (try opts.getTruthy(globalObject, "tls")) |tls| {
@@ -1955,7 +1955,7 @@ pub fn jsUpgradeDuplexToTLS(globalObject: *jsc.JSGlobalObject, callframe: *jsc.C
 
     const is_server = false; // A duplex socket is always handled as a client
 
-    var handlers_ptr = bun.handleOom(handlers.vm.allocator.create(Handlers));
+    var handlers_ptr = bun.new(Handlers, undefined);
     handlers_ptr.* = handlers;
     handlers_ptr.is_server = is_server;
     handlers_ptr.withAsyncContextIfNeeded(globalObject);

src/bun.js/api/server.zig

@@ -3214,9 +3214,7 @@ extern fn Bun__addInspector(bool, *anyopaque, *jsc.JSGlobalObject) void;
 pub export fn Server__setIdleTimeout(server: jsc.JSValue, seconds: jsc.JSValue, globalThis: *jsc.JSGlobalObject) void {
     Server__setIdleTimeout_(server, seconds, globalThis) catch |err| switch (err) {
         error.JSError => {},
-        error.OutOfMemory => {
-            _ = globalThis.throwOutOfMemoryValue();
-        },
+        error.OutOfMemory => globalThis.throwOutOfMemory() catch {},
     };
 }
 

src/bun.js/bindings/BunPlugin.cpp

@@ -709,7 +709,7 @@ void JSModuleMock::visitChildrenImpl(JSCell* cell, Visitor& visitor)
 
 DEFINE_VISIT_CHILDREN(JSModuleMock);
 
-EncodedJSValue BunPlugin::OnLoad::run(JSC::JSGlobalObject* globalObject, BunString* namespaceString, BunString* path)
+EncodedJSValue BunPlugin::OnLoad::run(JSC::JSGlobalObject* globalObject, const BunString* namespaceString, const BunString* path)
 {
     Group* groupPtr = this->group(namespaceString ? namespaceString->toWTFString(BunString::ZeroCopy) : String());
     if (groupPtr == nullptr) {
@@ -779,7 +779,7 @@ std::optional<String> BunPlugin::OnLoad::resolveVirtualModule(const String& path
     return virtualModules->contains(path) ? std::optional<String> { path } : std::nullopt;
 }
 
-EncodedJSValue BunPlugin::OnResolve::run(JSC::JSGlobalObject* globalObject, BunString* namespaceString, BunString* path, BunString* importer)
+EncodedJSValue BunPlugin::OnResolve::run(JSC::JSGlobalObject* globalObject, const BunString* namespaceString, const BunString* path, const BunString* importer)
 {
     Group* groupPtr = this->group(namespaceString ? namespaceString->toWTFString(BunString::ZeroCopy) : String());
     if (groupPtr == nullptr) {
@@ -861,12 +861,12 @@ EncodedJSValue BunPlugin::OnResolve::run(JSC::JSGlobalObject* globalObject, BunS
 
 } // namespace Zig
 
-extern "C" JSC::EncodedJSValue Bun__runOnResolvePlugins(Zig::GlobalObject* globalObject, BunString* namespaceString, BunString* path, BunString* from, BunPluginTarget target)
+extern "C" [[ZIG_EXPORT(nothrow)]] JSC::EncodedJSValue Bun__runOnResolvePlugins(Zig::GlobalObject* globalObject, const BunString* namespaceString, const BunString* path, const BunString* from, BunPluginTarget target)
 {
     return globalObject->onResolvePlugins.run(globalObject, namespaceString, path, from);
 }
 
-extern "C" JSC::EncodedJSValue Bun__runOnLoadPlugins(Zig::GlobalObject* globalObject, BunString* namespaceString, BunString* path, BunPluginTarget target)
+extern "C" [[ZIG_EXPORT(nothrow)]] JSC::EncodedJSValue Bun__runOnLoadPlugins(Zig::GlobalObject* globalObject, const BunString* namespaceString, const BunString* path, BunPluginTarget target)
 {
     return globalObject->onLoadPlugins.run(globalObject, namespaceString, path);
 }

src/bun.js/bindings/BunPlugin.h

@@ -71,7 +71,7 @@ public:
 
         VirtualModuleMap* _Nullable virtualModules = nullptr;
         bool mustDoExpensiveRelativeLookup = false;
-        JSC::EncodedJSValue run(JSC::JSGlobalObject* globalObject, BunString* namespaceString, BunString* path);
+        JSC::EncodedJSValue run(JSC::JSGlobalObject* globalObject, const BunString* namespaceString, const BunString* path);
 
         bool hasVirtualModules() const { return virtualModules != nullptr; }
 
@@ -95,7 +95,7 @@ public:
         {
         }
 
-        JSC::EncodedJSValue run(JSC::JSGlobalObject* globalObject, BunString* namespaceString, BunString* path, BunString* importer);
+        JSC::EncodedJSValue run(JSC::JSGlobalObject* globalObject, const BunString* namespaceString, const BunString* path, const BunString* importer);
     };
 };
 

src/bun.js/bindings/JSGlobalObject.zig

@@ -33,11 +33,11 @@ pub const JSGlobalObject = opaque {
         return this.throwValue(err);
     }
 
-    pub const requestTermination = JSGlobalObject__requestTermination;
-    pub const clearTerminationException = JSGlobalObject__clearTerminationException;
+    pub const requestTermination = bun.cpp.JSGlobalObject__requestTermination;
+    pub const clearTerminationException = bun.cpp.JSGlobalObject__clearTerminationException;
 
     pub fn setTimeZone(this: *JSGlobalObject, timeZone: *const ZigString) bool {
-        return JSGlobalObject__setTimeZone(this, timeZone);
+        return bun.cpp.JSGlobalObject__setTimeZone(this, timeZone);
     }
 
     pub inline fn toJSValue(globalThis: *JSGlobalObject) JSValue {
@@ -241,19 +241,17 @@ pub const JSGlobalObject = opaque {
         node = 1,
         browser = 2,
     };
-    extern fn Bun__runOnLoadPlugins(*jsc.JSGlobalObject, ?*const bun.String, *const bun.String, BunPluginTarget) JSValue;
-    extern fn Bun__runOnResolvePlugins(*jsc.JSGlobalObject, ?*const bun.String, *const bun.String, *const String, BunPluginTarget) JSValue;
 
     pub fn runOnLoadPlugins(this: *JSGlobalObject, namespace_: bun.String, path: bun.String, target: BunPluginTarget) bun.JSError!?JSValue {
         jsc.markBinding(@src());
-        const result = try bun.jsc.fromJSHostCall(this, @src(), Bun__runOnLoadPlugins, .{ this, if (namespace_.length() > 0) &namespace_ else null, &path, target });
+        const result = try bun.jsc.fromJSHostCall(this, @src(), bun.cpp.Bun__runOnLoadPlugins, .{ this, if (namespace_.length() > 0) &namespace_ else null, &path, target });
         if (result.isUndefinedOrNull()) return null;
         return result;
     }
 
     pub fn runOnResolvePlugins(this: *JSGlobalObject, namespace_: bun.String, path: bun.String, source: bun.String, target: BunPluginTarget) bun.JSError!?JSValue {
         jsc.markBinding(@src());
-        const result = try bun.jsc.fromJSHostCall(this, @src(), Bun__runOnResolvePlugins, .{ this, if (namespace_.length() > 0) &namespace_ else null, &path, &source, target });
+        const result = try bun.jsc.fromJSHostCall(this, @src(), bun.cpp.Bun__runOnResolvePlugins, .{ this, if (namespace_.length() > 0) &namespace_ else null, &path, &source, target });
         if (result.isUndefinedOrNull()) return null;
         return result;
     }
@@ -603,42 +601,19 @@ pub const JSGlobalObject = opaque {
         return bun.jsc.fromJSHostCallGeneric(this, @src(), JSC__JSGlobalObject__handleRejectedPromises, .{this}) catch @panic("unreachable");
     }
 
-    extern fn ZigGlobalObject__readableStreamToArrayBuffer(*JSGlobalObject, JSValue) JSValue;
-    extern fn ZigGlobalObject__readableStreamToBytes(*JSGlobalObject, JSValue) JSValue;
-    extern fn ZigGlobalObject__readableStreamToText(*JSGlobalObject, JSValue) JSValue;
-    extern fn ZigGlobalObject__readableStreamToJSON(*JSGlobalObject, JSValue) JSValue;
-    extern fn ZigGlobalObject__readableStreamToFormData(*JSGlobalObject, JSValue, JSValue) JSValue;
-    extern fn ZigGlobalObject__readableStreamToBlob(*JSGlobalObject, JSValue) JSValue;
+    pub const readableStreamToArrayBuffer = bun.cpp.ZigGlobalObject__readableStreamToArrayBuffer;
 
-    pub fn readableStreamToArrayBuffer(this: *JSGlobalObject, value: JSValue) JSValue {
-        return ZigGlobalObject__readableStreamToArrayBuffer(this, value);
-    }
+    pub const readableStreamToBytes = bun.cpp.ZigGlobalObject__readableStreamToBytes;
 
-    pub fn readableStreamToBytes(this: *JSGlobalObject, value: JSValue) JSValue {
-        return ZigGlobalObject__readableStreamToBytes(this, value);
-    }
+    pub const readableStreamToText = bun.cpp.ZigGlobalObject__readableStreamToText;
 
-    pub fn readableStreamToText(this: *JSGlobalObject, value: JSValue) JSValue {
-        return ZigGlobalObject__readableStreamToText(this, value);
-    }
+    pub const readableStreamToJSON = bun.cpp.ZigGlobalObject__readableStreamToJSON;
 
-    pub fn readableStreamToJSON(this: *JSGlobalObject, value: JSValue) JSValue {
-        return ZigGlobalObject__readableStreamToJSON(this, value);
-    }
+    pub const readableStreamToBlob = bun.cpp.ZigGlobalObject__readableStreamToBlob;
 
-    pub fn readableStreamToBlob(this: *JSGlobalObject, value: JSValue) JSValue {
-        return ZigGlobalObject__readableStreamToBlob(this, value);
-    }
+    pub const readableStreamToFormData = bun.cpp.ZigGlobalObject__readableStreamToFormData;
 
-    pub fn readableStreamToFormData(this: *JSGlobalObject, value: JSValue, content_type: JSValue) JSValue {
-        return ZigGlobalObject__readableStreamToFormData(this, value, content_type);
-    }
-
-    extern fn ZigGlobalObject__makeNapiEnvForFFI(*JSGlobalObject) *napi.NapiEnv;
-
-    pub fn makeNapiEnvForFFI(this: *JSGlobalObject) *napi.NapiEnv {
-        return ZigGlobalObject__makeNapiEnvForFFI(this);
-    }
+    pub const makeNapiEnvForFFI = bun.cpp.ZigGlobalObject__makeNapiEnvForFFI;
 
     pub inline fn assertOnJSThread(this: *JSGlobalObject) void {
         if (bun.Environment.allow_assert) this.bunVM().assertOnJSThread();
@@ -803,13 +778,9 @@ pub const JSGlobalObject = opaque {
     extern fn JSC__JSGlobalObject__deleteModuleRegistryEntry(*JSGlobalObject, *const ZigString) void;
     extern fn JSGlobalObject__clearException(*JSGlobalObject) void;
     extern fn JSGlobalObject__clearExceptionExceptTermination(*JSGlobalObject) bool;
-    extern fn JSGlobalObject__clearTerminationException(this: *JSGlobalObject) void;
     extern fn JSGlobalObject__hasException(*JSGlobalObject) bool;
-    extern fn JSGlobalObject__setTimeZone(this: *JSGlobalObject, timeZone: *const ZigString) bool;
     extern fn JSGlobalObject__tryTakeException(*JSGlobalObject) JSValue;
-    extern fn JSGlobalObject__requestTermination(this: *JSGlobalObject) void;
 
-    extern fn Zig__GlobalObject__create(*anyopaque, i32, bool, bool, ?*anyopaque) *JSGlobalObject;
     pub fn create(
         v: *jsc.VirtualMachine,
         console: *anyopaque,
@@ -822,7 +793,7 @@ pub const JSGlobalObject = opaque {
         defer trace.end();
 
         v.eventLoop().ensureWaker();
-        const global = Zig__GlobalObject__create(console, context_id, mini_mode, eval_mode, worker_ptr);
+        const global = bun.cpp.Zig__GlobalObject__create(console, context_id, mini_mode, eval_mode, worker_ptr).?;
 
         // JSC might mess with the stack size.
         bun.StackCheck.configureThread();
@@ -830,15 +801,9 @@ pub const JSGlobalObject = opaque {
         return global;
     }
 
-    extern fn Zig__GlobalObject__getModuleRegistryMap(*JSGlobalObject) *anyopaque;
-    pub fn getModuleRegistryMap(global: *JSGlobalObject) *anyopaque {
-        return Zig__GlobalObject__getModuleRegistryMap(global);
-    }
+    pub const getModuleRegistryMap = bun.cpp.Zig__GlobalObject__getModuleRegistryMap;
 
-    extern fn Zig__GlobalObject__resetModuleRegistryMap(*JSGlobalObject, *anyopaque) bool;
-    pub fn resetModuleRegistryMap(global: *JSGlobalObject, map: *anyopaque) bool {
-        return Zig__GlobalObject__resetModuleRegistryMap(global, map);
-    }
+    pub const resetModuleRegistryMap = bun.cpp.Zig__GlobalObject__resetModuleRegistryMap;
 
     pub fn resolve(res: *ErrorableString, global: *JSGlobalObject, specifier: *bun.String, source: *bun.String, query: *ZigString) callconv(.C) void {
         jsc.markBinding(@src());
@@ -998,7 +963,6 @@ pub const JSGlobalObject = opaque {
 
 const string = []const u8;
 
-const napi = @import("../../napi/napi.zig");
 const std = @import("std");
 
 const bun = @import("bun");

src/bun.js/bindings/ZigException.zig

@@ -24,10 +24,8 @@ pub const ZigException = extern struct {
 
     browser_url: String = .empty,
 
-    pub extern fn ZigException__collectSourceLines(jsValue: JSValue, global: *JSGlobalObject, exception: *ZigException) void;
-
     pub fn collectSourceLines(this: *ZigException, value: JSValue, global: *JSGlobalObject) void {
-        ZigException__collectSourceLines(value, global, this);
+        bun.cpp.ZigException__collectSourceLines(value, global, this);
     }
 
     pub fn deinit(this: *ZigException) void {

src/bun.js/bindings/ZigGlobalObject.cpp

@@ -940,7 +940,7 @@ extern "C" size_t Bun__reported_memory_size;
 // executionContextId: -1 for main thread
 // executionContextId: maxInt32 for macros
 // executionContextId: >-1 for workers
-extern "C" JSC::JSGlobalObject* Zig__GlobalObject__create(void* console_client, int32_t executionContextId, bool miniMode, bool evalMode, void* worker_ptr)
+extern "C" [[ZIG_EXPORT(nothrow)]] JSC::JSGlobalObject* Zig__GlobalObject__create(void* console_client, int32_t executionContextId, bool miniMode, bool evalMode, void* worker_ptr)
 {
     auto heapSize = miniMode ? JSC::HeapType::Small : JSC::HeapType::Large;
     RefPtr<JSC::VM> vmPtr = JSC::VM::tryCreate(heapSize);
@@ -1125,7 +1125,7 @@ JSC_DEFINE_HOST_FUNCTION(functionFulfillModuleSync,
     RELEASE_AND_RETURN(scope, JSValue::encode(JSC::jsUndefined()));
 }
 
-extern "C" void* Zig__GlobalObject__getModuleRegistryMap(JSC::JSGlobalObject* arg0)
+extern "C" [[ZIG_EXPORT(nothrow)]] void* Zig__GlobalObject__getModuleRegistryMap(JSC::JSGlobalObject* arg0)
 {
     if (JSC::JSObject* loader = JSC::jsDynamicCast<JSC::JSObject*>(arg0->moduleLoader())) {
         JSC::JSMap* map = JSC::jsDynamicCast<JSC::JSMap*>(
@@ -1140,8 +1140,7 @@ extern "C" void* Zig__GlobalObject__getModuleRegistryMap(JSC::JSGlobalObject* ar
     return nullptr;
 }
 
-extern "C" bool Zig__GlobalObject__resetModuleRegistryMap(JSC::JSGlobalObject* globalObject,
-    void* map_ptr)
+extern "C" [[ZIG_EXPORT(nothrow)]] bool Zig__GlobalObject__resetModuleRegistryMap(JSC::JSGlobalObject* globalObject, void* map_ptr)
 {
     if (map_ptr == nullptr)
         return false;
@@ -2225,7 +2224,7 @@ extern "C" int32_t ReadableStreamTag__tagged(Zig::GlobalObject* globalObject, JS
     return 0;
 }
 
-extern "C" JSC::EncodedJSValue ZigGlobalObject__createNativeReadableStream(Zig::GlobalObject* globalObject, JSC::EncodedJSValue nativePtr)
+extern "C" [[ZIG_EXPORT(zero_is_throw)]] JSC::EncodedJSValue ZigGlobalObject__createNativeReadableStream(Zig::GlobalObject* globalObject, JSC::EncodedJSValue nativePtr)
 {
     auto& vm = JSC::getVM(globalObject);
     auto scope = DECLARE_THROW_SCOPE(vm);
@@ -2287,12 +2286,12 @@ static inline JSC::EncodedJSValue ZigGlobalObject__readableStreamToArrayBufferBo
     RELEASE_AND_RETURN(throwScope, JSC::JSValue::encode(promise));
 }
 
-extern "C" JSC::EncodedJSValue ZigGlobalObject__readableStreamToArrayBuffer(Zig::GlobalObject* globalObject, JSC::EncodedJSValue readableStreamValue)
+extern "C" [[ZIG_EXPORT(nothrow)]] JSC::EncodedJSValue ZigGlobalObject__readableStreamToArrayBuffer(Zig::GlobalObject* globalObject, JSC::EncodedJSValue readableStreamValue)
 {
     return ZigGlobalObject__readableStreamToArrayBufferBody(static_cast<Zig::GlobalObject*>(globalObject), readableStreamValue);
 }
 
-extern "C" JSC::EncodedJSValue ZigGlobalObject__readableStreamToBytes(Zig::GlobalObject* globalObject, JSC::EncodedJSValue readableStreamValue)
+extern "C" [[ZIG_EXPORT(nothrow)]] JSC::EncodedJSValue ZigGlobalObject__readableStreamToBytes(Zig::GlobalObject* globalObject, JSC::EncodedJSValue readableStreamValue)
 {
     auto& vm = JSC::getVM(globalObject);
 
@@ -2331,7 +2330,7 @@ extern "C" JSC::EncodedJSValue ZigGlobalObject__readableStreamToBytes(Zig::Globa
     RELEASE_AND_RETURN(throwScope, JSC::JSValue::encode(promise));
 }
 
-extern "C" JSC::EncodedJSValue ZigGlobalObject__readableStreamToText(Zig::GlobalObject* globalObject, JSC::EncodedJSValue readableStreamValue)
+extern "C" [[ZIG_EXPORT(nothrow)]] JSC::EncodedJSValue ZigGlobalObject__readableStreamToText(Zig::GlobalObject* globalObject, JSC::EncodedJSValue readableStreamValue)
 {
     auto& vm = JSC::getVM(globalObject);
 
@@ -2351,7 +2350,7 @@ extern "C" JSC::EncodedJSValue ZigGlobalObject__readableStreamToText(Zig::Global
     return JSC::JSValue::encode(call(globalObject, function, callData, JSC::jsUndefined(), arguments));
 }
 
-extern "C" JSC::EncodedJSValue ZigGlobalObject__readableStreamToFormData(Zig::GlobalObject* globalObject, JSC::EncodedJSValue readableStreamValue, JSC::EncodedJSValue contentTypeValue)
+extern "C" [[ZIG_EXPORT(nothrow)]] JSC::EncodedJSValue ZigGlobalObject__readableStreamToFormData(Zig::GlobalObject* globalObject, JSC::EncodedJSValue readableStreamValue, JSC::EncodedJSValue contentTypeValue)
 {
     auto& vm = JSC::getVM(globalObject);
 
@@ -2372,7 +2371,7 @@ extern "C" JSC::EncodedJSValue ZigGlobalObject__readableStreamToFormData(Zig::Gl
     return JSC::JSValue::encode(call(globalObject, function, callData, JSC::jsUndefined(), arguments));
 }
 
-extern "C" JSC::EncodedJSValue ZigGlobalObject__readableStreamToJSON(Zig::GlobalObject* globalObject, JSC::EncodedJSValue readableStreamValue)
+extern "C" [[ZIG_EXPORT(nothrow)]] JSC::EncodedJSValue ZigGlobalObject__readableStreamToJSON(Zig::GlobalObject* globalObject, JSC::EncodedJSValue readableStreamValue)
 {
     auto& vm = JSC::getVM(globalObject);
 
@@ -2392,7 +2391,7 @@ extern "C" JSC::EncodedJSValue ZigGlobalObject__readableStreamToJSON(Zig::Global
     return JSC::JSValue::encode(call(globalObject, function, callData, JSC::jsUndefined(), arguments));
 }
 
-extern "C" JSC::EncodedJSValue ZigGlobalObject__readableStreamToBlob(Zig::GlobalObject* globalObject, JSC::EncodedJSValue readableStreamValue)
+extern "C" [[ZIG_EXPORT(nothrow)]] JSC::EncodedJSValue ZigGlobalObject__readableStreamToBlob(Zig::GlobalObject* globalObject, JSC::EncodedJSValue readableStreamValue)
 {
     auto& vm = JSC::getVM(globalObject);
 
@@ -2412,7 +2411,7 @@ extern "C" JSC::EncodedJSValue ZigGlobalObject__readableStreamToBlob(Zig::Global
     return JSC::JSValue::encode(call(globalObject, function, callData, JSC::jsUndefined(), arguments));
 }
 
-extern "C" napi_env ZigGlobalObject__makeNapiEnvForFFI(Zig::GlobalObject* globalObject)
+extern "C" [[ZIG_EXPORT(nothrow)]] napi_env ZigGlobalObject__makeNapiEnvForFFI(Zig::GlobalObject* globalObject)
 {
     return globalObject->makeNapiEnvForFFI();
 }
@@ -3992,7 +3991,7 @@ void GlobalObject::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
-extern "C" bool JSGlobalObject__setTimeZone(JSC::JSGlobalObject* globalObject, const ZigString* timeZone)
+extern "C" [[ZIG_EXPORT(nothrow)]] bool JSGlobalObject__setTimeZone(JSC::JSGlobalObject* globalObject, const ZigString* timeZone)
 {
     auto& vm = JSC::getVM(globalObject);
 
@@ -4004,14 +4003,14 @@ extern "C" bool JSGlobalObject__setTimeZone(JSC::JSGlobalObject* globalObject, c
     return false;
 }
 
-extern "C" void JSGlobalObject__requestTermination(JSC::JSGlobalObject* globalObject)
+extern "C" [[ZIG_EXPORT(nothrow)]] void JSGlobalObject__requestTermination(JSC::JSGlobalObject* globalObject)
 {
     auto& vm = JSC::getVM(globalObject);
     vm.ensureTerminationException();
     vm.setHasTerminationRequest();
 }
 
-extern "C" void JSGlobalObject__clearTerminationException(JSC::JSGlobalObject* globalObject)
+extern "C" [[ZIG_EXPORT(nothrow)]] void JSGlobalObject__clearTerminationException(JSC::JSGlobalObject* globalObject)
 {
     auto& vm = JSC::getVM(globalObject);
     // Clear the request for the termination exception to be thrown
@@ -4652,7 +4651,7 @@ bool GlobalObject::untrackFFIFunction(JSC::JSFunction* function)
     });
 }
 
-extern "C" void Zig__GlobalObject__destructOnExit(Zig::GlobalObject* globalObject)
+extern "C" [[ZIG_EXPORT(nothrow)]] void Zig__GlobalObject__destructOnExit(Zig::GlobalObject* globalObject)
 {
     auto& vm = JSC::getVM(globalObject);
     if (vm.entryScope) {

src/bun.js/bindings/ZigSourceProvider.cpp

@@ -360,7 +360,7 @@ int SourceProvider::readCache(JSC::VM& vm, const JSC::SourceCode& sourceCode)
     // }
 }
 
-extern "C" BunString ZigSourceProvider__getSourceSlice(SourceProvider* provider)
+extern "C" [[ZIG_EXPORT(nothrow)]] BunString ZigSourceProvider__getSourceSlice(SourceProvider* provider)
 {
     return Bun::toStringView(provider->source());
 }

src/bun.js/bindings/ZigString.zig

@@ -48,13 +48,12 @@ pub const ZigString = extern struct {
         }
     }
 
-    extern fn ZigString__toValueGC(arg0: *const ZigString, arg1: *JSGlobalObject) jsc.JSValue;
     pub fn toJS(this: *const ZigString, ctx: *jsc.JSGlobalObject) JSValue {
         if (this.isGloballyAllocated()) {
             return this.toExternalValue(ctx);
         }
 
-        return ZigString__toValueGC(this, ctx);
+        return bun.cpp.ZigString__toValueGC(this, ctx);
     }
 
     /// This function is not optimized!
@@ -138,11 +137,9 @@ pub const ZigString = extern struct {
         return strings.isAllASCII(this.slice());
     }
 
-    extern fn ZigString__toJSONObject(this: *const ZigString, *jsc.JSGlobalObject) callconv(.C) jsc.JSValue;
-
     pub fn toJSONObject(this: ZigString, globalThis: *jsc.JSGlobalObject) JSValue {
         jsc.markBinding(@src());
-        return ZigString__toJSONObject(&this, globalThis);
+        return bun.cpp.ZigString__toJSONObject(&this, globalThis);
     }
 
     extern fn BunString__toURL(this: *const ZigString, *jsc.JSGlobalObject) callconv(.C) jsc.JSValue;
@@ -457,6 +454,12 @@ pub const ZigString = extern struct {
         return ZigString{ ._unsafe_ptr_do_not_use = slice_.ptr, .len = slice_.len };
     }
 
+    pub fn initGlobal(slice_: []const u8) ZigString {
+        var out = init(slice_);
+        out.markGlobal();
+        return out;
+    }
+
     pub fn initUTF8(slice_: []const u8) ZigString {
         var out = init(slice_);
         out.markUTF8();
@@ -494,9 +497,8 @@ pub const ZigString = extern struct {
         return GithubActionFormatter{ .text = this };
     }
 
-    extern fn ZigString__toAtomicValue(this: *const ZigString, globalThis: *jsc.JSGlobalObject) JSValue;
     pub fn toAtomicValue(this: *const ZigString, globalThis: *jsc.JSGlobalObject) JSValue {
-        return ZigString__toAtomicValue(this, globalThis);
+        return bun.cpp.ZigString__toAtomicValue(this, globalThis);
     }
 
     pub fn initUTF16(items: []const u16) ZigString {
@@ -542,14 +544,13 @@ pub const ZigString = extern struct {
         }
     }
 
-    extern fn ZigString__toExternalU16(ptr: [*]const u16, len: usize, global: *JSGlobalObject) JSValue;
     pub fn toExternalU16(ptr: [*]const u16, len: usize, global: *JSGlobalObject) JSValue {
         if (len > String.max_length()) {
             bun.default_allocator.free(ptr[0..len]);
             global.ERR(.STRING_TOO_LONG, "Cannot create a string longer than 2^32-1 characters", .{}).throw() catch {}; // TODO: propagate?
             return .zero;
         }
-        return ZigString__toExternalU16(ptr, len, global);
+        return bun.cpp.ZigString__toExternalU16(ptr, len, global);
     }
 
     pub fn isUTF8(this: ZigString) bool {
@@ -736,25 +737,14 @@ pub const ZigString = extern struct {
         return bun.cpp.ZigString__toExternalValue(this, global);
     }
 
-    extern fn ZigString__toExternalValueWithCallback(
-        this: *const ZigString,
-        global: *JSGlobalObject,
-        callback: *const fn (ctx: ?*anyopaque, ptr: ?*anyopaque, len: usize) callconv(.C) void,
-    ) JSValue;
     pub fn toExternalValueWithCallback(
         this: *const ZigString,
         global: *JSGlobalObject,
         callback: *const fn (ctx: ?*anyopaque, ptr: ?*anyopaque, len: usize) callconv(.C) void,
     ) JSValue {
-        return ZigString__toExternalValueWithCallback(this, global, callback);
+        return bun.cpp.ZigString__toExternalValueWithCallback(this, global, callback);
     }
 
-    extern fn ZigString__external(
-        this: *const ZigString,
-        global: *JSGlobalObject,
-        ctx: ?*anyopaque,
-        callback: *const fn (ctx: ?*anyopaque, ptr: ?*anyopaque, len: usize) callconv(.C) void,
-    ) JSValue;
     pub fn external(
         this: *const ZigString,
         global: *JSGlobalObject,
@@ -767,13 +757,12 @@ pub const ZigString = extern struct {
             return .zero;
         }
 
-        return ZigString__external(this, global, ctx, callback);
+        return bun.cpp.ZigString__external(this, global, ctx, callback);
     }
 
-    extern fn ZigString__to16BitValue(this: *const ZigString, global: *JSGlobalObject) JSValue;
     pub fn to16BitValue(this: *const ZigString, global: *JSGlobalObject) JSValue {
         this.assertGlobal();
-        return ZigString__to16BitValue(this, global);
+        return bun.cpp.ZigString__to16BitValue(this, global);
     }
 
     pub fn withEncoding(this: *const ZigString) ZigString {
@@ -793,29 +782,24 @@ pub const ZigString = extern struct {
             C_API.JSStringCreateStatic(untagged(this._unsafe_ptr_do_not_use), this.len);
     }
 
-    extern fn ZigString__toErrorInstance(this: *const ZigString, global: *JSGlobalObject) JSValue;
     pub fn toErrorInstance(this: *const ZigString, global: *JSGlobalObject) JSValue {
-        return ZigString__toErrorInstance(this, global);
+        return bun.cpp.ZigString__toErrorInstance(this, global);
     }
 
-    extern fn ZigString__toTypeErrorInstance(this: *const ZigString, global: *JSGlobalObject) JSValue;
     pub fn toTypeErrorInstance(this: *const ZigString, global: *JSGlobalObject) JSValue {
-        return ZigString__toTypeErrorInstance(this, global);
+        return bun.cpp.ZigString__toTypeErrorInstance(this, global);
     }
 
-    extern fn ZigString__toDOMExceptionInstance(this: *const ZigString, global: *JSGlobalObject, code: u8) JSValue;
     pub fn toDOMExceptionInstance(this: *const ZigString, global: *JSGlobalObject, code: jsc.WebCore.DOMExceptionCode) JSValue {
-        return ZigString__toDOMExceptionInstance(this, global, @intFromEnum(code));
+        return bun.cpp.ZigString__toDOMExceptionInstance(this, global, code);
     }
 
-    extern fn ZigString__toSyntaxErrorInstance(this: *const ZigString, global: *JSGlobalObject) JSValue;
     pub fn toSyntaxErrorInstance(this: *const ZigString, global: *JSGlobalObject) JSValue {
-        return ZigString__toSyntaxErrorInstance(this, global);
+        return bun.cpp.ZigString__toSyntaxErrorInstance(this, global);
     }
 
-    extern fn ZigString__toRangeErrorInstance(this: *const ZigString, global: *JSGlobalObject) JSValue;
     pub fn toRangeErrorInstance(this: *const ZigString, global: *JSGlobalObject) JSValue {
-        return ZigString__toRangeErrorInstance(this, global);
+        return bun.cpp.ZigString__toRangeErrorInstance(this, global);
     }
 };
 

src/bun.js/bindings/bindings.cpp

@@ -2159,7 +2159,7 @@ extern "C" JSC::EncodedJSValue JSC__JSValue__unwrapBoxedPrimitive(JSGlobalObject
     return JSValue::encode(object);
 }
 
-extern "C" JSC::EncodedJSValue ZigString__toJSONObject(const ZigString* strPtr, JSC::JSGlobalObject* globalObject)
+extern "C" [[ZIG_EXPORT(nothrow)]] JSC::EncodedJSValue ZigString__toJSONObject(const ZigString* strPtr, JSC::JSGlobalObject* globalObject)
 {
     ASSERT_NO_PENDING_EXCEPTION(globalObject);
     auto str = Zig::toString(*strPtr);
@@ -3163,7 +3163,7 @@ JSC::EncodedJSValue JSC__JSGlobalObject__createAggregateErrorWithArray(JSC::JSGl
     return JSC::JSValue::encode(JSC::createAggregateError(global, vm, errorStructure, array, JSC::jsString(vm, messageString), options, nullptr, JSC::TypeNothing, false));
 }
 
-JSC::EncodedJSValue ZigString__toAtomicValue(const ZigString* arg0, JSC::JSGlobalObject* arg1)
+[[ZIG_EXPORT(nothrow)]] JSC::EncodedJSValue ZigString__toAtomicValue(const ZigString* arg0, JSC::JSGlobalObject* arg1)
 {
     if (arg0->len == 0) {
         return JSC::JSValue::encode(JSC::jsEmptyString(arg1->vm()));
@@ -3182,13 +3182,13 @@ JSC::EncodedJSValue ZigString__toAtomicValue(const ZigString* arg0, JSC::JSGloba
     return JSC::JSValue::encode(JSC::jsString(arg1->vm(), makeAtomString(Zig::toStringCopy(*arg0))));
 }
 
-JSC::EncodedJSValue ZigString__to16BitValue(const ZigString* arg0, JSC::JSGlobalObject* arg1)
+[[ZIG_EXPORT(nothrow)]] JSC::EncodedJSValue ZigString__to16BitValue(const ZigString* arg0, JSC::JSGlobalObject* arg1)
 {
     auto str = WTF::String::fromUTF8(std::span { arg0->ptr, arg0->len });
     return JSC::JSValue::encode(JSC::jsString(arg1->vm(), str));
 }
 
-JSC::EncodedJSValue ZigString__toExternalU16(const uint16_t* arg0, size_t len, JSC::JSGlobalObject* global)
+[[ZIG_EXPORT(nothrow)]] JSC::EncodedJSValue ZigString__toExternalU16(const uint16_t* arg0, size_t len, JSC::JSGlobalObject* global)
 {
     if (len == 0) {
         return JSC::JSValue::encode(JSC::jsEmptyString(global->vm()));
@@ -3215,17 +3215,17 @@ JSC::EncodedJSValue ZigString__toExternalU16(const uint16_t* arg0, size_t len, J
     }
 }
 
-VirtualMachine* JSC__JSGlobalObject__bunVM(JSC::JSGlobalObject* arg0)
+[[ZIG_EXPORT(nothrow)]] VirtualMachine* JSC__JSGlobalObject__bunVM(JSC::JSGlobalObject* arg0)
 {
     return reinterpret_cast<VirtualMachine*>(WebCore::clientData(arg0->vm())->bunVM);
 }
 
-JSC::EncodedJSValue ZigString__toValueGC(const ZigString* arg0, JSC::JSGlobalObject* arg1)
+[[ZIG_EXPORT(nothrow)]] JSC::EncodedJSValue ZigString__toValueGC(const ZigString* arg0, JSC::JSGlobalObject* arg1)
 {
     return JSC::JSValue::encode(JSC::jsString(arg1->vm(), Zig::toStringCopy(*arg0)));
 }
 
-void JSC__JSValue__toZigString(JSC::EncodedJSValue JSValue0, ZigString* arg1, JSC::JSGlobalObject* arg2)
+[[ZIG_EXPORT(nothrow)]] void JSC__JSValue__toZigString(JSC::EncodedJSValue JSValue0, ZigString* arg1, JSC::JSGlobalObject* arg2)
 {
     JSC::JSValue value = JSC::JSValue::decode(JSValue0);
 
@@ -3254,7 +3254,7 @@ void JSC__JSValue__toZigString(JSC::EncodedJSValue JSValue0, ZigString* arg1, JS
     arg1->len = str->length();
 }
 
-JSC::EncodedJSValue ZigString__external(const ZigString* arg0, JSC::JSGlobalObject* arg1, void* arg2, void (*ArgFn3)(void* arg0, void* arg1, size_t arg2))
+[[ZIG_EXPORT(nothrow)]] JSC::EncodedJSValue ZigString__external(const ZigString* arg0, JSC::JSGlobalObject* arg1, void* arg2, void (*ArgFn3)(void* arg0, void* arg1, size_t arg2))
 {
     ZigString str
         = *arg0;
@@ -3265,7 +3265,7 @@ JSC::EncodedJSValue ZigString__external(const ZigString* arg0, JSC::JSGlobalObje
     }
 }
 
-JSC::EncodedJSValue ZigString__toExternalValueWithCallback(const ZigString* arg0, JSC::JSGlobalObject* arg1, void (*ArgFn2)(void* arg2, void* arg0, size_t arg1))
+[[ZIG_EXPORT(nothrow)]] JSC::EncodedJSValue ZigString__toExternalValueWithCallback(const ZigString* arg0, JSC::JSGlobalObject* arg1, void (*ArgFn2)(void* arg2, void* arg0, size_t arg1))
 {
 
     ZigString str
@@ -3277,27 +3277,27 @@ JSC::EncodedJSValue ZigString__toExternalValueWithCallback(const ZigString* arg0
     }
 }
 
-JSC::EncodedJSValue ZigString__toErrorInstance(const ZigString* str, JSC::JSGlobalObject* globalObject)
+[[ZIG_EXPORT(nothrow)]] JSC::EncodedJSValue ZigString__toErrorInstance(const ZigString* str, JSC::JSGlobalObject* globalObject)
 {
     return JSC::JSValue::encode(Zig::getErrorInstance(str, globalObject));
 }
 
-JSC::EncodedJSValue ZigString__toTypeErrorInstance(const ZigString* str, JSC::JSGlobalObject* globalObject)
+[[ZIG_EXPORT(nothrow)]] JSC::EncodedJSValue ZigString__toTypeErrorInstance(const ZigString* str, JSC::JSGlobalObject* globalObject)
 {
     return JSC::JSValue::encode(Zig::getTypeErrorInstance(str, globalObject));
 }
 
-JSC::EncodedJSValue ZigString__toDOMExceptionInstance(const ZigString* str, JSC::JSGlobalObject* globalObject, WebCore::ExceptionCode code)
+[[ZIG_EXPORT(nothrow)]] JSC::EncodedJSValue ZigString__toDOMExceptionInstance(const ZigString* str, JSC::JSGlobalObject* globalObject, WebCore::ExceptionCode code)
 {
     return JSValue::encode(createDOMException(globalObject, code, toStringCopy(*str)));
 }
 
-JSC::EncodedJSValue ZigString__toSyntaxErrorInstance(const ZigString* str, JSC::JSGlobalObject* globalObject)
+[[ZIG_EXPORT(nothrow)]] JSC::EncodedJSValue ZigString__toSyntaxErrorInstance(const ZigString* str, JSC::JSGlobalObject* globalObject)
 {
     return JSC::JSValue::encode(Zig::getSyntaxErrorInstance(str, globalObject));
 }
 
-JSC::EncodedJSValue ZigString__toRangeErrorInstance(const ZigString* str, JSC::JSGlobalObject* globalObject)
+[[ZIG_EXPORT(nothrow)]] JSC::EncodedJSValue ZigString__toRangeErrorInstance(const ZigString* str, JSC::JSGlobalObject* globalObject)
 {
     return JSC::JSValue::encode(Zig::getRangeErrorInstance(str, globalObject));
 }
@@ -5358,7 +5358,7 @@ extern "C" [[ZIG_EXPORT(check_slow)]] void JSC__JSValue__toZigException(JSC::Enc
     exceptionFromString(*exception, value, global);
 }
 
-void ZigException__collectSourceLines(JSC::EncodedJSValue jsException, JSC::JSGlobalObject* global, ZigException* exception)
+[[ZIG_EXPORT(nothrow)]] void ZigException__collectSourceLines(JSC::EncodedJSValue jsException, JSC::JSGlobalObject* global, ZigException* exception)
 {
     JSC::JSValue value = JSC::JSValue::decode(jsException);
     if (value == JSC::JSValue {}) {
@@ -6582,17 +6582,17 @@ CPP_DECL void JSC__VM__performOpportunisticallyScheduledTasks(JSC::VM* vm, doubl
     vm->performOpportunisticallyScheduledTasks(MonotonicTime::now() + Seconds(until), {});
 }
 
-extern "C" EncodedJSValue JSC__createError(JSC::JSGlobalObject* globalObject, const BunString* str)
+extern "C" [[ZIG_EXPORT(nothrow)]] EncodedJSValue JSC__createError(JSC::JSGlobalObject* globalObject, const BunString* str)
 {
     return JSValue::encode(JSC::createError(globalObject, str->toWTFString(BunString::ZeroCopy)));
 }
 
-extern "C" EncodedJSValue JSC__createTypeError(JSC::JSGlobalObject* globalObject, const BunString* str)
+extern "C" [[ZIG_EXPORT(nothrow)]] EncodedJSValue JSC__createTypeError(JSC::JSGlobalObject* globalObject, const BunString* str)
 {
     return JSValue::encode(JSC::createTypeError(globalObject, str->toWTFString(BunString::ZeroCopy)));
 }
 
-extern "C" EncodedJSValue JSC__createRangeError(JSC::JSGlobalObject* globalObject, const BunString* str)
+extern "C" [[ZIG_EXPORT(nothrow)]] EncodedJSValue JSC__createRangeError(JSC::JSGlobalObject* globalObject, const BunString* str)
 {
     return JSValue::encode(JSC::createRangeError(globalObject, str->toWTFString(BunString::ZeroCopy)));
 }

src/bun.js/bindings/webcore/Worker.cpp

@@ -465,7 +465,7 @@ void Worker::forEachWorker(const Function<Function<void(ScriptExecutionContext&)
         ScriptExecutionContext::postTaskTo(contextIdentifier, callback());
 }
 
-extern "C" void WebWorker__dispatchExit(Zig::GlobalObject* globalObject, Worker* worker, int32_t exitCode)
+extern "C" [[ZIG_EXPORT(nothrow)]] void WebWorker__dispatchExit(Zig::GlobalObject* globalObject, WebCore::Worker* worker, int32_t exitCode)
 {
     worker->dispatchExit(exitCode);
     // no longer referenced by Zig
@@ -494,17 +494,17 @@ extern "C" void WebWorker__dispatchExit(Zig::GlobalObject* globalObject, Worker*
         vm.derefSuppressingSaferCPPChecking(); // NOLINT
     }
 }
-extern "C" void WebWorker__dispatchOnline(Worker* worker, Zig::GlobalObject* globalObject)
+extern "C" [[ZIG_EXPORT(nothrow)]] void WebWorker__dispatchOnline(WebCore::Worker* worker, Zig::GlobalObject* globalObject)
 {
     worker->dispatchOnline(globalObject);
 }
 
-extern "C" void WebWorker__fireEarlyMessages(Worker* worker, Zig::GlobalObject* globalObject)
+extern "C" [[ZIG_EXPORT(nothrow)]] void WebWorker__fireEarlyMessages(WebCore::Worker* worker, Zig::GlobalObject* globalObject)
 {
     worker->fireEarlyMessages(globalObject);
 }
 
-extern "C" void WebWorker__dispatchError(Zig::GlobalObject* globalObject, Worker* worker, BunString message, JSC::EncodedJSValue errorValue)
+extern "C" [[ZIG_EXPORT(nothrow)]] void WebWorker__dispatchError(Zig::GlobalObject* globalObject, WebCore::Worker* worker, BunString message, JSC::EncodedJSValue errorValue)
 {
     JSValue error = JSC::JSValue::decode(errorValue);
     ErrorEvent::Init init;

src/bun.js/jsc/host_fn.zig

@@ -69,10 +69,7 @@ fn debugExceptionAssertion(globalThis: *JSGlobalObject, value: JSValue, comptime
 pub fn toJSHostSetterValue(globalThis: *JSGlobalObject, value: error{ OutOfMemory, JSError }!void) bool {
     value catch |err| switch (err) {
         error.JSError => return false,
-        error.OutOfMemory => {
-            _ = globalThis.throwOutOfMemoryValue();
-            return false;
-        },
+        error.OutOfMemory => globalThis.throwOutOfMemory() catch return false,
     };
     return true;
 }

src/bun.js/web_worker.zig

@@ -47,11 +47,6 @@ pub const Status = enum(u8) {
     terminated,
 };
 
-extern fn WebWorker__dispatchExit(?*jsc.JSGlobalObject, *anyopaque, i32) void;
-extern fn WebWorker__dispatchOnline(cpp_worker: *anyopaque, *jsc.JSGlobalObject) void;
-extern fn WebWorker__fireEarlyMessages(cpp_worker: *anyopaque, *jsc.JSGlobalObject) void;
-extern fn WebWorker__dispatchError(*jsc.JSGlobalObject, *anyopaque, bun.String, JSValue) void;
-
 export fn WebWorker__getParentWorker(vm: *jsc.VirtualMachine) ?*anyopaque {
     const worker = vm.worker orelse return null;
     return worker.cpp_worker;
@@ -386,7 +381,7 @@ fn flushLogs(this: *WebWorker) void {
         error.OutOfMemory => bun.outOfMemory(),
     };
     defer str.deref();
-    bun.jsc.fromJSHostCallGeneric(vm.global, @src(), WebWorker__dispatchError, .{ vm.global, this.cpp_worker, str, err }) catch |e| {
+    bun.jsc.fromJSHostCallGeneric(vm.global, @src(), bun.cpp.WebWorker__dispatchError, .{ vm.global, this.cpp_worker, str, err }) catch |e| {
         _ = vm.global.reportUncaughtException(vm.global.takeException(e).asException(vm.global.vm()).?);
     };
 }
@@ -433,7 +428,7 @@ fn onUnhandledRejection(vm: *jsc.VirtualMachine, globalObject: *jsc.JSGlobalObje
         bun.outOfMemory();
     };
     jsc.markBinding(@src());
-    WebWorker__dispatchError(globalObject, worker.cpp_worker, bun.String.cloneUTF8(array.slice()), error_instance);
+    bun.cpp.WebWorker__dispatchError(globalObject, worker.cpp_worker, bun.String.cloneUTF8(array.slice()), error_instance);
     if (vm.worker) |worker_| {
         _ = worker.setRequestedTerminate();
         worker.parent_poll_ref.unrefConcurrently(worker.parent);
@@ -501,8 +496,8 @@ fn spin(this: *WebWorker) void {
     log("[{d}] event loop start", .{this.execution_context_id});
     // TODO(@190n) call dispatchOnline earlier (basically as soon as spin() starts, before
     // we start running JS)
-    WebWorker__dispatchOnline(this.cpp_worker, vm.global);
-    WebWorker__fireEarlyMessages(this.cpp_worker, vm.global);
+    bun.cpp.WebWorker__dispatchOnline(this.cpp_worker, vm.global);
+    bun.cpp.WebWorker__fireEarlyMessages(this.cpp_worker, vm.global);
     this.setStatus(.running);
 
     // don't run the GC if we don't actually need to
@@ -604,7 +599,7 @@ pub fn exitAndDeinit(this: *WebWorker) noreturn {
     }
     var arena = this.arena;
 
-    WebWorker__dispatchExit(globalObject, cpp_worker, exit_code);
+    bun.cpp.WebWorker__dispatchExit(globalObject, cpp_worker, exit_code);
     if (loop) |loop_| {
         loop_.internal_loop_data.jsc_vm = null;
     }

src/bun.js/webcore/Blob.zig

@@ -1716,10 +1716,7 @@ fn writeBytesToFileFast(
 export fn JSDOMFile__construct(globalThis: *jsc.JSGlobalObject, callframe: *jsc.CallFrame) callconv(jsc.conv) ?*Blob {
     return JSDOMFile__construct_(globalThis, callframe) catch |err| switch (err) {
         error.JSError => null,
-        error.OutOfMemory => {
-            globalThis.throwOutOfMemory() catch {};
-            return null;
-        },
+        error.OutOfMemory => globalThis.throwOutOfMemory() catch null,
     };
 }
 pub fn JSDOMFile__construct_(globalThis: *jsc.JSGlobalObject, callframe: *jsc.CallFrame) bun.JSError!*Blob {

src/bun.js/webcore/ReadableStream.zig

@@ -283,11 +283,9 @@ pub fn fromJS(value: JSValue, globalThis: *JSGlobalObject) bun.JSError!?Readable
     };
 }
 
-extern fn ZigGlobalObject__createNativeReadableStream(*JSGlobalObject, nativePtr: JSValue) JSValue;
-
 pub fn fromNative(globalThis: *JSGlobalObject, native: jsc.JSValue) bun.JSError!jsc.JSValue {
     jsc.markBinding(@src());
-    return bun.jsc.fromJSHostCall(globalThis, @src(), ZigGlobalObject__createNativeReadableStream, .{ globalThis, native });
+    return bun.cpp.ZigGlobalObject__createNativeReadableStream(globalThis, native);
 }
 
 pub fn fromOwnedSlice(globalThis: *JSGlobalObject, bytes: []u8, recommended_chunk_size: Blob.SizeType) bun.JSError!jsc.JSValue {

src/bun.js/webcore/S3File.zig

@@ -605,16 +605,10 @@ pub fn constructInternal(
     return constructS3FileInternal(globalObject, path, args.nextEat());
 }
 
-pub fn construct(
-    globalObject: *jsc.JSGlobalObject,
-    callframe: *jsc.CallFrame,
-) callconv(jsc.conv) ?*Blob {
+pub fn construct(globalObject: *jsc.JSGlobalObject, callframe: *jsc.CallFrame) callconv(jsc.conv) ?*Blob {
     return constructInternal(globalObject, callframe) catch |err| switch (err) {
         error.JSError => null,
-        error.OutOfMemory => {
-            _ = globalObject.throwOutOfMemoryValue();
-            return null;
-        },
+        error.OutOfMemory => globalObject.throwOutOfMemory() catch null,
     };
 }
 pub fn hasInstance(_: jsc.JSValue, _: *jsc.JSGlobalObject, value: jsc.JSValue) callconv(jsc.conv) bool {

src/bun.zig

@@ -2675,12 +2675,12 @@ pub const heap_breakdown = @import("./heap_breakdown.zig");
 /// - Additional assertions when freeing memory.
 ///
 /// On macOS, you can use `Bun.unsafe.mimallocDump()` to dump the heap.
-pub inline fn new(comptime T: type, init: T) *T {
+pub fn new(comptime T: type, init: T) *T {
     return handleOom(tryNew(T, init));
 }
 
 /// Error-returning version of `new`.
-pub inline fn tryNew(comptime T: type, init: T) OOM!*T {
+pub fn tryNew(comptime T: type, init: T) OOM!*T {
     const pointer = if (heap_breakdown.enabled)
         try heap_breakdown.getZoneT(T).tryCreate(T, init)
     else pointer: {
@@ -2702,7 +2702,7 @@ pub inline fn tryNew(comptime T: type, init: T) OOM!*T {
 /// Destruction performs additional safety checks:
 /// - Generic assertions can be added to T.assertBeforeDestroy()
 /// - Automatic integration with `RefCount`
-pub inline fn destroy(pointer: anytype) void {
+pub fn destroy(pointer: anytype) void {
     const T = std.meta.Child(@TypeOf(pointer));
 
     if (Environment.allow_assert) {
@@ -2724,7 +2724,7 @@ pub inline fn destroy(pointer: anytype) void {
     }
 }
 
-pub inline fn dupe(comptime T: type, t: *T) *T {
+pub fn dupe(comptime T: type, t: *T) *T {
     return new(T, t.*);
 }
 

src/codegen/generate-classes.ts

@@ -2041,7 +2041,7 @@ const JavaScriptCoreBindings = struct {
       output += `
         pub fn ${classSymbolName(typeName, "finalize")}(thisValue: *${typeName}) callconv(jsc.conv) void {
           if (comptime Environment.enable_logs) log_zig_finalize("${typeName}", thisValue);
-          @call(.always_inline, ${typeName}.finalize, .{thisValue});
+          @call(bun.callmod_inline, ${typeName}.finalize, .{thisValue});
         }
       `;
     }
@@ -2054,10 +2054,7 @@ const JavaScriptCoreBindings = struct {
           if (comptime Environment.enable_logs) log_zig_constructor("${typeName}", callFrame);
           return @as(*${typeName}, ${typeName}.constructor(globalObject, callFrame, thisValue) catch |err| switch (err) {
             error.JSError => return null,
-            error.OutOfMemory => {
-              globalObject.throwOutOfMemory() catch {};
-              return null;
-            },
+            error.OutOfMemory => globalObject.throwOutOfMemory() catch return null,
           });
         }
       `;
@@ -2067,10 +2064,7 @@ const JavaScriptCoreBindings = struct {
           if (comptime Environment.enable_logs) log_zig_constructor("${typeName}", callFrame);
           return @as(*${typeName}, ${typeName}.constructor(globalObject, callFrame) catch |err| switch (err) {
             error.JSError => return null,
-            error.OutOfMemory => {
-              globalObject.throwOutOfMemory() catch {};
-              return null;
-            },
+            error.OutOfMemory => globalObject.throwOutOfMemory() catch return null,
           });
         }
       `;
@@ -2082,7 +2076,7 @@ const JavaScriptCoreBindings = struct {
       output += `
         pub fn ${classSymbolName(typeName, "call")}(globalObject: *jsc.JSGlobalObject, callFrame: *jsc.CallFrame) callconv(jsc.conv) jsc.JSValue {
           if (comptime Environment.enable_logs) log_zig_call("${typeName}", callFrame);
-          return @call(.always_inline, jsc.toJSHostFn(${typeName}.call), .{globalObject, callFrame});
+          return @call(bun.callmod_inline, jsc.toJSHostFn(${typeName}.call), .{globalObject, callFrame});
         }
       `;
     }
@@ -2092,7 +2086,7 @@ const JavaScriptCoreBindings = struct {
       output += `
         pub fn ${classSymbolName(typeName, "getInternalProperties")}(thisValue: *${typeName}, globalObject: *jsc.JSGlobalObject, thisValue: jsc.JSValue) callconv(jsc.conv) jsc.JSValue {
           if (comptime Environment.enable_logs) log_zig_get_internal_properties("${typeName}");
-          return @call(.always_inline, ${typeName}.getInternalProperties, .{thisValue, globalObject, thisValue});
+          return @call(bun.callmod_inline, ${typeName}.getInternalProperties, .{thisValue, globalObject, thisValue});
         }
       `;
     }
@@ -2108,9 +2102,9 @@ const JavaScriptCoreBindings = struct {
           if (comptime Environment.enable_logs) log_zig_getter("${typeName}", "${name}");
           return switch (@typeInfo(@typeInfo(@TypeOf(${typeName}.${getter})).@"fn".return_type.?)) {
             .error_union => {
-              return @call(.always_inline, jsc.toJSHostCall, .{globalObject, @src(), ${typeName}.${getter}, .{this, ${thisValue ? "thisValue," : ""} globalObject}});
+              return @call(bun.callmod_inline, jsc.toJSHostCall, .{globalObject, @src(), ${typeName}.${getter}, .{this, ${thisValue ? "thisValue," : ""} globalObject}});
             },
-            else => @call(.always_inline, ${typeName}.${getter}, .{this, ${thisValue ? "thisValue," : ""} globalObject}),
+            else => @call(bun.callmod_inline, ${typeName}.${getter}, .{this, ${thisValue ? "thisValue," : ""} globalObject}),
           };
         }
       `;
@@ -2125,10 +2119,10 @@ const JavaScriptCoreBindings = struct {
               if (error_union.payload != void) {
                 @compileError("Setter return type must be JSError!void or void");
               }
-              return @call(.always_inline, jsc.host_fn.toJSHostSetterValue, .{globalObject, @call(.always_inline, ${typeName}.${setter}, .{this, ${thisValue ? "thisValue," : ""} globalObject, value})});
+              return @call(bun.callmod_inline, jsc.host_fn.toJSHostSetterValue, .{globalObject, @call(bun.callmod_inline, ${typeName}.${setter}, .{this, ${thisValue ? "thisValue," : ""} globalObject, value})});
             },
             .void => {
-              @call(.always_inline, ${typeName}.${setter}, .{this, ${thisValue ? "thisValue," : ""} globalObject, value});
+              @call(bun.callmod_inline, ${typeName}.${setter}, .{this, ${thisValue ? "thisValue," : ""} globalObject, value});
               return true;
             },
             else => @compileError("Setter return type must be JSError!void or void"),
@@ -2152,7 +2146,7 @@ const JavaScriptCoreBindings = struct {
           output += `
         pub fn ${names.fn}(thisValue: *${typeName}, globalObject: *jsc.JSGlobalObject, callFrame: *jsc.CallFrame${proto[name].passThis ? ", js_this_value: jsc.JSValue" : ""}) callconv(jsc.conv) jsc.JSValue {
           if (comptime Environment.enable_logs) log_zig_method("${typeName}", "${name}", callFrame);
-          return @call(.always_inline, jsc.toJSHostCall, .{globalObject, @src(), ${typeName}.${fn}, .{thisValue, globalObject, callFrame${proto[name].passThis ? ", js_this_value" : ""}}});
+          return @call(bun.callmod_inline, jsc.toJSHostCall, .{globalObject, @src(), ${typeName}.${fn}, .{thisValue, globalObject, callFrame${proto[name].passThis ? ", js_this_value" : ""}}});
         }
         `;
         }
@@ -2170,10 +2164,10 @@ const JavaScriptCoreBindings = struct {
           if (comptime Environment.enable_logs) log_zig_class_getter("${typeName}", "${name}");
           return switch (@typeInfo(@typeInfo(@TypeOf(${typeName}.${getter})).@"fn".return_type.?)) {
             .error_union => {
-              return @call(.always_inline, jsc.toJSHostCall, .{globalObject, @src(), ${typeName}.${getter}, .{globalObject, ${thisValue ? "thisValue," : ""} propertyName}});
+              return @call(bun.callmod_inline, jsc.toJSHostCall, .{globalObject, @src(), ${typeName}.${getter}, .{globalObject, ${thisValue ? "thisValue," : ""} propertyName}});
             },
             else => {
-              return @call(.always_inline, ${typeName}.${getter}, .{globalObject, ${thisValue ? "thisValue," : ""} propertyName});
+              return @call(bun.callmod_inline, ${typeName}.${getter}, .{globalObject, ${thisValue ? "thisValue," : ""} propertyName});
             },
           };
         }
@@ -2184,7 +2178,7 @@ const JavaScriptCoreBindings = struct {
           output += `
         pub fn ${names.setter}(globalObject: *jsc.JSGlobalObject, thisValue: jsc.JSValue, target: jsc.JSValue) callconv(jsc.conv) bool {
           if (comptime Environment.enable_logs) log_zig_class_setter("${typeName}", "${name}", target);
-          return @call(.always_inline, ${typeName}.${setter || accessor.setter}, .{thisValue, globalObject, target});
+          return @call(bun.callmod_inline, ${typeName}.${setter || accessor.setter}, .{thisValue, globalObject, target});
         }
         `;
         }
@@ -2198,7 +2192,7 @@ const JavaScriptCoreBindings = struct {
             .map(ZigDOMJITArgTypeDefinition)
             .join(", ")}) callconv(jsc.conv) jsc.JSValue {
             if (comptime Environment.enable_logs) log_zig_class_domjit("${typeName}", "${name}");
-            return @call(.always_inline, ${typeName}.${DOMJITName(fn)}, .{thisValue, globalObject, ${args.map((_, i) => `arg${i}`).join(", ")}});
+            return @call(bun.callmod_inline, ${typeName}.${DOMJITName(fn)}, .{thisValue, globalObject, ${args.map((_, i) => `arg${i}`).join(", ")}});
           }
           `;
           }
@@ -2206,7 +2200,7 @@ const JavaScriptCoreBindings = struct {
           output += `
         pub fn ${names.fn}(globalObject: *jsc.JSGlobalObject, callFrame: *jsc.CallFrame) callconv(jsc.conv) jsc.JSValue {
           if (comptime Environment.enable_logs) log_zig_class_method("${typeName}", "${name}", callFrame);
-          return @call(.always_inline, jsc.toJSHostFn(${typeName}.${fn}), .{globalObject, callFrame});
+          return @call(bun.callmod_inline, jsc.toJSHostFn(${typeName}.${fn}), .{globalObject, callFrame});
         }
         `;
         }
@@ -2218,7 +2212,7 @@ const JavaScriptCoreBindings = struct {
       output += `
       pub fn ${symbolName(typeName, "onStructuredCloneSerialize")}(thisValue: *${typeName}, globalObject: *jsc.JSGlobalObject, ctx: *anyopaque, writeBytes: WriteBytesFn) callconv(jsc.conv) void {
         if (comptime Environment.enable_logs) log_zig_structured_clone_serialize("${typeName}");
-        @call(.always_inline, ${typeName}.onStructuredCloneSerialize, .{thisValue, globalObject, ctx, writeBytes});
+        @call(bun.callmod_inline, ${typeName}.onStructuredCloneSerialize, .{thisValue, globalObject, ctx, writeBytes});
       }
       `;
 
@@ -2227,7 +2221,7 @@ const JavaScriptCoreBindings = struct {
         output += `
         pub fn ${exports.get("structuredClone_transferable")}(thisValue: *${typeName}, globalObject: *jsc.JSGlobalObject, ctx: *anyopaque, write: WriteBytesFn) callconv(jsc.conv) void {
           if (comptime Environment.enable_logs) log_zig_structured_clone_transfer("${typeName}");
-          @call(.always_inline, ${typeName}.onStructuredCloneTransfer, .{thisValue, globalObject, ctx, write});
+          @call(bun.callmod_inline, ${typeName}.onStructuredCloneTransfer, .{thisValue, globalObject, ctx, write});
         }
         `;
       }
@@ -2237,7 +2231,7 @@ const JavaScriptCoreBindings = struct {
       output += `
       pub fn ${symbolName(typeName, "onStructuredCloneDeserialize")}(globalObject: *jsc.JSGlobalObject, ptr: *[*]u8, end: [*]u8) callconv(jsc.conv) jsc.JSValue {
         if (comptime Environment.enable_logs) log_zig_structured_clone_deserialize("${typeName}");
-        return @call(.always_inline, jsc.toJSHostCall, .{ globalObject, @src(), ${typeName}.onStructuredCloneDeserialize, .{globalObject, ptr, end} });
+        return @call(bun.callmod_inline, jsc.toJSHostCall, .{ globalObject, @src(), ${typeName}.onStructuredCloneDeserialize, .{globalObject, ptr, end} });
       }
       `;
     } else {

src/codegen/shared-types.ts

@@ -57,6 +57,12 @@ export const sharedTypes: Record<string, string> = {
   "JSC::CallFrame": "bun.jsc.CallFrame",
   "JSC::JSObject": "bun.jsc.JSObject",
   "JSC::JSString": "bun.jsc.JSString",
+  "VirtualMachine": "bun.jsc.VM",
+  "BunPluginTarget": "bun.jsc.JSGlobalObject.BunPluginTarget",
+  "napi_env": "*bun.api.napi.NapiEnv",
+  "SourceProvider": "bun.sourcemap.SourceProviderMap",
+  "WebCore::ExceptionCode": "bun.jsc.WebCore.DOMExceptionCode",
+  "WebCore::Worker": "anyopaque",
 };
 
 export const bannedTypes: Record<string, string> = {

src/js/internal/streams/native-readable.ts

@@ -51,6 +51,7 @@ let debugId = 0;
 function constructNativeReadable(readableStream: ReadableStream, options): NativeReadable {
   $assert(typeof readableStream === "object" && readableStream instanceof ReadableStream, "Invalid readable stream");
   const bunNativePtr = (readableStream as any).$bunNativePtr;
+  $assert(typeof bunNativePtr !== "undefined");
   $assert(typeof bunNativePtr === "object", "Invalid native ptr");
 
   const stream = new Readable(options);

src/sourcemap/sourcemap.zig

@@ -1229,8 +1229,8 @@ pub fn getSourceMapImpl(
 ///
 /// This is used for files that were pre-bundled with `bun build --target=bun --sourcemap`
 pub const SourceProviderMap = opaque {
-    extern fn ZigSourceProvider__getSourceSlice(*SourceProviderMap) bun.String;
-    pub const getSourceSlice = ZigSourceProvider__getSourceSlice;
+    pub const getSourceSlice = bun.cpp.ZigSourceProvider__getSourceSlice;
+
     pub fn toSourceContentPtr(this: *SourceProviderMap) ParsedSourceMap.SourceContentPtr {
         return ParsedSourceMap.SourceContentPtr.fromProvider(this);
     }

src/string.zig

@@ -341,17 +341,17 @@ pub const String = extern struct {
 
     pub fn toErrorInstance(this: *const String, globalObject: *jsc.JSGlobalObject) jsc.JSValue {
         defer this.deref();
-        return JSC__createError(globalObject, this);
+        return bun.cpp.JSC__createError(globalObject, this);
     }
 
     pub fn toTypeErrorInstance(this: *const String, globalObject: *jsc.JSGlobalObject) jsc.JSValue {
         defer this.deref();
-        return JSC__createTypeError(globalObject, this);
+        return bun.cpp.JSC__createTypeError(globalObject, this);
     }
 
     pub fn toRangeErrorInstance(this: *const String, globalObject: *jsc.JSGlobalObject) jsc.JSValue {
         defer this.deref();
-        return JSC__createRangeError(globalObject, this);
+        return bun.cpp.JSC__createRangeError(globalObject, this);
     }
 
     extern fn BunString__createExternal(
@@ -1050,10 +1050,6 @@ pub const String = extern struct {
         return this.toZigString().eql(other.toZigString());
     }
 
-    extern fn JSC__createError(*jsc.JSGlobalObject, str: *const String) jsc.JSValue;
-    extern fn JSC__createTypeError(*jsc.JSGlobalObject, str: *const String) jsc.JSValue;
-    extern fn JSC__createRangeError(*jsc.JSGlobalObject, str: *const String) jsc.JSValue;
-
     pub fn jsGetStringWidth(globalObject: *jsc.JSGlobalObject, callFrame: *jsc.CallFrame) bun.JSError!jsc.JSValue {
         const args = callFrame.arguments_old(1).slice();